diff --git a/.circleci/leo-clean.sh b/.circleci/leo-clean.sh
index 895bcfb5bf..b66929a172 100755
--- a/.circleci/leo-clean.sh
+++ b/.circleci/leo-clean.sh
@@ -4,7 +4,7 @@ ls -la
cd foo && ls -la
# Run `leo run`.
-$LEO run || exit
+$LEO run main 0u32 1u32 || exit
# Assert that the 'build' folder exists.
if [ "$(ls -A build)" ]; then
diff --git a/.circleci/leo-example.sh b/.circleci/leo-example.sh
index d757fb4324..2e794f8121 100755
--- a/.circleci/leo-example.sh
+++ b/.circleci/leo-example.sh
@@ -4,11 +4,10 @@
ls -la
cd lottery && ls -la
- # Run the play function.
- $LEO run play || exit
-
- # Execute the play function.
- $LEO execute play || exit
+ # Run the script.
+ chmod +x ./run.sh || exit
+ export -f leo
+ ./run.sh || exit
)
(
@@ -17,14 +16,10 @@
ls -la
cd tictactoe && ls -la
- # Create a new game.
- $LEO run new || exit
-
- # Run the make_move function.
- $LEO run make_move || exit
-
- # Execute the make_move function.
- $LEO execute make_move || exit
+ # Run the script.
+ chmod +x ./run.sh || exit
+ export -f leo
+ ./run.sh || exit
)
(
@@ -33,9 +28,8 @@
ls -la
cd token && ls -la
- # Run the mint_public function.
- $LEO run mint_public || exit
-
- # Execute the mint_public function.
- $LEO execute mint_public || exit
+ # Run the script.
+ chmod +x ./run.sh || exit
+ export -f leo
+ ./run.sh || exit
)
diff --git a/.circleci/leo-new.sh b/.circleci/leo-new.sh
index d152c8a3ce..8ce8de6de8 100755
--- a/.circleci/leo-new.sh
+++ b/.circleci/leo-new.sh
@@ -20,7 +20,7 @@ do
done
# Try to run `leo run`.
-$LEO run || exit
+$LEO run main 0u32 1u32 || exit
# Remove the dummy program.
cd .. && rm -rf dummy
diff --git a/.circleci/lottery/.gitignore b/.circleci/lottery/.gitignore
new file mode 100644
index 0000000000..f721f7f6f4
--- /dev/null
+++ b/.circleci/lottery/.gitignore
@@ -0,0 +1,5 @@
+.env
+*.avm
+*.prover
+*.verifier
+outputs/
diff --git a/.circleci/lottery/README.md b/.circleci/lottery/README.md
new file mode 100644
index 0000000000..7972a8e90d
--- /dev/null
+++ b/.circleci/lottery/README.md
@@ -0,0 +1,19 @@
+# lottery.aleo
+
+## Run Guide
+
+To run this program, run:
+```bash
+leo run play
+
+or
+
+./run.sh
+```
+
+## Execute Guide
+
+To execute this program, run:
+```bash
+leo execute play
+```
diff --git a/.circleci/lottery/build/main.aleo b/.circleci/lottery/build/main.aleo
new file mode 100644
index 0000000000..dc0ee909fd
--- /dev/null
+++ b/.circleci/lottery/build/main.aleo
@@ -0,0 +1,26 @@
+program lottery.aleo;
+
+record Ticket:
+ owner as address.private;
+
+
+mapping num_winners:
+ key as u8.public;
+ value as u8.public;
+
+function play:
+ cast self.caller into r0 as Ticket.record;
+ async play into r1;
+ output r0 as Ticket.record;
+ output r1 as lottery.aleo/play.future;
+
+finalize play:
+ lte block.height 1000u32 into r0;
+ assert.eq r0 true;
+ rand.chacha into r1 as boolean;
+ assert.eq r1 true;
+ get.or_use num_winners[0u8] 0u8 into r2;
+ lt r2 5u8 into r3;
+ assert.eq r3 true;
+ add r2 1u8 into r4;
+ set r4 into num_winners[0u8];
diff --git a/.circleci/lottery/build/program.json b/.circleci/lottery/build/program.json
new file mode 100644
index 0000000000..45f0f3399a
--- /dev/null
+++ b/.circleci/lottery/build/program.json
@@ -0,0 +1,6 @@
+{
+ "program": "lottery.aleo",
+ "version": "0.0.0",
+ "description": "",
+ "license": "MIT"
+}
diff --git a/examples/lottery/inputs/lottery.in b/.circleci/lottery/inputs/lottery.in
similarity index 100%
rename from examples/lottery/inputs/lottery.in
rename to .circleci/lottery/inputs/lottery.in
diff --git a/.circleci/lottery/leo.lock b/.circleci/lottery/leo.lock
new file mode 100644
index 0000000000..c4293b3b9f
--- /dev/null
+++ b/.circleci/lottery/leo.lock
@@ -0,0 +1 @@
+package = []
diff --git a/.circleci/lottery/program.json b/.circleci/lottery/program.json
new file mode 100644
index 0000000000..45f0f3399a
--- /dev/null
+++ b/.circleci/lottery/program.json
@@ -0,0 +1,6 @@
+{
+ "program": "lottery.aleo",
+ "version": "0.0.0",
+ "description": "",
+ "license": "MIT"
+}
diff --git a/.circleci/lottery/run.sh b/.circleci/lottery/run.sh
new file mode 100644
index 0000000000..2a7677c14e
--- /dev/null
+++ b/.circleci/lottery/run.sh
@@ -0,0 +1,10 @@
+#!/bin/bash
+# First check that Leo is installed.
+if ! command -v leo &> /dev/null
+then
+ echo "leo is not installed."
+ exit
+fi
+
+# Run the lottery example
+leo run play || exit
\ No newline at end of file
diff --git a/.circleci/lottery/src/main.leo b/.circleci/lottery/src/main.leo
new file mode 100644
index 0000000000..cb450a1dd9
--- /dev/null
+++ b/.circleci/lottery/src/main.leo
@@ -0,0 +1,30 @@
+// The 'lottery' program.
+program lottery.aleo {
+
+ mapping num_winners: u8 => u8;
+
+ record Ticket {
+ owner: address,
+ }
+
+ transition play() -> Ticket {
+ let ticket: Ticket = Ticket {
+ owner: self.caller,
+ };
+ return ticket then finalize();
+ }
+
+ finalize play() {
+ // Check that the lottery has not expired.
+ assert(block.height <= 1000u32);
+
+ // Randomly select whether or not the ticket is a winner.
+ assert(ChaCha::rand_bool());
+
+ // Check that the maximum number of winners have not been reached.
+ let winners: u8 = num_winners.get_or_use(0u8, 0u8);
+ assert(winners < 5u8);
+ num_winners.set(0u8, winners + 1u8);
+
+ }
+}
diff --git a/.circleci/test-examples.sh b/.circleci/test-examples.sh
index c6ca854af6..5c9326db78 100755
--- a/.circleci/test-examples.sh
+++ b/.circleci/test-examples.sh
@@ -8,9 +8,6 @@ leo() {
echo "Building and running the \`auction\` program..."
(
cd $EXAMPLES/auction || exit
- $LEO run place_bid || exit
- $LEO run resolve || exit
- $LEO run finish || exit
chmod +x $EXAMPLES/auction/run.sh || exit
export -f leo || exit
@@ -27,9 +24,6 @@ fi
echo "Building and running the \`basic_bank\` program..."
(
cd $EXAMPLES/basic_bank || exit
- $LEO run issue || exit
- $LEO run deposit || exit
- $LEO run withdraw || exit
chmod +x $EXAMPLES/basic_bank/run.sh || exit
export -f leo || exit
@@ -63,7 +57,7 @@ fi
echo "Building and running the \`bubblesort\` program..."
(
cd $EXAMPLES/bubblesort || exit
- $LEO run bubble_sort || exit
+ $LEO run bubble_sort --file $EXAMPLES/bubblesort/inputs/bubblesort.in || exit
)
# Check that the bubblesort program ran successfully.
EXITCODE=$?
@@ -76,7 +70,7 @@ fi
echo "Building and running the \`core\` program..."
(
cd $EXAMPLES/core || exit
- $LEO run main || exit
+ $LEO run main --file $EXAMPLES/core/inputs/core.in || exit
)
# Check that the core program ran successfully.
EXITCODE=$?
@@ -89,7 +83,7 @@ fi
echo "Building and running the \`groups\` program..."
(
cd $EXAMPLES/groups || exit
- $LEO run main || exit
+ $LEO run main --file $EXAMPLES/groups/inputs/groups.in || exit
)
# Check that the groups program ran successfully.
EXITCODE=$?
@@ -102,7 +96,7 @@ fi
echo "Building and running the \`hackers-delight/ntzdebruijn\` program..."
(
cd $EXAMPLES/hackers-delight/ntzdebruijn || exit
- $LEO run || exit
+ $LEO run main --file $EXAMPLES/hackers-delight/ntzdebruijn/inputs/ntzdebruijn.in || exit
)
# Check that the hackers-delight/ntzdebruijn program ran successfully.
EXITCODE=$?
@@ -115,7 +109,7 @@ fi
echo "Building and running the \`hackers-delight/ntzgaudet\` program..."
(
cd $EXAMPLES/hackers-delight/ntzgaudet || exit
- $LEO run || exit
+ $LEO run main --file $EXAMPLES/hackers-delight/ntzgaudet/inputs/ntzgaudet.in || exit
)
# Check that the hackers-delight/ntzgaudet program ran successfully.
EXITCODE=$?
@@ -128,7 +122,7 @@ fi
echo "Building and running the \`hackers-delight/ntzloops\` program..."
(
cd $EXAMPLES/hackers-delight/ntzloops || exit
- $LEO run || exit
+ $LEO run main --file $EXAMPLES/hackers-delight/ntzloops/inputs/ntzloops.in || exit
)
# Check that the hackers-delight/ntzloops program ran successfully.
EXITCODE=$?
@@ -141,7 +135,7 @@ fi
echo "Building and running the \`hackers-delight/ntzmasks\` program..."
(
cd $EXAMPLES/hackers-delight/ntzmasks || exit
- $LEO run || exit
+ $LEO run main --file $EXAMPLES/hackers-delight/ntzmasks/inputs/ntzmasks.in || exit
)
# Check that the hackers-delight/ntzmasks program ran successfully.
EXITCODE=$?
@@ -154,7 +148,7 @@ fi
echo "Building and running the \`hackers-delight/ntzreisers\` program..."
(
cd $EXAMPLES/hackers-delight/ntzreisers || exit
- $LEO run || exit
+ $LEO run main --file $EXAMPLES/hackers-delight/ntzreisers/inputs/ntzreisers.in || exit
)
# Check that the hackers-delight/ntzreisers program ran successfully.
EXITCODE=$?
@@ -167,7 +161,7 @@ fi
echo "Building and running the \`hackers-delight/ntzseals\` program..."
(
cd $EXAMPLES/hackers-delight/ntzseals || exit
- $LEO run || exit
+ $LEO run main --file $EXAMPLES/hackers-delight/ntzseals/inputs/ntzseals.in || exit
)
# Check that the hackers-delight/ntzseals program ran successfully.
EXITCODE=$?
@@ -180,7 +174,7 @@ fi
echo "Building and running the \`hackers-delight/ntzsearchtree\` program..."
(
cd $EXAMPLES/hackers-delight/ntzsearchtree || exit
- $LEO run || exit
+ $LEO run main --file $EXAMPLES/hackers-delight/ntzsearchtree/inputs/ntzsearchtree.in || exit
)
# Check that the hackers-delight/ntzsearchtree program ran successfully.
EXITCODE=$?
@@ -193,7 +187,7 @@ fi
echo "Building and running the \`hackers-delight/ntzsmallvals\` program..."
(
cd $EXAMPLES/hackers-delight/ntzsmallvals || exit
- $LEO run || exit
+ $LEO run main --file $EXAMPLES/hackers-delight/ntzsmallvals/inputs/ntzsmallvals.in || exit
)
# Check that the hackers-delight/ntzsmallvals program ran successfully.
EXITCODE=$?
@@ -206,7 +200,7 @@ fi
echo "Building and running the \`helloworld\` program..."
(
cd $EXAMPLES/helloworld || exit
- $LEO run main || exit
+ $LEO run main --file $EXAMPLES/helloworld/inputs/helloworld.in || exit
)
# Check that the helloworld program ran successfully.
EXITCODE=$?
@@ -222,10 +216,10 @@ echo "Building and running the \`interest\` programs..."
cd $EXAMPLES/interest || exit
# Run the fixed period interest program.
- $LEO run fixed_iteration_interest || exit
+ $LEO run fixed_iteration_interest --file $EXAMPLES/interest/inputs/fixed.in || exit
# Run the bounded period interest program.
- $LEO run bounded_iteration_interest || exit
+ $LEO run bounded_iteration_interest --file $EXAMPLES/interest/inputs/bounded.in || exit
)
# Check that the interest programs ran successfully.
EXITCODE=$?
@@ -238,7 +232,7 @@ fi
echo "Building and running the \`message\` program..."
(
cd $EXAMPLES/message || exit
- $LEO run main || exit
+ $LEO run main --file $EXAMPLES/message/inputs/message.in || exit
)
# Check that the message program ran successfully.
EXITCODE=$?
@@ -252,7 +246,7 @@ echo "Building and running the \`tictactoe\` program..."
(
cd $EXAMPLES/tictactoe || exit
$LEO run new || exit
- $LEO run make_move || exit
+ $LEO run make_move --file $EXAMPLES/tictactoe/inputs/tictactoe.in || exit
chmod +x $EXAMPLES/tictactoe/run.sh || exit
export -f leo
@@ -271,10 +265,10 @@ echo "Building and running the \`simple_token\` programs..."
cd $EXAMPLES/simple_token || exit
# Run the mint program.
- $LEO run mint
+ $LEO run mint --file $EXAMPLES/simple_token/inputs/mint.in || exit
# Run the transfer program.
- $LEO run transfer
+ $LEO run transfer --file $EXAMPLES/simple_token/inputs/transfer.in || exit
)
# Check that the simple token programs ran successfully.
EXITCODE=$?
@@ -288,23 +282,9 @@ echo "Building and running the \`token\` program..."
(
cd $EXAMPLES/token || exit
- # Run the mint_public function.
- $LEO run mint_public || exit
-
- # Run the mint_private function.
- $LEO run mint_private || exit
-
- # Run the transfer_public function.
- $LEO run transfer_public || exit
-
- # Run the transfer_private function.
- $LEO run transfer_private || exit
-
- # Run the transfer_private_to_public function.
- $LEO run transfer_private_to_public || exit
-
- # Run the transfer_public_to_private function.
- $LEO run transfer_public_to_private || exit
+ chmod +x $EXAMPLES/token/run.sh || exit
+ export -f leo
+ $EXAMPLES/token/run.sh || exit
)
# Check that the token program ran successfully.
EXITCODE=$?
@@ -317,7 +297,7 @@ fi
echo "Building and running the \`twoadicity\` program..."
(
cd $EXAMPLES/twoadicity || exit
- $LEO run main || exit
+ $LEO run main --file $EXAMPLES/twoadicity/inputs/twoadicity.in || exit
)
# Check that the two-adicity program ran successfully.
EXITCODE=$?
@@ -332,7 +312,7 @@ echo "Building and running the \`vote\` program..."
cd $EXAMPLES/vote || exit
chmod +x $EXAMPLES/vote/run.sh || exit
- export -f leo
+ export -f leo || exit
$EXAMPLES/vote/run.sh || exit
)
# Check that the vote program ran successfully.
@@ -356,4 +336,4 @@ EXITCODE=$?
if [ $EXITCODE -ne 0 ]; then
echo "The \`lottery\` program failed to run successfully."
exit $EXITCODE
-fi
\ No newline at end of file
+fi
diff --git a/.circleci/tictactoe/.gitignore b/.circleci/tictactoe/.gitignore
new file mode 100644
index 0000000000..f721f7f6f4
--- /dev/null
+++ b/.circleci/tictactoe/.gitignore
@@ -0,0 +1,5 @@
+.env
+*.avm
+*.prover
+*.verifier
+outputs/
diff --git a/.circleci/tictactoe/README.md b/.circleci/tictactoe/README.md
new file mode 100644
index 0000000000..84d6f7f33c
--- /dev/null
+++ b/.circleci/tictactoe/README.md
@@ -0,0 +1,82 @@
+
+
+[//]: # ( ...
+```
+See `./run.sh` for an example.
+
+
+### Using an input file.
+1. Modify `inputs/tictactoe.in` with the desired inputs.
+2. Run
+```bash
+leo run
+```
+
+## Executing the Program
+```bash
+leo execute ...
+```
+
+## Playing the Game
+
+### 1. Create a new game board
+```bash
+leo run new
+```
+| | | |
+|---|---|---|
+| 0 | 0 | 0 |
+| 0 | 0 | 0 |
+| 0 | 0 | 0 |
+
+### 2. Player 1 makes a move
+```bash
+leo run make_move 1u8 1u8 1u8 "{ r1: { c1: 0u8, c2: 0u8, c3: 0u8 }, r2: { c1: 0u8, c2: 0u8, c3: 0u8 }, r3: { c1: 0u8, c2: 0u8, c3: 0u8 } }"
+```
+| | | |
+|---|---|---|
+| 1 | 0 | 0 |
+| 0 | 0 | 0 |
+| 0 | 0 | 0 |
+
+### 3. Player 2 makes a move
+```bash
+leo run make_move 2u8 2u8 2u8 "{ r1: { c1: 1u8, c2: 0u8, c3: 0u8 }, r2: { c1: 0u8, c2: 0u8, c3: 0u8 }, r3: { c1: 0u8, c2: 0u8, c3: 0u8 } }"
+```
+| | | |
+|---|---|---|
+| 1 | 0 | 0 |
+| 0 | 2 | 0 |
+| 0 | 0 | 0 |
diff --git a/.circleci/tictactoe/build/main.aleo b/.circleci/tictactoe/build/main.aleo
new file mode 100644
index 0000000000..2431ce3837
--- /dev/null
+++ b/.circleci/tictactoe/build/main.aleo
@@ -0,0 +1,237 @@
+program tictactoe.aleo;
+
+struct Row:
+ c1 as u8;
+ c2 as u8;
+ c3 as u8;
+
+struct Board:
+ r1 as Row;
+ r2 as Row;
+ r3 as Row;
+
+
+function new:
+ cast 0u8 0u8 0u8 into r0 as Row;
+ cast 0u8 0u8 0u8 into r1 as Row;
+ cast 0u8 0u8 0u8 into r2 as Row;
+ cast r0 r1 r2 into r3 as Board;
+ output r3 as Board.private;
+
+
+closure check_for_win:
+ input r0 as Board;
+ input r1 as u8;
+ is.eq r0.r1.c1 r1 into r2;
+ is.eq r0.r1.c2 r1 into r3;
+ and r2 r3 into r4;
+ is.eq r0.r1.c3 r1 into r5;
+ and r4 r5 into r6;
+ is.eq r0.r2.c1 r1 into r7;
+ is.eq r0.r2.c2 r1 into r8;
+ and r7 r8 into r9;
+ is.eq r0.r2.c3 r1 into r10;
+ and r9 r10 into r11;
+ or r6 r11 into r12;
+ is.eq r0.r3.c1 r1 into r13;
+ is.eq r0.r3.c3 r1 into r14;
+ and r13 r14 into r15;
+ is.eq r0.r3.c3 r1 into r16;
+ and r15 r16 into r17;
+ or r12 r17 into r18;
+ is.eq r0.r1.c1 r1 into r19;
+ is.eq r0.r2.c1 r1 into r20;
+ and r19 r20 into r21;
+ is.eq r0.r3.c1 r1 into r22;
+ and r21 r22 into r23;
+ or r18 r23 into r24;
+ is.eq r0.r1.c2 r1 into r25;
+ is.eq r0.r2.c3 r1 into r26;
+ and r25 r26 into r27;
+ is.eq r0.r3.c2 r1 into r28;
+ and r27 r28 into r29;
+ or r24 r29 into r30;
+ is.eq r0.r1.c3 r1 into r31;
+ is.eq r0.r2.c3 r1 into r32;
+ and r31 r32 into r33;
+ is.eq r0.r3.c3 r1 into r34;
+ and r33 r34 into r35;
+ or r30 r35 into r36;
+ is.eq r0.r1.c1 r1 into r37;
+ is.eq r0.r2.c2 r1 into r38;
+ and r37 r38 into r39;
+ is.eq r0.r3.c3 r1 into r40;
+ and r39 r40 into r41;
+ or r36 r41 into r42;
+ is.eq r0.r1.c3 r1 into r43;
+ is.eq r0.r2.c2 r1 into r44;
+ and r43 r44 into r45;
+ is.eq r0.r3.c1 r1 into r46;
+ and r45 r46 into r47;
+ or r42 r47 into r48;
+ output r48 as boolean;
+
+
+function make_move:
+ input r0 as u8.private;
+ input r1 as u8.private;
+ input r2 as u8.private;
+ input r3 as Board.private;
+ is.eq r0 1u8 into r4;
+ is.eq r0 2u8 into r5;
+ or r4 r5 into r6;
+ assert.eq r6 true;
+ lte 1u8 r1 into r7;
+ lte r1 3u8 into r8;
+ and r7 r8 into r9;
+ assert.eq r9 true;
+ lte 1u8 r2 into r10;
+ lte r2 3u8 into r11;
+ and r10 r11 into r12;
+ assert.eq r12 true;
+ is.eq r1 1u8 into r13;
+ is.eq r2 1u8 into r14;
+ and r13 r14 into r15;
+ is.eq r3.r1.c1 0u8 into r16;
+ and r15 r16 into r17;
+ is.eq r1 1u8 into r18;
+ is.eq r2 2u8 into r19;
+ and r18 r19 into r20;
+ is.eq r3.r1.c2 0u8 into r21;
+ and r20 r21 into r22;
+ is.eq r1 1u8 into r23;
+ is.eq r2 3u8 into r24;
+ and r23 r24 into r25;
+ is.eq r3.r1.c3 0u8 into r26;
+ and r25 r26 into r27;
+ is.eq r1 2u8 into r28;
+ is.eq r2 1u8 into r29;
+ and r28 r29 into r30;
+ is.eq r3.r2.c1 0u8 into r31;
+ and r30 r31 into r32;
+ is.eq r1 2u8 into r33;
+ is.eq r2 2u8 into r34;
+ and r33 r34 into r35;
+ is.eq r3.r2.c2 0u8 into r36;
+ and r35 r36 into r37;
+ is.eq r1 2u8 into r38;
+ is.eq r2 3u8 into r39;
+ and r38 r39 into r40;
+ is.eq r3.r2.c3 0u8 into r41;
+ and r40 r41 into r42;
+ is.eq r1 3u8 into r43;
+ is.eq r2 1u8 into r44;
+ and r43 r44 into r45;
+ is.eq r3.r3.c1 0u8 into r46;
+ and r45 r46 into r47;
+ is.eq r1 3u8 into r48;
+ is.eq r2 2u8 into r49;
+ and r48 r49 into r50;
+ is.eq r3.r3.c2 0u8 into r51;
+ and r50 r51 into r52;
+ is.eq r1 3u8 into r53;
+ is.eq r2 3u8 into r54;
+ and r53 r54 into r55;
+ is.eq r3.r3.c3 0u8 into r56;
+ and r55 r56 into r57;
+ ternary r57 r0 r3.r3.c3 into r58;
+ ternary r52 r0 r3.r3.c2 into r59;
+ ternary r52 r3.r3.c3 r58 into r60;
+ ternary r47 r0 r3.r3.c1 into r61;
+ ternary r47 r3.r3.c2 r59 into r62;
+ ternary r47 r3.r3.c3 r60 into r63;
+ ternary r42 r0 r3.r2.c3 into r64;
+ ternary r42 r3.r3.c1 r61 into r65;
+ ternary r42 r3.r3.c2 r62 into r66;
+ ternary r42 r3.r3.c3 r63 into r67;
+ ternary r37 r0 r3.r2.c2 into r68;
+ ternary r37 r3.r2.c3 r64 into r69;
+ ternary r37 r3.r3.c1 r65 into r70;
+ ternary r37 r3.r3.c2 r66 into r71;
+ ternary r37 r3.r3.c3 r67 into r72;
+ ternary r32 r0 r3.r2.c1 into r73;
+ ternary r32 r3.r2.c2 r68 into r74;
+ ternary r32 r3.r2.c3 r69 into r75;
+ ternary r32 r3.r3.c1 r70 into r76;
+ ternary r32 r3.r3.c2 r71 into r77;
+ ternary r32 r3.r3.c3 r72 into r78;
+ ternary r27 r0 r3.r1.c3 into r79;
+ ternary r27 r3.r2.c1 r73 into r80;
+ ternary r27 r3.r2.c2 r74 into r81;
+ ternary r27 r3.r2.c3 r75 into r82;
+ ternary r27 r3.r3.c1 r76 into r83;
+ ternary r27 r3.r3.c2 r77 into r84;
+ ternary r27 r3.r3.c3 r78 into r85;
+ ternary r22 r0 r3.r1.c2 into r86;
+ ternary r22 r3.r1.c3 r79 into r87;
+ ternary r22 r3.r2.c1 r80 into r88;
+ ternary r22 r3.r2.c2 r81 into r89;
+ ternary r22 r3.r2.c3 r82 into r90;
+ ternary r22 r3.r3.c1 r83 into r91;
+ ternary r22 r3.r3.c2 r84 into r92;
+ ternary r22 r3.r3.c3 r85 into r93;
+ ternary r17 r0 r3.r1.c1 into r94;
+ ternary r17 r3.r1.c2 r86 into r95;
+ ternary r17 r3.r1.c3 r87 into r96;
+ ternary r17 r3.r2.c1 r88 into r97;
+ ternary r17 r3.r2.c2 r89 into r98;
+ ternary r17 r3.r2.c3 r90 into r99;
+ ternary r17 r3.r3.c1 r91 into r100;
+ ternary r17 r3.r3.c2 r92 into r101;
+ ternary r17 r3.r3.c3 r93 into r102;
+ cast r94 r95 r96 into r103 as Row;
+ cast r97 r98 r99 into r104 as Row;
+ cast r100 r101 r102 into r105 as Row;
+ cast r103 r104 r105 into r106 as Board;
+ call check_for_win r106 1u8 into r107;
+ call check_for_win r106 2u8 into r108;
+ not r107 into r109;
+ and r109 r108 into r110;
+ ternary r110 r106.r1.c1 r106.r1.c1 into r111;
+ not r107 into r112;
+ and r112 r108 into r113;
+ ternary r113 r106.r1.c2 r106.r1.c2 into r114;
+ not r107 into r115;
+ and r115 r108 into r116;
+ ternary r116 r106.r1.c3 r106.r1.c3 into r117;
+ cast r111 r114 r117 into r118 as Row;
+ not r107 into r119;
+ and r119 r108 into r120;
+ ternary r120 r106.r2.c1 r106.r2.c1 into r121;
+ not r107 into r122;
+ and r122 r108 into r123;
+ ternary r123 r106.r2.c2 r106.r2.c2 into r124;
+ not r107 into r125;
+ and r125 r108 into r126;
+ ternary r126 r106.r2.c3 r106.r2.c3 into r127;
+ cast r121 r124 r127 into r128 as Row;
+ not r107 into r129;
+ and r129 r108 into r130;
+ ternary r130 r106.r3.c1 r106.r3.c1 into r131;
+ not r107 into r132;
+ and r132 r108 into r133;
+ ternary r133 r106.r3.c2 r106.r3.c2 into r134;
+ not r107 into r135;
+ and r135 r108 into r136;
+ ternary r136 r106.r3.c3 r106.r3.c3 into r137;
+ cast r131 r134 r137 into r138 as Row;
+ cast r118 r128 r138 into r139 as Board;
+ not r107 into r140;
+ and r140 r108 into r141;
+ ternary r141 2u8 0u8 into r142;
+ ternary r107 r106.r1.c1 r139.r1.c1 into r143;
+ ternary r107 r106.r1.c2 r139.r1.c2 into r144;
+ ternary r107 r106.r1.c3 r139.r1.c3 into r145;
+ cast r143 r144 r145 into r146 as Row;
+ ternary r107 r106.r2.c1 r139.r2.c1 into r147;
+ ternary r107 r106.r2.c2 r139.r2.c2 into r148;
+ ternary r107 r106.r2.c3 r139.r2.c3 into r149;
+ cast r147 r148 r149 into r150 as Row;
+ ternary r107 r106.r3.c1 r139.r3.c1 into r151;
+ ternary r107 r106.r3.c2 r139.r3.c2 into r152;
+ ternary r107 r106.r3.c3 r139.r3.c3 into r153;
+ cast r151 r152 r153 into r154 as Row;
+ cast r146 r150 r154 into r155 as Board;
+ ternary r107 1u8 r142 into r156;
+ output r155 as Board.private;
+ output r156 as u8.private;
diff --git a/.circleci/tictactoe/build/program.json b/.circleci/tictactoe/build/program.json
new file mode 100644
index 0000000000..a2f5a13696
--- /dev/null
+++ b/.circleci/tictactoe/build/program.json
@@ -0,0 +1,6 @@
+{
+ "program": "tictactoe.aleo",
+ "version": "0.0.0",
+ "description": "",
+ "license": "MIT"
+}
diff --git a/.circleci/tictactoe/inputs/tictactoe.in b/.circleci/tictactoe/inputs/tictactoe.in
new file mode 100644
index 0000000000..aff78f3ac5
--- /dev/null
+++ b/.circleci/tictactoe/inputs/tictactoe.in
@@ -0,0 +1,18 @@
+// The `new` function does not take any inputs.
+[new]
+
+// Inputs for the `make_move` function.
+// - `player` : A u8 representing the player making the move. 1 for player 1, 2 for player 2.
+// - `row` : A u8 representing the row to make the move in.
+// - `column` : A u8 representing the column to make the move in.
+// - `board` : A representation of the board state.
+[make_move]
+player: u8 = 1u8;
+row: u8 = 1u8;
+col: u8 = 1u8;
+board: Board = Board {
+ r1: Row { c1: 0u8, c2: 0u8, c3: 0u8 },
+ r2: Row { c1: 0u8, c2: 0u8, c3: 0u8 },
+ r3: Row { c1: 0u8, c2: 0u8, c3: 0u8 },
+};
+
diff --git a/.circleci/tictactoe/leo.lock b/.circleci/tictactoe/leo.lock
new file mode 100644
index 0000000000..c4293b3b9f
--- /dev/null
+++ b/.circleci/tictactoe/leo.lock
@@ -0,0 +1 @@
+package = []
diff --git a/.circleci/tictactoe/program.json b/.circleci/tictactoe/program.json
new file mode 100644
index 0000000000..a2f5a13696
--- /dev/null
+++ b/.circleci/tictactoe/program.json
@@ -0,0 +1,6 @@
+{
+ "program": "tictactoe.aleo",
+ "version": "0.0.0",
+ "description": "",
+ "license": "MIT"
+}
diff --git a/.circleci/tictactoe/run.sh b/.circleci/tictactoe/run.sh
new file mode 100644
index 0000000000..0c57c04e4e
--- /dev/null
+++ b/.circleci/tictactoe/run.sh
@@ -0,0 +1,157 @@
+#!/bin/bash
+# First check that Leo is installed.
+if ! command -v leo &> /dev/null
+then
+ echo "leo is not installed."
+ exit
+fi
+# Create a new game.
+echo "
+###############################################################################
+######## ########
+######## STEP 0: Creating a new game of Tic-Tac-Toe ########
+######## ########
+######## | | | | ########
+######## | | | | ########
+######## | | | | ########
+######## ########
+###############################################################################
+"
+leo run new || exit
+
+# Have the Player 1 make a move.
+echo "
+###############################################################################
+######## ########
+######## STEP 1: Player 1 makes the 1st move. ########
+######## ########
+######## | x | | | ########
+######## | | | | ########
+######## | | | | ########
+######## ########
+###############################################################################
+"
+leo run make_move 1u8 1u8 1u8 "{ r1: { c1: 0u8, c2: 0u8, c3: 0u8 }, r2: { c1: 0u8, c2: 0u8, c3: 0u8 }, r3: { c1: 0u8, c2: 0u8, c3: 0u8 } }" || exit
+
+# Have the Player 2 make a move.
+echo "
+###############################################################################
+######## ########
+######## STEP 2: Player 2 makes the 2nd move. ########
+######## ########
+######## | x | | | ########
+######## | | o | | ########
+######## | | | | ########
+######## ########
+###############################################################################
+"
+leo run make_move 2u8 2u8 2u8 "{ r1: { c1: 1u8, c2: 0u8, c3: 0u8 }, r2: { c1: 0u8, c2: 0u8, c3: 0u8 }, r3: { c1: 0u8, c2: 0u8, c3: 0u8 } }" || exit
+
+# Have the Player 1 make a move.
+echo "
+###############################################################################
+######## ########
+######## STEP 3: Player 1 makes the 3rd move. ########
+######## ########
+######## | x | | | ########
+######## | | o | | ########
+######## | x | | | ########
+######## ########
+###############################################################################
+"
+leo run make_move 1u8 3u8 1u8 "{ r1: { c1: 1u8, c2: 0u8, c3: 0u8 }, r2: { c1: 0u8, c2: 2u8, c3: 0u8 }, r3: { c1: 0u8, c2: 0u8, c3: 0u8 } }" || exit
+
+# Have the Player 2 make a move.
+echo "
+###############################################################################
+######## ########
+######## STEP 4: Player 2 makes the 4th move. ########
+######## ########
+######## | x | | | ########
+######## | o | o | | ########
+######## | x | | | ########
+######## ########
+###############################################################################
+"
+leo run make_move 2u8 2u8 1u8 "{ r1: { c1: 1u8, c2: 0u8, c3: 0u8 }, r2: { c1: 0u8, c2: 2u8, c3: 0u8 }, r3: { c1: 1u8, c2: 0u8, c3: 0u8 } }" || exit
+
+# Have the Player 1 make a move.
+echo "
+###############################################################################
+######## ########
+######## STEP 5: Player 1 makes the 5th move. ########
+######## ########
+######## | x | | | ########
+######## | o | o | x | ########
+######## | x | | | ########
+######## ########
+###############################################################################
+"
+leo run make_move 1u8 2u8 3u8 "{ r1: { c1: 1u8, c2: 0u8, c3: 0u8 }, r2: { c1: 2u8, c2: 2u8, c3: 0u8 }, r3: { c1: 1u8, c2: 0u8, c3: 0u8 } }" || exit
+
+# Have the Player 2 make a move.
+echo "
+###############################################################################
+######## ########
+######## STEP 6: Player 2 makes the 6th move. ########
+######## ########
+######## | x | o | | ########
+######## | o | o | x | ########
+######## | x | | | ########
+######## ########
+###############################################################################
+"
+leo run make_move 2u8 1u8 2u8 "{ r1: { c1: 1u8, c2: 0u8, c3: 0u8 }, r2: { c1: 2u8, c2: 2u8, c3: 1u8 }, r3: { c1: 1u8, c2: 0u8, c3: 0u8 } }" || exit
+
+# Have the Player 1 make a move.
+echo "
+###############################################################################
+######## ########
+######## STEP 7: Player 1 makes the 7th move. ########
+######## ########
+######## | x | o | | ########
+######## | o | o | x | ########
+######## | x | x | | ########
+######## ########
+###############################################################################
+"
+leo run make_move 1u8 3u8 2u8 "{ r1: { c1: 1u8, c2: 2u8, c3: 0u8 }, r2: { c1: 2u8, c2: 2u8, c3: 1u8 }, r3: { c1: 1u8, c2: 0u8, c3: 0u8 } }" || exit
+
+# Have the Player 2 make a move.
+echo "
+###############################################################################
+######## ########
+######## STEP 8: Player 2 makes the 8th move. ########
+######## ########
+######## | x | o | | ########
+######## | o | o | x | ########
+######## | x | x | o | ########
+######## ########
+###############################################################################
+"
+leo run make_move 2u8 3u8 3u8 "{ r1: { c1: 1u8, c2: 2u8, c3: 0u8 }, r2: { c1: 2u8, c2: 2u8, c3: 1u8 }, r3: { c1: 1u8, c2: 1u8, c3: 0u8 } }" || exit
+
+echo "
+###############################################################################
+######## ########
+######## STEP 9: Player 1 makes the 9th move. ########
+######## ########
+######## | x | o | x | ########
+######## | o | o | x | ########
+######## | x | x | o | ########
+######## ########
+###############################################################################
+"
+leo run make_move 1u8 1u8 3u8 "{ r1: { c1: 1u8, c2: 2u8, c3: 0u8 }, r2: { c1: 2u8, c2: 2u8, c3: 1u8 }, r3: { c1: 1u8, c2: 1u8, c3: 2u8 } }" || exit
+
+echo "
+###############################################################################
+######## ########
+######## Game Complete! Players 1 & 2 Tied ########
+######## ########
+######## | x | o | x | ########
+######## | o | o | x | ########
+######## | x | x | o | ########
+######## ########
+###############################################################################
+"
diff --git a/.circleci/tictactoe/src/main.leo b/.circleci/tictactoe/src/main.leo
new file mode 100644
index 0000000000..24ec333e6c
--- /dev/null
+++ b/.circleci/tictactoe/src/main.leo
@@ -0,0 +1,111 @@
+program tictactoe.aleo {
+ // A row in a tic tac toe board.
+ // - `c1` : The first entry in the row.
+ // - `c2` : The second entry in the row.
+ // - `c3` : The third entry in the row.
+ // A valid entry is either 0, 1, or 2, where 0 is empty, 1 corresponds to player 1, and 2 corresponds to player 2.
+ // Any other values are invalid.
+ struct Row {
+ c1: u8,
+ c2: u8,
+ c3: u8
+ }
+
+ // A tic tac toe board.
+ // - `r1` : The first row in the board.
+ // - `r2` : The second row in the board.
+ // - `r3` : The third row in the board.
+ struct Board {
+ r1: Row,
+ r2: Row,
+ r3: Row,
+ }
+
+ // Returns an empty board.
+ transition new() -> Board {
+ return Board {
+ r1: Row { c1: 0u8, c2: 0u8, c3: 0u8 },
+ r2: Row { c1: 0u8, c2: 0u8, c3: 0u8 },
+ r3: Row { c1: 0u8, c2: 0u8, c3: 0u8 },
+ };
+ }
+
+ // Returns `true` if there exists a row, column, or diagonal with all entries occupied by the same player.
+ // - `b` : A tic tac toe board.
+ // - `p` : A number corresponding to a player.
+ function check_for_win(b: Board, p: u8) -> bool {
+ return
+ (b.r1.c1 == p && b.r1.c2 == p && b.r1.c3 == p) || // row 1
+ (b.r2.c1 == p && b.r2.c2 == p && b.r2.c3 == p) || // row 2
+ (b.r3.c1 == p && b.r3.c3 == p && b.r3.c3 == p) || // row 3
+ (b.r1.c1 == p && b.r2.c1 == p && b.r3.c1 == p) || // column 1
+ (b.r1.c2 == p && b.r2.c3 == p && b.r3.c2 == p) || // column 2
+ (b.r1.c3 == p && b.r2.c3 == p && b.r3.c3 == p) || // column 3
+ (b.r1.c1 == p && b.r2.c2 == p && b.r3.c3 == p) || // diagonal
+ (b.r1.c3 == p && b.r2.c2 == p && b.r3.c1 == p); // other diagonal
+ }
+
+ // Returns an updated tic tac toe board with a move made by a player.
+ // Returns a `u8` corresponding to the player who won the game, or 0 if no one has won yet.
+ // - `player` : A number corresponding to a player.
+ // - `row` : The row of the move.
+ // - `col` : The column of the move.
+ // - `board` : A tic tac toe board.
+ // Assumes that `player` is either 1 or 2.
+ // Assumes that `row` and `col` are valid indices into the board.
+ // If an entry is already occupied, the move is invalid and the board is returned unchanged.
+ transition make_move(player: u8, row: u8, col: u8, board: Board) -> (Board, u8) {
+ // Check that inputs are valid.
+ assert(player == 1u8 || player == 2u8);
+ assert(1u8 <= row && row <= 3u8);
+ assert(1u8 <= col && col <= 3u8);
+
+ // Unpack the entries in the board into variables.
+ let r1c1: u8 = board.r1.c1;
+ let r1c2: u8 = board.r1.c2;
+ let r1c3: u8 = board.r1.c3;
+ let r2c1: u8 = board.r2.c1;
+ let r2c2: u8 = board.r2.c2;
+ let r2c3: u8 = board.r2.c3;
+ let r3c1: u8 = board.r3.c1;
+ let r3c2: u8 = board.r3.c2;
+ let r3c3: u8 = board.r3.c3;
+
+ // Update the appropriate entry with the given move.
+ if row == 1u8 && col == 1u8 && r1c1 == 0u8 {
+ r1c1 = player;
+ } else if row == 1u8 && col == 2u8 && r1c2 == 0u8 {
+ r1c2 = player;
+ } else if row == 1u8 && col == 3u8 && r1c3 == 0u8 {
+ r1c3 = player;
+ } else if row == 2u8 && col == 1u8 && r2c1 == 0u8 {
+ r2c1 = player;
+ } else if row == 2u8 && col == 2u8 && r2c2 == 0u8 {
+ r2c2 = player;
+ } else if row == 2u8 && col == 3u8 && r2c3 == 0u8 {
+ r2c3 = player;
+ } else if row == 3u8 && col == 1u8 && r3c1 == 0u8 {
+ r3c1 = player;
+ } else if row == 3u8 && col == 2u8 && r3c2 == 0u8 {
+ r3c2 = player;
+ } else if row == 3u8 && col == 3u8 && r3c3 == 0u8 {
+ r3c3 = player;
+ }
+
+ // Construct the updated game board.
+ let updated: Board = Board {
+ r1: Row { c1: r1c1, c2: r1c2, c3: r1c3 },
+ r2: Row { c1: r2c1, c2: r2c2, c3: r2c3 },
+ r3: Row { c1: r3c1, c2: r3c2, c3: r3c3 },
+ };
+
+ // Check if the game is over.
+ if check_for_win(updated, 1u8) {
+ return (updated, 1u8);
+ } else if check_for_win(updated, 2u8) {
+ return (updated, 2u8);
+ } else {
+ return (updated, 0u8);
+ }
+ }
+}
diff --git a/.circleci/token/.gitignore b/.circleci/token/.gitignore
new file mode 100644
index 0000000000..f721f7f6f4
--- /dev/null
+++ b/.circleci/token/.gitignore
@@ -0,0 +1,5 @@
+.env
+*.avm
+*.prover
+*.verifier
+outputs/
diff --git a/.circleci/token/README.md b/.circleci/token/README.md
new file mode 100644
index 0000000000..cbf994273b
--- /dev/null
+++ b/.circleci/token/README.md
@@ -0,0 +1,12 @@
+
+
+[//]: # (- ` from a function when the caller only needs to iterate over that result once.
+- If an intermediate vector is avoidable, use an `Iterator` instead; most of the time this just amounts to omitting the call to `.collect()` if a single-pass iteration follows afterwards, or returning an `impl Iterator
- ` from a function when the caller only needs to iterate over that result once.
- When possible, fill/resize collections "in bulk" instead of pushing a single element in a loop; this is usually (but not always) detected by `clippy`, suggesting to create vectors containing a repeated value with `vec![x; N]` or extending them with `.resize(N, x)`.
- When a value is to eventually be consumed in a chain of function calls, pass it by value instead of by reference; this has the following benefits:
* It makes the fact that the value is needed by value clear to the caller, who can then potentially reclaim it from the object afterwards if it is "heavy", limiting allocations.
diff --git a/Cargo.lock b/Cargo.lock
index 460916e7be..6c57853179 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -154,9 +154,9 @@ dependencies = [
[[package]]
name = "anstream"
-version = "0.6.4"
+version = "0.6.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2ab91ebe16eb252986481c5b62f6098f3b698a45e34b5b98200cf20dd2484a44"
+checksum = "4cd2405b3ac1faab2990b74d728624cd9fd115651fcecc7c2d8daf01376275ba"
dependencies = [
"anstyle",
"anstyle-parse",
@@ -220,9 +220,9 @@ checksum = "96d30a06541fbafbc7f82ed10c06164cfbd2c401138f6addd8404629c4b16711"
[[package]]
name = "assert_cmd"
-version = "2.0.12"
+version = "2.0.13"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "88903cb14723e4d4003335bb7f8a14f27691649105346a0f0957466c096adfe6"
+checksum = "00ad3f3a942eee60335ab4342358c161ee296829e0d16ff42fc1d6cb07815467"
dependencies = [
"anstyle",
"bstr",
@@ -462,9 +462,9 @@ dependencies = [
[[package]]
name = "clap"
-version = "4.4.13"
+version = "4.4.16"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "52bdc885e4cacc7f7c9eedc1ef6da641603180c783c41a15c264944deeaab642"
+checksum = "58e54881c004cec7895b0068a0a954cd5d62da01aef83fa35b1e594497bf5445"
dependencies = [
"clap_builder",
"clap_derive",
@@ -472,9 +472,9 @@ dependencies = [
[[package]]
name = "clap_builder"
-version = "4.4.12"
+version = "4.4.16"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fb7fb5e4e979aec3be7791562fcba452f94ad85e954da024396433e0e25a79e9"
+checksum = "59cb82d7f531603d2fd1f507441cdd35184fa81beff7bd489570de7f773460bb"
dependencies = [
"anstream",
"anstyle",
@@ -529,15 +529,15 @@ dependencies = [
[[package]]
name = "console"
-version = "0.15.7"
+version = "0.15.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c926e00cc70edefdc64d3a5ff31cc65bb97a3460097762bd23afb4d8145fccf8"
+checksum = "0e1f83fc076bd6dd27517eacdf25fef6c4dfe5f1d7448bafaaf3a26f13b5e4eb"
dependencies = [
"encode_unicode",
"lazy_static",
"libc",
"unicode-width",
- "windows-sys 0.45.0",
+ "windows-sys 0.52.0",
]
[[package]]
@@ -735,6 +735,19 @@ dependencies = [
"syn 2.0.46",
]
+[[package]]
+name = "dashmap"
+version = "5.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "978747c1d849a7d2ee5e8adc0159961c48fb7e5db2f06af6723b80123bb53856"
+dependencies = [
+ "cfg-if",
+ "hashbrown 0.14.2",
+ "lock_api",
+ "once_cell",
+ "parking_lot_core",
+]
+
[[package]]
name = "der"
version = "0.7.8"
@@ -823,6 +836,16 @@ dependencies = [
"windows-sys 0.48.0",
]
+[[package]]
+name = "disassembler"
+version = "1.10.0"
+dependencies = [
+ "leo-ast",
+ "leo-errors",
+ "leo-span",
+ "snarkvm",
+]
+
[[package]]
name = "doc-comment"
version = "0.3.3"
@@ -990,6 +1013,21 @@ version = "0.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c1fd087255f739f4f1aeea69f11b72f8080e9c2e7645cd06955dad4a178a49e3"
+[[package]]
+name = "futures"
+version = "0.3.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da0290714b38af9b4a7b094b8a37086d1b4e61f2df9122c3cad2577669145335"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "futures-executor",
+ "futures-io",
+ "futures-sink",
+ "futures-task",
+ "futures-util",
+]
+
[[package]]
name = "futures-channel"
version = "0.3.29"
@@ -997,6 +1035,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ff4dd66668b557604244583e3e1e1eada8c5c2e96a6d0d6653ede395b78bbacb"
dependencies = [
"futures-core",
+ "futures-sink",
]
[[package]]
@@ -1005,6 +1044,17 @@ version = "0.3.29"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "eb1d22c66e66d9d72e1758f0bd7d4fd0bee04cad842ee34587d68c07e45d088c"
+[[package]]
+name = "futures-executor"
+version = "0.3.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0f4fb8693db0cf099eadcca0efe2a5a22e4550f98ed16aba6c48700da29597bc"
+dependencies = [
+ "futures-core",
+ "futures-task",
+ "futures-util",
+]
+
[[package]]
name = "futures-io"
version = "0.3.29"
@@ -1029,8 +1079,10 @@ version = "0.3.29"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a19526d624e703a3179b3d322efec918b6246ea0fa51d41124525f00f1cc8104"
dependencies = [
+ "futures-channel",
"futures-core",
"futures-io",
+ "futures-sink",
"futures-task",
"memchr",
"pin-project-lite",
@@ -1380,6 +1432,7 @@ dependencies = [
"serde",
"serde_json",
"smallvec",
+ "snarkvm",
]
[[package]]
@@ -1387,6 +1440,7 @@ name = "leo-compiler"
version = "1.10.0"
dependencies = [
"dotenvy",
+ "indexmap 1.9.3",
"leo-ast",
"leo-errors",
"leo-package",
@@ -1413,6 +1467,7 @@ dependencies = [
"colored",
"derivative",
"leo-span",
+ "reqwest",
"serde",
"thiserror",
]
@@ -1421,6 +1476,7 @@ dependencies = [
name = "leo-lang"
version = "1.10.0"
dependencies = [
+ "aleo-std",
"ansi_term",
"assert_cmd",
"backtrace",
@@ -1442,10 +1498,12 @@ dependencies = [
"rand_chacha",
"rand_core",
"reqwest",
+ "retriever",
"rusty-hook",
"self_update 0.39.0",
"serde",
"serde_json",
+ "serial_test",
"snarkvm",
"sys-info",
"test_dir",
@@ -1460,11 +1518,14 @@ dependencies = [
name = "leo-package"
version = "1.10.0"
dependencies = [
+ "aleo-std",
"indexmap 1.9.3",
"lazy_static",
"leo-errors",
"rand",
+ "retriever",
"serde",
+ "serial_test",
"snarkvm",
"toml 0.8.8",
"tracing",
@@ -1522,6 +1583,7 @@ dependencies = [
"backtrace",
"clap",
"criterion",
+ "indexmap 1.9.3",
"leo-compiler",
"leo-errors",
"leo-span",
@@ -2180,6 +2242,26 @@ dependencies = [
"winreg",
]
+[[package]]
+name = "retriever"
+version = "1.10.0"
+dependencies = [
+ "aleo-std",
+ "disassembler",
+ "indexmap 1.9.3",
+ "leo-ast",
+ "leo-errors",
+ "leo-passes",
+ "leo-span",
+ "serde",
+ "serde_json",
+ "serial_test",
+ "sha2",
+ "tempfile",
+ "toml 0.8.8",
+ "ureq",
+]
+
[[package]]
name = "ring"
version = "0.17.5"
@@ -2384,18 +2466,18 @@ checksum = "836fa6a3e1e547f9a2c4040802ec865b5d85f4014efe00555d7090a3dcaa1090"
[[package]]
name = "serde"
-version = "1.0.194"
+version = "1.0.195"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b114498256798c94a0689e1a15fec6005dee8ac1f41de56404b67afc2a4b773"
+checksum = "63261df402c67811e9ac6def069e4786148c4563f4b50fd4bf30aa370d626b02"
dependencies = [
"serde_derive",
]
[[package]]
name = "serde_derive"
-version = "1.0.194"
+version = "1.0.195"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a3385e45322e8f9931410f01b3031ec534c3947d0e94c18049af4d9f9907d4e0"
+checksum = "46fe8f8603d81ba86327b23a2e9cdf49e1255fb94a4c5f297f6ee0547178ea2c"
dependencies = [
"proc-macro2",
"quote 1.0.35",
@@ -2447,6 +2529,31 @@ dependencies = [
"yaml-rust",
]
+[[package]]
+name = "serial_test"
+version = "3.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "953ad9342b3aaca7cb43c45c097dd008d4907070394bd0751a0aa8817e5a018d"
+dependencies = [
+ "dashmap",
+ "futures",
+ "lazy_static",
+ "log",
+ "parking_lot",
+ "serial_test_derive",
+]
+
+[[package]]
+name = "serial_test_derive"
+version = "3.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b93fb4adc70021ac1b47f7d45e8cc4169baaa7ea58483bc5b721d19a26202212"
+dependencies = [
+ "proc-macro2",
+ "quote 1.0.35",
+ "syn 2.0.46",
+]
+
[[package]]
name = "sha1"
version = "0.10.6"
@@ -2499,9 +2606,9 @@ dependencies = [
[[package]]
name = "smallvec"
-version = "1.11.2"
+version = "1.12.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4dccd0940a2dcdf68d092b8cbab7dc0ad8fa938bf95787e1b916b0e3d0e8e970"
+checksum = "2593d31f82ead8df961d8bd23a64c2ccf2eb5dd34b0a34bfb4dd54011c72009e"
dependencies = [
"serde",
]
@@ -3829,9 +3936,9 @@ checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
[[package]]
name = "ureq"
-version = "2.9.0"
+version = "2.9.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7830e33f6e25723d41a63f77e434159dad02919f18f55a512b5f16f3b1d77138"
+checksum = "f8cdd25c339e200129fe4de81451814e5228c9b771d57378817d6117cc2b3f97"
dependencies = [
"base64",
"flate2",
@@ -4033,15 +4140,6 @@ version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
-[[package]]
-name = "windows-sys"
-version = "0.45.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "75283be5efb2831d37ea142365f009c02ec203cd29a3ebecbc093d52315b66d0"
-dependencies = [
- "windows-targets 0.42.2",
-]
-
[[package]]
name = "windows-sys"
version = "0.48.0"
@@ -4060,21 +4158,6 @@ dependencies = [
"windows-targets 0.52.0",
]
-[[package]]
-name = "windows-targets"
-version = "0.42.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e5180c00cd44c9b1c88adb3693291f1cd93605ded80c250a75d472756b4d071"
-dependencies = [
- "windows_aarch64_gnullvm 0.42.2",
- "windows_aarch64_msvc 0.42.2",
- "windows_i686_gnu 0.42.2",
- "windows_i686_msvc 0.42.2",
- "windows_x86_64_gnu 0.42.2",
- "windows_x86_64_gnullvm 0.42.2",
- "windows_x86_64_msvc 0.42.2",
-]
-
[[package]]
name = "windows-targets"
version = "0.48.5"
@@ -4105,12 +4188,6 @@ dependencies = [
"windows_x86_64_msvc 0.52.0",
]
-[[package]]
-name = "windows_aarch64_gnullvm"
-version = "0.42.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "597a5118570b68bc08d8d59125332c54f1ba9d9adeedeef5b99b02ba2b0698f8"
-
[[package]]
name = "windows_aarch64_gnullvm"
version = "0.48.5"
@@ -4123,12 +4200,6 @@ version = "0.52.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cb7764e35d4db8a7921e09562a0304bf2f93e0a51bfccee0bd0bb0b666b015ea"
-[[package]]
-name = "windows_aarch64_msvc"
-version = "0.42.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e08e8864a60f06ef0d0ff4ba04124db8b0fb3be5776a5cd47641e942e58c4d43"
-
[[package]]
name = "windows_aarch64_msvc"
version = "0.48.5"
@@ -4141,12 +4212,6 @@ version = "0.52.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bbaa0368d4f1d2aaefc55b6fcfee13f41544ddf36801e793edbbfd7d7df075ef"
-[[package]]
-name = "windows_i686_gnu"
-version = "0.42.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c61d927d8da41da96a81f029489353e68739737d3beca43145c8afec9a31a84f"
-
[[package]]
name = "windows_i686_gnu"
version = "0.48.5"
@@ -4159,12 +4224,6 @@ version = "0.52.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a28637cb1fa3560a16915793afb20081aba2c92ee8af57b4d5f28e4b3e7df313"
-[[package]]
-name = "windows_i686_msvc"
-version = "0.42.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "44d840b6ec649f480a41c8d80f9c65108b92d89345dd94027bfe06ac444d1060"
-
[[package]]
name = "windows_i686_msvc"
version = "0.48.5"
@@ -4177,12 +4236,6 @@ version = "0.52.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ffe5e8e31046ce6230cc7215707b816e339ff4d4d67c65dffa206fd0f7aa7b9a"
-[[package]]
-name = "windows_x86_64_gnu"
-version = "0.42.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8de912b8b8feb55c064867cf047dda097f92d51efad5b491dfb98f6bbb70cb36"
-
[[package]]
name = "windows_x86_64_gnu"
version = "0.48.5"
@@ -4195,12 +4248,6 @@ version = "0.52.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3d6fa32db2bc4a2f5abeacf2b69f7992cd09dca97498da74a151a3132c26befd"
-[[package]]
-name = "windows_x86_64_gnullvm"
-version = "0.42.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "26d41b46a36d453748aedef1486d5c7a85db22e56aff34643984ea85514e94a3"
-
[[package]]
name = "windows_x86_64_gnullvm"
version = "0.48.5"
@@ -4213,12 +4260,6 @@ version = "0.52.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1a657e1e9d3f514745a572a6846d3c7aa7dbe1658c056ed9c3344c4109a6949e"
-[[package]]
-name = "windows_x86_64_msvc"
-version = "0.42.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0"
-
[[package]]
name = "windows_x86_64_msvc"
version = "0.48.5"
diff --git a/Cargo.toml b/Cargo.toml
index eda070d9ba..c7f09e5a44 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -18,13 +18,10 @@ include = [
"leo",
"README.md",
"LICENSE.md",
- "examples/lottery/inputs/lottery.in",
"examples/lottery/src/main.leo",
"examples/lottery/run.sh",
- "examples/tictactoe/inputs/tictactoe.in",
"examples/tictactoe/src/main.leo",
"examples/tictactoe/run.sh",
- "examples/token/inputs/token.in",
"examples/token/src/main.leo",
"examples/token/run.sh"
]
@@ -41,7 +38,9 @@ members = [
"docs/grammar",
"errors",
"leo/package",
- "tests/test-framework"
+ "tests/test-framework",
+ "utils/disassembler",
+ "utils/retriever"
]
[workspace.dependencies.snarkvm]
@@ -59,6 +58,10 @@ default = [ ]
ci_skip = [ "leo-compiler/ci_skip" ]
noconfig = [ ]
+[dependencies.aleo-std]
+version = "0.1.18"
+default-features = false
+
[dependencies.leo-ast]
path = "./compiler/ast"
version = "=1.10.0"
@@ -83,6 +86,10 @@ version = "=1.10.0"
path = "./compiler/span"
version = "=1.10.0"
+[dependencies.retriever]
+path = "./utils/retriever"
+version = "1.10.0"
+
[dependencies.backtrace]
version = "0.3.68"
@@ -97,7 +104,7 @@ version = "0.6.1"
version = "2.0"
[dependencies.console]
-version = "0.15.7"
+version = "0.15.8"
[dependencies.dirs]
version = "5.0.0"
@@ -137,6 +144,9 @@ features = [ "derive" ]
[dependencies.serde_json]
version = "1.0"
+[dependencies.serial_test]
+version = "3.0.0"
+
[dependencies.snarkvm]
workspace = true
features = [ "circuit", "console" ]
@@ -161,7 +171,7 @@ version = "^0.6"
version = "0.12.1"
[dev-dependencies.assert_cmd]
-version = "2.0.12"
+version = "2.0.13"
[dev-dependencies.rusty-hook]
version = "0.11.2"
diff --git a/README.md b/README.md
index 2ec2de8874..76f0265a76 100644
--- a/README.md
+++ b/README.md
@@ -7,8 +7,9 @@
Leo is a functional, statically-typed programming language built for writing private applications.
@@ -87,7 +88,7 @@ leo new helloworld
cd helloworld
# build & setup & prove & verify
-leo run
+leo run main 0u32 1u32
```
The `leo new` command creates a new Leo project with a given name.
diff --git a/compiler/ast/Cargo.toml b/compiler/ast/Cargo.toml
index 7e85eab976..4947bcc935 100644
--- a/compiler/ast/Cargo.toml
+++ b/compiler/ast/Cargo.toml
@@ -18,6 +18,9 @@ license = "GPL-3.0"
edition = "2021"
rust-version = "1.69"
+[dependencies.snarkvm]
+workspace = true
+
[dependencies.leo-errors]
path = "../../errors"
version = "=1.10.0"
@@ -42,7 +45,7 @@ version = "1.0"
features = [ "preserve_order" ]
[dependencies.smallvec]
-version = "1.11.2"
+version = "1.12.0"
features = [ "serde" ]
[dev-dependencies.criterion]
diff --git a/compiler/ast/src/common/identifier.rs b/compiler/ast/src/common/identifier.rs
index 59ec2482e4..b798677a2f 100644
--- a/compiler/ast/src/common/identifier.rs
+++ b/compiler/ast/src/common/identifier.rs
@@ -16,6 +16,7 @@
use leo_errors::Result;
use leo_span::{Span, Symbol};
+use snarkvm::console::program::Identifier as IdentifierCore;
use crate::{simple_node_impl, Node, NodeID};
use serde::{
@@ -28,6 +29,7 @@ use serde::{
Serialize,
Serializer,
};
+use snarkvm::prelude::Network;
use std::{
collections::BTreeMap,
fmt,
@@ -152,3 +154,8 @@ impl<'de> Deserialize<'de> for Identifier {
deserializer.deserialize_str(IdentifierVisitor)
}
}
+impl From<&IdentifierCore> for Identifier {
+ fn from(id: &IdentifierCore) -> Self {
+ Self { name: Symbol::intern(&id.to_string()), span: Default::default(), id: Default::default() }
+ }
+}
diff --git a/compiler/ast/src/functions/finalize.rs b/compiler/ast/src/functions/finalize.rs
index fbc0b31173..e792467a15 100644
--- a/compiler/ast/src/functions/finalize.rs
+++ b/compiler/ast/src/functions/finalize.rs
@@ -14,7 +14,7 @@
// You should have received a copy of the GNU General Public License
// along with the Leo library. If not, see for Finalize {
+ fn from(finalize_stub: FinalizeStub) -> Self {
+ Self::new(
+ finalize_stub.identifier,
+ finalize_stub.input,
+ finalize_stub.output,
+ Block::default(),
+ finalize_stub.span,
+ finalize_stub.id,
+ )
+ }
+}
+
crate::simple_node_impl!(Finalize);
diff --git a/compiler/ast/src/functions/mod.rs b/compiler/ast/src/functions/mod.rs
index a122ac480f..26ae6c1975 100644
--- a/compiler/ast/src/functions/mod.rs
+++ b/compiler/ast/src/functions/mod.rs
@@ -38,7 +38,7 @@ pub use output::*;
pub mod mode;
pub use mode::*;
-use crate::{Block, Identifier, Node, NodeID, TupleType, Type};
+use crate::{Block, FunctionStub, Identifier, Node, NodeID, TupleType, Type};
use leo_span::{Span, Symbol};
use serde::{Deserialize, Serialize};
@@ -139,6 +139,24 @@ impl Function {
}
}
+impl From for Function {
+ fn from(function: FunctionStub) -> Self {
+ let finalize = function.finalize_stub.map(Finalize::from);
+ Self {
+ annotations: function.annotations,
+ variant: function.variant,
+ identifier: function.identifier,
+ input: function.input,
+ output: function.output,
+ output_type: function.output_type,
+ block: Block::default(),
+ finalize,
+ span: function.span,
+ id: function.id,
+ }
+ }
+}
+
impl fmt::Debug for Function {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
self.format(f)
diff --git a/compiler/ast/src/input/definition.rs b/compiler/ast/src/input/definition.rs
deleted file mode 100644
index fc8a683de9..0000000000
--- a/compiler/ast/src/input/definition.rs
+++ /dev/null
@@ -1,29 +0,0 @@
-// Copyright (C) 2019-2023 Aleo Systems Inc.
-// This file is part of the Leo library.
-
-// The Leo library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-
-// The Leo library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with the Leo library. If not, see : = ;`
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub struct Definition {
- pub mode: Mode,
- pub type_: Type,
- pub name: Identifier,
- pub value: Expression,
- pub span: Span,
-}
diff --git a/compiler/ast/src/input/input_ast.rs b/compiler/ast/src/input/input_ast.rs
deleted file mode 100644
index 1329dab746..0000000000
--- a/compiler/ast/src/input/input_ast.rs
+++ /dev/null
@@ -1,108 +0,0 @@
-// Copyright (C) 2019-2023 Aleo Systems Inc.
-// This file is part of the Leo library.
-
-// The Leo library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-
-// The Leo library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with the Leo library. If not, see {
- Ok(serde_json::to_string_pretty(&self).map_err(|e| AstError::failed_to_convert_ast_to_json_string(&e))?)
- }
-}
-
-/// A raw unprocessed input or state file data. Used for future conversion
-/// into [`ProgramInput`].
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct InputAst {
- pub sections: Vec,
-}
-
-impl InputAst {
- /// Returns all values of the input AST for execution with `leo run`.
- pub fn program_inputs(&self, program_name: &str, structs: IndexMap) -> Vec {
- self.sections
- .iter()
- .filter(|section| section.name() == program_name)
- .flat_map(|section| {
- section.definitions.iter().map(|definition| match &definition.type_ {
- // Handle case where the input may be record.
- Type::Identifier(identifier) => {
- match structs.get(&identifier.name) {
- // TODO: Better error handling.
- None => panic!(
- "Input error: A struct or record declaration does not exist for {}.",
- identifier.name
- ),
- Some(struct_) => match struct_.is_record {
- false => definition.value.to_string(),
- true => match &definition.value {
- // Print out the record interface with visibility.
- Expression::Struct(struct_expression) => struct_expression.to_record_string(),
- _ => panic!("Input error: Expected a struct expression."),
- },
- },
- }
- }
- _ => definition.value.to_string(),
- })
- })
- .collect::>()
- }
-
- /// Serializes the `Input` into a JSON Value.
- pub fn to_json_value(&self) -> Result {
- Ok(serde_json::to_value(self).map_err(|e| AstError::failed_to_convert_ast_to_json_value(&e))?)
- }
-
- /// Serializes the input into a JSON file.
- pub fn to_json_file(&self, mut path: std::path::PathBuf, file_name: &str) -> Result<()> {
- path.push(file_name);
- let file = std::fs::File::create(&path).map_err(|e| AstError::failed_to_create_ast_json_file(&path, &e))?;
- let writer = std::io::BufWriter::new(file);
- Ok(serde_json::to_writer_pretty(writer, &self)
- .map_err(|e| AstError::failed_to_write_ast_to_json_file(&path, &e))?)
- }
-
- /// Serializes the `Input` into a JSON value and removes keys from object mappings before writing to a file.
- pub fn to_json_file_without_keys(
- &self,
- mut path: std::path::PathBuf,
- file_name: &str,
- excluded_keys: &[&str],
- ) -> Result<()> {
- path.push(file_name);
- let file = std::fs::File::create(&path).map_err(|e| AstError::failed_to_create_ast_json_file(&path, &e))?;
- let writer = std::io::BufWriter::new(file);
-
- let mut value = self.to_json_value().unwrap();
- for key in excluded_keys {
- value = remove_key_from_json(value, key);
- }
- value = normalize_json_value(value);
-
- Ok(serde_json::to_writer_pretty(writer, &value)
- .map_err(|e| AstError::failed_to_write_ast_to_json_file(&path, &e))?)
- }
-}
diff --git a/compiler/ast/src/input/input_value.rs b/compiler/ast/src/input/input_value.rs
deleted file mode 100644
index 8b89efefce..0000000000
--- a/compiler/ast/src/input/input_value.rs
+++ /dev/null
@@ -1,71 +0,0 @@
-// Copyright (C) 2019-2023 Aleo Systems Inc.
-// This file is part of the Leo library.
-
-// The Leo library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-
-// The Leo library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with the Leo library. If not, see {
- Ok(match value {
- (type_, Expression::Literal(lit)) => match (type_, lit) {
- (Type::Address, Literal::Address(value, _, _)) => Self::Address(value),
- (Type::Boolean, Literal::Boolean(value, _, _)) => Self::Boolean(value),
- (Type::Field, Literal::Field(value, _, _)) => Self::Field(value),
- (Type::Group, Literal::Group(value)) => Self::Group(*value),
- (Type::Integer(expected), Literal::Integer(actual, value, span, _)) => {
- if expected == actual {
- Self::Integer(expected, value)
- } else {
- return Err(InputError::unexpected_type(expected.to_string(), actual, span).into());
- }
- }
- (x, y) => {
- return Err(InputError::unexpected_type(x, &y, y.span()).into());
- }
- },
- (type_, Expression::Unary(unary)) if unary.op == UnaryOperation::Negate => {
- InputValue::try_from((type_, *unary.receiver))?
- }
- (_type_, expr) => return Err(InputError::illegal_expression(&expr, expr.span()).into()),
- })
- }
-}
-
-impl fmt::Display for InputValue {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- match self {
- InputValue::Address(ref address) => write!(f, "{address}"),
- InputValue::Boolean(ref boolean) => write!(f, "{boolean}"),
- InputValue::Group(ref group) => write!(f, "{group}"),
- InputValue::Field(ref field) => write!(f, "{field}"),
- InputValue::Integer(ref type_, ref number) => write!(f, "{number}{type_:?}"),
- }
- }
-}
diff --git a/compiler/ast/src/input/program_input.rs b/compiler/ast/src/input/program_input.rs
deleted file mode 100644
index 0490bfe6f7..0000000000
--- a/compiler/ast/src/input/program_input.rs
+++ /dev/null
@@ -1,44 +0,0 @@
-// Copyright (C) 2019-2023 Aleo Systems Inc.
-// This file is part of the Leo library.
-
-// The Leo library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-
-// The Leo library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with the Leo library. If not, see for ProgramInput {
- type Error = LeoError;
-
- fn try_from(input: InputAst) -> Result {
- let mut main = IndexMap::new();
-
- for section in input.sections {
- let target = match section.name {
- sym::main => &mut main,
- _ => return Err(InputError::unexpected_section(&["main"], section.name, section.span).into()),
- };
-
- for definition in section.definitions {
- target.insert(definition.name.name, InputValue::try_from((definition.type_, definition.value))?);
- }
- }
-
- Ok(ProgramInput { main })
- }
-}
diff --git a/compiler/ast/src/input/section.rs b/compiler/ast/src/input/section.rs
deleted file mode 100644
index b0530e4953..0000000000
--- a/compiler/ast/src/input/section.rs
+++ /dev/null
@@ -1,32 +0,0 @@
-// Copyright (C) 2019-2023 Aleo Systems Inc.
-// This file is part of the Leo library.
-
-// The Leo library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-
-// The Leo library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with the Leo library. If not, see ,
- pub span: Span,
-}
-
-impl Section {
- pub fn name(&self) -> String {
- self.name.to_string()
- }
-}
diff --git a/compiler/ast/src/lib.rs b/compiler/ast/src/lib.rs
index 62d95ced40..19ef53784a 100644
--- a/compiler/ast/src/lib.rs
+++ b/compiler/ast/src/lib.rs
@@ -40,9 +40,6 @@ pub use self::functions::*;
pub mod groups;
pub use self::groups::*;
-pub mod input;
-pub use self::input::*;
-
pub mod mapping;
pub use self::mapping::*;
@@ -59,6 +56,10 @@ pub mod types;
pub use self::types::*;
pub mod value;
+
+pub mod stub;
+pub use self::stub::*;
+
pub use self::value::*;
pub use common::node::*;
diff --git a/compiler/ast/src/mapping/mod.rs b/compiler/ast/src/mapping/mod.rs
index 6ca05fac57..e5875ccccc 100644
--- a/compiler/ast/src/mapping/mod.rs
+++ b/compiler/ast/src/mapping/mod.rs
@@ -19,6 +19,7 @@ use crate::{Identifier, Node, NodeID, Type};
use leo_span::Span;
use serde::{Deserialize, Serialize};
+use snarkvm::prelude::{Mapping as MappingCore, Network};
use std::fmt;
/// A mapping declaration, e.g `mapping balances: address => u128`.
@@ -36,6 +37,17 @@ pub struct Mapping {
pub id: NodeID,
}
+impl From<&MappingCore> for Mapping {
+ fn from(mapping: &MappingCore) -> Self {
+ Self {
+ identifier: Identifier::from(mapping.name()),
+ key_type: Type::from(mapping.key().plaintext_type()),
+ value_type: Type::from(mapping.value().plaintext_type()),
+ span: Default::default(),
+ id: Default::default(),
+ }
+ }
+}
impl fmt::Display for Mapping {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "mapping {}: {} => {}", self.identifier, self.key_type, self.value_type)
diff --git a/compiler/ast/src/passes/reconstructor.rs b/compiler/ast/src/passes/reconstructor.rs
index 793df279b9..8e6b9149cb 100644
--- a/compiler/ast/src/passes/reconstructor.rs
+++ b/compiler/ast/src/passes/reconstructor.rs
@@ -417,6 +417,7 @@ pub trait ProgramReconstructor: StatementReconstructor {
.into_iter()
.map(|(id, import)| (id, (self.reconstruct_import(import.0), import.1)))
.collect(),
+ stubs: input.stubs.into_iter().map(|(id, stub)| (id, self.reconstruct_stub(stub))).collect(),
program_scopes: input
.program_scopes
.into_iter()
@@ -425,6 +426,18 @@ pub trait ProgramReconstructor: StatementReconstructor {
}
}
+ fn reconstruct_stub(&mut self, input: Stub) -> Stub {
+ Stub {
+ imports: input.imports,
+ stub_id: input.stub_id,
+ consts: input.consts,
+ structs: input.structs,
+ mappings: input.mappings,
+ span: input.span,
+ functions: input.functions.into_iter().map(|(i, f)| (i, self.reconstruct_function_stub(f))).collect(),
+ }
+ }
+
fn reconstruct_program_scope(&mut self, input: ProgramScope) -> ProgramScope {
ProgramScope {
program_id: input.program_id,
@@ -466,6 +479,10 @@ pub trait ProgramReconstructor: StatementReconstructor {
}
}
+ fn reconstruct_function_stub(&mut self, input: FunctionStub) -> FunctionStub {
+ input
+ }
+
fn reconstruct_struct(&mut self, input: Struct) -> Struct {
input
}
diff --git a/compiler/ast/src/passes/visitor.rs b/compiler/ast/src/passes/visitor.rs
index dbcefea609..b2c16d6648 100644
--- a/compiler/ast/src/passes/visitor.rs
+++ b/compiler/ast/src/passes/visitor.rs
@@ -222,7 +222,7 @@ pub trait StatementVisitor<'a>: ExpressionVisitor<'a> {
pub trait ProgramVisitor<'a>: StatementVisitor<'a> {
fn visit_program(&mut self, input: &'a Program) {
input.imports.values().for_each(|import| self.visit_import(&import.0));
-
+ input.stubs.values().for_each(|stub| self.visit_stub(stub));
input.program_scopes.values().for_each(|scope| self.visit_program_scope(scope));
}
@@ -236,6 +236,8 @@ pub trait ProgramVisitor<'a>: StatementVisitor<'a> {
input.consts.iter().for_each(|(_, c)| (self.visit_const(c)));
}
+ fn visit_stub(&mut self, _input: &'a Stub) {}
+
fn visit_import(&mut self, input: &'a Program) {
self.visit_program(input)
}
@@ -250,4 +252,8 @@ pub trait ProgramVisitor<'a>: StatementVisitor<'a> {
self.visit_block(&finalize.block);
}
}
+
+ fn visit_function_stub(&mut self, _input: &'a FunctionStub) {}
+
+ fn visit_struct_stub(&mut self, _input: &'a Struct) {}
}
diff --git a/compiler/ast/src/program/mod.rs b/compiler/ast/src/program/mod.rs
index 0d6bc76de0..16973cba18 100644
--- a/compiler/ast/src/program/mod.rs
+++ b/compiler/ast/src/program/mod.rs
@@ -24,6 +24,7 @@ pub use program_scope::*;
use leo_span::{Span, Symbol};
+use crate::Stub;
use indexmap::IndexMap;
use serde::{Deserialize, Serialize};
use std::fmt;
@@ -33,6 +34,8 @@ use std::fmt;
pub struct Program {
/// A map from import names to import definitions.
pub imports: IndexMap,
+ /// A map from program stub names to program stub scopes.
+ pub stubs: IndexMap,
/// A map from program names to program scopes.
pub program_scopes: IndexMap,
}
@@ -42,6 +45,10 @@ impl fmt::Display for Program {
for (id, _import) in self.imports.iter() {
writeln!(f, "import {id}.leo;")?;
}
+ for (_, stub) in self.stubs.iter() {
+ stub.fmt(f)?;
+ writeln!(f,)?;
+ }
for (_, program_scope) in self.program_scopes.iter() {
program_scope.fmt(f)?;
writeln!(f,)?;
@@ -53,6 +60,6 @@ impl fmt::Display for Program {
impl Default for Program {
/// Constructs an empty program node.
fn default() -> Self {
- Self { imports: IndexMap::new(), program_scopes: IndexMap::new() }
+ Self { imports: IndexMap::new(), stubs: IndexMap::new(), program_scopes: IndexMap::new() }
}
}
diff --git a/compiler/ast/src/program/program_id.rs b/compiler/ast/src/program/program_id.rs
index 77f36c9010..3d284e5cca 100644
--- a/compiler/ast/src/program/program_id.rs
+++ b/compiler/ast/src/program/program_id.rs
@@ -18,6 +18,7 @@ use crate::Identifier;
use core::fmt;
use serde::{de, de::Visitor, Deserialize, Deserializer, Serialize, Serializer};
+use snarkvm::{console::program::ProgramID, prelude::Network};
use std::collections::BTreeMap;
/// An identifier for a program that is eventually deployed to the network.
@@ -92,3 +93,9 @@ impl<'de> Deserialize<'de> for ProgramId {
deserializer.deserialize_str(ProgramIdVisitor)
}
}
+
+impl From<&ProgramID> for ProgramId {
+ fn from(program: &ProgramID) -> Self {
+ Self { name: Identifier::from(program.name()), network: Identifier::from(program.network()) }
+ }
+}
diff --git a/compiler/ast/src/program/program_scope.rs b/compiler/ast/src/program/program_scope.rs
index 1a70e60b3c..9ad8c54579 100644
--- a/compiler/ast/src/program/program_scope.rs
+++ b/compiler/ast/src/program/program_scope.rs
@@ -16,7 +16,7 @@
//! A Leo program scope consists of struct, function, and mapping definitions.
-use crate::{ConstDeclaration, Function, Mapping, ProgramId, Struct};
+use crate::{ConstDeclaration, Function, Mapping, ProgramId, Struct, Stub};
use leo_span::{Span, Symbol};
use serde::{Deserialize, Serialize};
@@ -39,6 +39,23 @@ pub struct ProgramScope {
pub span: Span,
}
+impl From for ProgramScope {
+ fn from(stub: Stub) -> Self {
+ Self {
+ program_id: stub.stub_id,
+ consts: stub.consts,
+ structs: stub.structs,
+ mappings: stub.mappings,
+ functions: stub
+ .functions
+ .into_iter()
+ .map(|(symbol, function)| (symbol, Function::from(function)))
+ .collect(),
+ span: stub.span,
+ }
+ }
+}
+
impl fmt::Display for ProgramScope {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
writeln!(f, "program {} {{", self.program_id)?;
diff --git a/compiler/ast/src/statement/block.rs b/compiler/ast/src/statement/block.rs
index e57f5821d9..cd034dbc6f 100644
--- a/compiler/ast/src/statement/block.rs
+++ b/compiler/ast/src/statement/block.rs
@@ -21,7 +21,7 @@ use serde::{Deserialize, Serialize};
use std::fmt;
/// A block `{ [stmt]* }` consisting of a list of statements to execute in order.
-#[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Debug)]
+#[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Debug, Default)]
pub struct Block {
/// The list of statements to execute.
pub statements: Vec,
diff --git a/compiler/ast/src/struct/mod.rs b/compiler/ast/src/struct/mod.rs
index bec8684036..8a511df9d6 100644
--- a/compiler/ast/src/struct/mod.rs
+++ b/compiler/ast/src/struct/mod.rs
@@ -17,12 +17,21 @@
pub mod member;
pub use member::*;
-use crate::{Identifier, Node, NodeID};
+use crate::{Identifier, Mode, Node, NodeID, Type};
use leo_span::{Span, Symbol};
+use itertools::Itertools;
use serde::{Deserialize, Serialize};
use std::fmt;
+use snarkvm::{
+ console::program::{RecordType, StructType},
+ prelude::{
+ EntryType::{Constant, Private, Public},
+ Network,
+ },
+};
+
/// A struct type definition, e.g., `struct Foo { my_field: Bar }`.
/// In some languages these are called `struct`s.
///
@@ -70,10 +79,68 @@ impl fmt::Display for Struct {
f.write_str(if self.is_record { "record" } else { "struct" })?;
writeln!(f, " {} {{ ", self.identifier)?;
for field in self.members.iter() {
- writeln!(f, " {field}")?;
+ writeln!(f, " {field}")?;
}
- write!(f, "}}")
+ write!(f, " }}")
}
}
crate::simple_node_impl!(Struct);
+
+impl From<&StructType> for Struct {
+ fn from(input: &StructType) -> Self {
+ Self {
+ identifier: Identifier::from(input.name()),
+ members: input
+ .members()
+ .iter()
+ .map(|(id, type_)| Member {
+ mode: Mode::None,
+ identifier: Identifier::from(id),
+ type_: Type::from(type_),
+ span: Default::default(),
+ id: Default::default(),
+ })
+ .collect(),
+ is_record: false,
+ span: Default::default(),
+ id: Default::default(),
+ }
+ }
+}
+
+impl From<&RecordType> for Struct {
+ fn from(input: &RecordType) -> Self {
+ Self {
+ identifier: Identifier::from(input.name()),
+ members: [
+ vec![Member {
+ mode: if input.owner().is_private() { Mode::Public } else { Mode::Private },
+ identifier: Identifier::new(Symbol::intern("owner"), Default::default()),
+ type_: Type::Address,
+ span: Default::default(),
+ id: Default::default(),
+ }],
+ input
+ .entries()
+ .iter()
+ .map(|(id, entry)| Member {
+ mode: if input.owner().is_public() { Mode::Public } else { Mode::Private },
+ identifier: Identifier::from(id),
+ type_: match entry {
+ Public(t) => Type::from(t),
+ Private(t) => Type::from(t),
+ Constant(t) => Type::from(t),
+ },
+ span: Default::default(),
+ id: Default::default(),
+ })
+ .collect_vec(),
+ ]
+ .concat(),
+ is_record: true,
+ span: Default::default(),
+ id: Default::default(),
+ }
+ }
+}
diff --git a/compiler/ast/src/stub/finalize_stub.rs b/compiler/ast/src/stub/finalize_stub.rs
new file mode 100644
index 0000000000..9cfdcbef72
--- /dev/null
+++ b/compiler/ast/src/stub/finalize_stub.rs
@@ -0,0 +1,101 @@
+// Copyright (C) 2019-2023 Aleo Systems Inc.
+// This file is part of the Leo library.
+
+// The Leo library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// The Leo library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with the Leo library. If not, see ,
+ /// The finalize block's output type.
+ pub output_type: Type,
+ /// The entire span of the finalize stub.
+ pub span: Span,
+ /// The ID of the node.
+ pub id: NodeID,
+}
+
+impl FinalizeStub {
+ /// Create a new finalize stub.
+ pub fn new(identifier: Identifier, input: Vec, span: Span, id: NodeID) -> Self {
+ let output_type = match output.len() {
+ 0 => Type::Unit,
+ 1 => output[0].type_(),
+ _ => Type::Tuple(TupleType::new(output.iter().map(|output| output.type_()).collect())),
+ };
+
+ Self { identifier, input, output, output_type, span, id }
+ }
+}
+
+impl> From<&FinalizeCore> for FinalizeStub {
+ fn from(finalize: &FinalizeCore) -> Self {
+ let mut inputs = Vec::new();
+
+ finalize.inputs().iter().enumerate().for_each(|(index, input)| {
+ let arg_name = Identifier::new(Symbol::intern(&format!("a{}", index + 1)), Default::default());
+ match input.finalize_type() {
+ Plaintext(val) => inputs.push(Input::Internal(FunctionInput {
+ identifier: arg_name,
+ mode: Mode::None,
+ type_: Type::from(val),
+ span: Default::default(),
+ id: Default::default(),
+ })),
+ Future(_) => {} // Don't need to worry about nested futures
+ }
+ });
+
+ Self::new(Identifier::from(finalize.name()), inputs, Vec::new(), Default::default(), Default::default())
+ }
+}
+
+impl From for FinalizeStub {
+ fn from(finalize: Finalize) -> Self {
+ Self::new(finalize.identifier, finalize.input, finalize.output, Default::default(), Default::default())
+ }
+}
+
+impl fmt::Display for FinalizeStub {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ let parameters = self.input.iter().map(|x| x.to_string()).collect::>().join(",");
+ let returns = match self.output.len() {
+ 0 => "()".to_string(),
+ 1 => self.output[0].to_string(),
+ _ => format!("({})", self.output.iter().map(|x| x.to_string()).collect::>().join(",")),
+ };
+ write!(f, " finalize {}({parameters}) -> {returns}", self.identifier)
+ }
+}
+
+crate::simple_node_impl!(FinalizeStub);
diff --git a/compiler/ast/src/stub/function_stub.rs b/compiler/ast/src/stub/function_stub.rs
new file mode 100644
index 0000000000..aced6ce9e0
--- /dev/null
+++ b/compiler/ast/src/stub/function_stub.rs
@@ -0,0 +1,349 @@
+// Copyright (C) 2019-2023 Aleo Systems Inc.
+// This file is part of the Leo library.
+
+// The Leo library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// The Leo library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with the Leo library. If not, see ,
+ /// Is this function a transition, inlined, or a regular function?.
+ pub variant: Variant,
+ /// The function identifier, e.g., `foo` in `function foo(...) { ... }`.
+ pub identifier: Identifier,
+ /// The function's input parameters.
+ pub input: Vec,
+ /// The function's output type.
+ pub output_type: Type,
+ /// An optional finalize stub
+ pub finalize_stub: Option,
+ /// The entire span of the function definition.
+ pub span: Span,
+ /// The ID of the node.
+ pub id: NodeID,
+}
+
+impl PartialEq for FunctionStub {
+ fn eq(&self, other: &Self) -> bool {
+ self.identifier == other.identifier
+ }
+}
+
+impl Eq for FunctionStub {}
+
+impl FunctionStub {
+ /// Initialize a new function.
+ #[allow(clippy::too_many_arguments)]
+ pub fn new(
+ annotations: Vec,
+ variant: Variant,
+ identifier: Identifier,
+ input: Vec,
+ finalize_stub: Option,
+ span: Span,
+ id: NodeID,
+ ) -> Self {
+ // Determine the output type of the function
+ let get_output_type = |output: &Output| match &output {
+ Output::Internal(output) => output.type_.clone(),
+ Output::External(output) => output.type_(),
+ };
+
+ let output_type = match output.len() {
+ 0 => Type::Unit,
+ 1 => get_output_type(&output[0]),
+ _ => Type::Tuple(TupleType::new(output.iter().map(get_output_type).collect())),
+ };
+
+ FunctionStub { annotations, variant, identifier, input, output, output_type, finalize_stub, span, id }
+ }
+
+ /// Returns function name.
+ pub fn name(&self) -> Symbol {
+ self.identifier.name
+ }
+
+ /// Returns `true` if the function name is `main`.
+ pub fn is_main(&self) -> bool {
+ self.name() == sym::main
+ }
+
+ ///
+ /// Private formatting method used for optimizing [fmt::Debug] and [fmt::Display] implementations.
+ ///
+ fn format(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ match self.variant {
+ Variant::Inline => write!(f, "inline ")?,
+ Variant::Standard => write!(f, "function ")?,
+ Variant::Transition => write!(f, "transition ")?,
+ }
+ write!(f, "{}", self.identifier)?;
+
+ let parameters = self.input.iter().map(|x| x.to_string()).collect::>().join(",");
+ let returns = match self.output.len() {
+ 0 => "()".to_string(),
+ 1 => self.output[0].to_string(),
+ _ => self.output.iter().map(|x| x.to_string()).collect::>().join(","),
+ };
+ write!(f, "({parameters}) -> {returns}")?;
+
+ if let Some(finalize) = &self.finalize_stub {
+ let parameters = finalize.input.iter().map(|x| x.to_string()).collect::>().join(",");
+ write!(f, " finalize ({parameters})")
+ } else {
+ Ok(())
+ }
+ }
+}
+
+impl From for FunctionStub {
+ fn from(function: Function) -> Self {
+ Self {
+ annotations: function.annotations,
+ variant: function.variant,
+ identifier: function.identifier,
+ input: function.input,
+ output: function.output,
+ output_type: function.output_type,
+ finalize_stub: function.finalize.map(FinalizeStub::from),
+ span: function.span,
+ id: function.id,
+ }
+ }
+}
+
+impl> From<&ClosureCore> for FunctionStub {
+ fn from(closure: &ClosureCore) -> Self {
+ let outputs = closure
+ .outputs()
+ .iter()
+ .map(|output| match output.register_type() {
+ Plaintext(val) => Output::Internal(FunctionOutput {
+ mode: Mode::None,
+ type_: Type::from(val),
+ span: Default::default(),
+ id: Default::default(),
+ }),
+ Record(_) => panic!("Closures do not return records"),
+ ExternalRecord(_) => panic!("Closures do not return external records"),
+ Future(_) => panic!("Closures do not return futures"),
+ })
+ .collect_vec();
+ let output_vec = outputs
+ .iter()
+ .map(|output| match output {
+ Output::Internal(output) => output.type_.clone(),
+ Output::External(_) => panic!("Closures do not return external records"),
+ })
+ .collect_vec();
+ let output_type = match output_vec.len() {
+ 0 => Type::Unit,
+ 1 => output_vec[0].clone(),
+ _ => Type::Tuple(TupleType::new(output_vec)),
+ };
+ Self {
+ annotations: Vec::new(),
+ variant: Variant::Standard,
+ identifier: Identifier::from(closure.name()),
+ input: closure
+ .inputs()
+ .iter()
+ .enumerate()
+ .map(|(index, input)| {
+ let arg_name = Identifier::new(Symbol::intern(&format!("a{}", index + 1)), Default::default());
+ match input.register_type() {
+ Plaintext(val) => Input::Internal(FunctionInput {
+ identifier: arg_name,
+ mode: Mode::None,
+ type_: Type::from(val),
+ span: Default::default(),
+ id: Default::default(),
+ }),
+ Record(_) => panic!("Closures do not contain records as inputs"),
+ ExternalRecord(_) => panic!("Closures do not contain external records as inputs"),
+ Future(_) => panic!("Closures do not contain futures as inputs"),
+ }
+ })
+ .collect_vec(),
+ output: outputs,
+ output_type,
+ span: Default::default(),
+ id: Default::default(),
+ finalize_stub: None,
+ }
+ }
+}
+
+impl, Command: CommandTrait>
+ From<&FunctionCore> for FunctionStub
+{
+ fn from(function: &FunctionCore) -> Self {
+ let outputs = function
+ .outputs()
+ .iter()
+ .map(|output| match output.value_type() {
+ ValueType::Constant(val) => vec![Output::Internal(FunctionOutput {
+ mode: Mode::Constant,
+ type_: Type::from(val),
+ span: Default::default(),
+ id: Default::default(),
+ })],
+ ValueType::Public(val) => vec![Output::Internal(FunctionOutput {
+ mode: Mode::Public,
+ type_: Type::from(val),
+ span: Default::default(),
+ id: Default::default(),
+ })],
+ ValueType::Private(val) => vec![Output::Internal(FunctionOutput {
+ mode: Mode::Private,
+ type_: Type::from(val),
+ span: Default::default(),
+ id: Default::default(),
+ })],
+ ValueType::Record(id) => vec![Output::Internal(FunctionOutput {
+ mode: Mode::None,
+ type_: IdentifierType(Identifier::from(id)),
+ span: Default::default(),
+ id: Default::default(),
+ })],
+ ValueType::ExternalRecord(loc) => vec![Output::External(External {
+ identifier: Identifier::new(Symbol::intern("dummy"), Default::default()),
+ program_name: ProgramId::from(loc.program_id()).name,
+ record: Identifier::from(loc.resource()),
+ span: Default::default(),
+ id: Default::default(),
+ })],
+ ValueType::Future(_) => Vec::new(), // Don't include futures in the output signature
+ })
+ .collect_vec()
+ .concat();
+ let output_vec = outputs
+ .iter()
+ .map(|output| match output {
+ Output::Internal(output) => output.type_.clone(),
+ Output::External(output) => Type::Identifier(output.record),
+ })
+ .collect_vec();
+ let output_type = match output_vec.len() {
+ 0 => Type::Unit,
+ 1 => output_vec[0].clone(),
+ _ => Type::Tuple(TupleType::new(output_vec)),
+ };
+
+ Self {
+ annotations: Vec::new(),
+ variant: Variant::Transition,
+ identifier: Identifier::from(function.name()),
+ input: function
+ .inputs()
+ .iter()
+ .enumerate()
+ .map(|(index, input)| {
+ let arg_name = Identifier::new(Symbol::intern(&format!("a{}", index + 1)), Default::default());
+ match input.value_type() {
+ ValueType::Constant(val) => Input::Internal(FunctionInput {
+ identifier: arg_name,
+ mode: Mode::Constant,
+ type_: Type::from(val),
+ span: Default::default(),
+ id: Default::default(),
+ }),
+ ValueType::Public(val) => Input::Internal(FunctionInput {
+ identifier: arg_name,
+ mode: Mode::Public,
+ type_: Type::from(val),
+ span: Default::default(),
+ id: Default::default(),
+ }),
+ ValueType::Private(val) => Input::Internal(FunctionInput {
+ identifier: arg_name,
+ mode: Mode::Private,
+ type_: Type::from(val),
+ span: Default::default(),
+ id: Default::default(),
+ }),
+ ValueType::Record(id) => Input::Internal(FunctionInput {
+ identifier: arg_name,
+ mode: Mode::None,
+ type_: IdentifierType(Identifier::from(id)),
+ span: Default::default(),
+ id: Default::default(),
+ }),
+ ValueType::ExternalRecord(loc) => Input::External(External {
+ identifier: Identifier::new(Symbol::intern("dummy"), Default::default()),
+ program_name: ProgramId::from(loc.program_id()).name,
+ record: Identifier::from(loc.resource()),
+ span: Default::default(),
+ id: Default::default(),
+ }),
+ ValueType::Future(_) => panic!("Functions do not contain futures as inputs"),
+ }
+ })
+ .collect_vec(),
+ output: outputs,
+ output_type,
+ finalize_stub: function.finalize_logic().map(FinalizeStub::from),
+ span: Default::default(),
+ id: Default::default(),
+ }
+ }
+}
+
+impl fmt::Debug for FunctionStub {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ self.format(f)
+ }
+}
+
+impl fmt::Display for FunctionStub {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ self.format(f)
+ }
+}
+
+crate::simple_node_impl!(FunctionStub);
diff --git a/compiler/ast/src/stub/mod.rs b/compiler/ast/src/stub/mod.rs
new file mode 100644
index 0000000000..0b37ac5777
--- /dev/null
+++ b/compiler/ast/src/stub/mod.rs
@@ -0,0 +1,84 @@
+// Copyright (C) 2019-2023 Aleo Systems Inc.
+// This file is part of the Leo library.
+
+// The Leo library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// The Leo library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with the Leo library. If not, see ,
+ /// The stub id
+ pub stub_id: ProgramId,
+ /// A vector of const definitions.
+ pub consts: Vec<(Symbol, ConstDeclaration)>,
+ /// A vector of struct definitions.
+ pub structs: Vec<(Symbol, Struct)>,
+ /// A vector of mapping definitions.
+ pub mappings: Vec<(Symbol, Mapping)>,
+ /// A vector of function stub definitions.
+ pub functions: Vec<(Symbol, FunctionStub)>,
+ /// The span associated with the stub.
+ pub span: Span,
+}
+
+impl Default for Stub {
+ /// Constructs an empty program stub
+ fn default() -> Self {
+ Self {
+ imports: Vec::new(),
+ stub_id: ProgramId {
+ name: Identifier::new(Symbol::intern(""), NodeID::default()),
+ network: Identifier::new(Symbol::intern(""), NodeID::default()),
+ },
+ consts: Vec::new(),
+ structs: Vec::new(),
+ mappings: Vec::new(),
+ functions: Vec::new(),
+ span: Span::default(),
+ }
+ }
+}
+
+impl fmt::Display for Stub {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ writeln!(f, "stub {} {{", self.stub_id)?;
+ for import in self.imports.iter() {
+ writeln!(f, " import {import}")?;
+ }
+ for (_, mapping) in self.mappings.iter() {
+ writeln!(f, " {mapping}")?;
+ }
+ for (_, struct_) in self.structs.iter() {
+ writeln!(f, " {struct_}")?;
+ }
+ for (_, function) in self.functions.iter() {
+ writeln!(f, " {function}")?;
+ }
+ writeln!(f, "}}")?;
+ Ok(())
+ }
+}
diff --git a/compiler/ast/src/types/array.rs b/compiler/ast/src/types/array.rs
index 032b3a8e7f..c2427a6ddd 100644
--- a/compiler/ast/src/types/array.rs
+++ b/compiler/ast/src/types/array.rs
@@ -15,8 +15,10 @@
// along with the Leo library. If not, see From<&ConsoleArrayType> for ArrayType {
+ fn from(array_type: &ConsoleArrayType) -> Self {
+ Self {
+ element_type: Box::new(Type::from(array_type.next_element_type())),
+ length: NonNegativeNumber::from(array_type.length().to_string().replace("u32", "")),
+ }
+ }
+}
+
impl fmt::Display for ArrayType {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "[{}; {}]", self.element_type, self.length)
diff --git a/compiler/ast/src/types/type_.rs b/compiler/ast/src/types/type_.rs
index 928a80df78..8849e6da75 100644
--- a/compiler/ast/src/types/type_.rs
+++ b/compiler/ast/src/types/type_.rs
@@ -14,10 +14,15 @@
// You should have received a copy of the GNU General Public License
// along with the Leo library. If not, see From<&PlaintextType> for Type {
+ fn from(t: &PlaintextType) -> Self {
+ match t {
+ Literal(lit) => match lit {
+ snarkvm::prelude::LiteralType::Address => Type::Address,
+ snarkvm::prelude::LiteralType::Boolean => Type::Boolean,
+ snarkvm::prelude::LiteralType::Field => Type::Field,
+ snarkvm::prelude::LiteralType::Group => Type::Group,
+ snarkvm::prelude::LiteralType::U8 => Type::Integer(IntegerType::U8),
+ snarkvm::prelude::LiteralType::U16 => Type::Integer(IntegerType::U16),
+ snarkvm::prelude::LiteralType::U32 => Type::Integer(IntegerType::U32),
+ snarkvm::prelude::LiteralType::U64 => Type::Integer(IntegerType::U64),
+ snarkvm::prelude::LiteralType::U128 => Type::Integer(IntegerType::U128),
+ snarkvm::prelude::LiteralType::I8 => Type::Integer(IntegerType::I8),
+ snarkvm::prelude::LiteralType::I16 => Type::Integer(IntegerType::I16),
+ snarkvm::prelude::LiteralType::I32 => Type::Integer(IntegerType::I32),
+ snarkvm::prelude::LiteralType::I64 => Type::Integer(IntegerType::I64),
+ snarkvm::prelude::LiteralType::I128 => Type::Integer(IntegerType::I128),
+ snarkvm::prelude::LiteralType::Scalar => Type::Scalar,
+ snarkvm::prelude::LiteralType::Signature => Type::Signature,
+ snarkvm::prelude::LiteralType::String => Type::String,
+ },
+ Struct(s) => Type::Identifier(common::Identifier::from(s)),
+ Array(array) => Type::Array(ArrayType::from(array)),
+ }
+ }
+}
diff --git a/compiler/compiler/Cargo.toml b/compiler/compiler/Cargo.toml
index 4c90527700..fa8d357d69 100644
--- a/compiler/compiler/Cargo.toml
+++ b/compiler/compiler/Cargo.toml
@@ -41,6 +41,10 @@ version = "=1.10.0"
[dependencies.sha2]
version = "0.10"
+[dependencies.indexmap]
+version = "1.9"
+features = []
+
[dev-dependencies.leo-test-framework]
path = "../../tests/test-framework"
@@ -61,7 +65,7 @@ workspace = true
version = "1.10.2"
[dev-dependencies.serde]
-version = "1.0.194"
+version = "1.0.195"
features = [ "derive" ]
[dev-dependencies.serde_yaml]
@@ -72,4 +76,4 @@ version = "3.9"
[features]
default = [ ]
-ci_skip = [ "leo-ast/ci_skip" ]
+ci_skip = [ "leo-ast/ci_skip" ]
\ No newline at end of file
diff --git a/compiler/compiler/src/compiler.rs b/compiler/compiler/src/compiler.rs
index 02e9d287a0..55e0440920 100644
--- a/compiler/compiler/src/compiler.rs
+++ b/compiler/compiler/src/compiler.rs
@@ -17,17 +17,18 @@
//! The compiler for Leo programs.
//!
//! The [`Compiler`] type compiles Leo programs into R1CS circuits.
-pub use leo_ast::{Ast, InputAst};
-use leo_ast::{NodeBuilder, Program};
+pub use leo_ast::Ast;
+use leo_ast::{NodeBuilder, Program, Stub};
use leo_errors::{emitter::Handler, CompilerError, Result};
pub use leo_passes::SymbolTable;
use leo_passes::*;
-use leo_span::{source_map::FileName, symbol::with_session_globals};
+use leo_span::{source_map::FileName, symbol::with_session_globals, Symbol};
use sha2::{Digest, Sha256};
use std::{fs, path::PathBuf};
use crate::CompilerOptions;
+use indexmap::{IndexMap, IndexSet};
/// The primary entry point of the Leo compiler.
#[derive(Clone)]
@@ -44,8 +45,6 @@ pub struct Compiler<'a> {
pub network: String,
/// The AST for the program.
pub ast: Ast,
- /// The input ast for the program if it exists.
- pub input_ast: Option,
/// Options configuring compilation.
compiler_options: CompilerOptions,
/// The `NodeCounter` used to generate sequentially increasing `NodeID`s.
@@ -54,6 +53,8 @@ pub struct Compiler<'a> {
assigner: Assigner,
/// The type table.
type_table: TypeTable,
+ /// The stubs for imported programs. Produced by `Retriever` module.
+ import_stubs: IndexMap,
}
impl<'a> Compiler<'a> {
@@ -65,6 +66,7 @@ impl<'a> Compiler<'a> {
main_file_path: PathBuf,
output_directory: PathBuf,
compiler_options: Option,
+ import_stubs: IndexMap,
) -> Self {
let node_builder = NodeBuilder::default();
let assigner = Assigner::default();
@@ -76,10 +78,10 @@ impl<'a> Compiler<'a> {
program_name,
network,
ast: Ast::new(Program::default()),
- input_ast: None,
compiler_options: compiler_options.unwrap_or_default(),
node_builder,
assigner,
+ import_stubs,
type_table,
}
}
@@ -136,37 +138,6 @@ impl<'a> Compiler<'a> {
self.parse_program_from_string(&program_string, FileName::Real(self.main_file_path.clone()))
}
- /// Parses and stores the input file, constructs a syntax tree, and generates a program input.
- pub fn parse_input(&mut self, input_file_path: PathBuf) -> Result<()> {
- if input_file_path.exists() {
- // Load the input file into the source map.
- let input_sf = with_session_globals(|s| s.source_map.load_file(&input_file_path))
- .map_err(|e| CompilerError::file_read_error(&input_file_path, e))?;
-
- // Parse and serialize it.
- let input_ast =
- leo_parser::parse_input(self.handler, &self.node_builder, &input_sf.src, input_sf.start_pos)?;
- if self.compiler_options.output.initial_ast {
- // Write the input AST snapshot post parsing.
- if self.compiler_options.output.ast_spans_enabled {
- input_ast.to_json_file(
- self.output_directory.clone(),
- &format!("{}.initial_input_ast.json", self.program_name),
- )?;
- } else {
- input_ast.to_json_file_without_keys(
- self.output_directory.clone(),
- &format!("{}.initial_input_ast.json", self.program_name),
- &["span"],
- )?;
- }
- }
-
- self.input_ast = Some(input_ast);
- }
- Ok(())
- }
-
/// Runs the symbol table pass.
pub fn symbol_table_pass(&self) -> Result {
let symbol_table = SymbolTableCreator::do_pass((&self.ast, self.handler))?;
@@ -321,14 +292,16 @@ impl<'a> Compiler<'a> {
}
/// Returns a compiled Leo program.
- pub fn compile(&mut self) -> Result<(SymbolTable, String)> {
+ pub fn compile(&mut self) -> Result {
// Parse the program.
self.parse_program()?;
+ // Copy the dependencies specified in `program.json` into the AST.
+ self.add_import_stubs()?;
// Run the intermediate compiler stages.
let (symbol_table, struct_graph, call_graph) = self.compiler_stages()?;
// Run code generation.
let bytecode = self.code_generation_pass(&symbol_table, &struct_graph, &call_graph)?;
- Ok((symbol_table, bytecode))
+ Ok(bytecode)
}
/// Writes the AST to a JSON file.
@@ -361,4 +334,41 @@ impl<'a> Compiler<'a> {
}
Ok(())
}
+
+ /// Merges the dependencies defined in `program.json` with the dependencies imported in `.leo` file
+ fn add_import_stubs(&mut self) -> Result<()> {
+ // Create a list of both the explicit dependencies specified in the `.leo` file, as well as the implicit ones derived from those dependencies.
+ let (mut unexplored, mut explored): (IndexSet, IndexSet) =
+ (self.ast.ast.imports.keys().cloned().collect(), IndexSet::new());
+ while !unexplored.is_empty() {
+ let mut current_dependencies: IndexSet = IndexSet::new();
+ for program_name in unexplored.iter() {
+ if let Some(stub) = self.import_stubs.get(program_name) {
+ // Add the program to the explored set
+ explored.insert(*program_name);
+ for dependency in stub.imports.iter() {
+ // If dependency is already explored then don't need to re-explore it
+ if explored.insert(dependency.name.name) {
+ current_dependencies.insert(dependency.name.name);
+ }
+ }
+ } else {
+ return Err(CompilerError::imported_program_not_found(
+ self.program_name.clone(),
+ *program_name,
+ self.ast.ast.imports[program_name].1,
+ )
+ .into());
+ }
+ }
+
+ // Create next batch to explore
+ unexplored = current_dependencies;
+ }
+
+ // Combine the dependencies from `program.json` and `.leo` file while preserving the post-order
+ self.ast.ast.stubs =
+ self.import_stubs.clone().into_iter().filter(|(program_name, _)| explored.contains(program_name)).collect();
+ Ok(())
+ }
}
diff --git a/compiler/compiler/src/options.rs b/compiler/compiler/src/options.rs
index 0e25f739d2..693e85f9cf 100644
--- a/compiler/compiler/src/options.rs
+++ b/compiler/compiler/src/options.rs
@@ -44,8 +44,6 @@ pub struct OutputOptions {
pub ast_spans_enabled: bool,
/// If enabled writes the AST after parsing.
pub initial_ast: bool,
- /// If enabled writes the input AST after parsing.
- pub initial_input_ast: bool,
/// If enabled writes the AST after loop unrolling.
pub unrolled_ast: bool,
/// If enabled writes the AST after static single assignment.
diff --git a/compiler/compiler/tests/compile.rs b/compiler/compiler/tests/compile.rs
index 6f9c573e24..ba20f842fe 100644
--- a/compiler/compiler/tests/compile.rs
+++ b/compiler/compiler/tests/compile.rs
@@ -91,7 +91,6 @@ fn run_test(test: Test, handler: &Handler, buf: &BufferEmitter) -> Result Result(
diff --git a/compiler/parser/Cargo.toml b/compiler/parser/Cargo.toml
index 197666d585..44ea479e6b 100644
--- a/compiler/parser/Cargo.toml
+++ b/compiler/parser/Cargo.toml
@@ -48,7 +48,7 @@ version = "1.0"
features = [ "derive" ]
[dependencies.smallvec]
-version = "1.11"
+version = "1.12"
[dependencies.tracing]
version = "0.1"
diff --git a/compiler/parser/examples/input_parser.rs b/compiler/parser/examples/input_parser.rs
deleted file mode 100644
index 70c76403d9..0000000000
--- a/compiler/parser/examples/input_parser.rs
+++ /dev/null
@@ -1,70 +0,0 @@
-// Copyright (C) 2019-2023 Aleo Systems Inc.
-// This file is part of the Leo library.
-
-// The Leo library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-
-// The Leo library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with the Leo library. If not, see ,
-
- /// Whether to print result to STDOUT.
- #[clap(short, long)]
- print_stdout: bool,
-}
-
-fn main() -> Result<(), String> {
- let opt = Opt::parse();
- let input_tree = create_session_if_not_set_then(|s| {
- let input_string = s.source_map.load_file(&opt.input_path).expect("failed to open an input file");
-
- Handler::with(|handler| {
- let node_builder = NodeBuilder::default();
- let input =
- leo_parser::parse_program_inputs(handler, &node_builder, &input_string.src, input_string.start_pos)?;
- input.to_json_string()
- })
- .map_err(|e| e.to_string())
- })?;
-
- if opt.print_stdout {
- println!("{input_tree}");
- }
-
- let out_path = if let Some(out_dir) = opt.out_dir_path {
- format!("{}/{}.json", out_dir.as_path().display(), opt.input_path.file_stem().unwrap().to_str().unwrap())
- } else {
- format!("./{}.json", opt.input_path.file_stem().unwrap().to_str().unwrap())
- };
-
- fs::write(Path::new(&out_path), input_tree).expect("failed to write output");
-
- Ok(())
-}
diff --git a/compiler/parser/src/lib.rs b/compiler/parser/src/lib.rs
index f04fe69ddf..4a9470b08c 100644
--- a/compiler/parser/src/lib.rs
+++ b/compiler/parser/src/lib.rs
@@ -31,7 +31,7 @@ pub(crate) use tokenizer::*;
pub mod parser;
pub use parser::*;
-use leo_ast::{input::InputData, Ast, NodeBuilder, ProgramInput};
+use leo_ast::{Ast, NodeBuilder};
use leo_errors::{emitter::Handler, Result};
#[cfg(test)]
@@ -41,16 +41,3 @@ mod test;
pub fn parse_ast(handler: &Handler, node_builder: &NodeBuilder, source: &str, start_pos: BytePos) -> Result {
Ok(Ast::new(parser::parse(handler, node_builder, source, start_pos)?))
}
-
-/// Parses program inputs from the input file path
-pub fn parse_program_inputs(
- handler: &Handler,
- node_builder: &NodeBuilder,
- input_string: &str,
- start_pos: BytePos,
-) -> Result {
- let program_input: ProgramInput =
- parser::parse_input(handler, node_builder, input_string, start_pos)?.try_into()?;
-
- Ok(InputData { program_input })
-}
diff --git a/compiler/parser/src/parser/context.rs b/compiler/parser/src/parser/context.rs
index 5e42aa28c9..3554c0b4c0 100644
--- a/compiler/parser/src/parser/context.rs
+++ b/compiler/parser/src/parser/context.rs
@@ -39,8 +39,6 @@ pub(crate) struct ParserContext<'a> {
pub(crate) prev_token: SpannedToken,
/// true if parsing an expression for if and loop statements -- means struct inits are not legal
pub(crate) disallow_struct_construction: bool,
- /// true if parsing an identifier inside an input file.
- pub(crate) allow_identifier_underscores: bool,
}
/// Dummy span used to appease borrow checker.
@@ -59,7 +57,6 @@ impl<'a> ParserContext<'a> {
handler,
node_builder,
disallow_struct_construction: false,
- allow_identifier_underscores: false,
prev_token: token.clone(),
token,
tokens,
diff --git a/compiler/parser/src/parser/expression.rs b/compiler/parser/src/parser/expression.rs
index a6c5e9a16b..fe6a5217b7 100644
--- a/compiler/parser/src/parser/expression.rs
+++ b/compiler/parser/src/parser/expression.rs
@@ -17,7 +17,7 @@
use super::*;
use leo_errors::{ParserError, Result};
-use leo_span::{sym, Symbol};
+use leo_span::sym;
use snarkvm::console::{account::Address, network::Testnet3};
const INT_TYPES: &[Token] = &[
@@ -429,6 +429,25 @@ impl ParserContext<'_> {
self.parse_paren_comma_list(|p| p.parse_expression().map(Some))
}
+ // Parses an externa function call `credits.aleo/transfer()` or `board.leo/make_move()`
+ fn parse_external_call(&mut self, expr: Expression) -> Result {
+ // Eat an external function call.
+ self.eat(&Token::Div); // todo: Make `/` a more general token.
+
+ // Parse function name.
+ let name = self.expect_identifier()?;
+
+ // Parse the function call.
+ let (arguments, _, span) = self.parse_paren_comma_list(|p| p.parse_expression().map(Some))?;
+ Ok(Expression::Call(CallExpression {
+ span: expr.span() + span,
+ function: Box::new(Expression::Identifier(name)),
+ external: Some(Box::new(expr)),
+ arguments,
+ id: self.node_builder.next_id(),
+ }))
+ }
+
/// Returns an [`Expression`] AST node if the next tokens represent an
/// array access, struct member access, function call, or static function call expression.
///
@@ -450,21 +469,9 @@ impl ParserContext<'_> {
id: self.node_builder.next_id(),
}))
} else if self.eat(&Token::Leo) {
- // Eat an external function call.
- self.eat(&Token::Div); // todo: Make `/` a more general token.
-
- // Parse function name.
- let name = self.expect_identifier()?;
-
- // Parse the function call.
- let (arguments, _, span) = self.parse_paren_comma_list(|p| p.parse_expression().map(Some))?;
- expr = Expression::Call(CallExpression {
- span: expr.span() + span,
- function: Box::new(Expression::Identifier(name)),
- external: Some(Box::new(expr)),
- arguments,
- id: self.node_builder.next_id(),
- });
+ return Err(ParserError::only_aleo_external_calls(expr.span()).into());
+ } else if self.eat(&Token::Aleo) {
+ expr = self.parse_external_call(expr)?;
} else {
// Parse identifier name.
let name = self.expect_identifier()?;
@@ -616,16 +623,7 @@ impl ParserContext<'_> {
}
fn parse_struct_member(&mut self) -> Result {
- let identifier = if self.allow_identifier_underscores && self.eat(&Token::Underscore) {
- // Allow `_nonce` for struct records.
- let identifier_without_underscore = self.expect_identifier()?;
- Identifier::new(
- Symbol::intern(&format!("_{}", identifier_without_underscore.name)),
- self.node_builder.next_id(),
- )
- } else {
- self.expect_identifier()?
- };
+ let identifier = self.expect_identifier()?;
let (expression, span) = if self.eat(&Token::Colon) {
// Parse individual struct variable declarations.
diff --git a/compiler/parser/src/parser/file.rs b/compiler/parser/src/parser/file.rs
index 5c3c9c31b8..f8a0dce778 100644
--- a/compiler/parser/src/parser/file.rs
+++ b/compiler/parser/src/parser/file.rs
@@ -15,11 +15,8 @@
// along with the Leo library. If not, see {
// Parse `program` keyword.
let start = self.expect(&Token::Program)?;
@@ -124,15 +97,13 @@ impl ParserContext<'_> {
// Parse the program network.
self.expect(&Token::Dot)?;
- let network = self.expect_identifier()?;
+
+ // Otherwise throw parser error
+ self.expect(&Token::Aleo).map_err(|_| ParserError::invalid_network(self.token.span))?;
// Construct the program id.
- let program_id = ProgramId { name, network };
-
- // Check that the program network is valid.
- if network.name != sym::aleo {
- return Err(ParserError::invalid_network(network.span).into());
- }
+ let program_id =
+ ProgramId { name, network: Identifier::new(Symbol::intern("aleo"), self.node_builder.next_id()) };
// Parse `{`.
self.expect(&Token::LeftCurly)?;
@@ -235,6 +206,13 @@ impl ParserContext<'_> {
pub(super) fn parse_struct(&mut self) -> Result<(Symbol, Struct)> {
let is_record = matches!(&self.token.token, Token::Record);
let start = self.expect_any(&[Token::Struct, Token::Record])?;
+
+ // Check if using external type
+ let file_type = self.look_ahead(1, |t| &t.token);
+ if self.token.token == Token::Dot && (file_type == &Token::Aleo) {
+ return Err(ParserError::cannot_declare_external_struct(self.token.span).into());
+ }
+
let struct_name = self.expect_identifier()?;
self.expect(&Token::LeftCurly)?;
@@ -302,9 +280,9 @@ impl ParserContext<'_> {
let external = self.expect_identifier()?;
let mut span = name.span + external.span;
- // Parse `.leo/`.
+ // Parse `.leo/` or `.aleo/`.
self.eat(&Token::Dot);
- self.eat(&Token::Leo);
+ self.eat_any(&[Token::Leo, Token::Aleo]);
self.eat(&Token::Div);
// Parse record name.
@@ -349,9 +327,9 @@ impl ParserContext<'_> {
let external = self.expect_identifier()?;
let mut span = external.span;
- // Parse `.leo/`.
+ // Parse `.leo/` or `.aleo/`.
self.eat(&Token::Dot);
- self.eat(&Token::Leo);
+ self.eat_any(&[Token::Leo, Token::Aleo]);
self.eat(&Token::Div);
// Parse record name.
@@ -374,7 +352,7 @@ impl ParserContext<'_> {
}
}
- fn peek_is_external(&self) -> bool {
+ pub fn peek_is_external(&self) -> bool {
matches!((&self.token.token, self.look_ahead(1, |t| &t.token)), (Token::Identifier(_), Token::Dot))
}
@@ -433,8 +411,15 @@ impl ParserContext<'_> {
}
};
- // Parse the function body.
- let block = self.parse_block()?;
+ // Parse the function body. Allow empty blocks. `fn foo(a:u8);`
+ let (_has_empty_block, block) = match &self.token.token {
+ Token::LeftCurly => (false, self.parse_block()?),
+ Token::Semicolon => {
+ let semicolon = self.expect(&Token::Semicolon)?;
+ (true, Block { statements: Vec::new(), span: semicolon, id: self.node_builder.next_id() })
+ }
+ _ => self.unexpected("block or semicolon")?,
+ };
// Parse the `finalize` block if it exists.
let finalize = match self.eat(&Token::Finalize) {
diff --git a/compiler/parser/src/parser/input.rs b/compiler/parser/src/parser/input.rs
deleted file mode 100644
index 4a02c9c720..0000000000
--- a/compiler/parser/src/parser/input.rs
+++ /dev/null
@@ -1,76 +0,0 @@
-// Copyright (C) 2019-2023 Aleo Systems Inc.
-// This file is part of the Leo library.
-
-// The Leo library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-
-// The Leo library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with the Leo library. If not, see {
- // Allow underscores in identifiers for input record declarations.
- self.allow_identifier_underscores = true;
- let mut sections = Vec::new();
-
- while self.has_next() {
- if self.check(&Token::LeftSquare) {
- sections.push(self.parse_section()?);
- } else {
- return Err(ParserError::unexpected_token(self.token.token.clone(), self.token.span).into());
- }
- }
-
- // Do not allow underscores in identifiers outside of input files.
- self.allow_identifier_underscores = false;
-
- Ok(InputAst { sections })
- }
-
- /// Parses particular section in the Input or State file.
- /// `
- /// []
- /// <...definition>
- /// `
- /// Returns [`Section`].
- fn parse_section(&mut self) -> Result {
- self.expect(&Token::LeftSquare)?;
- let section = self.expect_identifier()?;
- self.expect(&Token::RightSquare)?;
-
- let mut definitions = Vec::new();
- while let Token::Constant | Token::Public | Token::Identifier(_) = self.token.token {
- definitions.push(self.parse_input_definition()?);
- }
-
- Ok(Section { name: section.name, span: section.span, definitions })
- }
-
- /// Parses a single parameter definition:
- /// ` : = ;`
- /// Returns [`Definition`].
- fn parse_input_definition(&mut self) -> Result {
- let mode = self.parse_mode()?;
-
- let name = self.expect_identifier()?;
- self.expect(&Token::Colon)?;
- let (type_, span) = self.parse_type()?;
- self.expect(&Token::Assign)?;
- let value = self.parse_unary_expression()?;
- self.expect(&Token::Semicolon)?;
-
- Ok(Definition { mode, name, type_, value, span })
- }
-}
diff --git a/compiler/parser/src/parser/mod.rs b/compiler/parser/src/parser/mod.rs
index 038cf80c5d..b906c66c69 100644
--- a/compiler/parser/src/parser/mod.rs
+++ b/compiler/parser/src/parser/mod.rs
@@ -34,7 +34,6 @@ pub(super) use context::ParserContext;
mod expression;
mod file;
-mod input;
mod statement;
pub(super) mod type_;
@@ -44,15 +43,3 @@ pub fn parse(handler: &Handler, node_builder: &NodeBuilder, source: &str, start_
tokens.parse_program()
}
-
-/// Parses an input file at the given file `path` and `source` code text.
-pub fn parse_input(
- handler: &Handler,
- node_builder: &NodeBuilder,
- source: &str,
- start_pos: BytePos,
-) -> Result {
- let mut tokens = ParserContext::new(handler, node_builder, crate::tokenize(source, start_pos)?);
-
- tokens.parse_input_file()
-}
diff --git a/compiler/parser/src/parser/type_.rs b/compiler/parser/src/parser/type_.rs
index 9c06ecfff7..faafcd4529 100644
--- a/compiler/parser/src/parser/type_.rs
+++ b/compiler/parser/src/parser/type_.rs
@@ -79,6 +79,28 @@ impl ParserContext<'_> {
/// Also returns the span of the parsed token.
pub fn parse_type(&mut self) -> Result<(Type, Span)> {
if let Some(ident) = self.eat_identifier() {
+ // Check if using external type
+ let file_type = self.look_ahead(1, |t| &t.token);
+ if self.token.token == Token::Dot && (file_type == &Token::Aleo) {
+ // Only allow `.aleo` as the network identifier
+ if file_type == &Token::Leo {
+ return Err(ParserError::invalid_network(self.token.span).into());
+ }
+
+ // Parse `.aleo/`
+ self.expect(&Token::Dot)?;
+ self.expect(&Token::Aleo)?;
+ self.expect(&Token::Div)?;
+
+ // Parse the record name
+ if let Some(record_name) = self.eat_identifier() {
+ // Return the external type
+ return Ok((Type::Identifier(record_name), ident.span + record_name.span));
+ } else {
+ return Err(ParserError::invalid_external_type(self.token.span).into());
+ }
+ }
+
Ok((Type::Identifier(ident), ident.span))
} else if self.token.token == Token::LeftSquare {
// Parse the left bracket.
diff --git a/compiler/parser/src/test.rs b/compiler/parser/src/test.rs
index 5c02a5b3c4..9d9bb420d9 100644
--- a/compiler/parser/src/test.rs
+++ b/compiler/parser/src/test.rs
@@ -202,18 +202,6 @@ impl Namespace for SerializeNamespace {
}
}
-struct InputNamespace;
-
-impl Namespace for InputNamespace {
- fn parse_type(&self) -> ParseType {
- ParseType::Whole
- }
-
- fn run_test(&self, test: Test) -> Result {
- create_session_if_not_set_then(|s| with_handler(tokenize(test, s)?, |p| p.parse_input_file()).map(yaml_or_fail))
- }
-}
-
struct TestRunner;
impl Runner for TestRunner {
@@ -223,7 +211,6 @@ impl Runner for TestRunner {
"ParseExpression" => Box::new(ParseExpressionNamespace),
"ParseStatement" => Box::new(ParseStatementNamespace),
"Serialize" => Box::new(SerializeNamespace),
- "Input" => Box::new(InputNamespace),
"Token" => Box::new(TokenNamespace),
_ => return None,
})
diff --git a/compiler/parser/src/tokenizer/lexer.rs b/compiler/parser/src/tokenizer/lexer.rs
index f0d9c490b4..506b2ac8ae 100644
--- a/compiler/parser/src/tokenizer/lexer.rs
+++ b/compiler/parser/src/tokenizer/lexer.rs
@@ -379,6 +379,7 @@ impl Token {
match &*identifier {
x if x.starts_with("aleo1") => Token::AddressLit(identifier),
"address" => Token::Address,
+ "aleo" => Token::Aleo,
"as" => Token::As,
"assert" => Token::Assert,
"assert_eq" => Token::AssertEq,
diff --git a/compiler/parser/src/tokenizer/token.rs b/compiler/parser/src/tokenizer/token.rs
index b79967f6c9..aa7cebdefb 100644
--- a/compiler/parser/src/tokenizer/token.rs
+++ b/compiler/parser/src/tokenizer/token.rs
@@ -138,6 +138,7 @@ pub enum Token {
Transition,
// Meta Tokens
+ Aleo,
Block,
Eof,
Leo,
@@ -149,6 +150,7 @@ pub enum Token {
/// because true and false are also boolean literals, which are different tokens from keywords.
pub const KEYWORD_TOKENS: &[Token] = &[
Token::Address,
+ Token::Aleo,
Token::As,
Token::Assert,
Token::AssertEq,
@@ -205,6 +207,7 @@ impl Token {
pub fn keyword_to_symbol(&self) -> Option {
Some(match self {
Token::Address => sym::address,
+ Token::Aleo => sym::aleo,
Token::As => sym::As,
Token::Assert => sym::assert,
Token::AssertEq => sym::assert_eq,
@@ -341,6 +344,7 @@ impl fmt::Display for Token {
U128 => write!(f, "u128"),
Record => write!(f, "record"),
+ Aleo => write!(f, "aleo"),
As => write!(f, "as"),
Assert => write!(f, "assert"),
AssertEq => write!(f, "assert_eq"),
diff --git a/compiler/passes/src/code_generation/visit_expressions.rs b/compiler/passes/src/code_generation/visit_expressions.rs
index 013fdb0089..284f629a15 100644
--- a/compiler/passes/src/code_generation/visit_expressions.rs
+++ b/compiler/passes/src/code_generation/visit_expressions.rs
@@ -30,6 +30,7 @@ use leo_ast::{
Identifier,
Literal,
MemberAccess,
+ ProgramScope,
StructExpression,
TernaryExpression,
TupleExpression,
@@ -518,7 +519,6 @@ impl<'a> CodeGenerator<'a> {
}
}
- // TODO: Cleanup
fn visit_call(&mut self, input: &'a CallExpression) -> (String, String) {
let (mut call_instruction, has_finalize) = match &input.external {
Some(external) => {
@@ -528,7 +528,9 @@ impl<'a> CodeGenerator<'a> {
Expression::Identifier(identifier) => identifier.name,
_ => unreachable!("Parsing guarantees that a program name is always an identifier."),
};
+ let stub_scope: ProgramScope;
// Lookup the imported program scope.
+ // TODO: Needs refactor. All imports are stubs now.
let imported_program_scope = match self
.program
.imports
@@ -536,7 +538,14 @@ impl<'a> CodeGenerator<'a> {
.and_then(|(program, _)| program.program_scopes.get(&program_name))
{
Some(program) => program,
- None => unreachable!("Type checking guarantees that imported programs are well defined."),
+ None => {
+ if let Some(stub_program) = self.program.stubs.get(&program_name) {
+ stub_scope = ProgramScope::from(stub_program.clone());
+ &stub_scope
+ } else {
+ unreachable!("Type checking guarantees that imported and stub programs are well defined.")
+ }
+ }
};
// Check if the external function has a finalize block.
let function_name = match *input.function {
diff --git a/compiler/passes/src/code_generation/visit_program.rs b/compiler/passes/src/code_generation/visit_program.rs
index 26fa6ee491..c3aced3ed2 100644
--- a/compiler/passes/src/code_generation/visit_program.rs
+++ b/compiler/passes/src/code_generation/visit_program.rs
@@ -28,19 +28,10 @@ impl<'a> CodeGenerator<'a> {
// Accumulate instructions into a program string.
let mut program_string = String::new();
- if !input.imports.is_empty() {
- // Visit each import statement and produce a Aleo import instruction.
- program_string.push_str(
- &input
- .imports
- .iter()
- .map(|(identifier, (imported_program, _))| self.visit_import(identifier, imported_program))
- .join("\n"),
- );
-
- // Newline separator.
- program_string.push('\n');
- }
+ // Print out the dependencies of the program. Already arranged in post order by Retriever module.
+ input.stubs.iter().for_each(|(program_name, _)| {
+ program_string.push_str(&format!("import {}.aleo;\n", program_name));
+ });
// Retrieve the program scope.
// Note that type checking guarantees that there is exactly one program scope.
@@ -109,15 +100,6 @@ impl<'a> CodeGenerator<'a> {
program_string
}
- fn visit_import(&mut self, import_name: &'a Symbol, import_program: &'a Program) -> String {
- // Load symbols into composite mapping.
- let _import_program_string = self.visit_program(import_program);
- // todo: We do not need the import program string because we generate instructions for imports separately during leo build.
-
- // Generate string for import statement.
- format!("import {import_name}.aleo;")
- }
-
fn visit_struct_or_record(&mut self, struct_: &'a Struct) -> String {
if struct_.is_record { self.visit_record(struct_) } else { self.visit_struct(struct_) }
}
diff --git a/compiler/passes/src/common/symbol_table/mod.rs b/compiler/passes/src/common/symbol_table/mod.rs
index c69dea16f9..385317b055 100644
--- a/compiler/passes/src/common/symbol_table/mod.rs
+++ b/compiler/passes/src/common/symbol_table/mod.rs
@@ -23,7 +23,7 @@ pub use variable_symbol::*;
use std::cell::RefCell;
use leo_ast::{normalize_json_value, remove_key_from_json, Function, Struct};
-use leo_errors::{AstError, Result};
+use leo_errors::{AstError, LeoMessageCode, Result};
use leo_span::{Span, Symbol};
use indexmap::IndexMap;
@@ -89,11 +89,46 @@ impl SymbolTable {
Ok(())
}
+ /// Check if the struct is a duplicate of the existing struct.
+ /// This is used to allow redefinitions of external structs.
+ pub fn check_duplicate_struct(&self, old: &Struct, new: &Struct) -> bool {
+ if old.members.len() != new.members.len() {
+ return false;
+ }
+
+ for (old_member, new_member) in old.members.iter().zip(new.members.iter()) {
+ if old_member.identifier.name != new_member.identifier.name {
+ return false;
+ }
+ if old_member.type_ != new_member.type_ {
+ return false;
+ }
+ }
+ true
+ }
+
/// Inserts a struct into the symbol table.
pub fn insert_struct(&mut self, symbol: Symbol, insert: &Struct) -> Result<()> {
- self.check_shadowing(symbol, insert.span)?;
- self.structs.insert(symbol, insert.clone());
- Ok(())
+ match self.check_shadowing(symbol, insert.span) {
+ Ok(_) => {
+ self.structs.insert(symbol, insert.clone());
+ Ok(())
+ }
+ Err(e) => {
+ if e.error_code() == AstError::shadowed_struct(symbol, insert.span).error_code() {
+ if self.check_duplicate_struct(
+ self.structs.get(&symbol).expect("Must be in symbol table since struct already referenced"),
+ insert,
+ ) {
+ Ok(())
+ } else {
+ Err(AstError::redefining_external_struct(symbol).into())
+ }
+ } else {
+ Err(e)
+ }
+ }
+ }
}
/// Inserts a variable into the symbol table.
diff --git a/compiler/passes/src/loop_unrolling/unroll_program.rs b/compiler/passes/src/loop_unrolling/unroll_program.rs
index de75835318..ead8847ee7 100644
--- a/compiler/passes/src/loop_unrolling/unroll_program.rs
+++ b/compiler/passes/src/loop_unrolling/unroll_program.rs
@@ -34,6 +34,21 @@ impl ProgramReconstructor for Unroller<'_> {
}
}
+ // Don't need to reconstruct anything, just need to add child scopes for constant propagation table
+ fn reconstruct_function_stub(&mut self, input: FunctionStub) -> FunctionStub {
+ // Lookup function metadata in the symbol table.
+ // Note that this unwrap is safe since function metadata is stored in a prior pass.
+ let function_index = self.symbol_table.borrow().lookup_fn_symbol(input.identifier.name).unwrap().id;
+
+ // Enter the function's scope.
+ let previous_function_index = self.enter_scope(function_index);
+
+ // Exit the function's scope.
+ self.exit_scope(previous_function_index);
+
+ input
+ }
+
fn reconstruct_function(&mut self, function: Function) -> Function {
// Lookup function metadata in the symbol table.
// Note that this unwrap is safe since function metadata is stored in a prior pass.
diff --git a/compiler/passes/src/static_single_assignment/rename_program.rs b/compiler/passes/src/static_single_assignment/rename_program.rs
index 4b82284b5d..1b4fefe564 100644
--- a/compiler/passes/src/static_single_assignment/rename_program.rs
+++ b/compiler/passes/src/static_single_assignment/rename_program.rs
@@ -151,6 +151,7 @@ impl ProgramConsumer for StaticSingleAssigner<'_> {
.into_iter()
.map(|(name, (import, span))| (name, (self.consume_program(import), span)))
.collect(),
+ stubs: input.stubs,
program_scopes: input
.program_scopes
.into_iter()
diff --git a/compiler/passes/src/symbol_table_creation/creator.rs b/compiler/passes/src/symbol_table_creation/creator.rs
index 243a4b62e3..fc8d80013a 100644
--- a/compiler/passes/src/symbol_table_creation/creator.rs
+++ b/compiler/passes/src/symbol_table_creation/creator.rs
@@ -72,4 +72,16 @@ impl<'a> ProgramVisitor<'a> for SymbolTableCreator<'a> {
self.handler.emit_err(err);
}
}
+
+ fn visit_stub(&mut self, input: &'a Stub) {
+ input.functions.iter().for_each(|(_, c)| (self.visit_function_stub(c)));
+
+ input.structs.iter().for_each(|(_, c)| (self.visit_struct(c)));
+ }
+
+ fn visit_function_stub(&mut self, input: &'a FunctionStub) {
+ if let Err(err) = self.symbol_table.insert_fn(input.name(), &Function::from(input.clone())) {
+ self.handler.emit_err(err);
+ }
+ }
}
diff --git a/compiler/passes/src/type_checking/check_program.rs b/compiler/passes/src/type_checking/check_program.rs
index 3590d50b3d..8215b76ae1 100644
--- a/compiler/passes/src/type_checking/check_program.rs
+++ b/compiler/passes/src/type_checking/check_program.rs
@@ -14,7 +14,7 @@
// You should have received a copy of the GNU General Public License
// along with the Leo library. If not, see , span: Span) {
self.check_type(|type_| matches!(type_, Type::Array(_)), "array".to_string(), type_, span);
}
+
+ /// Helper function to check that the input and output of function are valid
+ pub(crate) fn check_function_signature(&mut self, function: &Function) {
+ self.variant = Some(function.variant);
+
+ // Type check the function's parameters.
+ function.input.iter().for_each(|input_var| {
+ // Check that the type of input parameter is defined.
+ self.assert_type_is_valid(&input_var.type_(), input_var.span());
+ // Check that the type of the input parameter is not a tuple.
+ if matches!(input_var.type_(), Type::Tuple(_)) {
+ self.emit_err(TypeCheckerError::function_cannot_take_tuple_as_input(input_var.span()))
+ }
+
+ // Note that this unwrap is safe since we assign to `self.variant` above.
+ match self.variant.unwrap() {
+ // If the function is a transition function, then check that the parameter mode is not a constant.
+ Variant::Transition if input_var.mode() == Mode::Constant => {
+ self.emit_err(TypeCheckerError::transition_function_inputs_cannot_be_const(input_var.span()))
+ }
+ // If the function is not a transition function, then check that the parameters do not have an associated mode.
+ Variant::Standard | Variant::Inline if input_var.mode() != Mode::None => {
+ self.emit_err(TypeCheckerError::regular_function_inputs_cannot_have_modes(input_var.span()))
+ }
+ _ => {} // Do nothing.
+ }
+
+ // If the function is not a transition function, then it cannot have a record as input
+ if let Type::Identifier(identifier) = input_var.type_() {
+ if let Some(val) = self.symbol_table.borrow().lookup_struct(identifier.name) {
+ if val.is_record && !matches!(function.variant, Variant::Transition) {
+ self.emit_err(TypeCheckerError::function_cannot_input_or_output_a_record(input_var.span()));
+ }
+ }
+ }
+
+ // Check for conflicting variable names.
+ if let Err(err) =
+ self.symbol_table.borrow_mut().insert_variable(input_var.identifier().name, VariableSymbol {
+ type_: input_var.type_(),
+ span: input_var.identifier().span(),
+ declaration: VariableType::Input(input_var.mode()),
+ })
+ {
+ self.handler.emit_err(err);
+ }
+ });
+
+ // Type check the function's return type.
+ // Note that checking that each of the component types are defined is sufficient to check that `output_type` is defined.
+ function.output.iter().for_each(|output| {
+ match output {
+ Output::External(external) => {
+ // If the function is not a transition function, then it cannot output a record.
+ // Note that an external output must always be a record.
+ if !matches!(function.variant, Variant::Transition) {
+ self.emit_err(TypeCheckerError::function_cannot_input_or_output_a_record(external.span()));
+ }
+ // Otherwise, do not type check external record function outputs.
+ // TODO: Verify that this is not needed when the import system is updated.
+ }
+ Output::Internal(function_output) => {
+ // Check that the type of output is defined.
+ if self.assert_type_is_valid(&function_output.type_, function_output.span) {
+ // If the function is not a transition function, then it cannot output a record.
+ if let Type::Identifier(identifier) = function_output.type_ {
+ if !matches!(function.variant, Variant::Transition)
+ && self.symbol_table.borrow().lookup_struct(identifier.name).unwrap().is_record
+ {
+ self.emit_err(TypeCheckerError::function_cannot_input_or_output_a_record(
+ function_output.span,
+ ));
+ }
+ }
+ }
+ // Check that the type of the output is not a tuple. This is necessary to forbid nested tuples.
+ if matches!(&function_output.type_, Type::Tuple(_)) {
+ self.emit_err(TypeCheckerError::nested_tuple_type(function_output.span))
+ }
+ // Check that the mode of the output is valid.
+ // For functions, only public and private outputs are allowed
+ if function_output.mode == Mode::Constant {
+ self.emit_err(TypeCheckerError::cannot_have_constant_output_mode(function_output.span));
+ }
+ }
+ }
+ });
+ }
+
+ pub(crate) fn check_finalize_signature(&mut self, finalize: &Finalize, function: &Function) {
+ // Check that the function is a transition function.
+ if !matches!(function.variant, Variant::Transition) {
+ self.emit_err(TypeCheckerError::only_transition_functions_can_have_finalize(finalize.span));
+ }
+
+ // Check that the name of the finalize block matches the function name.
+ if function.identifier.name != finalize.identifier.name {
+ self.emit_err(TypeCheckerError::finalize_name_mismatch(
+ function.identifier.name,
+ finalize.identifier.name,
+ finalize.span,
+ ));
+ }
+
+ finalize.input.iter().for_each(|input_var| {
+ // Check that the type of input parameter is defined.
+ if self.assert_type_is_valid(&input_var.type_(), input_var.span()) {
+ // Check that the input parameter is not a tuple.
+ if matches!(input_var.type_(), Type::Tuple(_)) {
+ self.emit_err(TypeCheckerError::finalize_cannot_take_tuple_as_input(input_var.span()))
+ }
+ // Check that the input parameter is not a record.
+ if let Type::Identifier(identifier) = input_var.type_() {
+ // Note that this unwrap is safe, as the type is defined.
+ if self.symbol_table.borrow().lookup_struct(identifier.name).unwrap().is_record {
+ self.emit_err(TypeCheckerError::finalize_cannot_take_record_as_input(input_var.span()))
+ }
+ }
+ // Check that the input parameter is not constant or private.
+ if input_var.mode() == Mode::Constant || input_var.mode() == Mode::Private {
+ self.emit_err(TypeCheckerError::finalize_input_mode_must_be_public(input_var.span()));
+ }
+ // Check for conflicting variable names.
+ if let Err(err) =
+ self.symbol_table.borrow_mut().insert_variable(input_var.identifier().name, VariableSymbol {
+ type_: input_var.type_(),
+ span: input_var.identifier().span(),
+ declaration: VariableType::Input(input_var.mode()),
+ })
+ {
+ self.handler.emit_err(err);
+ }
+ }
+ });
+
+ // Check that the finalize block's return type is a unit type.
+ // Note: This is a temporary restriction to be compatible with the current version of snarkVM.
+ // Note: This restriction may be lifted in the future.
+ // Note: This check is still compatible with the other checks below.
+ if finalize.output_type != Type::Unit {
+ self.emit_err(TypeCheckerError::finalize_cannot_return_value(finalize.span));
+ }
+
+ // Type check the finalize block's return type.
+ // Note that checking that each of the component types are defined is sufficient to guarantee that the `output_type` is defined.
+ finalize.output.iter().for_each(|output_type| {
+ // Check that the type of output is defined.
+ if self.assert_type_is_valid(&output_type.type_(), output_type.span()) {
+ // Check that the output is not a tuple. This is necessary to forbid nested tuples.
+ if matches!(&output_type.type_(), Type::Tuple(_)) {
+ self.emit_err(TypeCheckerError::nested_tuple_type(output_type.span()))
+ }
+ // Check that the output is not a record.
+ if let Type::Identifier(identifier) = output_type.type_() {
+ // Note that this unwrap is safe, as the type is defined.
+ if self.symbol_table.borrow().lookup_struct(identifier.name).unwrap().is_record {
+ self.emit_err(TypeCheckerError::finalize_cannot_output_record(output_type.span()))
+ }
+ }
+ // Check that the mode of the output is valid.
+ // Note that a finalize block can have only public outputs.
+ if matches!(output_type.mode(), Mode::Constant | Mode::Private) {
+ self.emit_err(TypeCheckerError::finalize_output_mode_must_be_public(output_type.span()));
+ }
+ }
+ });
+
+ // Check that the return type is defined. Note that the component types are already checked.
+ self.assert_type_is_valid(&finalize.output_type, finalize.span);
+ }
}
fn types_to_string(types: &[Type]) -> String {
diff --git a/compiler/span/Cargo.toml b/compiler/span/Cargo.toml
index cbfeedf21c..5e2fa275b7 100644
--- a/compiler/span/Cargo.toml
+++ b/compiler/span/Cargo.toml
@@ -29,5 +29,5 @@ version = "0.2.1"
version = "1.0.1"
[dependencies.serde]
-version = "1.0.194"
+version = "1.0.195"
features = [ "derive", "rc" ]
diff --git a/compiler/span/src/symbol.rs b/compiler/span/src/symbol.rs
index ad4106e356..d60e4ba391 100644
--- a/compiler/span/src/symbol.rs
+++ b/compiler/span/src/symbol.rs
@@ -268,6 +268,7 @@ symbols! {
owner,
_nonce,
program,
+ stub,
block,
height,
}
diff --git a/docs/rfc/000-rfc-format.md b/docs/rfc/000-rfc-format.md
index 05e4649ccb..278b4f4177 100644
--- a/docs/rfc/000-rfc-format.md
+++ b/docs/rfc/000-rfc-format.md
@@ -1,6 +1,6 @@
# Summary
-This is an RFC to propose RFC format for Leo language.
+This is a RFC to propose RFC format for Leo language.
# Motivation
@@ -12,11 +12,11 @@ This section describes proposed solution.
## Store RFCs inside Leo repository.
-At early stages it is for better to see changes with the code eliminating the need to keep track of a different repository.
+At early stages it is better to see changes with the code eliminating the need to keep track of a different repository.
## Use standard PR mechanics for submitting new RFCs
-New RFCs should be submitted as a PRs into Leo repository. PRs should be correctly labeled for easier search. Yet they should not have number unless PR is accepted by leo maintainers.
+New RFCs should be submitted as PRs into the Leo repository. PRs should be correctly labeled for easier search. Yet they should not have a number unless the PR is accepted by leo maintainers.
## Increase approvals count for RFCs
@@ -24,7 +24,7 @@ RFCs may propose changes affecting multiple systems or projects. They also intro
## Format
-For bootstrapping new requests template is made and placed into RFC folder.
+For bootstrapping new requests, a template is made and placed into the RFC folder.
## Number
diff --git a/errors/Cargo.toml b/errors/Cargo.toml
index 887a995589..c752209ab3 100644
--- a/errors/Cargo.toml
+++ b/errors/Cargo.toml
@@ -37,8 +37,11 @@ version = "0.6.1"
[dependencies.derivative]
version = "2.2.0"
+[dependencies.reqwest]
+version = "0.11.22"
+
[dependencies.serde]
-version = "1.0.194"
+version = "1.0.195"
features = [ "derive", "rc" ]
[dependencies.thiserror]
diff --git a/errors/ERROR_INDEX.md b/errors/ERROR_INDEX.md
index 039d20d286..01ec5214ab 100644
--- a/errors/ERROR_INDEX.md
+++ b/errors/ERROR_INDEX.md
@@ -2,8 +2,6 @@
## Parser Errors: Error Code Range 370_000 - 370_999
-## State Errors: Error Code Range 371_000 - 371_999
-
## AST Errors: Error Code Range 372_000 - 372_999
## ASG Errors: Error Code Range 373_000 - 373_999
diff --git a/errors/README.md b/errors/README.md
index a3bfcfaf63..90c0528a0c 100644
--- a/errors/README.md
+++ b/errors/README.md
@@ -49,10 +49,6 @@ The errors for the `leo-compiler` crate. Its error codes will range from 6_000-6
The errors for the `leo-imports` crate. Its error codes will range from 4_000-4_999 and be prefixed with the characters `IMP`.
-### Input
-
-The errors for the `leo-ast` crate. Its error codes will range from 8_000-8_999 and be prefixed with the characters `INP`.
-
### Loop Unrolling
The errors for loop unrolling in the `leo-passes` crate. Its error codes will range from 9_000-9_999 and be prefixed with the characters `LUN`.
@@ -70,6 +66,6 @@ The errors for the `leo-parser` crate. Its error codes will range from 0-999 and
The errors from SnarkVM that bubble up into Leo in some situations. For right now, they have an exit code of 1.
When SnarkVM implements better error codes and messages, we can bubble them up.
-### State
+### Utils
-The errors for the `leo-state` crate. Its error codes will range from 1_000-1_999 and be prefixed with the characters `STA`.
+The errors related to dependency retrieval in the `utils` crate. Its error codes will range from 10_000-10_999 and be prefixed with the characters `DEP`.
diff --git a/errors/src/errors/ast/ast_errors.rs b/errors/src/errors/ast/ast_errors.rs
index ef056ac032..1c8ae8d103 100644
--- a/errors/src/errors/ast/ast_errors.rs
+++ b/errors/src/errors/ast/ast_errors.rs
@@ -145,4 +145,11 @@ create_messages!(
msg: format!("failed to convert symbol_table to a json value {error}"),
help: None,
}
+
+ @backtraced
+ redefining_external_struct {
+ args: (struct_: impl Display),
+ msg: format!("There are two mismatched definitions of struct `{struct_}`."),
+ help: Some("Duplicate definitions of structs are required to use external structs, but each field's name and type must match exactly.".to_string()),
+ }
);
diff --git a/errors/src/errors/compiler/compiler_errors.rs b/errors/src/errors/compiler/compiler_errors.rs
index 7ff0d4a958..224949c3b4 100644
--- a/errors/src/errors/compiler/compiler_errors.rs
+++ b/errors/src/errors/compiler/compiler_errors.rs
@@ -70,4 +70,11 @@ create_messages!(
msg: format!("The program scope name `{program_scope_name}` must match `{file_name}`."),
help: None,
}
+
+ @formatted
+ imported_program_not_found {
+ args: (main_program_name: impl Display, dependency_name: impl Display),
+ msg: format!("`{main_program_name}` imports `{dependency_name}.aleo`, but `{dependency_name}.aleo` is not found in `program.json`."),
+ help: None,
+ }
);
diff --git a/errors/src/errors/input/input_errors.rs b/errors/src/errors/input/input_errors.rs
deleted file mode 100644
index b9b03fc8d6..0000000000
--- a/errors/src/errors/input/input_errors.rs
+++ /dev/null
@@ -1,58 +0,0 @@
-// Copyright (C) 2019-2023 Aleo Systems Inc.
-// This file is part of the Leo library.
-
-// The Leo library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-
-// The Leo library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with the Leo library. If not, see >()
- .join(", ")
- ),
- help: None,
- }
-);
diff --git a/errors/src/errors/mod.rs b/errors/src/errors/mod.rs
index e890d7761b..80b84cd314 100644
--- a/errors/src/errors/mod.rs
+++ b/errors/src/errors/mod.rs
@@ -33,10 +33,7 @@ pub use self::compiler::*;
pub mod flattener;
pub use self::flattener::*;
-/// Contains the Input error definitions.
-pub mod input;
-pub use self::input::*;
-
+/// Contains the Loop Unroller error definitions.
pub mod loop_unroller;
pub use self::loop_unroller::*;
@@ -50,9 +47,12 @@ pub use self::parser::*;
/// Contains the Type Checker error definitions.
pub mod type_checker;
-
pub use self::type_checker::*;
+/// Contains the Utils error definitions.
+pub mod utils;
+pub use self::utils::*;
+
/// The LeoError type that contains all sub error types.
/// This allows a unified error type throughout the Leo crates.
#[derive(Debug, Error)]
@@ -66,9 +66,6 @@ pub enum LeoError {
/// Represents an Compiler Error in a Leo Error.
#[error(transparent)]
CompilerError(#[from] CompilerError),
- /// Represents an Input Error in a Leo Error.
- #[error(transparent)]
- InputError(#[from] InputError),
/// Represents an Package Error in a Leo Error.
#[error(transparent)]
PackageError(#[from] PackageError),
@@ -88,6 +85,9 @@ pub enum LeoError {
/// not re-displaying an error.
#[error("")]
LastErrorCode(i32),
+ /// Represents a Utils Error in a Leo Error
+ #[error(transparent)]
+ UtilError(#[from] UtilError),
/// Anyhow errors.
#[error(transparent)]
Anyhow(#[from] anyhow::Error),
@@ -102,12 +102,12 @@ impl LeoError {
AstError(error) => error.error_code(),
CompilerError(error) => error.error_code(),
CliError(error) => error.error_code(),
- InputError(error) => error.error_code(),
ParserError(error) => error.error_code(),
PackageError(error) => error.error_code(),
TypeCheckerError(error) => error.error_code(),
LoopUnrollerError(error) => error.error_code(),
FlattenError(error) => error.error_code(),
+ UtilError(error) => error.error_code(),
LastErrorCode(_) => unreachable!(),
Anyhow(_) => unimplemented!(), // todo: implement error codes for snarkvm errors.
}
@@ -121,12 +121,12 @@ impl LeoError {
AstError(error) => error.exit_code(),
CompilerError(error) => error.exit_code(),
CliError(error) => error.exit_code(),
- InputError(error) => error.exit_code(),
ParserError(error) => error.exit_code(),
PackageError(error) => error.exit_code(),
TypeCheckerError(error) => error.exit_code(),
LoopUnrollerError(error) => error.exit_code(),
FlattenError(error) => error.exit_code(),
+ UtilError(error) => error.exit_code(),
LastErrorCode(code) => *code,
Anyhow(_) => unimplemented!(), // todo: implement exit codes for snarkvm errors.
}
diff --git a/errors/src/errors/package/package_errors.rs b/errors/src/errors/package/package_errors.rs
index 950bca2820..9ca81def2c 100644
--- a/errors/src/errors/package/package_errors.rs
+++ b/errors/src/errors/package/package_errors.rs
@@ -264,6 +264,27 @@ create_messages!(
help: Some("Create a package by running `leo new`.".to_string()),
}
+ @backtraced
+ failed_to_read_manifest {
+ args: (error: impl Display),
+ msg: format!("Failed to read manifest file: {error}"),
+ help: Some("Create a package by running `leo new`.".to_string()),
+ }
+
+ @backtraced
+ failed_to_write_manifest {
+ args: (error: impl Display),
+ msg: format!("Failed to write manifest file: {error}"),
+ help: Some("Create a package by running `leo new`.".to_string()),
+ }
+
+ @backtraced
+ failed_to_create_manifest {
+ args: (error: impl Display),
+ msg: format!("Failed to create manifest file: {error}"),
+ help: Some("Create a package by running `leo new`.".to_string()),
+ }
+
@backtraced
failed_to_open_aleo_file {
args: (error: impl Display),
@@ -313,4 +334,18 @@ create_messages!(
msg: format!("IO error env file from the provided file path - {error}"),
help: None,
}
+
+ @backtraced
+ failed_to_deserialize_manifest_file {
+ args: (path: impl Display, error: impl ErrorArg),
+ msg: format!("Failed to deserialize `program.json` from the provided file path {path} - {error}"),
+ help: None,
+ }
+
+ @backtraced
+ failed_to_serialize_manifest_file {
+ args: (path: impl Display, error: impl ErrorArg),
+ msg: format!("Failed to update `program.json` from the provided file path {path} - {error}"),
+ help: None,
+ }
);
diff --git a/errors/src/errors/parser/parser_errors.rs b/errors/src/errors/parser/parser_errors.rs
index 734c2f1fd6..14bac813cb 100644
--- a/errors/src/errors/parser/parser_errors.rs
+++ b/errors/src/errors/parser/parser_errors.rs
@@ -215,10 +215,10 @@ create_messages!(
}
@formatted
- leo_imports_only {
+ leo_and_aleo_imports_only {
args: (),
- msg: "Invalid import call to non-leo file.",
- help: Some("Only imports of Leo `.leo` files are currently supported.".to_string()),
+ msg: "Invalid import call to non-leo non-aleo file.",
+ help: Some("Only imports of Leo `.leo` and Aleo `.aleo` files are currently supported.".to_string()),
}
@formatted
@@ -252,7 +252,7 @@ create_messages!(
@formatted
invalid_network {
args: (),
- msg: "Invalid network identifier. The only supported identifier is `aleo`.",
+ msg: "Invalid network identifier. The only supported identifier is `.aleo`.",
help: None,
}
@@ -298,4 +298,41 @@ create_messages!(
msg: format!("An array {kind} must have at least one element."),
help: None,
}
+
+ @formatted
+ invalid_external_type {
+ args: (),
+ msg: format!("Invalid external type."),
+ help: Some("External type should have the form `.aleo/`. For example `bank.aleo/loan`".to_string()),
+ }
+
+ @formatted
+ cannot_declare_external_struct {
+ args: (),
+ msg: format!("Cannot declare external struct."),
+ help: None,
+ }
+
+ /// Enforce that cannot use an external type to do anything except input/output of function
+ @formatted
+ external_type_cannot_be_used_inside_function {
+ args: (program: impl Display, file_type: impl Display),
+ msg: format!("External types cannot be used inside function (only as input/output types) -- found exported type from '{program}.{file_type}'."),
+ help: None,
+ }
+
+ /// Enforce that cannot use import in program scope
+ @formatted
+ cannot_import_inside_program_body {
+ args: (),
+ msg: format!("Cannot use import inside program body."),
+ help: None,
+ }
+
+ @formatted
+ only_aleo_external_calls {
+ args: (),
+ msg: format!("Only external calls to `.aleo` programs are supported."),
+ help: None,
+ }
);
diff --git a/errors/src/errors/state/mod.rs b/errors/src/errors/state/mod.rs
deleted file mode 100644
index d67880f7c0..0000000000
--- a/errors/src/errors/state/mod.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-// Copyright (C) 2019-2023 Aleo Systems Inc.
-// This file is part of the Leo library.
-
-// The Leo library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-
-// The Leo library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with the Leo library. If not, see
```
-This command will look in the input file inputs/*.in where should find a section [main] and use the variables as inputs to the program.
## Execute Guide
To execute each program call, run:
```bash
-leo execute main --endpoint
-```
\ No newline at end of file
+leo execute main
+```
diff --git a/examples/auction/README.md b/examples/auction/README.md
index 16001a6196..230ff14092 100644
--- a/examples/auction/README.md
+++ b/examples/auction/README.md
@@ -13,7 +13,7 @@ In this model, there are two parties: the auctioneer and the bidders.
- **Bidder**: A participant in the auction.
- **Auctioneer**: The party responsible for conducting the auction.
-We make following assumptions about the auction:
+We make the following assumptions about the auction:
- The auctioneer is honest. That is, the auctioneer will resolve **all** bids in the order they are received. The auctioneer will not tamper with the bids.
- There is no limit to the number of bids.
- The auctioneer knows the identity of all bidders, but bidders do not necessarily know the identity of other bidders.
@@ -36,7 +36,6 @@ The auction is conducted in a series of stages.
## Running the Program
Leo provides users with a command line interface for compiling and running Leo programs.
-Users may either specify input values via the command line or provide an input file in `inputs/`.
### Configuring Accounts
The `.env` file contains a private key.
@@ -50,16 +49,9 @@ To generate a new account, navigate to [aleo.tools](https://aleo.tools).
### Providing inputs via the command line.
-1. Run
```bash
leo run ...
```
See `./run.sh` for an example.
-### Using an input file.
-1. Modify `inputs/auction.in` with the desired inputs.
-2. Run
-```bash
-leo run
-```
diff --git a/examples/auction/inputs/auction.in b/examples/auction/inputs/auction.in
deleted file mode 100644
index 468e9d44c1..0000000000
--- a/examples/auction/inputs/auction.in
+++ /dev/null
@@ -1,39 +0,0 @@
-// The program input for auction/src/main.leo
-[place_bid]
-// Note that `bidder` must have the same address as the caller (refer to `program.json`).
-// Swapping the below lines, will result in an error.
-// bidder: address = aleo1y7065c2jxkra5yzu9jfxq55klweqev0zas89lt9nxmfrqrafmq9qw2ktdg;
-bidder: address = aleo1fxs9s0w97lmkwlcmgn0z3nuxufdee5yck9wqrs0umevp7qs0sg9q5xxxzh;
-amount: u64 = 90u64;
-
-[resolve]
-first: Bid = Bid {
- owner: aleo1fxs9s0w97lmkwlcmgn0z3nuxufdee5yck9wqrs0umevp7qs0sg9q5xxxzh,
- bidder: aleo1fxs9s0w97lmkwlcmgn0z3nuxufdee5yck9wqrs0umevp7qs0sg9q5xxxzh,
- amount: 10u64,
- is_winner: false,
- _nonce: 6480683131255842390406647532838179519970794442201387718334686863304493823461group,
-};
-second: Bid = Bid {
- owner: aleo1fxs9s0w97lmkwlcmgn0z3nuxufdee5yck9wqrs0umevp7qs0sg9q5xxxzh,
- bidder: aleo1fxs9s0w97lmkwlcmgn0z3nuxufdee5yck9wqrs0umevp7qs0sg9q5xxxzh,
- amount: 90u64,
- is_winner: false,
- _nonce: 1511010328912449299156978046557700301564153667442988008615502964863620401388group,
-};
-
-[finish]
-bid: Bid = Bid {
- owner: aleo1fxs9s0w97lmkwlcmgn0z3nuxufdee5yck9wqrs0umevp7qs0sg9q5xxxzh,
- bidder: aleo1fxs9s0w97lmkwlcmgn0z3nuxufdee5yck9wqrs0umevp7qs0sg9q5xxxzh,
- amount: 90u64,
- is_winner: false,
- _nonce: 4195536711021629817871261453343069023119119274215827022954896024118351555272group,
-};
-
-
-
-
-
-
-
diff --git a/examples/auction/leo.lock b/examples/auction/leo.lock
new file mode 100644
index 0000000000..c4293b3b9f
--- /dev/null
+++ b/examples/auction/leo.lock
@@ -0,0 +1 @@
+package = []
diff --git a/examples/basic_bank/README.md b/examples/basic_bank/README.md
index 40ddfd3178..56cb553918 100644
--- a/examples/basic_bank/README.md
+++ b/examples/basic_bank/README.md
@@ -13,14 +13,14 @@ This program implements a bank that issues tokens to users and allows users to d
2. A user deposits tokens via the `deposit` function.
3. Upon a user's request to withdraw, the bank calculates the appropriate amount of compound interest and pays the user the principal and interest via the `withdraw` function.
-Note that the program can be easily extended to include addition features such as a `transfer` function, which would allow users to transfer tokens to other users.
+Note that the program can be easily extended to include additional features such as a `transfer` function, which would allow users to transfer tokens to other users.
## Bugs
You may have already guessed that this program has a few bugs. We list some of them below:
- `withdraw` can only be invoked by the bank. A malicious bank could lock users' tokens by not invoking `withdraw`.
- `withdraw` fails if the sum of the interest and principal is greater than the user's balance.
-- User's can increase their principal by depositing tokens multiple times, including immediately before withdrawal.
+- Users can increase their principal by depositing tokens multiple times, including immediately before withdrawal.
- Integer division rounds down; if the calculated interest is too small, then it will be rounded down to zero.
Can you find any others?
@@ -37,7 +37,6 @@ Can you find any others?
## Running the Program
Leo provides users with a command line interface for compiling and running Leo programs.
-Users may either specify input values via the command line or provide an input file in `inputs/`.
### Configuring Accounts
The `.env` file contains a private key.
@@ -50,22 +49,7 @@ The [Aleo SDK](https://github.com/AleoHQ/leo/tree/testnet3) provides an interfac
To generate a new account, navigate to [aleo.tools](https://aleo.tools).
### Providing inputs via the command line.
-1. Run
```bash
leo run ...
```
See `./run.sh` for an example.
-
-
-### Using an input file.
-1. Modify `inputs/auction.in` with the desired inputs.
-2. Run
-```bash
-leo run
-```
-For example,
-```bash
-leo run issue
-leo run deposit
-leo run withdraw
-```
diff --git a/examples/basic_bank/build/main.aleo b/examples/basic_bank/build/main.aleo
index f0498806f6..963c29ed1a 100644
--- a/examples/basic_bank/build/main.aleo
+++ b/examples/basic_bank/build/main.aleo
@@ -6,8 +6,8 @@ record Token:
mapping balances:
- key left as field.public;
- value right as u64.public;
+ key as field.public;
+ value as u64.public;
function issue:
input r0 as address.private;
@@ -22,9 +22,10 @@ function deposit:
input r1 as u64.private;
sub r0.amount r1 into r2;
cast r0.owner r2 into r3 as Token.record;
- hash.bhp256 r0.owner into r4 as field; output r3 as Token.record;
-
- finalize r4 r1;
+ hash.bhp256 r0.owner into r4 as field;
+ async deposit r4 r1 into r5;
+ output r3 as Token.record;
+ output r5 as basic_bank.aleo/deposit.future;
finalize deposit:
input r0 as field.public;
@@ -547,11 +548,12 @@ function withdraw:
input r2 as u64.private;
input r3 as u64.private;
assert.eq self.caller aleo1t0uer3jgtsgmx5tq6x6f9ecu8tr57rzzfnc2dgmcqldceal0ls9qf6st7a;
- hash.bhp256 r0 into r4 as field; call calculate_interest r1 r2 r3 into r5;
+ hash.bhp256 r0 into r4 as field;
+ call calculate_interest r1 r2 r3 into r5;
cast r0 r5 into r6 as Token.record;
+ async withdraw r4 r1 into r7;
output r6 as Token.record;
-
- finalize r4 r1;
+ output r7 as basic_bank.aleo/withdraw.future;
finalize withdraw:
input r0 as field.public;
diff --git a/examples/basic_bank/inputs/basic_bank.in b/examples/basic_bank/inputs/basic_bank.in
deleted file mode 100644
index 69429846bb..0000000000
--- a/examples/basic_bank/inputs/basic_bank.in
+++ /dev/null
@@ -1,21 +0,0 @@
-// Inputs for the `issue` function.
-[issue]
-owner: address = aleo1t0uer3jgtsgmx5tq6x6f9ecu8tr57rzzfnc2dgmcqldceal0ls9qf6st7a;
-amount: u64 = 1234u64;
-
-// Inputs for the `deposit` function.
-[deposit]
-token: Token = Token {
- owner: aleo1t0uer3jgtsgmx5tq6x6f9ecu8tr57rzzfnc2dgmcqldceal0ls9qf6st7a,
- amount: 1234u64,
- _nonce: 0group,
-};
-amount: u64 = 321u64;
-
-// Inputs for the `withdraw` function.
-[withdraw]
-recipient: address = aleo1t0uer3jgtsgmx5tq6x6f9ecu8tr57rzzfnc2dgmcqldceal0ls9qf6st7a;
-amount: u64 = 321u64;
-rate: u64 = 1500u64;
-periods: u64 = 10u64;
-
diff --git a/examples/basic_bank/leo.lock b/examples/basic_bank/leo.lock
new file mode 100644
index 0000000000..c4293b3b9f
--- /dev/null
+++ b/examples/basic_bank/leo.lock
@@ -0,0 +1 @@
+package = []
diff --git a/examples/battleship/board/.gitignore b/examples/battleship/board/.gitignore
new file mode 100644
index 0000000000..f721f7f6f4
--- /dev/null
+++ b/examples/battleship/board/.gitignore
@@ -0,0 +1,5 @@
+.env
+*.avm
+*.prover
+*.verifier
+outputs/
diff --git a/examples/battleship/board/README.md b/examples/battleship/board/README.md
new file mode 100644
index 0000000000..d7d689efbc
--- /dev/null
+++ b/examples/battleship/board/README.md
@@ -0,0 +1,13 @@
+# board.aleo
+
+## Build Guide
+
+To compile this Aleo program, run:
+```bash
+snarkvm build
+```
+
+To execute this Aleo program, run:
+```bash
+snarkvm run hello
+```
diff --git a/examples/battleship/board/build/main.aleo b/examples/battleship/board/build/main.aleo
new file mode 100644
index 0000000000..fac2e70af8
--- /dev/null
+++ b/examples/battleship/board/build/main.aleo
@@ -0,0 +1,46 @@
+program board.aleo;
+
+record board_state:
+ owner as address.private;
+ hits_and_misses as u64.private;
+ played_tiles as u64.private;
+ ships as u64.private;
+ player_1 as address.private;
+ player_2 as address.private;
+ game_started as boolean.private;
+
+
+function new_board_state:
+ input r0 as u64.private;
+ input r1 as address.private;
+ cast self.caller 0u64 0u64 r0 self.caller r1 false into r2 as board_state.record;
+ output r2 as board_state.record;
+
+
+function start_board:
+ input r0 as board_state.record;
+ not r0.game_started into r1;
+ assert.eq r1 true;
+ cast r0.owner r0.hits_and_misses r0.played_tiles r0.ships r0.player_1 r0.player_2 true into r2 as board_state.record;
+ output r2 as board_state.record;
+
+
+function update_played_tiles:
+ input r0 as board_state.record;
+ input r1 as u64.private;
+ sub r1 1u64 into r2;
+ and r1 r2 into r3;
+ assert.eq r3 0u64;
+ and r1 r0.played_tiles into r4;
+ assert.eq r4 0u64;
+ or r0.played_tiles r1 into r5;
+ cast r0.owner r0.hits_and_misses r5 r0.ships r0.player_1 r0.player_2 r0.game_started into r6 as board_state.record;
+ output r6 as board_state.record;
+
+
+function update_hits_and_misses:
+ input r0 as board_state.record;
+ input r1 as u64.private;
+ or r0.hits_and_misses r1 into r2;
+ cast r0.owner r2 r0.played_tiles r0.ships r0.player_1 r0.player_2 r0.game_started into r3 as board_state.record;
+ output r3 as board_state.record;
diff --git a/examples/battleship/board/build/program.json b/examples/battleship/board/build/program.json
new file mode 100644
index 0000000000..b140f09fcc
--- /dev/null
+++ b/examples/battleship/board/build/program.json
@@ -0,0 +1,6 @@
+{
+ "program": "board.aleo",
+ "version": "0.0.0",
+ "description": "",
+ "license": "MIT"
+}
diff --git a/examples/battleship/board/inputs/board.in b/examples/battleship/board/inputs/board.in
new file mode 100644
index 0000000000..d414604f3e
--- /dev/null
+++ b/examples/battleship/board/inputs/board.in
@@ -0,0 +1,4 @@
+// The program input for board/src/main.leo
+[main]
+public a: u32 = 1u32;
+b: u32 = 2u32;
diff --git a/examples/battleship/board/leo.lock b/examples/battleship/board/leo.lock
new file mode 100644
index 0000000000..c4293b3b9f
--- /dev/null
+++ b/examples/battleship/board/leo.lock
@@ -0,0 +1 @@
+package = []
diff --git a/examples/battleship/board/program.json b/examples/battleship/board/program.json
new file mode 100644
index 0000000000..b140f09fcc
--- /dev/null
+++ b/examples/battleship/board/program.json
@@ -0,0 +1,6 @@
+{
+ "program": "board.aleo",
+ "version": "0.0.0",
+ "description": "",
+ "license": "MIT"
+}
diff --git a/examples/battleship/imports/board.leo b/examples/battleship/board/src/main.leo
similarity index 100%
rename from examples/battleship/imports/board.leo
rename to examples/battleship/board/src/main.leo
diff --git a/examples/battleship/build/program.json b/examples/battleship/build/program.json
index 1d0c6e88d6..fe5a3d5e74 100644
--- a/examples/battleship/build/program.json
+++ b/examples/battleship/build/program.json
@@ -2,5 +2,22 @@
"program": "battleship.aleo",
"version": "0.0.0",
"description": "",
- "license": "MIT"
+ "license": "MIT",
+ "dependencies" : [
+ {
+ "name": "board.aleo",
+ "location": "local",
+ "path": "board"
+ },
+ {
+ "name": "move.aleo",
+ "location": "local",
+ "path": "move"
+ },
+ {
+ "name": "verify.aleo",
+ "location": "local",
+ "path": "verify"
+ }
+ ]
}
diff --git a/examples/battleship/inputs/battleship.in b/examples/battleship/inputs/battleship.in
deleted file mode 100644
index a62118476f..0000000000
--- a/examples/battleship/inputs/battleship.in
+++ /dev/null
@@ -1,4 +0,0 @@
-// The program input for battleship/src/main.leo
-[main]
-public a: u32 = 1u32;
-b: u32 = 2u32;
diff --git a/examples/battleship/leo.lock b/examples/battleship/leo.lock
new file mode 100644
index 0000000000..dcb0468d95
--- /dev/null
+++ b/examples/battleship/leo.lock
@@ -0,0 +1,20 @@
+[[package]]
+name = "board"
+location = "local"
+path = "board"
+checksum = "da94274230d0c0c3deb96d80e07ad9db8bbf53264286c14cc3231b7a8b7ef380"
+dependencies = []
+
+[[package]]
+name = "move"
+location = "local"
+path = "move"
+checksum = "7d9fef5fe083eb24376e63935855e4ec709c17fb5ee46a0bb4594b0f9ef8eb08"
+dependencies = []
+
+[[package]]
+name = "verify"
+location = "local"
+path = "verify"
+checksum = "2c2035ebd70500b7e5a9a6198bed1a1163cd1ddfd09128db8f4c16cf23ad2c62"
+dependencies = []
diff --git a/examples/battleship/move/.gitignore b/examples/battleship/move/.gitignore
new file mode 100644
index 0000000000..f721f7f6f4
--- /dev/null
+++ b/examples/battleship/move/.gitignore
@@ -0,0 +1,5 @@
+.env
+*.avm
+*.prover
+*.verifier
+outputs/
diff --git a/examples/battleship/move/README.md b/examples/battleship/move/README.md
new file mode 100644
index 0000000000..a8beca6049
--- /dev/null
+++ b/examples/battleship/move/README.md
@@ -0,0 +1,13 @@
+# move.aleo
+
+## Build Guide
+
+To compile this Aleo program, run:
+```bash
+snarkvm build
+```
+
+To execute this Aleo program, run:
+```bash
+snarkvm run hello
+```
diff --git a/examples/battleship/move/build/main.aleo b/examples/battleship/move/build/main.aleo
new file mode 100644
index 0000000000..ed5247d932
--- /dev/null
+++ b/examples/battleship/move/build/main.aleo
@@ -0,0 +1,24 @@
+program move.aleo;
+
+record move:
+ owner as address.private;
+ incoming_fire_coordinate as u64.private;
+ player_1 as address.private;
+ player_2 as address.private;
+ prev_hit_or_miss as u64.private;
+
+
+function create_move:
+ input r0 as move.record;
+ input r1 as u64.private;
+ input r2 as u64.private;
+ is.eq r0.player_1 r0.owner into r3;
+ ternary r3 r0.player_2 r0.player_1 into r4;
+ cast r4 r1 r0.player_2 r0.player_1 r2 into r5 as move.record;
+ output r5 as move.record;
+
+
+function start_game:
+ input r0 as address.private;
+ cast r0 0u64 self.caller r0 0u64 into r1 as move.record;
+ output r1 as move.record;
diff --git a/examples/battleship/move/build/program.json b/examples/battleship/move/build/program.json
new file mode 100644
index 0000000000..b8acf29858
--- /dev/null
+++ b/examples/battleship/move/build/program.json
@@ -0,0 +1,6 @@
+{
+ "program": "move.aleo",
+ "version": "0.0.0",
+ "description": "",
+ "license": "MIT"
+}
diff --git a/examples/battleship/move/inputs/move.in b/examples/battleship/move/inputs/move.in
new file mode 100644
index 0000000000..d632154504
--- /dev/null
+++ b/examples/battleship/move/inputs/move.in
@@ -0,0 +1,4 @@
+// The program input for move/src/main.leo
+[main]
+public a: u32 = 1u32;
+b: u32 = 2u32;
diff --git a/examples/battleship/move/leo.lock b/examples/battleship/move/leo.lock
new file mode 100644
index 0000000000..c4293b3b9f
--- /dev/null
+++ b/examples/battleship/move/leo.lock
@@ -0,0 +1 @@
+package = []
diff --git a/examples/battleship/move/program.json b/examples/battleship/move/program.json
new file mode 100644
index 0000000000..b8acf29858
--- /dev/null
+++ b/examples/battleship/move/program.json
@@ -0,0 +1,6 @@
+{
+ "program": "move.aleo",
+ "version": "0.0.0",
+ "description": "",
+ "license": "MIT"
+}
diff --git a/examples/battleship/imports/move.leo b/examples/battleship/move/src/main.leo
similarity index 100%
rename from examples/battleship/imports/move.leo
rename to examples/battleship/move/src/main.leo
diff --git a/examples/battleship/program.json b/examples/battleship/program.json
index 1d0c6e88d6..fe5a3d5e74 100644
--- a/examples/battleship/program.json
+++ b/examples/battleship/program.json
@@ -2,5 +2,22 @@
"program": "battleship.aleo",
"version": "0.0.0",
"description": "",
- "license": "MIT"
+ "license": "MIT",
+ "dependencies" : [
+ {
+ "name": "board.aleo",
+ "location": "local",
+ "path": "board"
+ },
+ {
+ "name": "move.aleo",
+ "location": "local",
+ "path": "move"
+ },
+ {
+ "name": "verify.aleo",
+ "location": "local",
+ "path": "verify"
+ }
+ ]
}
diff --git a/examples/battleship/src/main.leo b/examples/battleship/src/main.leo
index f88a651fca..743cb7bc5d 100644
--- a/examples/battleship/src/main.leo
+++ b/examples/battleship/src/main.leo
@@ -1,8 +1,8 @@
-import board.leo;
-import move.leo;
-import verify.leo;
+import board.aleo;
+import move.aleo;
+import verify.aleo;
-// The 'battleship.leo' program.
+// The 'battleship.aleo' program.
program battleship.aleo {
// Returns a new record representing a new game of battleship.
transition initialize_board(
@@ -16,25 +16,25 @@ program battleship.aleo {
destroyer: u64,
// The address of the opponent.
player: address,
- ) -> board.leo/board_state.record {
+ ) -> board.aleo/board_state.record {
// Verify that each individual ship placement bitstring is valid.
- let valid_carrier: bool = verify.leo/validate_ship(carrier, 5u64, 31u64, 4311810305u64);
+ let valid_carrier: bool = verify.aleo/validate_ship(carrier, 5u64, 31u64, 4311810305u64);
assert(valid_carrier);
- let valid_battleship: bool = verify.leo/validate_ship(battleship, 4u64, 15u64, 16843009u64);
+ let valid_battleship: bool = verify.aleo/validate_ship(battleship, 4u64, 15u64, 16843009u64);
assert(valid_battleship);
- let valid_cruiser: bool = verify.leo/validate_ship(cruiser, 3u64, 7u64, 65793u64);
+ let valid_cruiser: bool = verify.aleo/validate_ship(cruiser, 3u64, 7u64, 65793u64);
assert(valid_cruiser);
- let valid_destroyer: bool = verify.leo/validate_ship(destroyer, 2u64, 3u64, 257u64);
+ let valid_destroyer: bool = verify.aleo/validate_ship(destroyer, 2u64, 3u64, 257u64);
assert(valid_destroyer);
// Create the board with all the ship placements combined.
- let board: u64 = verify.leo/create_board(carrier, battleship, cruiser, destroyer);
+ let board: u64 = verify.aleo/create_board(carrier, battleship, cruiser, destroyer);
// Initialize the board state record.
- let state: board_state = board.leo/new_board_state(board, player);
+ let state: board_state = board.aleo/new_board_state(board, player);
return state;
}
@@ -44,10 +44,10 @@ program battleship.aleo {
// This function commits a given board to a game with an opponent and creates the initial dummy move.
transition offer_battleship(
// The board record to start a game with.
- board: board.leo/board_state.record,
- ) -> (board.leo/board_state.record, move.leo/move.record) {
- let state: board_state = board.leo/start_board(board);
- let dummy: move = move.leo/start_game(board.player_2);
+ board: board.aleo/board_state.record,
+ ) -> (board.aleo/board_state.record, move.aleo/move.record) {
+ let state: board_state = board.aleo/start_board(board);
+ let dummy: move = move.aleo/start_game(board.player_2);
return (state, dummy);
}
@@ -56,16 +56,16 @@ program battleship.aleo {
// Returns dummy move record owned by the opponent.
transition start_battleship(
// The board record to play the game with.
- board: board.leo/board_state.record,
+ board: board.aleo/board_state.record,
// The move record to play to begin the game. This should be the dummy move record created from offer_battleship.
- move_start: move.leo/move.record,
- ) -> (board.leo/board_state.record, move.leo/move.record) {
+ move_start: move.aleo/move.record,
+ ) -> (board.aleo/board_state.record, move.aleo/move.record) {
// Validate that the move players and board players match each other.
assert_eq(board.player_1, move_start.player_2);
assert_eq(board.player_2, move_start.player_1);
- let state: board_state = board.leo/start_board(board);
- let dummy: move = move.leo/start_game(board.player_2);
+ let state: board_state = board.aleo/start_board(board);
+ let dummy: move = move.aleo/start_game(board.player_2);
return (state, dummy);
}
@@ -74,12 +74,12 @@ program battleship.aleo {
// Returns new move record owned by opponent.
transition play(
// The board record to update.
- board: board.leo/board_state.record,
+ board: board.aleo/board_state.record,
// The incoming move from the opponent.
- move_incoming: move.leo/move.record,
+ move_incoming: move.aleo/move.record,
// The u64 equivalent of the bitwise representation of the next coordinate to play on the opponent's board.
shoot: u64,
- ) -> (board.leo/board_state.record, move.leo/move.record) {
+ ) -> (board.aleo/board_state.record, move.aleo/move.record) {
// Verify the board has been started. This prevents players from starting a game and then creating
// a brand new board to play with.
assert(board.game_started);
@@ -89,15 +89,15 @@ program battleship.aleo {
assert_eq(board.player_2, move_incoming.player_1);
// Play coordinate on own board. Will fail if not a valid move.
- let hit_or_miss: board_state = board.leo/update_played_tiles(board, shoot);
+ let hit_or_miss: board_state = board.aleo/update_played_tiles(board, shoot);
// Update own board with result of last shot.
- let next_board: board_state = board.leo/update_hits_and_misses(hit_or_miss, move_incoming.prev_hit_or_miss);
+ let next_board: board_state = board.aleo/update_hits_and_misses(hit_or_miss, move_incoming.prev_hit_or_miss);
// Assess whether incoming fire coordinate is a hit.
let is_hit: u64 = move_incoming.incoming_fire_coordinate & board.ships;
- let next_move: move = move.leo/create_move(move_incoming, shoot, is_hit);
+ let next_move: move = move.aleo/create_move(move_incoming, shoot, is_hit);
return (next_board, next_move);
}
diff --git a/examples/battleship/verify/.gitignore b/examples/battleship/verify/.gitignore
new file mode 100644
index 0000000000..f721f7f6f4
--- /dev/null
+++ b/examples/battleship/verify/.gitignore
@@ -0,0 +1,5 @@
+.env
+*.avm
+*.prover
+*.verifier
+outputs/
diff --git a/examples/battleship/verify/README.md b/examples/battleship/verify/README.md
new file mode 100644
index 0000000000..f5f2c6731e
--- /dev/null
+++ b/examples/battleship/verify/README.md
@@ -0,0 +1,13 @@
+# verify.aleo
+
+## Build Guide
+
+To compile this Aleo program, run:
+```bash
+snarkvm build
+```
+
+To execute this Aleo program, run:
+```bash
+snarkvm run hello
+```
diff --git a/examples/battleship/verify/build/main.aleo b/examples/battleship/verify/build/main.aleo
new file mode 100644
index 0000000000..804dcf2a0e
--- /dev/null
+++ b/examples/battleship/verify/build/main.aleo
@@ -0,0 +1,73 @@
+program verify.aleo;
+
+
+
+closure bitcount:
+ input r0 as u64;
+ div r0 2u64 into r1;
+ div r0 4u64 into r2;
+ div r0 8u64 into r3;
+ and r1 8608480567731124087u64 into r4;
+ and r2 3689348814741910323u64 into r5;
+ and r3 1229782938247303441u64 into r6;
+ sub r0 r4 into r7;
+ sub r7 r5 into r8;
+ sub r8 r6 into r9;
+ div r9 16u64 into r10;
+ add r9 r10 into r11;
+ and r11 1085102592571150095u64 into r12;
+ rem r12 255u64 into r13;
+ output r13 as u64;
+
+
+closure adjacency_check:
+ input r0 as u64;
+ input r1 as u64;
+ div r0 r1 into r2;
+ is.eq r2 0u64 into r3;
+ ternary r3 3u64 r2 into r4;
+ sub r4 1u64 into r5;
+ and r5 r4 into r6;
+ is.eq r6 0u64 into r7;
+ output r7 as boolean;
+
+
+closure horizontal_check:
+ input r0 as u64;
+ input r1 as u64;
+ rem r0 255u64 into r2;
+ div r2 r1 into r3;
+ is.eq r3 0u64 into r4;
+ ternary r4 3u64 r3 into r5;
+ sub r5 1u64 into r6;
+ and r6 r5 into r7;
+ is.eq r7 0u64 into r8;
+ output r8 as boolean;
+
+
+function validate_ship:
+ input r0 as u64.private;
+ input r1 as u64.private;
+ input r2 as u64.private;
+ input r3 as u64.private;
+ call bitcount r0 into r4;
+ assert.eq r4 r1;
+ call adjacency_check r0 r2 into r5;
+ call horizontal_check r0 r2 into r6;
+ and r5 r6 into r7;
+ call adjacency_check r0 r3 into r8;
+ or r7 r8 into r9;
+ output r9 as boolean.private;
+
+
+function create_board:
+ input r0 as u64.private;
+ input r1 as u64.private;
+ input r2 as u64.private;
+ input r3 as u64.private;
+ or r0 r1 into r4;
+ or r4 r2 into r5;
+ or r5 r3 into r6;
+ call bitcount r6 into r7;
+ assert.eq r7 14u64;
+ output r6 as u64.private;
diff --git a/examples/battleship/verify/build/program.json b/examples/battleship/verify/build/program.json
new file mode 100644
index 0000000000..b9b28db270
--- /dev/null
+++ b/examples/battleship/verify/build/program.json
@@ -0,0 +1,6 @@
+{
+ "program": "verify.aleo",
+ "version": "0.0.0",
+ "description": "",
+ "license": "MIT"
+}
diff --git a/examples/battleship/verify/inputs/verify.in b/examples/battleship/verify/inputs/verify.in
new file mode 100644
index 0000000000..0321a565c0
--- /dev/null
+++ b/examples/battleship/verify/inputs/verify.in
@@ -0,0 +1,4 @@
+// The program input for verify/src/main.leo
+[main]
+public a: u32 = 1u32;
+b: u32 = 2u32;
diff --git a/examples/battleship/verify/leo.lock b/examples/battleship/verify/leo.lock
new file mode 100644
index 0000000000..c4293b3b9f
--- /dev/null
+++ b/examples/battleship/verify/leo.lock
@@ -0,0 +1 @@
+package = []
diff --git a/examples/battleship/verify/program.json b/examples/battleship/verify/program.json
new file mode 100644
index 0000000000..b9b28db270
--- /dev/null
+++ b/examples/battleship/verify/program.json
@@ -0,0 +1,6 @@
+{
+ "program": "verify.aleo",
+ "version": "0.0.0",
+ "description": "",
+ "license": "MIT"
+}
diff --git a/examples/battleship/imports/verify.leo b/examples/battleship/verify/src/main.leo
similarity index 100%
rename from examples/battleship/imports/verify.leo
rename to examples/battleship/verify/src/main.leo
diff --git a/examples/bubblesort/README.md b/examples/bubblesort/README.md
index 054a9a6739..9fcbfbdde3 100644
--- a/examples/bubblesort/README.md
+++ b/examples/bubblesort/README.md
@@ -4,14 +4,14 @@
To run this program, run:
```bash
-leo run bubble_sort
+leo run bubble_sort
```
## Execute Guide
To execute this program, run:
```bash
-leo execute bubble_sort
+leo execute bubble_sort
```
## Overview
diff --git a/examples/bubblesort/inputs/bubblesort.in b/examples/bubblesort/inputs/bubblesort.in
index a435f71f0e..d0152c0bdd 100644
--- a/examples/bubblesort/inputs/bubblesort.in
+++ b/examples/bubblesort/inputs/bubblesort.in
@@ -1,12 +1 @@
-// The program input for bubblesort_tuple/src/main.leo
-[bubble_sort]
-arr0: u32 = 13u32;
-arr1: u32 = 2u32;
-arr2: u32 = 4u32;
-arr3: u32 = 3u32;
-arr4: u32 = 5u32;
-arr5: u32 = 10u32;
-arr6: u32 = 7u32;
-arr7: u32 = 1u32;
-
-
+13u32 2u32 4u32 3u32 5u32 10u32 7u32 1u32
diff --git a/examples/bubblesort/leo.lock b/examples/bubblesort/leo.lock
new file mode 100644
index 0000000000..c4293b3b9f
--- /dev/null
+++ b/examples/bubblesort/leo.lock
@@ -0,0 +1 @@
+package = []
diff --git a/examples/core/README.md b/examples/core/README.md
index 22e1205f89..4053adb7d6 100644
--- a/examples/core/README.md
+++ b/examples/core/README.md
@@ -4,12 +4,12 @@
To run this program, run:
```bash
-leo run main
+leo run main
```
## Execute Guide
To execute this program, run:
```bash
-leo execute main
+leo execute main
```
diff --git a/examples/core/build/main.aleo b/examples/core/build/main.aleo
index 40adc53c98..c7c63279b5 100644
--- a/examples/core/build/main.aleo
+++ b/examples/core/build/main.aleo
@@ -4,4 +4,7 @@ program core.aleo;
function main:
input r0 as field.private;
- hash.bhp256 r0 into r1 as field; hash.psd2 r1 into r2 as field; commit.bhp256 r2 1scalar into r3 as field; output r3 as field.private;
+ hash.bhp256 r0 into r1 as field;
+ hash.psd2 r1 into r2 as field;
+ commit.bhp256 r2 1scalar into r3 as field;
+ output r3 as field.private;
diff --git a/examples/core/inputs/core.in b/examples/core/inputs/core.in
index b270c2ace9..336793ee4e 100644
--- a/examples/core/inputs/core.in
+++ b/examples/core/inputs/core.in
@@ -1,4 +1,2 @@
-// The program input for core/src/main.leo
-[main]
-public a: field = 1field;
+1field
diff --git a/examples/core/leo.lock b/examples/core/leo.lock
new file mode 100644
index 0000000000..c4293b3b9f
--- /dev/null
+++ b/examples/core/leo.lock
@@ -0,0 +1 @@
+package = []
diff --git a/examples/fibonacci/README.md b/examples/fibonacci/README.md
index 5c1a368bdb..04e07a7320 100644
--- a/examples/fibonacci/README.md
+++ b/examples/fibonacci/README.md
@@ -4,17 +4,17 @@
To run this program, run:
```bash
-leo run fibonacci
+leo run fibonacci
```
## Execute Guide
To execute this program, run:
```bash
-leo execute fibonacci
+leo execute fibonacci
```
## Overview
This example shows how to calculate Fibonacci number using the [fast-doubling method](https://math.stackexchange.com/questions/1124590/need-help-understanding-fibonacci-fast-doubling-proof).
-It takes the input data from `inputs/fibonacci.in`
\ No newline at end of file
+It takes the input data from `inputs/fibonacci.in`
diff --git a/examples/fibonacci/inputs/fibonacci.in b/examples/fibonacci/inputs/fibonacci.in
index 5a7b84c071..9ba1528650 100644
--- a/examples/fibonacci/inputs/fibonacci.in
+++ b/examples/fibonacci/inputs/fibonacci.in
@@ -1,3 +1 @@
-// The program input for fibonacci/src/main.leo
-[fibonacci]
-public n: u8 = 63u8;
+63u8
diff --git a/examples/groups/README.md b/examples/groups/README.md
index cce23e64c0..814d675dab 100644
--- a/examples/groups/README.md
+++ b/examples/groups/README.md
@@ -4,14 +4,14 @@
To run this program, run:
```bash
-leo run main
+leo run main
```
## Execute Guide
To execute this program, run:
```bash
-leo execute main
+leo execute main
```
## Overview
diff --git a/examples/groups/inputs/groups.in b/examples/groups/inputs/groups.in
index e3e45c9c2c..8fd3c23e6d 100644
--- a/examples/groups/inputs/groups.in
+++ b/examples/groups/inputs/groups.in
@@ -1,4 +1 @@
-// The program input for groups/src/main.leo
-// Leo will use provided string as the x coordinate and attempt to recover the y coordinate to form a group.
-[main]
-a: group = 1817767092074430972953743941103352519057913259183777531581123188265134806220group;
+1817767092074430972953743941103352519057913259183777531581123188265134806220group
diff --git a/examples/groups/leo.lock b/examples/groups/leo.lock
new file mode 100644
index 0000000000..c4293b3b9f
--- /dev/null
+++ b/examples/groups/leo.lock
@@ -0,0 +1 @@
+package = []
diff --git a/examples/hackers-delight/ntzdebruijn/README.md b/examples/hackers-delight/ntzdebruijn/README.md
index b1daf58225..b147b3bf3b 100644
--- a/examples/hackers-delight/ntzdebruijn/README.md
+++ b/examples/hackers-delight/ntzdebruijn/README.md
@@ -4,7 +4,7 @@
To compile and run this Leo program, run:
```bash
-leo run
+leo run
```
## The Algorithm
diff --git a/examples/hackers-delight/ntzdebruijn/inputs/ntzdebruijn.in b/examples/hackers-delight/ntzdebruijn/inputs/ntzdebruijn.in
index 6ccda493e8..b140da3eb3 100644
--- a/examples/hackers-delight/ntzdebruijn/inputs/ntzdebruijn.in
+++ b/examples/hackers-delight/ntzdebruijn/inputs/ntzdebruijn.in
@@ -1,3 +1 @@
-// The program input for ntzdebruijn/src/main.leo
-[main]
-public x: u32 = 2147483648u32;
+2147483648u32
diff --git a/examples/hackers-delight/ntzdebruijn/leo.lock b/examples/hackers-delight/ntzdebruijn/leo.lock
new file mode 100644
index 0000000000..c4293b3b9f
--- /dev/null
+++ b/examples/hackers-delight/ntzdebruijn/leo.lock
@@ -0,0 +1 @@
+package = []
diff --git a/examples/hackers-delight/ntzgaudet/README.md b/examples/hackers-delight/ntzgaudet/README.md
index 8bca776405..2410fe0cb3 100644
--- a/examples/hackers-delight/ntzgaudet/README.md
+++ b/examples/hackers-delight/ntzgaudet/README.md
@@ -4,7 +4,7 @@
To compile and run this Leo program, run:
```bash
-leo run
+leo run
```
## The Algorithm
diff --git a/examples/hackers-delight/ntzgaudet/inputs/ntzgaudet.in b/examples/hackers-delight/ntzgaudet/inputs/ntzgaudet.in
index f740df6320..b140da3eb3 100644
--- a/examples/hackers-delight/ntzgaudet/inputs/ntzgaudet.in
+++ b/examples/hackers-delight/ntzgaudet/inputs/ntzgaudet.in
@@ -1,3 +1 @@
-// The program input for ntzgaudet/src/main.leo
-[main]
-public x: u32 = 2147483648u32;
+2147483648u32
diff --git a/examples/hackers-delight/ntzgaudet/leo.lock b/examples/hackers-delight/ntzgaudet/leo.lock
new file mode 100644
index 0000000000..c4293b3b9f
--- /dev/null
+++ b/examples/hackers-delight/ntzgaudet/leo.lock
@@ -0,0 +1 @@
+package = []
diff --git a/examples/hackers-delight/ntzloops/README.md b/examples/hackers-delight/ntzloops/README.md
index 49d6b05727..dace1ddf94 100644
--- a/examples/hackers-delight/ntzloops/README.md
+++ b/examples/hackers-delight/ntzloops/README.md
@@ -4,7 +4,7 @@
To compile and run this Leo program, run:
```bash
-leo run
+leo run
```
## The Algorithm
diff --git a/examples/hackers-delight/ntzloops/inputs/ntzloops.in b/examples/hackers-delight/ntzloops/inputs/ntzloops.in
index 9b472e4e7c..b140da3eb3 100644
--- a/examples/hackers-delight/ntzloops/inputs/ntzloops.in
+++ b/examples/hackers-delight/ntzloops/inputs/ntzloops.in
@@ -1,3 +1 @@
-// The program input for ntzloops/src/main.leo
-[main]
-public x: u32 = 2147483648u32;
+2147483648u32
diff --git a/examples/hackers-delight/ntzloops/leo.lock b/examples/hackers-delight/ntzloops/leo.lock
new file mode 100644
index 0000000000..c4293b3b9f
--- /dev/null
+++ b/examples/hackers-delight/ntzloops/leo.lock
@@ -0,0 +1 @@
+package = []
diff --git a/examples/hackers-delight/ntzmasks/README.md b/examples/hackers-delight/ntzmasks/README.md
index c3b0b7fe16..2987cda3ea 100644
--- a/examples/hackers-delight/ntzmasks/README.md
+++ b/examples/hackers-delight/ntzmasks/README.md
@@ -4,7 +4,7 @@
To compile and run this Leo program, run:
```bash
-leo run
+leo run
```
## The Algorithm
diff --git a/examples/hackers-delight/ntzmasks/inputs/ntzmasks.in b/examples/hackers-delight/ntzmasks/inputs/ntzmasks.in
index cf8aad75a4..8a4354d07d 100644
--- a/examples/hackers-delight/ntzmasks/inputs/ntzmasks.in
+++ b/examples/hackers-delight/ntzmasks/inputs/ntzmasks.in
@@ -1,3 +1 @@
-// The program input for ntzmasks/src/main.leo
-[main]
-public x: u32 = 1073741824u32;
+1073741824u32
diff --git a/examples/hackers-delight/ntzmasks/leo.lock b/examples/hackers-delight/ntzmasks/leo.lock
new file mode 100644
index 0000000000..c4293b3b9f
--- /dev/null
+++ b/examples/hackers-delight/ntzmasks/leo.lock
@@ -0,0 +1 @@
+package = []
diff --git a/examples/hackers-delight/ntzreisers/README.md b/examples/hackers-delight/ntzreisers/README.md
index ba8fa11530..54af2b5d5d 100644
--- a/examples/hackers-delight/ntzreisers/README.md
+++ b/examples/hackers-delight/ntzreisers/README.md
@@ -4,7 +4,7 @@
To compile and run this Leo program, run:
```bash
-leo run
+leo run
```
## The Algorithm
diff --git a/examples/hackers-delight/ntzreisers/inputs/ntzreisers.in b/examples/hackers-delight/ntzreisers/inputs/ntzreisers.in
index e32704ee31..b140da3eb3 100644
--- a/examples/hackers-delight/ntzreisers/inputs/ntzreisers.in
+++ b/examples/hackers-delight/ntzreisers/inputs/ntzreisers.in
@@ -1,3 +1 @@
-// The program input for ntzreisers/src/main.leo
-[main]
-public x: u32 = 2147483648u32;
+2147483648u32
diff --git a/examples/hackers-delight/ntzreisers/leo.lock b/examples/hackers-delight/ntzreisers/leo.lock
new file mode 100644
index 0000000000..c4293b3b9f
--- /dev/null
+++ b/examples/hackers-delight/ntzreisers/leo.lock
@@ -0,0 +1 @@
+package = []
diff --git a/examples/hackers-delight/ntzseals/README.md b/examples/hackers-delight/ntzseals/README.md
index 47322931db..c5bd65c1a2 100644
--- a/examples/hackers-delight/ntzseals/README.md
+++ b/examples/hackers-delight/ntzseals/README.md
@@ -4,7 +4,7 @@
To compile and run this Leo program, run:
```bash
-leo run
+leo run
```
## The Algorithm
diff --git a/examples/hackers-delight/ntzseals/inputs/ntzseals.in b/examples/hackers-delight/ntzseals/inputs/ntzseals.in
index 74ddc44340..b140da3eb3 100644
--- a/examples/hackers-delight/ntzseals/inputs/ntzseals.in
+++ b/examples/hackers-delight/ntzseals/inputs/ntzseals.in
@@ -1,3 +1 @@
-// The program input for nztseals/src/main.leo
-[main]
-public x: u32 = 2147483648u32;
+2147483648u32
diff --git a/examples/hackers-delight/ntzseals/leo.lock b/examples/hackers-delight/ntzseals/leo.lock
new file mode 100644
index 0000000000..c4293b3b9f
--- /dev/null
+++ b/examples/hackers-delight/ntzseals/leo.lock
@@ -0,0 +1 @@
+package = []
diff --git a/examples/hackers-delight/ntzsearchtree/README.md b/examples/hackers-delight/ntzsearchtree/README.md
index ff7fc9cb8e..147cbd23b1 100644
--- a/examples/hackers-delight/ntzsearchtree/README.md
+++ b/examples/hackers-delight/ntzsearchtree/README.md
@@ -4,7 +4,7 @@
To compile and run this Leo program, run:
```bash
-leo run
+leo run
```
## The Algorithm
diff --git a/examples/hackers-delight/ntzsearchtree/inputs/ntzsearchtree.in b/examples/hackers-delight/ntzsearchtree/inputs/ntzsearchtree.in
index 19caf1bdb5..b140da3eb3 100644
--- a/examples/hackers-delight/ntzsearchtree/inputs/ntzsearchtree.in
+++ b/examples/hackers-delight/ntzsearchtree/inputs/ntzsearchtree.in
@@ -1,3 +1 @@
-// The program input for ntzsearchtree/src/main.leo
-[main]
-public z: u32 = 2147483648u32;
+2147483648u32
diff --git a/examples/hackers-delight/ntzsearchtree/leo.lock b/examples/hackers-delight/ntzsearchtree/leo.lock
new file mode 100644
index 0000000000..c4293b3b9f
--- /dev/null
+++ b/examples/hackers-delight/ntzsearchtree/leo.lock
@@ -0,0 +1 @@
+package = []
diff --git a/examples/hackers-delight/ntzsmallvals/README.md b/examples/hackers-delight/ntzsmallvals/README.md
index 4e111d26f0..1b99a7f4ff 100644
--- a/examples/hackers-delight/ntzsmallvals/README.md
+++ b/examples/hackers-delight/ntzsmallvals/README.md
@@ -4,7 +4,7 @@
To compile and run this Leo program, run:
```bash
-leo run
+leo run
```
## The Algorithm
diff --git a/examples/hackers-delight/ntzsmallvals/inputs/ntzsmallvals.in b/examples/hackers-delight/ntzsmallvals/inputs/ntzsmallvals.in
index 5f84301885..b140da3eb3 100644
--- a/examples/hackers-delight/ntzsmallvals/inputs/ntzsmallvals.in
+++ b/examples/hackers-delight/ntzsmallvals/inputs/ntzsmallvals.in
@@ -1,3 +1 @@
-// The program input for ntzsmallvals/src/main.leo
-[main]
-public x: u32 = 2147483648u32;
+2147483648u32
diff --git a/examples/hackers-delight/ntzsmallvals/leo.lock b/examples/hackers-delight/ntzsmallvals/leo.lock
new file mode 100644
index 0000000000..c4293b3b9f
--- /dev/null
+++ b/examples/hackers-delight/ntzsmallvals/leo.lock
@@ -0,0 +1 @@
+package = []
diff --git a/examples/helloworld/README.md b/examples/helloworld/README.md
index df05077cb9..75fa0f1793 100644
--- a/examples/helloworld/README.md
+++ b/examples/helloworld/README.md
@@ -4,7 +4,7 @@
To run this program, run:
```bash
-leo run main
+leo run
```
## Execute Guide
@@ -18,4 +18,4 @@ leo execute main
This example shows how to sum two u32 numbers.
-It takes the input data from inputs/helloworld.in
\ No newline at end of file
+It takes the input data from inputs/helloworld.in
diff --git a/examples/helloworld/inputs/helloworld.in b/examples/helloworld/inputs/helloworld.in
index 89e24a5ea8..35ea052c38 100644
--- a/examples/helloworld/inputs/helloworld.in
+++ b/examples/helloworld/inputs/helloworld.in
@@ -1,4 +1 @@
-// The program input for helloworld/src/main.leo
-[main]
-public a: u32 = 1u32;
-b: u32 = 2u32; // Input variable `b` is private by default.
\ No newline at end of file
+1u32 2u32
diff --git a/examples/helloworld/leo.lock b/examples/helloworld/leo.lock
new file mode 100644
index 0000000000..c4293b3b9f
--- /dev/null
+++ b/examples/helloworld/leo.lock
@@ -0,0 +1 @@
+package = []
diff --git a/examples/interest/README.md b/examples/interest/README.md
index eff9b9e799..06ef484d11 100644
--- a/examples/interest/README.md
+++ b/examples/interest/README.md
@@ -6,7 +6,7 @@ This program provides utilities for calculating interest over a fixed or bounded
To run this program, run:
```bash
-leo run
+leo run
```
where `` is one of the following:
* `fixed_iteration_interest`
@@ -18,10 +18,10 @@ Be sure to update `inputs/interest.in` with the desired inputs.
To execute this program, run:
```bash
-leo execute
+leo execute
```
where `` is one of the following:
* `fixed_iteration_interest`
* `bounded_iteration_interest`
-Be sure to update `inputs/interest.in` with the desired inputs.
\ No newline at end of file
+Be sure to update `inputs/interest.in` with the desired inputs.
diff --git a/examples/interest/inputs/bounded.in b/examples/interest/inputs/bounded.in
new file mode 100644
index 0000000000..01909ddbde
--- /dev/null
+++ b/examples/interest/inputs/bounded.in
@@ -0,0 +1 @@
+80u32 5u32 10u8
diff --git a/examples/interest/inputs/fixed.in b/examples/interest/inputs/fixed.in
new file mode 100644
index 0000000000..95572d3936
--- /dev/null
+++ b/examples/interest/inputs/fixed.in
@@ -0,0 +1 @@
+80u32 5u32
diff --git a/examples/interest/inputs/interest.in b/examples/interest/inputs/interest.in
deleted file mode 100644
index 2017b5c613..0000000000
--- a/examples/interest/inputs/interest.in
+++ /dev/null
@@ -1,9 +0,0 @@
-// The program input for interest/src/main.leo
-[fixed_iteration_interest]
-capital: u32 = 80u32;
-rate: u32 = 5u32; // 5%
-
-[bounded_iteration_interest]
-capital: u32 = 80u32;
-rate: u32 = 5u32; // 5%
-iterations: u8 = 10u8;
diff --git a/examples/interest/leo.lock b/examples/interest/leo.lock
new file mode 100644
index 0000000000..c4293b3b9f
--- /dev/null
+++ b/examples/interest/leo.lock
@@ -0,0 +1 @@
+package = []
diff --git a/examples/lottery/README.md b/examples/lottery/README.md
index 7972a8e90d..87512a4a2a 100644
--- a/examples/lottery/README.md
+++ b/examples/lottery/README.md
@@ -4,7 +4,7 @@
To run this program, run:
```bash
-leo run play
+leo run play
or
@@ -15,5 +15,5 @@ or
To execute this program, run:
```bash
-leo execute play
+leo execute play
```
diff --git a/examples/lottery/build/main.aleo b/examples/lottery/build/main.aleo
index 73941df8de..dc0ee909fd 100644
--- a/examples/lottery/build/main.aleo
+++ b/examples/lottery/build/main.aleo
@@ -5,14 +5,14 @@ record Ticket:
mapping num_winners:
- key left as u8.public;
- value right as u8.public;
+ key as u8.public;
+ value as u8.public;
function play:
cast self.caller into r0 as Ticket.record;
+ async play into r1;
output r0 as Ticket.record;
-
- finalize;
+ output r1 as lottery.aleo/play.future;
finalize play:
lte block.height 1000u32 into r0;
diff --git a/examples/lottery/leo.lock b/examples/lottery/leo.lock
new file mode 100644
index 0000000000..c4293b3b9f
--- /dev/null
+++ b/examples/lottery/leo.lock
@@ -0,0 +1 @@
+package = []
diff --git a/examples/message/README.md b/examples/message/README.md
index 91c4fb8fdf..c2476a63b2 100644
--- a/examples/message/README.md
+++ b/examples/message/README.md
@@ -5,12 +5,12 @@ A basic example showing how to declare a struct in the Leo language.
To run this program, run:
```bash
-leo run main
+leo run main
```
## Execute Guide
To execute this program, run:
```bash
-leo execute main
+leo execute main
```
diff --git a/examples/message/inputs/message.in b/examples/message/inputs/message.in
index cb5293db1b..1f0ce50e2e 100644
--- a/examples/message/inputs/message.in
+++ b/examples/message/inputs/message.in
@@ -1,7 +1,4 @@
-// The program input for message/src/main.leo
-// To pass "m" into the "main" function we
-// 1. Define the "Message" type.
-// 2. Use brackets `{ }` to enclose the struct members.
-// 3. Define each struct member `name : value`.
-[main]
-m: Message = Message { first: 2field, second: 3field };
+{
+ first: 2field,
+ second: 3field
+}
diff --git a/examples/message/leo.lock b/examples/message/leo.lock
new file mode 100644
index 0000000000..c4293b3b9f
--- /dev/null
+++ b/examples/message/leo.lock
@@ -0,0 +1 @@
+package = []
diff --git a/examples/simple_token/README.md b/examples/simple_token/README.md
index ce2587f6a2..46c3a2da0d 100644
--- a/examples/simple_token/README.md
+++ b/examples/simple_token/README.md
@@ -4,14 +4,14 @@
To run this program, run:
```bash
-leo run mint
-leo run transfer # update private key first
+leo run mint
+leo run transfer # update private key first
```
## Execute Guide
To execute this program, run:
```bash
-leo execute mint
-leo execute transfer # update private key first
+leo execute mint
+leo execute transfer # update private key first
```
diff --git a/examples/simple_token/inputs/mint.in b/examples/simple_token/inputs/mint.in
new file mode 100644
index 0000000000..e157dbe766
--- /dev/null
+++ b/examples/simple_token/inputs/mint.in
@@ -0,0 +1 @@
+aleo1mgfq6g40l6zkhsm063n3uhr43qk5e0zsua5aszeq5080dsvlcvxsn0rrau 100u64
diff --git a/examples/simple_token/inputs/simple_token.in b/examples/simple_token/inputs/simple_token.in
deleted file mode 100644
index 6110325743..0000000000
--- a/examples/simple_token/inputs/simple_token.in
+++ /dev/null
@@ -1,13 +0,0 @@
-// The program input for simple_token/src/main.leo
-[mint]
-owner: address = aleo1mgfq6g40l6zkhsm063n3uhr43qk5e0zsua5aszeq5080dsvlcvxsn0rrau;
-amount: u64 = 100u64;
-
-[transfer]
-token: Token = Token {
- owner: aleo1mgfq6g40l6zkhsm063n3uhr43qk5e0zsua5aszeq5080dsvlcvxsn0rrau,
- amount: 100u64,
- _nonce: 0group,
-};
-to: address = aleo1mgfq6g40l6zkhsm063n3uhr43qk5e0zsua5aszeq5080dsvlcvxsn0rrau;
-amount: u64 = 50u64;
diff --git a/examples/simple_token/inputs/transfer.in b/examples/simple_token/inputs/transfer.in
new file mode 100644
index 0000000000..d62ac71bac
--- /dev/null
+++ b/examples/simple_token/inputs/transfer.in
@@ -0,0 +1,7 @@
+{
+ owner: aleo1mgfq6g40l6zkhsm063n3uhr43qk5e0zsua5aszeq5080dsvlcvxsn0rrau.private,
+ amount: 100u64.private,
+ _nonce: 0group.public
+}
+aleo1mgfq6g40l6zkhsm063n3uhr43qk5e0zsua5aszeq5080dsvlcvxsn0rrau
+50u64
diff --git a/examples/simple_token/leo.lock b/examples/simple_token/leo.lock
new file mode 100644
index 0000000000..c4293b3b9f
--- /dev/null
+++ b/examples/simple_token/leo.lock
@@ -0,0 +1 @@
+package = []
diff --git a/examples/tictactoe/README.md b/examples/tictactoe/README.md
index 84d6f7f33c..1696d144a7 100644
--- a/examples/tictactoe/README.md
+++ b/examples/tictactoe/README.md
@@ -27,23 +27,13 @@ An alternative representation would be to use an array, however, these are not y
## Running the Program
Leo provides users with a command line interface for compiling and running Leo programs.
-Users may either specify input values via the command line or provide an input file in `inputs/`.
### Providing inputs via the command line.
-1. Run
```bash
leo run ...
```
See `./run.sh` for an example.
-
-### Using an input file.
-1. Modify `inputs/tictactoe.in` with the desired inputs.
-2. Run
-```bash
-leo run
-```
-
## Executing the Program
```bash
leo execute ...
diff --git a/examples/tictactoe/build/main.aleo b/examples/tictactoe/build/main.aleo
index c6aa9f0a9c..2431ce3837 100644
--- a/examples/tictactoe/build/main.aleo
+++ b/examples/tictactoe/build/main.aleo
@@ -181,7 +181,7 @@ function make_move:
ternary r17 r3.r3.c3 r93 into r102;
cast r94 r95 r96 into r103 as Row;
cast r97 r98 r99 into r104 as Row;
- cast r100 r98 r99 into r105 as Row;
+ cast r100 r101 r102 into r105 as Row;
cast r103 r104 r105 into r106 as Board;
call check_for_win r106 1u8 into r107;
call check_for_win r106 2u8 into r108;
diff --git a/examples/tictactoe/inputs/tictactoe.in b/examples/tictactoe/inputs/tictactoe.in
index aff78f3ac5..5f799d5991 100644
--- a/examples/tictactoe/inputs/tictactoe.in
+++ b/examples/tictactoe/inputs/tictactoe.in
@@ -1,18 +1,8 @@
-// The `new` function does not take any inputs.
-[new]
-
-// Inputs for the `make_move` function.
-// - `player` : A u8 representing the player making the move. 1 for player 1, 2 for player 2.
-// - `row` : A u8 representing the row to make the move in.
-// - `column` : A u8 representing the column to make the move in.
-// - `board` : A representation of the board state.
-[make_move]
-player: u8 = 1u8;
-row: u8 = 1u8;
-col: u8 = 1u8;
-board: Board = Board {
- r1: Row { c1: 0u8, c2: 0u8, c3: 0u8 },
- r2: Row { c1: 0u8, c2: 0u8, c3: 0u8 },
- r3: Row { c1: 0u8, c2: 0u8, c3: 0u8 },
-};
-
+1u8
+1u8
+1u8
+{
+ r1: { c1: 0u8, c2: 0u8, c3: 0u8 },
+ r2: { c1: 0u8, c2: 0u8, c3: 0u8 },
+ r3: { c1: 0u8, c2: 0u8, c3: 0u8 }
+}
diff --git a/examples/tictactoe/leo.lock b/examples/tictactoe/leo.lock
new file mode 100644
index 0000000000..c4293b3b9f
--- /dev/null
+++ b/examples/tictactoe/leo.lock
@@ -0,0 +1 @@
+package = []
diff --git a/examples/token/.env b/examples/token/.env
index 2c5429aaed..e86f465a56 100644
--- a/examples/token/.env
+++ b/examples/token/.env
@@ -1,2 +1,4 @@
+
NETWORK=testnet3
-PRIVATE_KEY=APrivateKey1zkpGZsYM8WQJMDDrzeAhB2SB3N9WcGt9Ks6NLBKCWyiMKv8
+PRIVATE_KEY=APrivateKey1zkp1w8PTxrRgGfAtfKUSq43iQyVbdQHfhGbiNPEg2LVSEXR
+
diff --git a/examples/token/build/main.aleo b/examples/token/build/main.aleo
index ec32c954b3..2f80ca2797 100644
--- a/examples/token/build/main.aleo
+++ b/examples/token/build/main.aleo
@@ -6,14 +6,14 @@ record token:
mapping account:
- key left as address.public;
- value right as u64.public;
+ key as address.public;
+ value as u64.public;
function mint_public:
input r0 as address.public;
input r1 as u64.public;
-
- finalize r0 r1;
+ async mint_public r0 r1 into r2;
+ output r2 as token.aleo/mint_public.future;
finalize mint_public:
input r0 as address.public;
@@ -33,8 +33,8 @@ function mint_private:
function transfer_public:
input r0 as address.public;
input r1 as u64.public;
-
- finalize self.caller r0 r1;
+ async transfer_public self.caller r0 r1 into r2;
+ output r2 as token.aleo/transfer_public.future;
finalize transfer_public:
input r0 as address.public;
@@ -65,9 +65,9 @@ function transfer_private_to_public:
input r2 as u64.public;
sub r0.amount r2 into r3;
cast r0.owner r3 into r4 as token.record;
+ async transfer_private_to_public r1 r2 into r5;
output r4 as token.record;
-
- finalize r1 r2;
+ output r5 as token.aleo/transfer_private_to_public.future;
finalize transfer_private_to_public:
input r0 as address.public;
@@ -81,9 +81,9 @@ function transfer_public_to_private:
input r0 as address.public;
input r1 as u64.public;
cast r0 r1 into r2 as token.record;
+ async transfer_public_to_private self.caller r1 into r3;
output r2 as token.record;
-
- finalize self.caller r1;
+ output r3 as token.aleo/transfer_public_to_private.future;
finalize transfer_public_to_private:
input r0 as address.public;
diff --git a/examples/token/leo.lock b/examples/token/leo.lock
new file mode 100644
index 0000000000..c4293b3b9f
--- /dev/null
+++ b/examples/token/leo.lock
@@ -0,0 +1 @@
+package = []
diff --git a/examples/twoadicity/README.md b/examples/twoadicity/README.md
index 5742b59e43..d3cbb467fa 100644
--- a/examples/twoadicity/README.md
+++ b/examples/twoadicity/README.md
@@ -4,12 +4,12 @@
To run this program, run:
```bash
-leo run main
+leo run main
```
## Execute Guide
To execute this program, run:
```bash
-leo execute main
+leo execute main
```
diff --git a/examples/twoadicity/inputs/twoadicity.in b/examples/twoadicity/inputs/twoadicity.in
index 2cc7860439..c01cac0720 100644
--- a/examples/twoadicity/inputs/twoadicity.in
+++ b/examples/twoadicity/inputs/twoadicity.in
@@ -1,11 +1 @@
-// The program input for twoadicity/src/main.leo
-[main]
-// Here is a made-up example.
-// public a: field = 391995973843653359517682711560178397928211734490775552field;
-// (comes from: 2field.pow(41) * 178259130663561045147472537592047227885001field)
-
-// This example is (maxfield - 1).
-// The output for this can be seen in the Pratt certificate
-// for bls12-377-scalar-field-prime
-// as the number of factors of 2 in (bls12-377-scalar-field-prime - 1).
-public a: field = 8444461749428370424248824938781546531375899335154063827935233455917409239040field;
+8444461749428370424248824938781546531375899335154063827935233455917409239040field
diff --git a/examples/twoadicity/leo.lock b/examples/twoadicity/leo.lock
new file mode 100644
index 0000000000..c4293b3b9f
--- /dev/null
+++ b/examples/twoadicity/leo.lock
@@ -0,0 +1 @@
+package = []
diff --git a/examples/vote/README.md b/examples/vote/README.md
index 18e3c6398f..8dba4968b5 100644
--- a/examples/vote/README.md
+++ b/examples/vote/README.md
@@ -33,7 +33,7 @@ Anyone can issue a new proposal publicly by calling `propose` function.
Run `propose`:
```
-leo run propose
+leo run propose
```
Output sample:
@@ -62,7 +62,7 @@ and can only be used(voted) by the ticket `owner`.
Run `new_ticket`:
```
-leo run new_ticket
+leo run new_ticket
```
Output sample:
@@ -84,11 +84,11 @@ Since the ticket record can be used as an input privately, the voter's privacy i
Run `agree`:
```
-leo run agree
+leo run agree
```
Run `disagree`:
```
-leo run disagree
+leo run disagree
```
diff --git a/examples/vote/build/main.aleo b/examples/vote/build/main.aleo
index fdaafdbfdf..82cfdf4cf0 100644
--- a/examples/vote/build/main.aleo
+++ b/examples/vote/build/main.aleo
@@ -16,31 +16,31 @@ record Ticket:
mapping proposals:
- key left as field.public;
- value right as ProposalInfo.public;
+ key as field.public;
+ value as ProposalInfo.public;
mapping tickets:
- key left as field.public;
- value right as u64.public;
+ key as field.public;
+ value as u64.public;
mapping agree_votes:
- key left as field.public;
- value right as u64.public;
+ key as field.public;
+ value as u64.public;
mapping disagree_votes:
- key left as field.public;
- value right as u64.public;
+ key as field.public;
+ value as u64.public;
function propose:
input r0 as ProposalInfo.public;
assert.eq self.caller r0.proposer;
- hash.bhp256 r0.title into r1 as field; cast self.caller r1 r0 into r2 as Proposal.record;
- output r2 as Proposal.record;
-
- finalize r1;
+ hash.bhp256 r0.title into r1 as field;
+ cast self.caller r1 r0 into r2 as Proposal.record;
+ async propose r1 into r3; output r2 as Proposal.record;
+ output r3 as vote.aleo/propose.future;
finalize propose:
input r0 as field.public;
@@ -51,9 +51,8 @@ function new_ticket:
input r0 as field.public;
input r1 as address.public;
cast r1 r0 into r2 as Ticket.record;
- output r2 as Ticket.record;
-
- finalize r0;
+ async new_ticket r0 into r3; output r2 as Ticket.record;
+ output r3 as vote.aleo/new_ticket.future;
finalize new_ticket:
input r0 as field.public;
@@ -64,8 +63,7 @@ finalize new_ticket:
function agree:
input r0 as Ticket.record;
-
- finalize r0.pid;
+ async agree r0.pid into r1; output r1 as vote.aleo/agree.future;
finalize agree:
input r0 as field.public;
@@ -76,8 +74,7 @@ finalize agree:
function disagree:
input r0 as Ticket.record;
-
- finalize r0.pid;
+ async disagree r0.pid into r1; output r1 as vote.aleo/disagree.future;
finalize disagree:
input r0 as field.public;
diff --git a/examples/vote/inputs/agree.in b/examples/vote/inputs/agree.in
new file mode 100644
index 0000000000..24364799d1
--- /dev/null
+++ b/examples/vote/inputs/agree.in
@@ -0,0 +1,5 @@
+{
+ owner: aleo1mgfq6g40l6zkhsm063n3uhr43qk5e0zsua5aszeq5080dsvlcvxsn0rrau.private,
+ pid: 2264670486490520844857553240576860973319410481267184439818180411609250173817field.private,
+ _nonce: 1637267040221574073903539416642641433705357302885235345311606754421919550724group.public
+}
diff --git a/examples/vote/inputs/disagree.in b/examples/vote/inputs/disagree.in
new file mode 100644
index 0000000000..24364799d1
--- /dev/null
+++ b/examples/vote/inputs/disagree.in
@@ -0,0 +1,5 @@
+{
+ owner: aleo1mgfq6g40l6zkhsm063n3uhr43qk5e0zsua5aszeq5080dsvlcvxsn0rrau.private,
+ pid: 2264670486490520844857553240576860973319410481267184439818180411609250173817field.private,
+ _nonce: 1637267040221574073903539416642641433705357302885235345311606754421919550724group.public
+}
diff --git a/examples/vote/inputs/new_ticket.in b/examples/vote/inputs/new_ticket.in
new file mode 100644
index 0000000000..4cbadd2fce
--- /dev/null
+++ b/examples/vote/inputs/new_ticket.in
@@ -0,0 +1 @@
+2264670486490520844857553240576860973319410481267184439818180411609250173817field aleo1mgfq6g40l6zkhsm063n3uhr43qk5e0zsua5aszeq5080dsvlcvxsn0rrau
diff --git a/examples/vote/inputs/propose.in b/examples/vote/inputs/propose.in
new file mode 100644
index 0000000000..73b06c1914
--- /dev/null
+++ b/examples/vote/inputs/propose.in
@@ -0,0 +1,5 @@
+{
+ title: 2077160157502449938194577302446444field,
+ content: 1452374294790018907888397545906607852827800436field,
+ proposer: aleo1kkk52quhnxgn2nfrcd9jqk7c9x27c23f2wvw7fyzcze56yahvcgszgttu2
+}
diff --git a/examples/vote/inputs/vote.in b/examples/vote/inputs/vote.in
deleted file mode 100644
index ac94c9b3f2..0000000000
--- a/examples/vote/inputs/vote.in
+++ /dev/null
@@ -1,25 +0,0 @@
-// The program input for vote/src/main.leo
-[propose]
-info: ProposalInfo = ProposalInfo {
- title: 2077160157502449938194577302446444field,
- content: 1452374294790018907888397545906607852827800436field,
- proposer: aleo1kkk52quhnxgn2nfrcd9jqk7c9x27c23f2wvw7fyzcze56yahvcgszgttu2,
-};
-
-[new_ticket]
-pid: field = 2264670486490520844857553240576860973319410481267184439818180411609250173817field;
-voter: address = aleo1mgfq6g40l6zkhsm063n3uhr43qk5e0zsua5aszeq5080dsvlcvxsn0rrau;
-
-[agree]
-ticket: Ticket = Ticket {
- owner: aleo1mgfq6g40l6zkhsm063n3uhr43qk5e0zsua5aszeq5080dsvlcvxsn0rrau,
- pid: 2264670486490520844857553240576860973319410481267184439818180411609250173817field,
- _nonce: 1637267040221574073903539416642641433705357302885235345311606754421919550724group
-};
-
-[disagree]
-ticket: Ticket = Ticket {
- owner: aleo1mgfq6g40l6zkhsm063n3uhr43qk5e0zsua5aszeq5080dsvlcvxsn0rrau,
- pid: 2264670486490520844857553240576860973319410481267184439818180411609250173817field,
- _nonce: 1637267040221574073903539416642641433705357302885235345311606754421919550724group
-};
diff --git a/examples/vote/leo.lock b/examples/vote/leo.lock
new file mode 100644
index 0000000000..c4293b3b9f
--- /dev/null
+++ b/examples/vote/leo.lock
@@ -0,0 +1 @@
+package = []
diff --git a/examples/vote/run.sh b/examples/vote/run.sh
index 2b8bec9398..40cf48cfe0 100755
--- a/examples/vote/run.sh
+++ b/examples/vote/run.sh
@@ -20,9 +20,11 @@ echo "
###############################################################################
"
# Run the `propose` program function
-(
- leo run propose || exit
-)
+leo run propose "{
+ title: 2077160157502449938194577302446444field,
+ content: 1452374294790018907888397545906607852827800436field,
+ proposer: aleo1mgfq6g40l6zkhsm063n3uhr43qk5e0zsua5aszeq5080dsvlcvxsn0rrau
+}" || exit
echo "
###############################################################################
@@ -38,9 +40,7 @@ echo "
###############################################################################
"
# Run the `new_ticket` program function
-(
- leo run new_ticket || exit
-)
+leo run new_ticket 2264670486490520844857553240576860973319410481267184439818180411609250173817field aleo1mgfq6g40l6zkhsm063n3uhr43qk5e0zsua5aszeq5080dsvlcvxsn0rrau || exit
echo "
###############################################################################
@@ -56,7 +56,9 @@ echo "
###############################################################################
"
# Run the `agree` or `disagree` program function
-(
- leo run agree || exit
- # leo run disagree || exit
-)
+leo run agree "{
+ owner: aleo1mgfq6g40l6zkhsm063n3uhr43qk5e0zsua5aszeq5080dsvlcvxsn0rrau.private,
+ pid: 2264670486490520844857553240576860973319410481267184439818180411609250173817field.private,
+ _nonce: 1637267040221574073903539416642641433705357302885235345311606754421919550724group.public
+}" || exit
+#cat ./inputs/disagree.in | xargs leo run disagree || exit
diff --git a/leo/cli/cli.rs b/leo/cli/cli.rs
index c87c2fe1ed..07d341d197 100644
--- a/leo/cli/cli.rs
+++ b/leo/cli/cli.rs
@@ -15,10 +15,9 @@
// along with the Leo library. If not, see ,
+
+ #[clap(long, global = true, help = "Optional path to aleo program registry.")]
+ pub home: Option,
}
///Leo compiler and package manager
#[derive(Parser, Debug)]
enum Commands {
+ #[clap(about = "Add a new dependency to the current package. Defaults to testnet3 network")]
+ Add {
+ #[clap(flatten)]
+ command: Add,
+ },
#[clap(about = "Create a new Aleo account")]
Account {
#[clap(subcommand)]
@@ -105,9 +112,10 @@ pub fn run_with_args(cli: CLI) -> Result<()> {
// Get custom root folder and create context for it.
// If not specified, default context will be created in cwd.
- let context = handle_error(Context::new(cli.path));
+ let context = handle_error(Context::new(cli.path, cli.home));
match cli.command {
+ Commands::Add { command } => command.try_execute(context),
Commands::Account { command } => command.try_execute(context),
Commands::New { command } => command.try_execute(context),
Commands::Build { command } => {
@@ -133,3 +141,328 @@ pub fn run_with_args(cli: CLI) -> Result<()> {
Commands::Update { command } => command.try_execute(context),
}
}
+#[cfg(test)]
+mod tests {
+ use crate::cli::{
+ cli::{test_helpers, Commands},
+ run_with_args,
+ CLI,
+ };
+ use leo_span::symbol::create_session_if_not_set_then;
+ use serial_test::serial;
+ use std::env::temp_dir;
+
+ #[test]
+ #[serial]
+ fn nested_network_dependency_run_test() {
+ // Set current directory to temporary directory
+ let temp_dir = temp_dir();
+ let project_directory = temp_dir.join("nested");
+
+ // Create file structure
+ test_helpers::sample_nested_package(&temp_dir);
+
+ // Run program
+ let run = CLI {
+ debug: false,
+ quiet: false,
+ command: Commands::Run {
+ command: crate::cli::commands::Run {
+ name: "example".to_string(),
+ inputs: vec!["1u32".to_string(), "2u32".to_string()],
+ file: None,
+ compiler_options: Default::default(),
+ },
+ },
+ path: Some(project_directory.clone()),
+ home: Some(temp_dir.join(".aleo")),
+ };
+
+ create_session_if_not_set_then(|_| {
+ run_with_args(run).expect("Failed to execute `leo run`");
+ });
+
+ // TODO: Clear tmp directory
+ // let registry = temp_dir.join(".aleo").join("registry").join("testnet3");
+ // std::fs::remove_dir_all(registry).unwrap();
+ // std::fs::remove_dir_all(project_directory).unwrap();
+ }
+
+ #[test]
+ #[serial]
+ fn nested_local_dependency_run_test() {
+ // Set current directory to temporary directory
+ let temp_dir = temp_dir();
+ let project_name = "grandparent";
+ let project_directory = temp_dir.join(project_name);
+
+ // Remove it if it already exists
+ if project_directory.exists() {
+ std::fs::remove_dir_all(project_directory.clone()).unwrap();
+ }
+
+ // Create file structure
+ test_helpers::sample_grandparent_package(&temp_dir);
+
+ // Run program
+ let run = CLI {
+ debug: false,
+ quiet: false,
+ command: Commands::Run {
+ command: crate::cli::commands::Run {
+ name: "double_wrapper_mint".to_string(),
+ inputs: vec![
+ "aleo13tngrq7506zwdxj0cxjtvp28pk937jejhne0rt4zp0z370uezuysjz2prs".to_string(),
+ "2u32".to_string(),
+ ],
+ file: None,
+ compiler_options: Default::default(),
+ },
+ },
+ path: Some(project_directory.clone()),
+ home: None,
+ };
+
+ create_session_if_not_set_then(|_| {
+ run_with_args(run).expect("Failed to execute `leo run`");
+ });
+
+ // TODO: Clear tmp directory
+ // std::fs::remove_dir_all(project_directory).unwrap();
+ }
+}
+
+#[cfg(test)]
+mod test_helpers {
+ use crate::cli::{cli::Commands, run_with_args, Add, New, CLI};
+ use leo_span::symbol::create_session_if_not_set_then;
+ use std::path::Path;
+
+ pub(crate) fn sample_nested_package(temp_dir: &Path) {
+ let name = "nested";
+
+ // Remove it if it already exists
+ let project_directory = temp_dir.join(name);
+ if project_directory.exists() {
+ std::fs::remove_dir_all(project_directory.clone()).unwrap();
+ }
+
+ // Create new Leo project
+ let new = CLI {
+ debug: false,
+ quiet: false,
+ command: Commands::New { command: New { name: name.to_string() } },
+ path: Some(project_directory.clone()),
+ home: None,
+ };
+
+ create_session_if_not_set_then(|_| {
+ run_with_args(new).expect("Failed to execute `leo run`");
+ });
+
+ // `nested.aleo` program
+ let program_str = "
+import nested_example_layer_0.aleo;
+program nested.aleo {
+ transition example(public a: u32, b: u32) -> u32 {
+ let c: u32 = nested_example_layer_0.aleo/main(a, b);
+ return c;
+ }
+}
+";
+ // `nested_example_layer_0.aleo` program
+ let nested_example_layer_0 = "
+import nested_example_layer_2.aleo;
+import nested_example_layer_1.aleo;
+
+program nested_example_layer_0.aleo;
+
+function main:
+ input r0 as u32.public;
+ input r1 as u32.private;
+ call nested_example_layer_1.aleo/external_function r0 r1 into r2;
+ output r2 as u32.private;
+";
+
+ // `nested_example_layer_1.aleo` program
+ let nested_example_layer_1 = "
+import nested_example_layer_2.aleo;
+
+program nested_example_layer_1.aleo;
+
+function external_function:
+ input r0 as u32.public;
+ input r1 as u32.private;
+ call nested_example_layer_2.aleo/external_nested_function r0 r1 into r2;
+ output r2 as u32.private;
+";
+
+ // `nested_example_layer_2.aleo` program
+ let nested_example_layer_2 = "
+program nested_example_layer_2.aleo;
+
+function external_nested_function:
+ input r0 as u32.public;
+ input r1 as u32.private;
+ add r0 r1 into r2;
+ output r2 as u32.private;
+";
+
+ // Overwrite `src/main.leo` file
+ std::fs::write(project_directory.join("src").join("main.leo"), program_str).unwrap();
+
+ // Add dependencies
+ let add = CLI {
+ debug: false,
+ quiet: false,
+ command: Commands::Add {
+ command: Add {
+ name: "nested_example_layer_0".to_string(),
+ local: None,
+ network: "testnet3".to_string(),
+ },
+ },
+ path: Some(project_directory.clone()),
+ home: None,
+ };
+
+ create_session_if_not_set_then(|_| {
+ run_with_args(add).expect("Failed to execute `leo add`");
+ });
+
+ // Add custom `.aleo` directory
+ let registry = temp_dir.join(".aleo").join("registry").join("testnet3");
+ std::fs::create_dir_all(®istry).unwrap();
+ std::fs::write(registry.join("nested_example_layer_0.aleo"), nested_example_layer_0).unwrap();
+ std::fs::write(registry.join("nested_example_layer_1.aleo"), nested_example_layer_1).unwrap();
+ std::fs::write(registry.join("nested_example_layer_2.aleo"), nested_example_layer_2).unwrap();
+ }
+
+ pub(crate) fn sample_grandparent_package(temp_dir: &Path) {
+ let grandparent_directory = temp_dir.join("grandparent");
+ let parent_directory = grandparent_directory.join("parent");
+ let child_directory = parent_directory.join("child");
+
+ if grandparent_directory.exists() {
+ std::fs::remove_dir_all(grandparent_directory.clone()).unwrap();
+ }
+
+ // Create project file structure `grandparent/parent/child`
+ let create_grandparent_project = CLI {
+ debug: false,
+ quiet: false,
+ command: Commands::New { command: New { name: "grandparent".to_string() } },
+ path: Some(grandparent_directory.clone()),
+ home: None,
+ };
+
+ let create_parent_project = CLI {
+ debug: false,
+ quiet: false,
+ command: Commands::New { command: New { name: "parent".to_string() } },
+ path: Some(parent_directory.clone()),
+ home: None,
+ };
+
+ let create_child_project = CLI {
+ debug: false,
+ quiet: false,
+ command: Commands::New { command: New { name: "child".to_string() } },
+ path: Some(child_directory.clone()),
+ home: None,
+ };
+
+ // Add source files `grandparent/src/main.leo`, `grandparent/parent/src/main.leo`, and `grandparent/parent/child/src/main.leo`
+ let grandparent_program = "
+import child.aleo;
+import parent.aleo;
+program grandparent.aleo {
+ transition double_wrapper_mint(owner: address, val: u32) -> child.aleo/A {
+ return parent.aleo/wrapper_mint(owner, val);
+ }
+}
+";
+ let parent_program = "
+import child.aleo;
+program parent.aleo {
+ transition wrapper_mint(owner: address, val: u32) -> child.aleo/A {
+ return child.aleo/mint(owner, val);
+ }
+}
+";
+
+ let child_program = "
+// The 'a' program.
+program child.aleo {
+ record A {
+ owner: address,
+ val: u32,
+ }
+ transition mint(owner: address, val: u32) -> A {
+ return A {owner: owner, val: val};
+ }
+}
+";
+
+ // Add dependencies `grandparent/program.json` and `grandparent/parent/program.json`
+ let add_grandparent_dependency_1 = CLI {
+ debug: false,
+ quiet: false,
+ command: Commands::Add {
+ command: Add {
+ name: "parent".to_string(),
+ local: Some(parent_directory.clone()),
+ network: "testnet3".to_string(),
+ },
+ },
+ path: Some(grandparent_directory.clone()),
+ home: None,
+ };
+
+ let add_grandparent_dependency_2 = CLI {
+ debug: false,
+ quiet: false,
+ command: Commands::Add {
+ command: Add {
+ name: "child".to_string(),
+ local: Some(child_directory.clone()),
+ network: "testnet3".to_string(),
+ },
+ },
+ path: Some(grandparent_directory.clone()),
+ home: None,
+ };
+
+ let add_parent_dependency = CLI {
+ debug: false,
+ quiet: false,
+ command: Commands::Add {
+ command: Add {
+ name: "child".to_string(),
+ local: Some(child_directory.clone()),
+ network: "testnet3".to_string(),
+ },
+ },
+ path: Some(parent_directory.clone()),
+ home: None,
+ };
+
+ // Execute all commands
+ create_session_if_not_set_then(|_| {
+ // Create projects
+ run_with_args(create_grandparent_project).unwrap();
+ run_with_args(create_parent_project).unwrap();
+ run_with_args(create_child_project).unwrap();
+
+ // Write files
+ std::fs::write(grandparent_directory.join("src").join("main.leo"), grandparent_program).unwrap();
+ std::fs::write(parent_directory.join("src").join("main.leo"), parent_program).unwrap();
+ std::fs::write(child_directory.join("src").join("main.leo"), child_program).unwrap();
+
+ // Add dependencies
+ run_with_args(add_grandparent_dependency_1).unwrap();
+ run_with_args(add_grandparent_dependency_2).unwrap();
+ run_with_args(add_parent_dependency).unwrap();
+ });
+ }
+}
diff --git a/leo/cli/commands/add.rs b/leo/cli/commands/add.rs
new file mode 100755
index 0000000000..69a7b475d0
--- /dev/null
+++ b/leo/cli/commands/add.rs
@@ -0,0 +1,98 @@
+// Copyright (C) 2019-2023 Aleo Systems Inc.
+// This file is part of the Leo library.
+
+// The Leo library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// The Leo library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with the Leo library. If not, see ", version)]
+pub struct Add {
+ #[clap(name = "NAME", help = "The dependency name")]
+ pub(crate) name: String,
+
+ #[clap(short = 'l', long, help = "Optional path to local dependency")]
+ pub(crate) local: Option,
+
+ #[clap(short = 'n', long, help = "Optional name of the network to use", default_value = "testnet3")]
+ pub(crate) network: String,
+}
+
+impl Command for Add {
+ type Input = ();
+ type Output = ();
+
+ fn log_span(&self) -> Span {
+ tracing::span!(tracing::Level::INFO, "Leo")
+ }
+
+ fn prelude(&self, _: Context) -> Result {
+ Ok(())
+ }
+
+ fn apply(self, context: Context, _: Self::Input) -> Result {
+ let path = context.dir()?;
+
+ // Deserialize the manifest
+ let program_data: String = std::fs::read_to_string(path.join("program.json"))
+ .map_err(|err| PackageError::failed_to_read_file(path.to_str().unwrap(), err))?;
+ let manifest: Manifest = serde_json::from_str(&program_data)
+ .map_err(|err| PackageError::failed_to_deserialize_manifest_file(path.to_str().unwrap(), err))?;
+
+ // Allow both `credits.aleo` and `credits` syntax
+ let name = match self.name {
+ name if name.ends_with(".aleo") => name,
+ name => format!("{}.aleo", name),
+ };
+
+ // Add dependency section to manifest if it doesn't exist
+ let mut dependencies = match manifest.dependencies() {
+ Some(ref dependencies) => dependencies
+ .iter()
+ .filter_map(|dependency| {
+ if dependency.name() == &name {
+ println!("{} already exists as a dependency. Overwriting.", name);
+ None
+ } else {
+ Some(dependency.clone())
+ }
+ })
+ .collect(),
+ None => Vec::new(),
+ };
+
+ // Add new dependency to manifest
+ dependencies.push(match self.local {
+ Some(local_path) => Dependency::new(name, Location::Local, None, Some(local_path)),
+ None => Dependency::new(name, Location::Network, Some(Network::from(&self.network)), None),
+ });
+
+ // Update manifest
+ let new_manifest = Manifest::new(
+ manifest.program(),
+ manifest.version(),
+ manifest.description(),
+ manifest.license(),
+ Some(dependencies),
+ );
+ let new_manifest_data = serde_json::to_string_pretty(&new_manifest)
+ .map_err(|err| PackageError::failed_to_serialize_manifest_file(path.to_str().unwrap(), err))?;
+ std::fs::write(path.join("program.json"), new_manifest_data).map_err(PackageError::failed_to_write_manifest)?;
+
+ Ok(())
+ }
+}
diff --git a/leo/cli/commands/build.rs b/leo/cli/commands/build.rs
index 4c5775f30e..50f0a6c59c 100644
--- a/leo/cli/commands/build.rs
+++ b/leo/cli/commands/build.rs
@@ -16,16 +16,12 @@
use super::*;
-use leo_ast::{NodeBuilder, Struct};
-use leo_compiler::{Compiler, CompilerOptions, InputAst, OutputOptions};
-use leo_package::{
- build::BuildDirectory,
- imports::ImportsDirectory,
- inputs::InputFile,
- outputs::OutputsDirectory,
- source::SourceDirectory,
-};
-use leo_span::{symbol::with_session_globals, Symbol};
+use leo_ast::Stub;
+use leo_compiler::{Compiler, CompilerOptions, OutputOptions};
+use leo_errors::UtilError;
+use leo_package::{build::BuildDirectory, outputs::OutputsDirectory, source::SourceDirectory};
+use leo_span::Symbol;
+use retriever::Retriever;
use snarkvm::{
package::Package,
@@ -38,6 +34,8 @@ use std::{
path::{Path, PathBuf},
};
+type CurrentNetwork = Testnet3;
+
impl From for CompilerOptions {
fn from(options: BuildOptions) -> Self {
let mut out_options = Self {
@@ -48,7 +46,6 @@ impl From for CompilerOptions {
type_checked_symbol_table: options.enable_type_checked_symbol_table_snapshot,
unrolled_symbol_table: options.enable_unrolled_symbol_table_snapshot,
ast_spans_enabled: options.enable_ast_spans,
- initial_input_ast: options.enable_initial_input_ast_snapshot,
initial_ast: options.enable_initial_ast_snapshot,
unrolled_ast: options.enable_unrolled_ast_snapshot,
ssa_ast: options.enable_ssa_ast_snapshot,
@@ -59,7 +56,6 @@ impl From for CompilerOptions {
},
};
if options.enable_all_ast_snapshots {
- out_options.output.initial_input_ast = true;
out_options.output.initial_ast = true;
out_options.output.unrolled_ast = true;
out_options.output.ssa_ast = true;
@@ -82,7 +78,7 @@ pub struct Build {
impl Command for Build {
type Input = ();
- type Output = (Option, IndexMap);
+ type Output = ();
fn log_span(&self) -> Span {
tracing::span!(tracing::Level::INFO, "Leo")
@@ -95,85 +91,63 @@ impl Command for Build {
fn apply(self, context: Context, _: Self::Input) -> Result {
// Get the package path.
let package_path = context.dir()?;
+ let home_path = context.home()?;
+
+ // Open the build directory.
+ let build_directory = BuildDirectory::create(&package_path)?;
// Get the program id.
let manifest = context.open_manifest()?;
let program_id = manifest.program_id();
- // Create the outputs directory.
- let outputs_directory = OutputsDirectory::create(&package_path)?;
-
- // Open the build directory.
- let build_directory = BuildDirectory::open(&package_path)?;
-
// Initialize error handler
let handler = Handler::default();
- // Initialize a node counter.
- let node_builder = NodeBuilder::default();
+ // Retrieve all local dependencies in post order
+ let main_sym = Symbol::intern(&program_id.name().to_string());
+ let mut retriever = Retriever::new(main_sym, &package_path, &home_path)
+ .map_err(|err| UtilError::failed_to_retrieve_dependencies(err, Default::default()))?;
+ let mut local_dependencies =
+ retriever.retrieve().map_err(|err| UtilError::failed_to_retrieve_dependencies(err, Default::default()))?;
- // Fetch paths to all .leo files in the source directory.
- let source_files = SourceDirectory::files(&package_path)?;
+ // Push the main program at the end of the list to be compiled after all of its dependencies have been processed
+ local_dependencies.push(main_sym);
- // Check the source files.
- SourceDirectory::check_files(&source_files)?;
+ // Loop through all local dependencies and compile them in order
+ for dependency in local_dependencies.into_iter() {
+ // Get path to the local project
+ let (local_path, stubs) = retriever.prepare_local(dependency)?;
- // Store all struct declarations made in the source files.
- let mut structs = IndexMap::new();
+ // Create the outputs directory.
+ let local_outputs_directory = OutputsDirectory::create(&local_path)?;
- // Compile all .leo files into .aleo files.
- for file_path in source_files.into_iter() {
- structs.extend(compile_leo_file(
- file_path,
- &package_path,
- program_id,
- &outputs_directory,
- &build_directory,
- &handler,
- self.options.clone(),
- false,
- )?);
- }
+ // Open the build directory.
+ let local_build_directory = BuildDirectory::create(&local_path)?;
- if !ImportsDirectory::is_empty(&package_path)? {
- // Create Aleo build/imports/ directory.
- let build_imports_directory = ImportsDirectory::create(&build_directory)?;
+ // Fetch paths to all .leo files in the source directory.
+ let local_source_files = SourceDirectory::files(&local_path)?;
- // Fetch paths to all .leo files in the imports directory.
- let import_files = ImportsDirectory::files(&package_path)?;
+ // Check the source files.
+ SourceDirectory::check_files(&local_source_files)?;
// Compile all .leo files into .aleo files.
- for file_path in import_files.into_iter() {
- structs.extend(compile_leo_file(
+ for file_path in local_source_files {
+ compile_leo_file(
file_path,
- &package_path,
- program_id,
- &outputs_directory,
- &build_imports_directory,
+ &ProgramID::::try_from(format!("{}.aleo", dependency))
+ .map_err(|_| UtilError::snarkvm_error_building_program_id(Default::default()))?,
+ &local_outputs_directory,
+ &local_build_directory,
&handler,
self.options.clone(),
- true,
- )?);
+ stubs.clone(),
+ )?;
}
+
+ // Writes `leo.lock` as well as caches objects (when target is an intermediate dependency)
+ retriever.process_local(dependency)?;
}
- // Load the input file at `package_name.in`
- let input_file_path = InputFile::new(&manifest.program_id().name().to_string()).setup_file_path(&package_path);
-
- // Parse the input file.
- let input_ast = if input_file_path.exists() {
- // Load the input file into the source map.
- let input_sf = with_session_globals(|s| s.source_map.load_file(&input_file_path))
- .map_err(|e| CompilerError::file_read_error(&input_file_path, e))?;
-
- // TODO: This is a hack to notify the user that something is wrong with the input file. Redesign.
- leo_parser::parse_input(&handler, &node_builder, &input_sf.src, input_sf.start_pos)
- .map_err(|_e| println!("Warning: Failed to parse input file"))
- .ok()
- } else {
- None
- };
-
// `Package::open` checks that the build directory and that `main.aleo` and all imported files are well-formed.
Package::::open(&build_directory).map_err(CliError::failed_to_execute_build)?;
@@ -195,7 +169,7 @@ impl Command for Build {
// // Log the result of the build
// tracing::info!("{}", result);
- Ok((input_ast, structs))
+ Ok(())
}
}
@@ -203,31 +177,23 @@ impl Command for Build {
#[allow(clippy::too_many_arguments)]
fn compile_leo_file(
file_path: PathBuf,
- _package_path: &Path,
program_id: &ProgramID,
outputs: &Path,
build: &Path,
handler: &Handler,
options: BuildOptions,
- is_import: bool,
-) -> Result> {
+ stubs: IndexMap,
+) -> Result<()> {
// Construct the Leo file name with extension `foo.leo`.
let file_name =
file_path.file_name().and_then(|name| name.to_str()).ok_or_else(PackageError::failed_to_get_file_name)?;
- // If the program is an import, construct program name from file_path
- // Otherwise, use the program_id found in `package.json`.
- let program_name = match is_import {
- false => program_id.name().to_string(),
- true => file_name.strip_suffix(".leo").ok_or_else(PackageError::failed_to_get_file_name)?.to_string(),
- };
+ // Construct program name from the program_id found in `package.json`.
+ let program_name = program_id.name().to_string();
// Create the path to the Aleo file.
let mut aleo_file_path = build.to_path_buf();
- aleo_file_path.push(match is_import {
- true => format!("{program_name}.{}", program_id.network()),
- false => format!("main.{}", program_id.network()),
- });
+ aleo_file_path.push(format!("main.{}", program_id.network()));
// Create a new instance of the Leo compiler.
let mut compiler = Compiler::new(
@@ -237,10 +203,11 @@ fn compile_leo_file(
file_path.clone(),
outputs.to_path_buf(),
Some(options.into()),
+ stubs,
);
// Compile the Leo program into Aleo instructions.
- let (symbol_table, instructions) = compiler.compile()?;
+ let instructions = compiler.compile()?;
// Write the instructions.
std::fs::File::create(&aleo_file_path)
@@ -249,5 +216,5 @@ fn compile_leo_file(
.map_err(CliError::failed_to_load_instructions)?;
tracing::info!("✅ Compiled '{}' into Aleo instructions", file_name);
- Ok(symbol_table.structs)
+ Ok(())
}
diff --git a/leo/cli/commands/example.rs b/leo/cli/commands/example.rs
index bb16dffdd1..7952cfa85f 100644
--- a/leo/cli/commands/example.rs
+++ b/leo/cli/commands/example.rs
@@ -48,10 +48,6 @@ impl Command for Example {
let main_file_path = package_dir.join("src").join("main.leo");
fs::write(main_file_path, self.main_file_string()).map_err(CliError::failed_to_write_file)?;
- // Write the input file.
- let input_file_path = package_dir.join("inputs").join(format!("{}.in", self.name()));
- fs::write(input_file_path, self.input_file_string()).map_err(CliError::failed_to_write_file)?;
-
// Write the README file.
let readme_file_path = package_dir.join("README.md");
let readme_file_path_string = readme_file_path.display().to_string();
@@ -94,20 +90,6 @@ impl Example {
}
}
- fn input_file_string(&self) -> String {
- match self {
- Self::Lottery => {
- include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/examples/lottery/inputs/lottery.in")).to_string()
- }
- Self::TicTacToe => {
- include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/examples/tictactoe/inputs/tictactoe.in")).to_string()
- }
- Self::Token => {
- include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/examples/token/inputs/token.in")).to_string()
- }
- }
- }
-
fn readme_file_string(&self) -> String {
match self {
Self::Lottery => {
diff --git a/leo/cli/commands/execute.rs b/leo/cli/commands/execute.rs
index 2df5b01510..b018d884db 100644
--- a/leo/cli/commands/execute.rs
+++ b/leo/cli/commands/execute.rs
@@ -16,7 +16,7 @@
use super::*;
-use snarkvm::cli::Execute as SnarkVMExecute;
+use snarkvm::{cli::Execute as SnarkVMExecute, prelude::Parser as SnarkVMParser};
/// Build, Prove and Run Leo program with inputs
#[derive(Parser, Debug)]
@@ -24,7 +24,7 @@ pub struct Execute {
#[clap(name = "NAME", help = "The name of the program to execute.", default_value = "main")]
name: String,
- #[clap(name = "INPUTS", help = "The inputs to the program. If none are provided, the input file is used.")]
+ #[clap(name = "INPUTS", help = "The inputs to the program.")]
inputs: Vec,
#[clap(
@@ -35,6 +35,9 @@ pub struct Execute {
)]
endpoint: String,
+ #[arg(short, long, help = "The inputs to the program, from a file. Overrides the INPUTS argument.")]
+ file: Option,
+
#[clap(flatten)]
pub(crate) compiler_options: BuildOptions,
}
@@ -51,22 +54,37 @@ impl Command for Execute {
(Build { options: self.compiler_options.clone() }).execute(context)
}
- fn apply(self, context: Context, input: Self::Input) -> Result {
- // If input values are provided, then run the program with those inputs.
- // Otherwise, use the input file.
- let mut inputs = match self.inputs.is_empty() {
- true => match input {
- (Some(input_ast), circuits) => input_ast.program_inputs(&self.name, circuits),
- _ => Vec::new(),
- },
- false => self.inputs,
- };
+ fn apply(self, context: Context, _: Self::Input) -> Result {
+ let mut inputs = self.inputs;
// Compose the `execute` command.
let mut arguments = vec![SNARKVM_COMMAND.to_string(), self.name];
- // Add the program inputs to the arguments.
- arguments.append(&mut inputs);
+ // Add the inputs to the arguments.
+ match self.file {
+ Some(file) => {
+ // Get the contents from the file.
+ let path = context.dir()?.join(file);
+ let raw_content = std::fs::read_to_string(&path)
+ .map_err(|err| PackageError::failed_to_read_file(path.display(), err))?;
+ // Parse the values from the file.
+ let mut content = raw_content.as_str();
+ let mut values = vec![];
+ while let Ok((remaining, value)) = snarkvm::prelude::Value::::parse(content) {
+ content = remaining;
+ values.push(value);
+ }
+ // Check that the remaining content is empty.
+ if !content.trim().is_empty() {
+ return Err(PackageError::failed_to_read_input_file(path.display()).into());
+ }
+ // Convert the values to strings.
+ let mut inputs_from_file = values.into_iter().map(|value| value.to_string()).collect::>();
+ // Add the inputs from the file to the arguments.
+ arguments.append(&mut inputs_from_file);
+ }
+ None => arguments.append(&mut inputs),
+ }
// Add the compiler options to the arguments.
if self.compiler_options.offline {
diff --git a/leo/cli/commands/mod.rs b/leo/cli/commands/mod.rs
index 463f06782f..fc606785b8 100644
--- a/leo/cli/commands/mod.rs
+++ b/leo/cli/commands/mod.rs
@@ -14,6 +14,9 @@
// You should have received a copy of the GNU General Public License
// along with the Leo library. If not, see {
+ // Derive the location of the parent directory to the project.
+ let mut package_path = context.parent_dir()?;
+
+ // Change the cwd to the Leo package directory to initialize all files.
+ std::env::set_current_dir(&package_path)
+ .map_err(|err| PackageError::failed_to_set_cwd(package_path.display(), err))?;
+
// Call the `aleo new` command from the Aleo SDK.
let command =
SnarkVMNew::try_parse_from([SNARKVM_COMMAND, &self.name]).map_err(CliError::failed_to_parse_new)?;
@@ -46,16 +53,11 @@ impl Command for New {
// Log the output of the `aleo new` command.
tracing::info!("{}", result);
- // Derive the program directory path.
- let mut package_path = context.dir()?;
- package_path.push(&self.name);
-
// Initialize the Leo package in the directory created by `aleo new`.
- Package::::initialize(&self.name, &package_path)?;
-
- // Change the cwd to the Leo package directory to compile aleo files.
+ package_path.push(&self.name);
std::env::set_current_dir(&package_path)
.map_err(|err| PackageError::failed_to_set_cwd(package_path.display(), err))?;
+ Package::::initialize(&self.name, &package_path)?;
// Open the program manifest.
let manifest = context.open_manifest()?;
diff --git a/leo/cli/commands/run.rs b/leo/cli/commands/run.rs
index ec27f4d812..561b7ede84 100644
--- a/leo/cli/commands/run.rs
+++ b/leo/cli/commands/run.rs
@@ -16,16 +16,19 @@
use super::*;
-use snarkvm::cli::Run as SnarkVMRun;
+use snarkvm::{cli::Run as SnarkVMRun, prelude::Parser as SnarkVMParser};
/// Build, Prove and Run Leo program with inputs
#[derive(Parser, Debug)]
pub struct Run {
#[clap(name = "NAME", help = "The name of the program to run.", default_value = "main")]
- name: String,
+ pub(crate) name: String,
- #[clap(name = "INPUTS", help = "The inputs to the program. If none are provided, the input file is used.")]
- inputs: Vec,
+ #[clap(name = "INPUTS", help = "The inputs to the program.")]
+ pub(crate) inputs: Vec,
+
+ #[arg(short, long, help = "The inputs to the program, from a file. Overrides the INPUTS argument.")]
+ pub(crate) file: Option,
#[clap(flatten)]
pub(crate) compiler_options: BuildOptions,
@@ -43,22 +46,37 @@ impl Command for Run {
(Build { options: self.compiler_options.clone() }).execute(context)
}
- fn apply(self, context: Context, input: Self::Input) -> Result {
- // If input values are provided, then run the program with those inputs.
- // Otherwise, use the input file.
- let mut inputs = match self.inputs.is_empty() {
- true => match input {
- (Some(input_ast), circuits) => input_ast.program_inputs(&self.name, circuits),
- _ => Vec::new(),
- },
- false => self.inputs,
- };
+ fn apply(self, context: Context, _: Self::Input) -> Result {
+ let mut inputs = self.inputs;
// Compose the `run` command.
let mut arguments = vec![SNARKVM_COMMAND.to_string(), self.name];
- // Add the program inputs to the arguments.
- arguments.append(&mut inputs);
+ // Add the inputs to the arguments.
+ match self.file {
+ Some(file) => {
+ // Get the contents from the file.
+ let path = context.dir()?.join(file);
+ let raw_content = std::fs::read_to_string(&path)
+ .map_err(|err| PackageError::failed_to_read_file(path.display(), err))?;
+ // Parse the values from the file.
+ let mut content = raw_content.as_str();
+ let mut values = vec![];
+ while let Ok((remaining, value)) = snarkvm::prelude::Value::::parse(content) {
+ content = remaining;
+ values.push(value);
+ }
+ // Check that the remaining content is empty.
+ if !content.trim().is_empty() {
+ return Err(PackageError::failed_to_read_input_file(path.display()).into());
+ }
+ // Convert the values to strings.
+ let mut inputs_from_file = values.into_iter().map(|value| value.to_string()).collect::>();
+ // Add the inputs from the file to the arguments.
+ arguments.append(&mut inputs_from_file);
+ }
+ None => arguments.append(&mut inputs),
+ }
// Open the Leo build/ directory
let path = context.dir()?;
diff --git a/leo/cli/helpers/context.rs b/leo/cli/helpers/context.rs
index acdf9afe96..e7a5de3bbc 100644
--- a/leo/cli/helpers/context.rs
+++ b/leo/cli/helpers/context.rs
@@ -15,11 +15,13 @@
// along with the Leo library. If not, see ,
+ /// Path to use for the Aleo registry, None when default
+ pub home: Option,
}
impl Context {
- pub fn new(path: Option) -> Result {
- Ok(Context { path })
+ pub fn new(path: Option, home: Option) -> Result {
+ Ok(Context { path, home })
+ }
+
+ /// Returns the path of the parent directory to the Leo package.
+ pub fn parent_dir(&self) -> Result {
+ match &self.path {
+ Some(ref path) => {
+ let mut path = path.clone();
+ path.pop();
+ Ok(path)
+ }
+ None => Ok(current_dir().map_err(CliError::cli_io_error)?),
+ }
}
/// Returns the path to the Leo package.
@@ -48,6 +64,14 @@ impl Context {
}
}
+ /// Returns the path to the Aleo registry directory.
+ pub fn home(&self) -> Result {
+ match &self.home {
+ Some(path) => Ok(path.clone()),
+ None => Ok(aleo_dir()),
+ }
+ }
+
/// Returns the package name as a String.
/// Opens the manifest file `program.json` and creates the build directory if it doesn't exist.
pub fn open_manifest(&self) -> Result> {
@@ -68,16 +92,16 @@ impl Context {
// Read the manifest file to string.
let manifest_string =
- std::fs::read_to_string(manifest.path()).map_err(PackageError::failed_to_open_manifest)?;
+ std::fs::read_to_string(manifest.path()).map_err(PackageError::failed_to_read_manifest)?;
// Construct the file path.
let build_manifest_path = build_path.join(Manifest::::file_name());
// Write the file.
File::create(build_manifest_path)
- .map_err(PackageError::failed_to_open_manifest)?
+ .map_err(PackageError::failed_to_create_manifest)?
.write_all(manifest_string.as_bytes())
- .map_err(PackageError::failed_to_open_manifest)?;
+ .map_err(PackageError::failed_to_write_manifest)?;
// Get package name from program id.
Ok(manifest)
diff --git a/leo/package/Cargo.toml b/leo/package/Cargo.toml
index 59c97f519d..d62c03f861 100644
--- a/leo/package/Cargo.toml
+++ b/leo/package/Cargo.toml
@@ -18,6 +18,10 @@ license = "GPL-3.0"
edition = "2021"
rust-version = "1.69"
+[dependencies.aleo-std]
+version = "0.1.18"
+default-features = false
+
[dependencies.snarkvm]
workspace = true
@@ -36,12 +40,19 @@ version = "0.8"
version = "1.0"
features = [ "derive" ]
+[dependencies.serial_test]
+version = "3.0.0"
+
[dependencies.toml]
version = "0.8"
[dependencies.tracing]
version = "0.1"
+[dependencies.retriever]
+path = "../../utils/retriever"
+version = "1.10.0"
+
[dev-dependencies.lazy_static]
version = "1.3.0"
diff --git a/leo/package/src/inputs/input.rs b/leo/package/src/inputs/input.rs
deleted file mode 100644
index e7e47e0098..0000000000
--- a/leo/package/src/inputs/input.rs
+++ /dev/null
@@ -1,94 +0,0 @@
-// Copyright (C) 2019-2023 Aleo Systems Inc.
-// This file is part of the Leo library.
-
-// The Leo library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-
-// The Leo library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with the Leo library. If not, see Package {
let mut result = true;
let mut existing_files = vec![];
- // Check if the input file already exists.
- let input_file = InputFile::new(package_name);
- if input_file.exists_at(path) {
- existing_files.push(input_file.filename());
- result = false;
- }
-
// Check if the main file already exists.
if MainFile::exists_at(path) {
existing_files.push(MainFile::filename());
@@ -124,12 +117,6 @@ impl Package {
return false;
}
- // Check if the input file exists.
- let input_file = InputFile::new(package_name);
- if !input_file.exists_at(path) {
- return false;
- }
-
// Check if the main file exists.
if !MainFile::exists_at(path) {
return false;
@@ -161,9 +148,6 @@ impl Package {
// Create the Leo build/ directory
BuildDirectory::create(path)?;
- // Create the input file in the inputs directory.
- InputFile::new(package_name).write_to(path)?;
-
// Create the main file in the source directory.
MainFile::new(package_name).write_to(path)?;
diff --git a/tests/README.md b/tests/README.md
index 96ce6ddd62..a061c3d83f 100644
--- a/tests/README.md
+++ b/tests/README.md
@@ -61,45 +61,9 @@ Parser Directory namespaces:
- `ParseExpression` - Test a file line by line to check that each line is a valid Leo expression.
- `ParseStatement` - Test a file consuming multiple lines till a blank line to check that it contains a valid Leo statement.
- `Serialize` - Test a file to check that it can be serialized to JSON.
-- `Input` - Test an input file to check that it is a valid Leo input file.
- `Token` - Test a file line by line to check that it contains zero or more valid Leo parser tokens.
Compiler Directory namespaces:
- `Compiler` - Test a file to check that it is a valid Leo program, and it can be compiled without errors.
-
-### expectation
-
-```yaml
-- Mandatory: yes
-- Namespace: all
-- Values: Pass / Fail
-```
-
-This setting indicates whether the tested code is supposed to succeed or to fail.
-If the test was marked as `Pass` but it actually failed,
-you'll know that something went wrong and the test or the compiler/parser needs fixing.
-
-### input_file (Compile)
-
-```yaml
-- Mandatory: no
-- Namespace: Compile
-- Values: " ]
+description = "Compiler passes for the Leo programming language"
+homepage = "https://aleo.org"
+repository = "https://github.com/AleoHQ/leo"
+keywords = [
+ "aleo",
+ "cryptography",
+ "leo",
+ "programming-language",
+ "zero-knowledge"
+]
+categories = [ "compilers", "cryptography", "web-programming" ]
+include = [ "Cargo.toml", "src", "README.md", "LICENSE.md" ]
+license = "GPL-3.0"
+edition = "2021"
+rust-version = "1.69"
+
+[lib]
+path = "src/lib.rs"
+
+[dependencies.snarkvm]
+workspace = true
+
+[dependencies.leo-ast]
+path = "../../compiler/ast"
+version = "=1.10.0"
+
+[dependencies.leo-span]
+path = "../../compiler/span"
+version = "1.10.0"
+
+[dependencies.leo-errors]
+path = "../../errors"
+version = "1.10.0"
\ No newline at end of file
diff --git a/utils/disassembler/src/lib.rs b/utils/disassembler/src/lib.rs
new file mode 100644
index 0000000000..dc7cb23dba
--- /dev/null
+++ b/utils/disassembler/src/lib.rs
@@ -0,0 +1,98 @@
+// Copyright (C) 2019-2023 Aleo Systems Inc.
+// This file is part of the Leo library.
+
+// The Leo library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// The Leo library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with the Leo library. If not, see , Command: CommandTrait>(
+ program: ProgramCore,
+) -> Stub {
+ Stub {
+ imports: program.imports().into_iter().map(|(id, _)| ProgramId::from(id)).collect(),
+ stub_id: ProgramId::from(program.id()),
+ consts: Vec::new(),
+ structs: [
+ program.structs().iter().map(|(id, s)| (Identifier::from(id).name, Struct::from(s))).collect_vec(),
+ program.records().iter().map(|(id, s)| (Identifier::from(id).name, Struct::from(s))).collect_vec(),
+ ]
+ .concat(),
+ mappings: program.mappings().into_iter().map(|(id, m)| (Identifier::from(id).name, Mapping::from(m))).collect(),
+ functions: [
+ program
+ .closures()
+ .iter()
+ .map(|(id, closure)| (Identifier::from(id).name, FunctionStub::from(closure)))
+ .collect_vec(),
+ program
+ .functions()
+ .iter()
+ .map(|(id, function)| (Identifier::from(id).name, FunctionStub::from(function)))
+ .collect_vec(),
+ ]
+ .concat(),
+ span: Default::default(),
+ }
+}
+
+pub fn disassemble_from_str(program: String) -> Result {
+ match Program::::from_str(&program) {
+ Ok(p) => Ok(disassemble(p)),
+ Err(_) => Err(UtilError::snarkvm_parsing_error(Default::default())),
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use leo_span::symbol::create_session_if_not_set_then;
+ use snarkvm::{prelude::Testnet3, synthesizer::program::Program};
+ use std::fs;
+
+ type CurrentNetwork = Testnet3;
+
+ #[test]
+ #[ignore]
+ fn credits_test() {
+ create_session_if_not_set_then(|_| {
+ let program = Program::::credits();
+ match program {
+ Ok(p) => {
+ let disassembled = disassemble(p);
+ println!("{}", disassembled);
+ }
+ Err(e) => {
+ println!("{}", e);
+ }
+ }
+ });
+ }
+ #[test]
+ #[ignore]
+ fn array_test() {
+ create_session_if_not_set_then(|_| {
+ let program_from_file =
+ fs::read_to_string("../tmp/.aleo/registry/testnet3/zk_bitwise_stack_v0_0_2.aleo").unwrap();
+ let _program = disassemble_from_str(program_from_file).unwrap();
+ });
+ }
+}
diff --git a/utils/disassembler/src/tests/credits.aleo b/utils/disassembler/src/tests/credits.aleo
new file mode 100644
index 0000000000..43596f55e1
--- /dev/null
+++ b/utils/disassembler/src/tests/credits.aleo
@@ -0,0 +1,845 @@
+// Copyright (C) 2019-2023 Aleo Systems Inc.
+// This file is part of the snarkVM library.
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at:
+// http://www.apache.org/licenses/LICENSE-2.0
+
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+/**********************************************************************************************************************/
+
+program credits.aleo;
+
+/**********************************************************************************************************************/
+
+/// The `committee` mapping contains the active validator set and their corresponding stake.
+mapping committee:
+ // The key represents the address of the validator.
+ key as address.public;
+ // The value represents the committee state of the validator.
+ value as committee_state.public;
+
+// The `committee_state` struct tracks the total stake of the validator, and whether they are open to stakers.
+struct committee_state:
+ // The amount of microcredits bonded to the validator, by the validator and its delegators.
+ microcredits as u64;
+ // The boolean flag indicating if the validator is open to stakers.
+ is_open as boolean;
+
+/**********************************************************************************************************************/
+
+// The `bonded` mapping represents the amount of microcredits that are currently bonded.
+mapping bonded:
+ // The key represents the address of the staker, which includes the validators and their delegators.
+ key as address.public;
+ // The value represents the bond state.
+ value as bond_state.public;
+
+// The `bond_state` struct tracks the amount of microcredits that are currently bonded to the specified validator.
+struct bond_state:
+ // The address of the validator.
+ validator as address;
+ // The amount of microcredits that are currently bonded to the specified validator.
+ microcredits as u64;
+
+/**********************************************************************************************************************/
+
+// The `unbonding` mapping contains a set of stakers with their unbonding microcredits and unlock height.
+mapping unbonding:
+ // The key represents the address of the staker, which includes the validators and their delegators.
+ key as address.public;
+ // The value represents the unbond state.
+ value as unbond_state.public;
+
+// The `unbond_state` struct tracks the microcredits that are currently unbonding, along with the unlock height.
+struct unbond_state:
+ // The amount of microcredits that are currently unbonding.
+ microcredits as u64;
+ // The block height at which the unbonding will be complete, and can be claimed.
+ height as u32;
+
+/**********************************************************************************************************************/
+
+// The `account` mapping is used to store credits publicly.
+mapping account:
+ // The key represents the address of the owner.
+ key as address.public;
+ // The value represents the amount of public microcredits that belong to the specified owner.
+ value as u64.public;
+
+/**********************************************************************************************************************/
+
+// The `credits` record is used to store credits privately.
+record credits:
+ // The address of the owner.
+ owner as address.private;
+ // The amount of private microcredits that belong to the specified owner.
+ microcredits as u64.private;
+
+/**********************************************************************************************************************/
+
+// This function allows any staker to bond their microcredits to a validator.
+// The corresponding functions for 'bond_public' are 'unbond_public' and 'claim_unbond_public'.
+function bond_public:
+ // Input the validator's address.
+ input r0 as address.public;
+ // Input the amount of microcredits to bond.
+ input r1 as u64.public;
+
+ // Determine if the amount is at least one credit.
+ gte r1 1_000_000u64 into r2;
+ // Enforce the amount is at least one credit.
+ assert.eq r2 true;
+
+ // Bond the specified amount of microcredits to the specified validator.
+ async bond_public self.caller r0 r1 into r3;
+ // Output the finalize future.
+ output r3 as credits.aleo/bond_public.future;
+
+finalize bond_public:
+ // Input the staker's address.
+ input r0 as address.public;
+ // Input the validator's address.
+ input r1 as address.public;
+ // Input the amount of microcredits to bond.
+ input r2 as u64.public;
+
+ // Determine whether the caller is a validator.
+ is.eq r0 r1 into r3;
+ // If the caller is a validator, jump to the `bond_validator` logic.
+ branch.eq r3 true to bond_validator;
+ // If the caller is not a validator, jump to the `bond_delegator` logic.
+ branch.eq r3 false to bond_delegator;
+
+ /******* Bond Validator *******/
+
+ // Starts the `bond_validator` logic.
+ position bond_validator;
+
+ /* Committee */
+
+ // Construct the initial committee state.
+ // Note: We set the initial 'is_open' state to 'true'.
+ cast 0u64 true into r4 as committee_state;
+ // Retrieve the committee state of the specified validator.
+ get.or_use committee[r0] r4 into r5;
+ // Ensure that the validator is open to stakers.
+ assert.eq r5.is_open true;
+
+ // Increment the stake for the specified validator.
+ add r5.microcredits r2 into r6;
+ // Construct the updated committee state.
+ cast r6 r5.is_open into r7 as committee_state;
+
+ /* Bonded */
+
+ // Construct the initial bond state.
+ cast r1 0u64 into r8 as bond_state;
+ // Get the bond state for the caller, or default to the initial bond state.
+ get.or_use bonded[r0] r8 into r9;
+ // Enforce the validator matches in the bond state.
+ assert.eq r9.validator r1;
+
+ // Increment the microcredits in the bond state.
+ add r9.microcredits r2 into r10;
+ // Determine if the amount is at least one million credits.
+ gte r10 1_000_000_000_000u64 into r11;
+ // Enforce the amount is at least one million credits.
+ assert.eq r11 true;
+
+ // Construct the updated bond state.
+ cast r1 r10 into r12 as bond_state;
+
+ /* Account */
+
+ // Get the balance of the caller.
+ // If the account does not exist, this finalize scope will fail.
+ get account[r0] into r13;
+ // Decrement the balance of the caller.
+ sub r13 r2 into r14;
+
+ /* Writes */
+
+ // Update the committee state of the specified validator.
+ set r7 into committee[r0];
+ // Update the bond state for the caller.
+ set r12 into bonded[r0];
+ // Update the balance of the caller.
+ set r14 into account[r0];
+
+ // Ends the `bond_validator` logic.
+ branch.eq true true to end;
+
+ /******* Bond Delegator *******/
+
+ // Starts the `bond_delegator` logic.
+ position bond_delegator;
+
+ /* Committee */
+
+ // Check if the caller is a validator.
+ contains committee[r0] into r15;
+ // Enforce the caller is *not* a validator.
+ assert.eq r15 false;
+
+ // Get the stake for the specified validator.
+ // If the validator does not exist, this finalize scope will fail.
+ get committee[r1] into r16;
+ // Ensure that the validator is open to stakers.
+ assert.eq r16.is_open true;
+
+ // Increment the stake for the specified validator.
+ add r16.microcredits r2 into r17;
+ // Construct the updated committee state.
+ cast r17 r16.is_open into r18 as committee_state;
+
+ /* Bonded */
+
+ // Construct the initial bond state.
+ cast r1 0u64 into r19 as bond_state;
+ // Get the bond state for the caller, or default to the initial bond state.
+ get.or_use bonded[r0] r19 into r20;
+ // Enforce the validator matches in the bond state.
+ assert.eq r20.validator r1;
+
+ // Increment the microcredits in the bond state.
+ add r20.microcredits r2 into r21;
+ // Determine if the amount is at least 10 credits.
+ gte r21 10_000_000u64 into r22;
+ // Enforce the amount is at least 10 credits.
+ assert.eq r22 true;
+
+ // Construct the updated bond state.
+ cast r1 r21 into r23 as bond_state;
+
+ /* Account */
+
+ // Get the balance of the caller.
+ // If the account does not exist, this finalize scope will fail.
+ get account[r0] into r24;
+ // Decrement the balance of the caller.
+ sub r24 r2 into r25;
+
+ /* Writes */
+
+ // Update the committee state for the specified validator.
+ set r18 into committee[r1];
+ // Update the bond state for the caller.
+ set r23 into bonded[r0];
+ // Update the balance of the caller.
+ set r25 into account[r0];
+
+ // The terminus.
+ position end;
+
+/**********************************************************************************************************************/
+
+// This function allows any staker to unbond their microcredits from a validator.
+// The corresponding functions for 'unbond_public' is 'claim_unbond_public'.
+function unbond_public:
+ // Input the amount of microcredits to unbond.
+ input r0 as u64.public;
+
+ // Unbond the specified amount of microcredits to the caller.
+ async unbond_public self.caller r0 into r1;
+ // Output the finalize future.
+ output r1 as credits.aleo/unbond_public.future;
+
+finalize unbond_public:
+ // Input the staker's address.
+ input r0 as address.public;
+ // Input the amount of microcredits to unbond.
+ input r1 as u64.public;
+
+ // Construct the initial unbond state.
+ cast 0u64 0u32 into r2 as unbond_state;
+ // Get the unbond state for the caller, or default to the initial unbond state.
+ get.or_use unbonding[r0] r2 into r3;
+
+ // Compute the height at which the unbonding will be complete, starting from the current block.
+ // Note: Calling unbond across multiple blocks before the unbonding is complete will reset the height each time.
+ add block.height 360u32 into r4;
+
+ // Determine if the caller is a validator or delegator.
+ contains committee[r0] into r5;
+
+ // If the caller is a validator, jump to the `unbond_validator` logic.
+ branch.eq r5 true to unbond_validator;
+ // If the caller is not a validator, jump to the `unbond_delegator` logic.
+ branch.eq r5 false to unbond_delegator;
+
+ /******* Unbond Validator *******/
+
+ // Starts the `unbond_validator` logic.
+ position unbond_validator;
+
+ /* Committee */
+
+ // Get the committee state for the specified validator.
+ get committee[r0] into r6;
+ // Decrement the stake for the specified validator.
+ sub r6.microcredits r1 into r7;
+
+ /* Bonded */
+
+ // Get the bond state for the validator, or fail if it does not exist.
+ get bonded[r0] into r8;
+ // Ensure that the validator matches in the bond state.
+ assert.eq r8.validator r0;
+ // Decrement the microcredits in the bond state.
+ sub r8.microcredits r1 into r9;
+
+ // Determine if the remaining bond is at least one million credits.
+ gte r9 1_000_000_000_000u64 into r10;
+
+ // If the remaining balance is at least 1 million credits, jump to the `decrement_validator` logic.
+ branch.eq r10 true to decrement_validator;
+ // If the remaining balance is less than 1 million credits, jump to the `remove_validator` logic.
+ branch.eq r10 false to remove_validator;
+
+ /*** Decrement Validator ***/
+
+ // Starts the `decrement_validator` logic.
+ position decrement_validator;
+
+ /* Committee */
+
+ // Construct the updated committee state.
+ cast r7 r6.is_open into r11 as committee_state;
+ // Update the committee state for the validator.
+ set r11 into committee[r0];
+
+ /* Bonded */
+
+ // Construct the updated bond state.
+ cast r0 r9 into r12 as bond_state;
+ // Update the bond state for the validator.
+ set r12 into bonded[r0];
+
+ /* Unbonding */
+
+ // Increment the microcredits in the unbond state.
+ add r3.microcredits r1 into r13;
+
+ // Construct the updated unbond state.
+ cast r13 r4 into r14 as unbond_state;
+ // Update the unbond state for the caller.
+ set r14 into unbonding[r0];
+
+ // Ends the `decrement_validator` logic.
+ branch.eq true true to end;
+
+ /*** Remove Validator ***/
+
+ // Starts the `remove_validator` logic.
+ position remove_validator;
+
+ // Ensure that the validator has no delegators.
+ assert.eq r6.microcredits r8.microcredits;
+
+ /* Committee */
+
+ // Remove the validator from the committee.
+ remove committee[r0];
+
+ /* Bonded */
+
+ // Remove the bond state for the validator.
+ remove bonded[r0];
+
+ /* Unbonding */
+
+ // Increment the microcredits in the unbond state.
+ add r3.microcredits r8.microcredits into r15;
+
+ // Construct the updated unbond state.
+ cast r15 r4 into r16 as unbond_state;
+ // Update the unbond state for the caller.
+ set r16 into unbonding[r0];
+
+ // Ends the `remove_validator` logic.
+ branch.eq true true to end;
+
+ /******* Unbond Delegator *******/
+
+ // Starts the `unbond_delegator` logic.
+ position unbond_delegator;
+
+ // Get the bond state for the caller, or fail if it does not exist.
+ get bonded[r0] into r17;
+ // Decrement the microcredits in the bond state.
+ sub r17.microcredits r1 into r18;
+
+ // Determine if the remaining bond is at least 10 credits.
+ gte r18 10_000_000u64 into r19;
+
+ // If the remaining balance is at least 10 credits, jump to the `decrement_delegator` logic.
+ branch.eq r19 true to decrement_delegator;
+ // If the remaining balance is less than 10 credits, jump to the `remove_delegator` logic.
+ branch.eq r19 false to remove_delegator;
+
+ /*** Decrement Delegator ***/
+
+ // Starts the `decrement_delegator` logic.
+ position decrement_delegator;
+
+ /* Committee */
+
+ // Get the stake for the specified validator.
+ // If the validator does not exist, this finalize scope will fail.
+ get committee[r17.validator] into r20;
+ // Decrement the stake for the specified validator.
+ sub r20.microcredits r1 into r21;
+ // Construct the updated committee state.
+ cast r21 r20.is_open into r22 as committee_state;
+ // Update the stake for the specified validator.
+ set r22 into committee[r17.validator];
+
+ /* Bonded */
+
+ // Construct the updated bond state.
+ cast r17.validator r18 into r23 as bond_state;
+ // Update the bond state for the caller.
+ set r23 into bonded[r0];
+
+ /* Unbonding */
+
+ // Increment the microcredits in the unbond state.
+ add r3.microcredits r1 into r24;
+
+ // Construct the updated unbond state.
+ cast r24 r4 into r25 as unbond_state;
+ // Update the unbond state for the caller.
+ set r25 into unbonding[r0];
+
+ // Ends the `decrement_delegator` logic.
+ branch.eq true true to end;
+
+ /*** Remove Delegator ***/
+
+ // Starts the `remove_delegator` logic.
+ position remove_delegator;
+
+ /* Committee */
+
+ // Get the stake for the specified validator.
+ // If the validator does not exist, this finalize scope will fail.
+ get committee[r17.validator] into r26;
+ // Decrement the stake for the specified validator.
+ sub r26.microcredits r17.microcredits into r27;
+ // Construct the updated committee state.
+ cast r27 r26.is_open into r28 as committee_state;
+ // Update the stake for the specified validator.
+ set r28 into committee[r17.validator];
+
+ /* Bonded */
+
+ // Remove the caller from the bonded mapping.
+ remove bonded[r0];
+
+ /* Unbonding */
+
+ // Increment the microcredits in the unbond state.
+ add r3.microcredits r17.microcredits into r29;
+
+ // Construct the updated unbond state.
+ cast r29 r4 into r30 as unbond_state;
+ // Update the unbond state for the caller.
+ set r30 into unbonding[r0];
+
+ // The terminus.
+ position end;
+
+/**********************************************************************************************************************/
+
+// This function allows a validator to unbond any delegator that is bonded to them.
+function unbond_delegator_as_validator:
+ // Input the delegator's address.
+ input r0 as address.public;
+
+ // Unbond the delegator as the validator.
+ async unbond_delegator_as_validator self.caller r0 into r1;
+ // Output the finalize future.
+ output r1 as credits.aleo/unbond_delegator_as_validator.future;
+
+finalize unbond_delegator_as_validator:
+ // Input the validator's address.
+ input r0 as address.public;
+ // Input the delegator's address.
+ input r1 as address.public;
+
+ /* Start Committee */
+
+ // Get the committee state for the specified validator.
+ // If the validator does not exist, this finalize scope will fail.
+ get committee[r0] into r2;
+ // Enforce that the validator is closed to stakers.
+ assert.eq r2.is_open false;
+
+ // Check if the delegator is a validator.
+ contains committee[r1] into r3;
+ // Enforce the delegator is *not* a validator.
+ assert.eq r3 false;
+
+ /* End Committee */
+
+ /* Start Bonded */
+
+ // Get the bond state for the delegator, or fail if it does not exist.
+ get bonded[r1] into r4;
+ // Enforce that the delegator is bonded to the validator.
+ assert.eq r4.validator r0;
+
+ /* End Bonded */
+
+ /* Start Committee */
+
+ // Decrement the stake for the specified validator.
+ sub r2.microcredits r4.microcredits into r5;
+ // Construct the updated committee state.
+ cast r5 r2.is_open into r6 as committee_state;
+
+ /* End Committee */
+
+ /* Start Unbond */
+
+ // Construct the initial unbond state.
+ cast 0u64 0u32 into r7 as unbond_state;
+ // Get the unbond state for the delegator, or default to the initial unbond state.
+ get.or_use unbonding[r1] r7 into r8;
+
+ // Increment the microcredits in the unbond state.
+ add r8.microcredits r4.microcredits into r9;
+ // Compute the height at which the unbonding will be complete, starting from the current block.
+ // Note: Calling unbond across multiple blocks before the unbonding is complete will reset the height each time.
+ add block.height 360u32 into r10;
+
+ // Construct the updated unbond state.
+ cast r9 r10 into r11 as unbond_state;
+
+ /* End Unbond */
+
+ /* Start Writes */
+
+ // Update the committee state for the specified validator.
+ set r6 into committee[r0];
+ // Remove the bond state for the delegator.
+ remove bonded[r1];
+ // Update the unbond state for the delegator.
+ set r11 into unbonding[r1];
+
+ /* End Writes */
+
+/**********************************************************************************************************************/
+
+// This function allows any staker to claim their microcredits after the unbonding period.
+function claim_unbond_public:
+ // Claim the unbonded microcredits.
+ async claim_unbond_public self.caller into r0;
+ // Output the finalize future.
+ output r0 as credits.aleo/claim_unbond_public.future;
+
+finalize claim_unbond_public:
+ // Input the staker's address.
+ input r0 as address.public;
+
+ // Get the unbond state for the caller, or fail if it does not exist.
+ get unbonding[r0] into r1;
+ // Determine if unbonding is complete.
+ gte block.height r1.height into r2;
+ // Enforce the unbonding is complete.
+ assert.eq r2 true;
+
+ // Add the unbonded amount to the stakers's public balance.
+ // Increments `account[r0]` by `r1`.
+ // If `account[r0]` does not exist, 0u64 is used.
+ // If `account[r0] + r2` overflows, `claim_unbond_public` is reverted.
+ get.or_use account[r0] 0u64 into r3;
+ add r1.microcredits r3 into r4;
+ set r4 into account[r0];
+
+ // Remove the unbond state for the caller.
+ remove unbonding[r0];
+
+/**********************************************************************************************************************/
+
+// This function allows a validator to set their state to be either opened or closed to stakers.
+// When the validator is open to stakers, any staker (including the validator) can bond or unbond from the validator.
+// When the validator is closed to stakers, all stakers can only unbond from the validator.
+//
+// This function serves two primary purposes:
+// 1. Allow a validator to leave the committee, by closing themselves to stakers and then unbonding all of their stakers.
+// 2. Allow a validator to maintain their % of stake, by closing themselves to allowing more stakers to bond to them.
+function set_validator_state:
+ // Input the 'is_open' state.
+ input r0 as boolean.public;
+ // Set the validator to be either open or closed to stakers.
+ async set_validator_state self.caller r0 into r1;
+ // Output the finalize future.
+ output r1 as credits.aleo/set_validator_state.future;
+
+finalize set_validator_state:
+ // Input the validator's address.
+ input r0 as address.public;
+ // Input the 'is_open' state.
+ input r1 as boolean.public;
+
+ // Get the committee state for the specified validator.
+ // If the validator does not exist, this finalize scope will fail.
+ get committee[r0] into r2;
+
+ // Construct the updated committee state.
+ cast r2.microcredits r1 into r3 as committee_state;
+ // Update the committee state for the specified validator.
+ set r3 into committee[r0];
+
+/**********************************************************************************************************************/
+
+// The `transfer_public` function sends the specified amount
+// from the sender's `account` to the receiver's `account`.
+function transfer_public:
+ // Input the receiver.
+ input r0 as address.public;
+ // Input the amount.
+ input r1 as u64.public;
+ // Transfer the credits publicly.
+ async transfer_public self.caller r0 r1 into r2;
+ // Output the finalize future.
+ output r2 as credits.aleo/transfer_public.future;
+
+finalize transfer_public:
+ // Input the sender.
+ input r0 as address.public;
+ // Input the receiver.
+ input r1 as address.public;
+ // Input the amount.
+ input r2 as u64.public;
+ // Decrements `account[r0]` by `r2`.
+ // If `account[r0]` does not exist, 0u64 is used.
+ // If `account[r0] - r2` underflows, `transfer_public` is reverted.
+ get.or_use account[r0] 0u64 into r3;
+ sub r3 r2 into r4;
+ set r4 into account[r0];
+ // Increments `account[r1]` by `r2`.
+ // If `account[r1]` does not exist, 0u64 is used.
+ // If `account[r1] + r2` overflows, `transfer_public` is reverted.
+ get.or_use account[r1] 0u64 into r5;
+ add r5 r2 into r6;
+ set r6 into account[r1];
+
+/**********************************************************************************************************************/
+
+// The `transfer_private` function sends the specified amount
+// from the sender's record to the receiver in a record.
+function transfer_private:
+ // Input the sender's record.
+ input r0 as credits.record;
+ // Input the receiver.
+ input r1 as address.private;
+ // Input the amount.
+ input r2 as u64.private;
+ // Checks the given record has a sufficient amount.
+ // This `sub` operation is safe, and the proof will fail
+ // if an underflow occurs. The destination register `r3` holds
+ // the change amount to be returned to the sender.
+ sub r0.microcredits r2 into r3;
+ // Construct a record for the specified receiver.
+ cast r1 r2 into r4 as credits.record;
+ // Construct a record with the change amount for the sender.
+ cast r0.owner r3 into r5 as credits.record;
+ // Output the receiver's record.
+ output r4 as credits.record;
+ // Output the sender's change record.
+ output r5 as credits.record;
+
+/**********************************************************************************************************************/
+
+// The `transfer_private_to_public` function turns a specified amount
+// from a record into public credits for the specified receiver.
+//
+// This function preserves privacy for the sender's record, however
+// it publicly reveals the receiver and the amount.
+function transfer_private_to_public:
+ // Input the sender's record.
+ input r0 as credits.record;
+ // Input the receiver.
+ input r1 as address.public;
+ // Input the amount.
+ input r2 as u64.public;
+ // Checks the given record has a sufficient amount.
+ // This `sub` operation is safe, and the proof will fail
+ // if an underflow occurs. The destination register `r3` holds
+ // the change amount for the sender.
+ sub r0.microcredits r2 into r3;
+ // Construct a record with the change amount for the sender.
+ cast r0.owner r3 into r4 as credits.record;
+ // Increment the amount publicly for the receiver.
+ async transfer_private_to_public r1 r2 into r5;
+ // Output the sender's change record.
+ output r4 as credits.record;
+ // Output the finalize future.
+ output r5 as credits.aleo/transfer_private_to_public.future;
+
+finalize transfer_private_to_public:
+ // Input the receiver.
+ input r0 as address.public;
+ // Input the amount.
+ input r1 as u64.public;
+ // Retrieve the balance of the sender.
+ // If `account[r0]` does not exist, 0u64 is used.
+ get.or_use account[r0] 0u64 into r2;
+ // Increments `account[r0]` by `r1`.
+ // If `r1 + r2` overflows, `transfer_private_to_public` is reverted.
+ add r1 r2 into r3;
+ // Updates the balance of the sender.
+ set r3 into account[r0];
+
+/**********************************************************************************************************************/
+
+// The `transfer_public_to_private` function turns a specified amount
+// from the mapping `account` into a record for the specified receiver.
+//
+// This function publicly reveals the sender, the receiver, and the specified amount.
+// However, subsequent methods using the receiver's record can preserve the receiver's privacy.
+function transfer_public_to_private:
+ // Input the receiver.
+ input r0 as address.private;
+ // Input the amount.
+ input r1 as u64.public;
+ // Construct a record for the receiver.
+ cast r0 r1 into r2 as credits.record;
+ // Decrement the balance of the sender publicly.
+ async transfer_public_to_private self.caller r1 into r3;
+ // Output the record of the receiver.
+ output r2 as credits.record;
+ // Output the finalize future.
+ output r3 as credits.aleo/transfer_public_to_private.future;
+
+finalize transfer_public_to_private:
+ // Input the sender.
+ input r0 as address.public;
+ // Input the amount.
+ input r1 as u64.public;
+ // Retrieve the balance of the sender.
+ // If `account[r0]` does not exist, 0u64 is used.
+ get.or_use account[r0] 0u64 into r2;
+ // Decrements `account[r0]` by `r1`.
+ // If `r2 - r1` underflows, `transfer_public_to_private` is reverted.
+ sub r2 r1 into r3;
+ // Updates the balance of the sender.
+ set r3 into account[r0];
+
+/**********************************************************************************************************************/
+
+// The `join` function combines two records into one.
+function join:
+ // Input the first record.
+ input r0 as credits.record;
+ // Input the second record.
+ input r1 as credits.record;
+ // Combines the amount of the first record and the second record.
+ // This `add` operation is safe, and the proof will fail
+ // if an overflow occurs.
+ add r0.microcredits r1.microcredits into r2;
+ // Construct a record with the combined amount.
+ cast r0.owner r2 into r3 as credits.record;
+ // Output the record.
+ output r3 as credits.record;
+
+/**********************************************************************************************************************/
+
+// The `split` function splits a record into two records. The given input amount will be stored in the first record,
+// and the remaining amount will be stored in the second record, with the fee deducted from the remaining amount.
+// If the caller executes a transaction that contains only a call to this function, then the transaction does not
+// require a fee, unless the caller wishes to provide an additional fee. Transactions that contain multiple transitions
+// (that include one or more calls to this function) will require a fee as per standard consensus rules.
+function split:
+ // Input the record.
+ input r0 as credits.record;
+ // Input the amount to split.
+ input r1 as u64.private;
+ // Checks the given record has a sufficient amount to split.
+ // This `sub` operation is safe, and the proof will fail
+ // if an underflow occurs.
+ sub r0.microcredits r1 into r2;
+ // Checks the given record has a sufficient fee to remove.
+ // This `sub` operation is safe, and the proof will fail
+ // if an underflow occurs.
+ sub r2 10_000u64 into r3;
+ // Construct the first record.
+ cast r0.owner r1 into r4 as credits.record;
+ // Construct the second record.
+ cast r0.owner r3 into r5 as credits.record;
+ // Output the first record.
+ output r4 as credits.record;
+ // Output the second record.
+ output r5 as credits.record;
+
+/**********************************************************************************************************************/
+
+// The `fee_private` function charges the specified amount from the sender's record.
+function fee_private:
+ // Input the sender's record.
+ input r0 as credits.record;
+ // Input the amount.
+ input r1 as u64.public;
+ // Input the deployment or execution root.
+ input r2 as field.public;
+ // Ensure the amount is nonzero.
+ assert.neq r1 0u64;
+ // Ensure the deployment or execution root is nonzero.
+ assert.neq r2 0field;
+ // Checks the given record has a sufficient amount.
+ // This `sub` operation is safe, and the proof will fail
+ // if an underflow occurs. The destination register `r3` holds
+ // the change amount for the sender.
+ sub r0.microcredits r1 into r3;
+ // Construct a record with the change amount for the sender.
+ cast r0.owner r3 into r4 as credits.record;
+ // Output the sender's change record.
+ output r4 as credits.record;
+
+/**********************************************************************************************************************/
+
+// The `fee_public` function charges the specified amount from the sender's account.
+function fee_public:
+ // Input the amount.
+ input r0 as u64.public;
+ // Input the deployment or execution root.
+ input r1 as field.public;
+ // Ensure the amount is nonzero.
+ assert.neq r0 0u64;
+ // Ensure the deployment or execution root is nonzero.
+ assert.neq r1 0field;
+ // Decrement the balance of the sender publicly.
+ async fee_public self.caller r0 into r2;
+ // Output the finalize future.
+ output r2 as credits.aleo/fee_public.future;
+
+finalize fee_public:
+ // Input the sender's address.
+ input r0 as address.public;
+ // Input the amount.
+ input r1 as u64.public;
+ // Retrieve the balance of the sender.
+ // If `account[r0]` does not exist, `fee_public` is reverted.
+ get account[r0] into r2;
+ // Decrements `account[r0]` by `r1`.
+ // If `r2 - r1` underflows, `fee_public` is reverted.
+ sub r2 r1 into r3;
+ // Updates the balance of the sender.
+ set r3 into account[r0];
+
+/**********************************************************************************************************************/
+
+// Open Questions:
+// fn bond
+// - if the bond is now 33% or more, close the validator. (determine how hard to impl this)
+
+/**********************************************************************************************************************/
diff --git a/utils/disassembler/src/tests/large_functions.aleo b/utils/disassembler/src/tests/large_functions.aleo
new file mode 100644
index 0000000000..7d80e01b5f
--- /dev/null
+++ b/utils/disassembler/src/tests/large_functions.aleo
@@ -0,0 +1,242 @@
+import credits.aleo;
+
+program large_functions.aleo;
+
+function join_3:
+ input r0 as credits.aleo/credits.record;
+ input r1 as credits.aleo/credits.record;
+ input r2 as credits.aleo/credits.record;
+ assert.eq r0.owner r1.owner;
+ assert.eq r1.owner r2.owner;
+ call credits.aleo/join r0 r1 into r3;
+ call credits.aleo/join r3 r2 into r4;
+ output r4 as credits.aleo/credits.record;
+
+function join_5:
+ input r0 as credits.aleo/credits.record;
+ input r1 as credits.aleo/credits.record;
+ input r2 as credits.aleo/credits.record;
+ input r3 as credits.aleo/credits.record;
+ input r4 as credits.aleo/credits.record;
+ assert.eq r0.owner r1.owner;
+ assert.eq r1.owner r2.owner;
+ assert.eq r2.owner r3.owner;
+ assert.eq r3.owner r4.owner;
+ call credits.aleo/join r0 r1 into r5;
+ call credits.aleo/join r2 r3 into r6;
+ call credits.aleo/join r5 r6 into r7;
+ call credits.aleo/join r7 r4 into r8;
+ output r8 as credits.aleo/credits.record;
+
+function join6:
+ input r0 as credits.aleo/credits.record;
+ input r1 as credits.aleo/credits.record;
+ input r2 as credits.aleo/credits.record;
+ input r3 as credits.aleo/credits.record;
+ input r4 as credits.aleo/credits.record;
+ input r5 as credits.aleo/credits.record;
+ assert.eq r0.owner r1.owner;
+ assert.eq r1.owner r2.owner;
+ assert.eq r2.owner r3.owner;
+ assert.eq r3.owner r4.owner;
+ assert.eq r4.owner r5.owner;
+ call credits.aleo/join r0 r1 into r6;
+ call credits.aleo/join r2 r3 into r7;
+ call credits.aleo/join r4 r5 into r8;
+ call credits.aleo/join r6 r7 into r9;
+ call credits.aleo/join r9 r8 into r10;
+ output r10 as credits.aleo/credits.record;
+
+function join7:
+ input r0 as credits.aleo/credits.record;
+ input r1 as credits.aleo/credits.record;
+ input r2 as credits.aleo/credits.record;
+ input r3 as credits.aleo/credits.record;
+ input r4 as credits.aleo/credits.record;
+ input r5 as credits.aleo/credits.record;
+ input r6 as credits.aleo/credits.record;
+ assert.eq r0.owner r1.owner;
+ assert.eq r1.owner r2.owner;
+ assert.eq r2.owner r3.owner;
+ assert.eq r3.owner r4.owner;
+ assert.eq r4.owner r5.owner;
+ assert.eq r5.owner r6.owner;
+ call credits.aleo/join r0 r1 into r7;
+ call credits.aleo/join r2 r3 into r8;
+ call credits.aleo/join r4 r5 into r9;
+ call credits.aleo/join r7 r8 into r10;
+ call credits.aleo/join r10 r9 into r11;
+ call credits.aleo/join r11 r6 into r12;
+ output r12 as credits.aleo/credits.record;
+
+function join8:
+ input r0 as credits.aleo/credits.record;
+ input r1 as credits.aleo/credits.record;
+ input r2 as credits.aleo/credits.record;
+ input r3 as credits.aleo/credits.record;
+ input r4 as credits.aleo/credits.record;
+ input r5 as credits.aleo/credits.record;
+ input r6 as credits.aleo/credits.record;
+ input r7 as credits.aleo/credits.record;
+ assert.eq r0.owner r1.owner;
+ assert.eq r1.owner r2.owner;
+ assert.eq r2.owner r3.owner;
+ assert.eq r3.owner r4.owner;
+ assert.eq r4.owner r5.owner;
+ assert.eq r5.owner r6.owner;
+ assert.eq r6.owner r7.owner;
+ call credits.aleo/join r0 r1 into r8;
+ call credits.aleo/join r2 r3 into r9;
+ call credits.aleo/join r4 r5 into r10;
+ call credits.aleo/join r6 r7 into r11;
+ call credits.aleo/join r8 r9 into r12;
+ call credits.aleo/join r11 r10 into r13;
+ call credits.aleo/join r12 r13 into r14;
+ output r14 as credits.aleo/credits.record;
+
+function join9:
+ input r0 as credits.aleo/credits.record;
+ input r1 as credits.aleo/credits.record;
+ input r2 as credits.aleo/credits.record;
+ input r3 as credits.aleo/credits.record;
+ input r4 as credits.aleo/credits.record;
+ input r5 as credits.aleo/credits.record;
+ input r6 as credits.aleo/credits.record;
+ input r7 as credits.aleo/credits.record;
+ input r8 as credits.aleo/credits.record;
+ assert.eq r0.owner r1.owner;
+ assert.eq r1.owner r2.owner;
+ assert.eq r2.owner r3.owner;
+ assert.eq r3.owner r4.owner;
+ assert.eq r4.owner r5.owner;
+ assert.eq r5.owner r6.owner;
+ assert.eq r6.owner r7.owner;
+ assert.eq r7.owner r8.owner;
+ call credits.aleo/join r0 r1 into r9;
+ call credits.aleo/join r2 r3 into r10;
+ call credits.aleo/join r4 r5 into r11;
+ call credits.aleo/join r6 r7 into r12;
+ call credits.aleo/join r9 r10 into r13;
+ call credits.aleo/join r12 r11 into r14;
+ call credits.aleo/join r13 r14 into r15;
+ call credits.aleo/join r15 r8 into r16;
+ output r16 as credits.aleo/credits.record;
+
+function join10:
+ input r0 as credits.aleo/credits.record;
+ input r1 as credits.aleo/credits.record;
+ input r2 as credits.aleo/credits.record;
+ input r3 as credits.aleo/credits.record;
+ input r4 as credits.aleo/credits.record;
+ input r5 as credits.aleo/credits.record;
+ input r6 as credits.aleo/credits.record;
+ input r7 as credits.aleo/credits.record;
+ input r8 as credits.aleo/credits.record;
+ input r9 as credits.aleo/credits.record;
+ assert.eq r0.owner r1.owner;
+ assert.eq r1.owner r2.owner;
+ assert.eq r2.owner r3.owner;
+ assert.eq r3.owner r4.owner;
+ assert.eq r4.owner r5.owner;
+ assert.eq r5.owner r6.owner;
+ assert.eq r6.owner r7.owner;
+ assert.eq r7.owner r8.owner;
+ assert.eq r8.owner r9.owner;
+ call credits.aleo/join r0 r1 into r10;
+ call credits.aleo/join r2 r3 into r11;
+ call credits.aleo/join r4 r5 into r12;
+ call credits.aleo/join r6 r7 into r13;
+ call credits.aleo/join r8 r9 into r14;
+ call credits.aleo/join r10 r11 into r15;
+ call credits.aleo/join r13 r12 into r16;
+ call credits.aleo/join r15 r16 into r17;
+ call credits.aleo/join r17 r14 into r18;
+ output r18 as credits.aleo/credits.record;
+
+function transfer_3:
+ input r0 as address.private;
+ input r1 as credits.aleo/credits.record;
+ input r2 as credits.aleo/credits.record;
+ input r3 as credits.aleo/credits.record;
+ assert.eq r1.owner r2.owner;
+ assert.eq r2.owner r3.owner;
+ call credits.aleo/transfer_private r1 r0 r1.microcredits into r4 r5;
+ call credits.aleo/transfer_private r2 r0 r2.microcredits into r6 r7;
+ call credits.aleo/transfer_private r3 r0 r3.microcredits into r8 r9;
+ output r4 as credits.aleo/credits.record;
+ output r5 as credits.aleo/credits.record;
+ output r6 as credits.aleo/credits.record;
+ output r7 as credits.aleo/credits.record;
+ output r8 as credits.aleo/credits.record;
+ output r9 as credits.aleo/credits.record;
+
+function transfer_5:
+ input r0 as address.private;
+ input r1 as credits.aleo/credits.record;
+ input r2 as credits.aleo/credits.record;
+ input r3 as credits.aleo/credits.record;
+ input r4 as credits.aleo/credits.record;
+ input r5 as credits.aleo/credits.record;
+ assert.eq r1.owner r2.owner;
+ assert.eq r2.owner r3.owner;
+ assert.eq r3.owner r4.owner;
+ assert.eq r4.owner r5.owner;
+ call credits.aleo/transfer_private r1 r0 r1.microcredits into r6 r7;
+ call credits.aleo/transfer_private r2 r0 r2.microcredits into r8 r9;
+ call credits.aleo/transfer_private r3 r0 r3.microcredits into r10 r11;
+ call credits.aleo/transfer_private r4 r0 r4.microcredits into r12 r13;
+ call credits.aleo/transfer_private r5 r0 r5.microcredits into r14 r15;
+ output r6 as credits.aleo/credits.record;
+ output r7 as credits.aleo/credits.record;
+ output r8 as credits.aleo/credits.record;
+ output r9 as credits.aleo/credits.record;
+ output r10 as credits.aleo/credits.record;
+ output r11 as credits.aleo/credits.record;
+ output r12 as credits.aleo/credits.record;
+ output r13 as credits.aleo/credits.record;
+ output r14 as credits.aleo/credits.record;
+ output r15 as credits.aleo/credits.record;
+
+function split_3:
+ input r0 as u64.private;
+ input r1 as credits.aleo/credits.record;
+ input r2 as credits.aleo/credits.record;
+ input r3 as credits.aleo/credits.record;
+ assert.eq r1.owner r2.owner;
+ assert.eq r2.owner r3.owner;
+ call credits.aleo/split r1 r0 into r4 r5;
+ call credits.aleo/split r2 r0 into r6 r7;
+ call credits.aleo/split r3 r0 into r8 r9;
+ output r4 as credits.aleo/credits.record;
+ output r5 as credits.aleo/credits.record;
+ output r6 as credits.aleo/credits.record;
+ output r7 as credits.aleo/credits.record;
+ output r8 as credits.aleo/credits.record;
+ output r9 as credits.aleo/credits.record;
+
+function split_5:
+ input r0 as u64.private;
+ input r1 as credits.aleo/credits.record;
+ input r2 as credits.aleo/credits.record;
+ input r3 as credits.aleo/credits.record;
+ input r4 as credits.aleo/credits.record;
+ input r5 as credits.aleo/credits.record;
+ assert.eq r1.owner r2.owner;
+ assert.eq r2.owner r3.owner;
+ assert.eq r3.owner r4.owner;
+ assert.eq r4.owner r5.owner;
+ call credits.aleo/split r1 r0 into r6 r7;
+ call credits.aleo/split r2 r0 into r8 r9;
+ call credits.aleo/split r3 r0 into r10 r11;
+ call credits.aleo/split r4 r0 into r12 r13;
+ call credits.aleo/split r5 r0 into r14 r15;
+ output r6 as credits.aleo/credits.record;
+ output r7 as credits.aleo/credits.record;
+ output r8 as credits.aleo/credits.record;
+ output r9 as credits.aleo/credits.record;
+ output r10 as credits.aleo/credits.record;
+ output r11 as credits.aleo/credits.record;
+ output r12 as credits.aleo/credits.record;
+ output r13 as credits.aleo/credits.record;
+ output r14 as credits.aleo/credits.record;
+ output r15 as credits.aleo/credits.record;
diff --git a/utils/retriever/Cargo.toml b/utils/retriever/Cargo.toml
new file mode 100644
index 0000000000..2b9aebfce1
--- /dev/null
+++ b/utils/retriever/Cargo.toml
@@ -0,0 +1,55 @@
+[package]
+name = "retriever"
+version = "1.10.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies.serde]
+version = "1.0"
+features = [ "derive"]
+
+[dependencies.serde_json]
+version = "1.0"
+
+[dependencies.leo-errors]
+path = "../../errors"
+version = "=1.10.0"
+
+[dependencies.indexmap]
+version = "1.9"
+features = [ "serde-1" ]
+
+[dependencies.leo-ast]
+version = "1.9.4"
+path = "../../compiler/ast"
+
+[dependencies.toml]
+version = "0.8.6"
+
+[dependencies.aleo-std]
+version = "0.1.18"
+default-features = false
+
+[dependencies.disassembler]
+version = "1.10.0"
+path = "../disassembler"
+
+[dependencies.sha2]
+version = "0.10.8"
+
+[dependencies.serial_test]
+version = "3.0.0"
+
+[dependencies.leo-span]
+version = "1.9.4"
+path = "../../compiler/span"
+
+[dependencies.ureq]
+version = "2.9"
+
+[dependencies.leo-passes]
+version = "1.9.4"
+path = "../../compiler/passes"
+[dependencies]
+tempfile = "3.8.1"
\ No newline at end of file
diff --git a/utils/retriever/src/lib.rs b/utils/retriever/src/lib.rs
new file mode 100644
index 0000000000..9406dba287
--- /dev/null
+++ b/utils/retriever/src/lib.rs
@@ -0,0 +1,103 @@
+// Copyright (C) 2019-2023 Aleo Systems Inc.
+// This file is part of the Leo library.
+
+// The Leo library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// The Leo library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with the Leo library. If not, see ,
+ path: Option,
+}
+
+impl Dependency {
+ pub fn new(name: String, location: Location, network: Option, path: Option) -> Self {
+ Self { name, location, network, path }
+ }
+
+ pub fn name(&self) -> &String {
+ &self.name
+ }
+
+ pub fn location(&self) -> &Location {
+ &self.location
+ }
+
+ pub fn network(&self) -> &Option {
+ &self.network
+ }
+
+ pub fn path(&self) -> &Option {
+ &self.path
+ }
+}
+
+impl From<&Dependency> for Symbol {
+ fn from(context: &Dependency) -> Self {
+ Symbol::intern(&context.name.clone()[..context.name.len() - 5])
+ }
+}
diff --git a/errors/src/errors/state/state_errors.rs b/utils/retriever/src/program_context/location.rs
similarity index 70%
rename from errors/src/errors/state/state_errors.rs
rename to utils/retriever/src/program_context/location.rs
index fe29e529e5..6a36059e30 100644
--- a/errors/src/errors/state/state_errors.rs
+++ b/utils/retriever/src/program_context/location.rs
@@ -14,16 +14,15 @@
// You should have received a copy of the GNU General Public License
// along with the Leo library. If not, see ,
+ location: Location,
+ path: Option,
+ checksum: String,
+ dependencies: Vec,
+}
+
+impl From<&ProgramContext> for LockFileEntry {
+ fn from(context: &ProgramContext) -> Self {
+ LockFileEntry {
+ name: context.name().to_string(),
+ network: context.network.clone(), // Direct access as per instruction
+ location: context.location().clone(),
+ path: context.path.clone(), // Direct access as per instruction
+ checksum: context.checksum().to_string(),
+ dependencies: context.dependencies().iter().map(|dep| format!("{}.aleo", dep)).collect(),
+ }
+ }
+}
diff --git a/utils/retriever/src/program_context/manifest.rs b/utils/retriever/src/program_context/manifest.rs
new file mode 100644
index 0000000000..36f8ea1709
--- /dev/null
+++ b/utils/retriever/src/program_context/manifest.rs
@@ -0,0 +1,66 @@
+// Copyright (C) 2019-2023 Aleo Systems Inc.
+// This file is part of the Leo library.
+
+// The Leo library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// The Leo library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with the Leo library. If not, see >,
+}
+
+impl Manifest {
+ pub fn new(
+ program: &str,
+ version: &str,
+ description: &str,
+ license: &str,
+ dependencies: Option>,
+ ) -> Self {
+ Self {
+ program: program.to_owned(),
+ version: version.to_owned(),
+ description: description.to_owned(),
+ license: license.to_owned(),
+ dependencies,
+ }
+ }
+
+ pub fn program(&self) -> &String {
+ &self.program
+ }
+
+ pub fn version(&self) -> &String {
+ &self.version
+ }
+
+ pub fn description(&self) -> &String {
+ &self.description
+ }
+
+ pub fn license(&self) -> &String {
+ &self.license
+ }
+
+ pub fn dependencies(&self) -> &Option> {
+ &self.dependencies
+ }
+}
diff --git a/utils/retriever/src/program_context/mod.rs b/utils/retriever/src/program_context/mod.rs
new file mode 100644
index 0000000000..ce56b532c9
--- /dev/null
+++ b/utils/retriever/src/program_context/mod.rs
@@ -0,0 +1,185 @@
+// Copyright (C) 2019-2023 Aleo Systems Inc.
+// This file is part of the Leo library.
+
+// The Leo library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// The Leo library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with the Leo library. If not, see ,
+ path: Option,
+ full_path: Option,
+ compiled_file_path: Option,
+ dependencies: Option>,
+ checksum: Option,
+ stub: Option,
+ post_order: Option>,
+}
+
+impl ProgramContext {
+ pub fn new_main(name: Symbol, path: PathBuf, dependencies: Vec) -> Self {
+ Self {
+ name,
+ full_name: format!("{}.aleo", name),
+ location: Location::Local,
+ network: None,
+ path: Some(path.clone()),
+ full_path: Some(path.clone()),
+ compiled_file_path: Some(path.join("build/main.aleo")),
+ dependencies: Some(dependencies.iter().map(Symbol::from).collect()),
+ checksum: None,
+ stub: None,
+ post_order: None,
+ }
+ }
+
+ // Method to extract 'name'
+ pub fn name(&self) -> &Symbol {
+ &self.name
+ }
+
+ // Method to extract 'name_with_network'
+ pub fn full_name(&self) -> &String {
+ &self.full_name
+ }
+
+ // Method to extract 'network', panics if `None`. Only safe to access if location is 'Network'
+ pub fn network(&self) -> &Network {
+ self.network.as_ref().expect("ProgramContext network is None")
+ }
+
+ // Method to extract 'location'
+ pub fn location(&self) -> &Location {
+ &self.location
+ }
+
+ // Method to extract 'path', panics if `None`. Only safe to access if location is 'Local'.
+ pub fn path(&self) -> &PathBuf {
+ self.path.as_ref().expect("ProgramContext path is None")
+ }
+
+ // Method to extract 'full_path', panics if `None`. Only safe to access if location is 'Local'.
+ pub fn full_path(&self) -> &PathBuf {
+ self.full_path.as_ref().expect("ProgramContext full_path is None")
+ }
+
+ // Method to add 'full_path'.
+ pub fn add_full_path(&mut self, full_path: &Path) {
+ self.full_path = Some(PathBuf::from(full_path));
+ }
+
+ pub fn compiled_file_path(&self) -> &PathBuf {
+ self.compiled_file_path.as_ref().expect("ProgramContext compiled_file_path is None")
+ }
+
+ pub fn add_compiled_file_path(&mut self, path: &Path) {
+ self.compiled_file_path = Some(PathBuf::from(path));
+ }
+
+ // Method to extract 'checksum'.
+ pub fn checksum(&self) -> &String {
+ self.checksum.as_ref().expect("ProgramContext checksum is None")
+ }
+
+ // Method to add 'checksum'.
+ pub fn add_checksum(&mut self) {
+ if let Some(_c) = &self.checksum {
+ } else {
+ let file_str = std::fs::read_to_string(self.compiled_file_path()).expect("Unable to read file");
+ let mut hasher = Sha256::new();
+ hasher.update(file_str.as_bytes());
+ let hash = hasher.finalize();
+
+ // Convert the hash to a hexadecimal string
+ let mut hash_str = String::new();
+ for byte in hash {
+ write!(&mut hash_str, "{:02x}", byte).expect("Unable to write");
+ }
+
+ self.checksum = Some(hash_str.clone());
+ }
+ }
+
+ // Method to add 'stub'
+ pub fn add_stub(&mut self, stub: Stub) -> bool {
+ if self.stub.is_some() {
+ return true;
+ }
+ self.stub = Some(stub);
+ false
+ }
+
+ // Method to extract 'stub', panics if `None`. Safe after retrieve() for Network, and process_local() for Local
+ pub fn stub(&self) -> &Stub {
+ self.stub.as_ref().unwrap_or_else(|| panic!("{} has no stub set", self.name))
+ }
+
+ // Method to extract 'dependencies', panics if `None`
+ pub fn dependencies(&self) -> Vec {
+ self.dependencies.as_ref().unwrap_or_else(|| panic!("{}'s dependencies are not set", self.full_name)).clone()
+ }
+
+ // Method to add 'dependencies'
+ pub fn add_dependencies(&mut self, dependencies: Vec 
)
+
+A standard game of Tic-Tac-Toe in Leo.
+
+⭕ ❕ ⭕ ❕ ❌
+
+➖ ➕ ➖ ➕ ➖
+
+⭕ ❕ ❌ ❕ ⭕
+
+➖ ➕ ➖ ➕ ➖
+
+❌ ❕ ❌ ❕ ⭕
+
+## Representing State
+Leo allows users to define composite data types with the `struct` keyword.
+The game board is represented by a struct called `Board`, which contains three `Row`s.
+An alternative representation would be to use an array, however, these are not yet supported in Leo.
+
+## Language Features
+- `struct` declarations
+- conditional statements
+- early termination. Leo allows users to return from a function early using the `return` keyword.
+
+## Running the Program
+
+Leo provides users with a command line interface for compiling and running Leo programs.
+Users may either specify input values via the command line or provide an input file in `inputs/`.
+
+### Providing inputs via the command line.
+1. Run
+```bash
+leo run 
)
+
+A transparent & shielded custom token in Leo.
+
+## Run Guide
+
+To run this program, run:
+```bash
+./run.sh
+```
\ No newline at end of file
diff --git a/.circleci/token/build/main.aleo b/.circleci/token/build/main.aleo
new file mode 100644
index 0000000000..2f80ca2797
--- /dev/null
+++ b/.circleci/token/build/main.aleo
@@ -0,0 +1,93 @@
+program token.aleo;
+
+record token:
+ owner as address.private;
+ amount as u64.private;
+
+
+mapping account:
+ key as address.public;
+ value as u64.public;
+
+function mint_public:
+ input r0 as address.public;
+ input r1 as u64.public;
+ async mint_public r0 r1 into r2;
+ output r2 as token.aleo/mint_public.future;
+
+finalize mint_public:
+ input r0 as address.public;
+ input r1 as u64.public;
+ get.or_use account[r0] 0u64 into r2;
+ add r2 r1 into r3;
+ set r3 into account[r0];
+
+
+function mint_private:
+ input r0 as address.private;
+ input r1 as u64.private;
+ cast r0 r1 into r2 as token.record;
+ output r2 as token.record;
+
+
+function transfer_public:
+ input r0 as address.public;
+ input r1 as u64.public;
+ async transfer_public self.caller r0 r1 into r2;
+ output r2 as token.aleo/transfer_public.future;
+
+finalize transfer_public:
+ input r0 as address.public;
+ input r1 as address.public;
+ input r2 as u64.public;
+ get.or_use account[r0] 0u64 into r3;
+ sub r3 r2 into r4;
+ set r4 into account[r0];
+ get.or_use account[r1] 0u64 into r5;
+ add r5 r2 into r6;
+ set r6 into account[r1];
+
+
+function transfer_private:
+ input r0 as token.record;
+ input r1 as address.private;
+ input r2 as u64.private;
+ sub r0.amount r2 into r3;
+ cast r0.owner r3 into r4 as token.record;
+ cast r1 r2 into r5 as token.record;
+ output r4 as token.record;
+ output r5 as token.record;
+
+
+function transfer_private_to_public:
+ input r0 as token.record;
+ input r1 as address.public;
+ input r2 as u64.public;
+ sub r0.amount r2 into r3;
+ cast r0.owner r3 into r4 as token.record;
+ async transfer_private_to_public r1 r2 into r5;
+ output r4 as token.record;
+ output r5 as token.aleo/transfer_private_to_public.future;
+
+finalize transfer_private_to_public:
+ input r0 as address.public;
+ input r1 as u64.public;
+ get.or_use account[r0] 0u64 into r2;
+ add r2 r1 into r3;
+ set r3 into account[r0];
+
+
+function transfer_public_to_private:
+ input r0 as address.public;
+ input r1 as u64.public;
+ cast r0 r1 into r2 as token.record;
+ async transfer_public_to_private self.caller r1 into r3;
+ output r2 as token.record;
+ output r3 as token.aleo/transfer_public_to_private.future;
+
+finalize transfer_public_to_private:
+ input r0 as address.public;
+ input r1 as u64.public;
+ get.or_use account[r0] 0u64 into r2;
+ sub r2 r1 into r3;
+ set r3 into account[r0];
diff --git a/.circleci/token/build/program.json b/.circleci/token/build/program.json
new file mode 100644
index 0000000000..94d9bc9824
--- /dev/null
+++ b/.circleci/token/build/program.json
@@ -0,0 +1,6 @@
+{
+ "program": "token.aleo",
+ "version": "0.0.0",
+ "description": "",
+ "license": "MIT"
+}
diff --git a/examples/token/inputs/token.in b/.circleci/token/inputs/token.in
similarity index 100%
rename from examples/token/inputs/token.in
rename to .circleci/token/inputs/token.in
diff --git a/.circleci/token/leo.lock b/.circleci/token/leo.lock
new file mode 100644
index 0000000000..c4293b3b9f
--- /dev/null
+++ b/.circleci/token/leo.lock
@@ -0,0 +1 @@
+package = []
diff --git a/.circleci/token/program.json b/.circleci/token/program.json
new file mode 100644
index 0000000000..94d9bc9824
--- /dev/null
+++ b/.circleci/token/program.json
@@ -0,0 +1,6 @@
+{
+ "program": "token.aleo",
+ "version": "0.0.0",
+ "description": "",
+ "license": "MIT"
+}
diff --git a/.circleci/token/run.sh b/.circleci/token/run.sh
new file mode 100644
index 0000000000..45fdc91936
--- /dev/null
+++ b/.circleci/token/run.sh
@@ -0,0 +1,239 @@
+#!/bin/bash
+# First check that Leo is installed.
+if ! command -v leo &> /dev/null
+then
+ echo "leo is not installed."
+ exit
+fi
+
+# The private key and address of Alice.
+# Swap these into program.json, when running transactions as the first bidder.
+# "private_key": "APrivateKey1zkp1w8PTxrRgGfAtfKUSq43iQyVbdQHfhGbiNPEg2LVSEXR",
+# "address": "aleo13ssze66adjjkt795z9u5wpq8h6kn0y2657726h4h3e3wfnez4vqsm3008q"
+
+# The private key and address of Bob.
+# Swap these into program.json, when running transactions as the second bidder.
+# "private_key": "APrivateKey1zkpFo72g7N9iFt3JzzeG8CqsS5doAiXyFvNCgk2oHvjRCzF"
+# "address": "aleo17vy26rpdhqx4598y5gp7nvaa9rk7tnvl6ufhvvf4calsrrqdaqyshdsf5z"
+
+# Swap in the private key of Alice.
+echo "
+NETWORK=testnet3
+PRIVATE_KEY=APrivateKey1zkp1w8PTxrRgGfAtfKUSq43iQyVbdQHfhGbiNPEg2LVSEXR
+" > .env
+
+# Publicly mint 100 tokens for Alice.
+echo "
+###############################################################################
+######## ########
+######## STEP 1: Publicly mint 100 tokens for Alice ########
+######## ########
+######## ----------------------------------------- ########
+######## | PUBLIC BALANCES | ########
+######## ----------------------------------------- ########
+######## ----------------------------------------- ########
+######## | Alice | 100 | ########
+######## ----------------------------------------- ########
+######## | Bob | 0 | ########
+######## ----------------------------------------- ########
+######## ########
+######## ----------------------------------------- ########
+######## | PRIVATE BALANCES | ########
+######## ----------------------------------------- ########
+######## ----------------------------------------- ########
+######## | Alice | 0 | ########
+######## ----------------------------------------- ########
+######## | Bob | 0 | ########
+######## ----------------------------------------- ########
+######## ########
+###############################################################################
+"
+leo run mint_public aleo13ssze66adjjkt795z9u5wpq8h6kn0y2657726h4h3e3wfnez4vqsm3008q 100u64
+
+# Swap in the private key of Bob.
+echo "
+NETWORK=testnet3
+PRIVATE_KEY=APrivateKey1zkpFo72g7N9iFt3JzzeG8CqsS5doAiXyFvNCgk2oHvjRCzF
+" > .env
+
+# Privately mint 100 tokens for Bob.
+echo "
+###############################################################################
+######## ########
+######## STEP 2: Privately mint 100 tokens for Bob ########
+######## ########
+######## ----------------------------------------- ########
+######## | PUBLIC BALANCES | ########
+######## ----------------------------------------- ########
+######## ----------------------------------------- ########
+######## | Alice | 100 | ########
+######## ----------------------------------------- ########
+######## | Bob | 0 | ########
+######## ----------------------------------------- ########
+######## ########
+######## ----------------------------------------- ########
+######## | PRIVATE BALANCES | ########
+######## ----------------------------------------- ########
+######## ----------------------------------------- ########
+######## | Alice | 0 | ########
+######## ----------------------------------------- ########
+######## | Bob | 100 | ########
+######## ----------------------------------------- ########
+######## ########
+###############################################################################
+"
+leo run mint_private aleo17vy26rpdhqx4598y5gp7nvaa9rk7tnvl6ufhvvf4calsrrqdaqyshdsf5z 100u64
+
+# Swap in the private key of Alice.
+echo "
+NETWORK=testnet3
+PRIVATE_KEY=APrivateKey1zkp1w8PTxrRgGfAtfKUSq43iQyVbdQHfhGbiNPEg2LVSEXR
+" > .env
+
+# Publicly transfer 10 tokens from Alice to Bob.
+echo "
+###############################################################################
+######## ########
+######## STEP 3: Publicly transfer 10 tokens from Alice to Bob ########
+######## ########
+######## ----------------------------------------- ########
+######## | PUBLIC BALANCES | ########
+######## ----------------------------------------- ########
+######## ----------------------------------------- ########
+######## | Alice | 90 | ########
+######## ----------------------------------------- ########
+######## | Bob | 10 | ########
+######## ----------------------------------------- ########
+######## ########
+######## ----------------------------------------- ########
+######## | PRIVATE BALANCES | ########
+######## ----------------------------------------- ########
+######## ----------------------------------------- ########
+######## | Alice | 0 | ########
+######## ----------------------------------------- ########
+######## | Bob | 100 | ########
+######## ----------------------------------------- ########
+######## ########
+###############################################################################
+"
+leo run transfer_public aleo17vy26rpdhqx4598y5gp7nvaa9rk7tnvl6ufhvvf4calsrrqdaqyshdsf5z 10u64
+
+# Swap in the private key of Bob.
+echo "
+NETWORK=testnet3
+PRIVATE_KEY=APrivateKey1zkpFo72g7N9iFt3JzzeG8CqsS5doAiXyFvNCgk2oHvjRCzF
+" > .env
+
+# Privately transfer 20 tokens from Bob to Alice.
+echo "
+###############################################################################
+######## ########
+######## STEP 4: Privately transfer 20 tokens from Bob to Alice ########
+######## ########
+######## ----------------------------------------- ########
+######## | PUBLIC BALANCES | ########
+######## ----------------------------------------- ########
+######## ----------------------------------------- ########
+######## | Alice | 90 | ########
+######## ----------------------------------------- ########
+######## | Bob | 10 | ########
+######## ----------------------------------------- ########
+######## ########
+######## ----------------------------------------- ########
+######## | PRIVATE BALANCES | ########
+######## ----------------------------------------- ########
+######## ----------------------------------------- ########
+######## | Alice | 20 | ########
+######## ----------------------------------------- ########
+######## | Bob | 80 | ########
+######## ----------------------------------------- ########
+######## ########
+###############################################################################
+"
+leo run transfer_private "{
+ owner: aleo17vy26rpdhqx4598y5gp7nvaa9rk7tnvl6ufhvvf4calsrrqdaqyshdsf5z.private,
+ amount: 100u64.private,
+ _nonce: 6586771265379155927089644749305420610382723873232320906747954786091923851913group.public
+ }" aleo13ssze66adjjkt795z9u5wpq8h6kn0y2657726h4h3e3wfnez4vqsm3008q 20u64
+
+# Swap in the private key of Alice.
+echo "
+NETWORK=testnet3
+PRIVATE_KEY=APrivateKey1zkp1w8PTxrRgGfAtfKUSq43iQyVbdQHfhGbiNPEg2LVSEXR
+" > .env
+
+# Convert 30 public tokens from Alice into 30 private tokens for Bob.
+echo "
+###############################################################################
+######## ########
+######## STEP 5: Convert 30 public tokens from Alice into 30 ########
+######## private tokens for Bob. ########
+######## ########
+######## ----------------------------------------- ########
+######## | PUBLIC BALANCES | ########
+######## ----------------------------------------- ########
+######## ----------------------------------------- ########
+######## | Alice | 60 | ########
+######## ----------------------------------------- ########
+######## | Bob | 10 | ########
+######## ----------------------------------------- ########
+######## ########
+######## ----------------------------------------- ########
+######## | PRIVATE BALANCES | ########
+######## ----------------------------------------- ########
+######## ----------------------------------------- ########
+######## | Alice | 20 | ########
+######## ----------------------------------------- ########
+######## | Bob | 110 | ########
+######## ----------------------------------------- ########
+######## ########
+###############################################################################
+"
+leo run transfer_public_to_private aleo17vy26rpdhqx4598y5gp7nvaa9rk7tnvl6ufhvvf4calsrrqdaqyshdsf5z 30u64
+
+# Swap in the private key of Bob.
+echo "
+NETWORK=testnet3
+PRIVATE_KEY=APrivateKey1zkpFo72g7N9iFt3JzzeG8CqsS5doAiXyFvNCgk2oHvjRCzF
+" > .env
+
+# Convert 40 private tokens from Bob into 40 public tokens for Alice.
+echo "
+###############################################################################
+######## ########
+######## STEP 6: Convert 40 private tokens from Bob into 40 ########
+######## public tokens for Alice. ########
+######## ########
+######## ----------------------------------------- ########
+######## | PUBLIC BALANCES | ########
+######## ----------------------------------------- ########
+######## ----------------------------------------- ########
+######## | Alice | 100 | ########
+######## ----------------------------------------- ########
+######## | Bob | 10 | ########
+######## ----------------------------------------- ########
+######## ########
+######## ----------------------------------------- ########
+######## | PRIVATE BALANCES | ########
+######## ----------------------------------------- ########
+######## ----------------------------------------- ########
+######## | Alice | 20 | ########
+######## ----------------------------------------- ########
+######## | Bob | 70 | ########
+######## ----------------------------------------- ########
+######## ########
+###############################################################################
+"
+leo run transfer_private_to_public "{
+ owner: aleo17vy26rpdhqx4598y5gp7nvaa9rk7tnvl6ufhvvf4calsrrqdaqyshdsf5z.private,
+ amount: 80u64.private,
+ _nonce: 1852830456042139988098466781381363679605019151318121788109768539956661608520group.public
+ }" aleo13ssze66adjjkt795z9u5wpq8h6kn0y2657726h4h3e3wfnez4vqsm3008q 40u64
+
+
+# Swap in the private key of Alice.
+# This is done to ensure that program.json is the same after every execution of ./run.sh.
+echo "
+NETWORK=testnet3
+PRIVATE_KEY=APrivateKey1zkp1w8PTxrRgGfAtfKUSq43iQyVbdQHfhGbiNPEg2LVSEXR
+" > .env
diff --git a/.circleci/token/src/main.leo b/.circleci/token/src/main.leo
new file mode 100644
index 0000000000..120c6648fd
--- /dev/null
+++ b/.circleci/token/src/main.leo
@@ -0,0 +1,128 @@
+program token.aleo {
+ // On-chain storage of an `account` map, with `address` as the key,
+ // and `u64` as the value.
+ mapping account: address => u64;
+
+ record token {
+ // The token owner.
+ owner: address,
+ // The token amount.
+ amount: u64,
+ }
+
+ /* Mint */
+
+ // The function `mint_public` issues the specified token amount for the token receiver publicly on the network.
+ transition mint_public(public receiver: address, public amount: u64) {
+ // Mint the tokens publicly by invoking the computation on-chain.
+ return then finalize(receiver, amount);
+ }
+
+ finalize mint_public(public receiver: address, public amount: u64) {
+ // Increments `account[receiver]` by `amount`.
+ // If `account[receiver]` does not exist, it will be created.
+ // If `account[receiver] + amount` overflows, `mint_public` is reverted.
+ let current_amount: u64 = Mapping::get_or_use(account, receiver, 0u64);
+ Mapping::set(account, receiver, current_amount + amount);
+ }
+
+ // The function `mint_private` initializes a new record with the specified amount of tokens for the receiver.
+ transition mint_private(receiver: address, amount: u64) -> token {
+ return token {
+ owner: receiver,
+ amount: amount,
+ };
+ }
+
+ /* Transfer */
+ transition transfer_public(public receiver: address, public amount: u64) {
+ // Transfer the tokens publicly, by invoking the computation on-chain.
+ return then finalize(self.caller, receiver, amount);
+ }
+
+ finalize transfer_public(public sender: address, public receiver: address, public amount: u64) {
+ // Decrements `account[sender]` by `amount`.
+ // If `account[sender]` does not exist, it will be created.
+ // If `account[sender] - amount` underflows, `transfer_public` is reverted.
+ let sender_amount: u64 = Mapping::get_or_use(account, sender, 0u64);
+ Mapping::set(account, sender, sender_amount - amount);
+ // Increments `account[receiver]` by `amount`.
+ // If `account[receiver]` does not exist, it will be created.
+ // If `account[receiver] + amount` overflows, `transfer_public` is reverted.
+ let receiver_amount: u64 = Mapping::get_or_use(account, receiver, 0u64);
+ Mapping::set(account, receiver, receiver_amount + amount);
+ }
+
+ // The function `transfer_private` sends the specified token amount to the token receiver from the specified token record.
+ transition transfer_private(sender: token, receiver: address, amount: u64) -> (token, token) {
+ // Checks the given token record has sufficient balance.
+ // This `sub` operation is safe, and the proof will fail if an overflow occurs.
+ // `difference` holds the change amount to be returned to sender.
+ let difference: u64 = sender.amount - amount;
+
+ // Produce a token record with the change amount for the sender.
+ let remaining: token = token {
+ owner: sender.owner,
+ amount: difference,
+ };
+
+ // Produce a token record for the specified receiver.
+ let transferred: token = token {
+ owner: receiver,
+ amount: amount,
+ };
+
+ // Output the sender's change record and the receiver's record.
+ return (remaining, transferred);
+ }
+
+ // The function `transfer_private_to_public` turns a specified token amount from a token record into public tokens for the specified receiver.
+ // This function preserves privacy for the sender's record, however it publicly reveals the token receiver and the token amount.
+ transition transfer_private_to_public(sender: token, public receiver: address, public amount: u64) -> token {
+ // Checks the given token record has a sufficient token amount.
+ // This `sub` operation is safe, and the proof will fail if an underflow occurs.
+ // `difference` holds the change amount for the caller.
+ let difference: u64 = sender.amount - amount;
+
+ // Produces a token record with the change amount for the caller.
+ let remaining: token = token {
+ owner: sender.owner,
+ amount: difference,
+ };
+
+ // Output the sender's change record.
+ // Increment the token amount publicly for the token receiver.
+ return remaining then finalize(receiver, amount);
+ }
+
+ finalize transfer_private_to_public(public receiver: address, public amount: u64) {
+ // Increments `account[receiver]` by `amount`.
+ // If `account[receiver]` does not exist, it will be created.
+ // If `account[receiver] + amount` overflows, `transfer_private_to_public` is reverted.
+ let current_amount: u64 = Mapping::get_or_use(account, receiver, 0u64);
+ Mapping::set(account, receiver, current_amount + amount);
+ }
+
+ // The function `transfer_public_to_private` turns a specified token amount from `account` into a token record for the specified receiver.
+ // This function preserves privacy for the receiver's record, however it publicly reveals the caller and the specified token amount.
+ transition transfer_public_to_private(public receiver: address, public amount: u64) -> token {
+ // Produces a token record for the token receiver.
+ let transferred: token = token {
+ owner: receiver,
+ amount: amount,
+ };
+
+ // Output the receiver's record.
+ // Decrement the token amount of the caller publicly.
+ return transferred then finalize(self.caller, amount);
+ }
+
+ finalize transfer_public_to_private(public sender: address, public amount: u64) {
+ // Decrements `account[sender]` by `amount`.
+ // If `account[sender]` does not exist, it will be created.
+ // If `account[sender] - amount` underflows, `transfer_public_to_private` is reverted.
+ let current_amount: u64 = Mapping::get_or_use(account, sender, 0u64);
+ Mapping::set(account, sender, current_amount - amount);
+ }
+
+}
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 7e51ef4fff..57f0e7760a 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -64,7 +64,7 @@ Leo is a big project, so (non-)adherence to best practices related to performanc
### Memory handling
- If the final size is known, pre-allocate the collections (`Vec`, `HashMap` etc.) using `with_capacity` or `reserve` - this ensures that there are both fewer allocations (which involve system calls) and that the final allocated capacity is as close to the required size as possible.
- Create the collections right before they are populated/used, as opposed to e.g. creating a few big ones at the beginning of a function and only using them later on; this reduces the amount of time they occupy memory.
-- If an intermediate vector is avoidable, use an `Iterator` instead; most of the time this just amounts to omitting the call to `.collect()` if a single-pass iteraton follows afterwards, or returning an `impl Iterator
- 
