Update code, tutorials, and code snippets to be compatible with async circuits

docs/zkapps/faq.mdx

@@ -56,7 +56,7 @@ Use the appropriate module to work with the live network or with historical arch
 
 ### Does o1js compile my JavaScript code to an arithmetic circuit?
 
-No, o1js **does NOT compile into anything else**. In contrast to other zk ecosystems, o1js is just a JS library. It creates zk circuits from user code by _executing_ that code. If you have a smart contract with a `@method myMethod()`, for example, o1js simply calls `myMethod();` during proof generation.
+No, o1js **does NOT compile into anything else**. In contrast to other zk ecosystems, o1js is just a JS library. It creates zk circuits from user code by _executing_ that code. If you have a smart contract with a `@method async myMethod()`, for example, o1js simply calls `myMethod();` during proof generation.
 
 This works because o1js sets up some global state - a "circuit" - where it collects variables and constraints. The use of functions like `Field.mul` or `Bool.assertEquals` inside your smart contract methods add corresponding variables and constraints to the global circuit.
 
@@ -83,7 +83,7 @@ The previous for-loop example just stitches together a fixed number of o1js comm
 
 ```ts
 // bad
-@method myMethod(x: Field, n: Field) {
+@method async myMethod(x: Field, n: Field) {
   let n0 = Number(n.toString()); // nope
   for (let y = 0; y < n0; y += 5) {
     x.equals(y).assertFalse();

docs/zkapps/getting-started-zkapps.mdx

@@ -85,7 +85,7 @@ Add the logic for your smart contract.
 
 1. Start experimenting with iterative development to build and test one method at a time. Add functionality to the smart contract by implementing a `@method`.
 
-    See `@method update()` in the [Add.ts](https://github.com/o1-labs/zkapp-cli/blob/main/templates/project-ts/src/Add.ts#L20-L24) example file.
+    See `@method async update()` in the [Add.ts](https://github.com/o1-labs/zkapp-cli/blob/main/templates/project-ts/src/Add.ts#L20-L24) example file.
 
 1. Build the smart contract:
 

docs/zkapps/how-to-write-a-zkapp-ui.mdx

@@ -259,9 +259,9 @@ To interact with your zkApp, users of your zkApp must have the Auro Wallet insta
     // This is the public key of the deployed zkapp you want to interact with.
     const zkAppAddress = 'B62qq8sm7JdsED6VuDKNWKLAi1Tvz1jrnffuud5gXMq3mgtd';
 
-    const tx = await Mina.transaction(() => {
+    const tx = await Mina.transaction(async () => {
       const YourSmartContractInstance = new YourSmartContract(zkAppAddress);
-      YourSmartContractInstance.foo();
+      await YourSmartContractInstance.foo();
     });
 
     await tx.prove();

docs/zkapps/o1js/custom-tokens.mdx

@@ -104,15 +104,15 @@ The usual implementation is as easy as this:
 
 
 ```ts
-@method approveBase(forest: AccountUpdateForest) {
+@method async approveBase(forest: AccountUpdateForest) {
   this.checkZeroBalanceChange(forest);
 }
 ```
 
 However, if you want to do a custom implementation for every child account update, you can utilize the `forEachUpdate()` method.
 
 ```ts
-@method
+@method async 
 approveBase(updates: AccountUpdateForest) {
   let totalBalanceChange = Int64.zero;
 

docs/zkapps/o1js/events.mdx

@@ -49,7 +49,7 @@ class MyContract extends SmartContract {
     "update-merkle-leaf": Field,
   }
 
-  @method updateMerkleTree(leaf: Field, ...) {
+  @method async updateMerkleTree(leaf: Field, ...) {
     this.emitEvent("update-merkle-leaf", leaf);
     // ...
   }

docs/zkapps/o1js/fetch-events-and-actions.mdx

@@ -78,7 +78,7 @@ Within your smart contract, you can use `getActions()` to retrieve actions emitt
 ```ts
 class MyContract extends SmartContract {
   ...
-  @method getActionsExample() {
+  @method async getActionsExample() {
     // Get all actions for this zkApp
     let pendingActions = this.reducer.getActions({
       fromActionHash: actionsHash,

docs/zkapps/o1js/foreign-fields.mdx

@@ -192,7 +192,7 @@ class AlmostField17 extends Field17.AlmostReduced {}
 class MyContract extends SmartContract {
   @state(AlmostField17.provable) x = State<AlmostField17>();
 
-  @method myMethod(y: AlmostField17) {
+  @method async myMethod(y: AlmostField17) {
     let x = y.mul(2);
     this.x.set(x.assertAlmostReduced());
   }

docs/zkapps/o1js/interact-with-mina.md

@@ -62,8 +62,8 @@ You create transactions in o1js by calling `Mina.transaction(...)`, which takes
 const sender = PublicKey.fromBase58('B62..'); // the user address
 const zkapp = new MyContract(address); // MyContract is a SmartContract
 
-const tx = await Mina.transaction(sender, () => {
-  zkapp.myMethod(someArgument);
+const tx = await Mina.transaction(sender, async () => {
+  await zkapp.myMethod(someArgument);
 });
 ```
 
@@ -135,8 +135,8 @@ await MyContract.compile(); // this might take a while
 
 // ...
 
-const tx = await Mina.transaction(sender, () => {
-  zkapp.myMethod(someArgument);
+const tx = await Mina.transaction(sender, async () => {
+  await zkapp.myMethod(someArgument);
 });
 await tx.prove(); // this might take a while
 ```
@@ -192,15 +192,15 @@ To send MINA, use `this.send()` from a smart contract method:
 
 ```ts
 class MyContract extends SmartContract {
-  @method payout(amount: UInt64) {
+  @method async payout(amount: UInt64) {
     // TODO: logic that determines whether the user is allowed to claim this amount
 
     this.send({ to: this.sender, amount });
   }
 }
 ```
 
-The `@method payout()` pays out a given amount of nanoMINA to the sender of the transaction, which you get with `this.sender`.
+The `@method async payout()` pays out a given amount of nanoMINA to the sender of the transaction, which you get with `this.sender`.
 
 In a real zkApp, you would add conditions to this method to determine who can call it with which amounts.
 
@@ -209,8 +209,8 @@ To call this method in a transaction and print the result:
 ```ts
 const MINA = 1e9;
 
-const tx = await Mina.transaction(sender, () => {
-  zkapp.payout(UInt64.from(5 * MINA));
+const tx = await Mina.transaction(sender, async () => {
+  await zkapp.payout(UInt64.from(5 * MINA));
 });
 await tx.prove();
 console.log(tx.toPretty());
@@ -295,7 +295,7 @@ Here's the smart contract code:
 
 ```ts
 class MyContract extends SmartContract {
-  @method deposit(amount: UInt64) {
+  @method async deposit(amount: UInt64) {
     let senderUpdate = AccountUpdate.create(this.sender);
     senderUpdate.requireSignature();
     senderUpdate.send({ to: this, amount });
@@ -376,8 +376,8 @@ For example:
 ```ts
 const sender = senderPrivateKey.toPublicKey(); // public key from sender's private key
 
-const tx = await Mina.transaction(sender, () => {
-  zkapp.deposit(UInt64.from(5 * MINA));
+const tx = await Mina.transaction(sender, async () => {
+  await zkapp.deposit(UInt64.from(5 * MINA));
 });
 await tx.prove();
 
@@ -439,7 +439,7 @@ const Network = Mina.Network('https://example.com/graphql');
 Mina.setActiveInstance(Network);
 
 // create the transaction, add proofs and signatures
-const tx = await Mina.transaction(sender, () => {
+const tx = await Mina.transaction(sender, async () => {
   // ...
 });
 await tx.prove();

docs/zkapps/o1js/merkle-tree.mdx

@@ -111,7 +111,7 @@ class Leaderboard extends SmartContract {
     );
   }
 
-  @method guessPreimage(guess: Field, account: Account, path: MerkleWitness) {
+  @method async guessPreimage(guess: Field, account: Account, path: MerkleWitness) {
     // we fetch z from the chain
     const z = this.z.get();
     this.z.requireEquals(z);
@@ -135,7 +135,7 @@ class Leaderboard extends SmartContract {
     this.root.set(newRoot);
   }
 
-  @method claimReward(account: Account, path: MerkleWitness) {
+  @method async claimReward(account: Account, path: MerkleWitness) {
     // we fetch the on-chain commitment
     const root = this.root.get();
     this.root.requireEquals(root);

docs/zkapps/o1js/on-chain-values.mdx

@@ -58,7 +58,7 @@ const endDate = UInt64.from(Date.UTC(2022, 10, 1));
 class VotingApp extends SmartContract {
   // ...
 
-  @method vote(...) {
+  @method async vote(...) {
     this.network.timestamp.requireBetween(startDate, endDate);
     // ...
   }

docs/zkapps/o1js/permissions.mdx

@@ -147,7 +147,7 @@ class UnsecureContract extends SmartContract {
     });
   }
 
-  @method withdraw(amount: UInt64) {
+  @method async withdraw(amount: UInt64) {
     this.send({ to: this.sender, amount });
   }
 }
@@ -160,9 +160,9 @@ But first, notice that the permissions specified in the `init()` method have set
 Take a look at the following malicious transaction that abuses this permission:
 
 ```ts
-tx = await Mina.transaction(account1Address, () => {
+tx = await Mina.transaction(account1Address, async () => {
   let withdrawal = AccountUpdate.create(zkappAddress);
-  withdrawal.send({ to: account1Address, amount: 1e9 });
+  await withdrawal.send({ to: account1Address, amount: 1e9 });
 });
 await tx.sign([account1Key]).send();
 ```
@@ -184,9 +184,9 @@ If you try to run the same transaction as before, the manual account update fail
 You can slightly modify the withdraw transaction to include a valid signature by adding `.requireSignature()` on the withdrawal account update and providing the private key of the smart contract account to `tx.send([zkappKey])`:
 
 ```ts
-tx = await Mina.transaction(account1Address, () => {
+tx = await Mina.transaction(account1Address, async () => {
   let withdrawal = AccountUpdate.create(zkappAddress);
-  withdrawal.send({ to: account1Address, amount: 1e9 });
+  await withdrawal.send({ to: account1Address, amount: 1e9 });
   withdrawal.requireSignature();
 });
 await tx.sign([account1Key, zkappKey]).send();
@@ -227,9 +227,9 @@ The contract already has an `@method` that you can use: `withdraw()`.
 To create a withdrawal transaction that contains a valid proof:
 
 ```ts
-tx = await Mina.transaction(account1Address, () => {
+tx = await Mina.transaction(account1Address, async () => {
   let zkapp = new UnsecureContract(zkappAddress);
-  zkapp.withdraw(UInt64.from(1e9));
+  await zkapp.withdraw(UInt64.from(1e9));
 });
 await tx.prove();
 await tx.sign([account1Key, zkappKey]).send();
@@ -269,7 +269,7 @@ class UpgradeabilityImpossible extends SmartContract {
     });
   }
 
-  @method updateVerificationKey(vk: VerificationKey) {
+  @method async updateVerificationKey(vk: VerificationKey) {
     this.account.verificationKey.set(vk);
   }
 }
@@ -280,8 +280,8 @@ But since `setVerificationKey` permission is specified to be `impossible`, invok
 
 ```ts
 console.log('try upgrading vk');
-tx = await Mina.transaction(feePayer, () => {
-  zkapp.updateVerificationKey(newVerificationKey);
+tx = await Mina.transaction(feePayer, async () => {
+  await zkapp.updateVerificationKey(newVerificationKey);
 });
 await tx.prove();
 await tx.sign([feePayerKey, zkappKey]).send();
@@ -303,7 +303,7 @@ Modify the method `updateVerificationKey` to do some checks before you can updat
 For now, just check that you can provide an `x` that is greater than or equal to 5. If this check succeeds, then update the verification key.
 
 ```ts
-@method updateVerificationKey(vk: VerificationKey, x: Field) {
+@method async updateVerificationKey(vk: VerificationKey, x: Field) {
   let y = Field(5);
   x.gte(y).assertTrue();
 
@@ -324,8 +324,8 @@ Now when you invoke the `updateVerificationKey` method, the transaction generate
 
 ```ts
 console.log('try upgrading vk');
-tx = await Mina.transaction(feePayer, () => {
-  zkapp.updateVerificationKey(newVerificationKey);
+tx = await Mina.transaction(feePayer, async () => {
+  await zkapp.updateVerificationKey(newVerificationKey);
 });
 await tx.prove();
 await tx.sign([feePayerKey, zkappKey]).send();

docs/zkapps/o1js/recursion.mdx

@@ -84,7 +84,7 @@ const proof = await SimpleProgram.run(Field(0));
 To verify this proof from within any method of your `SmartContract` class:
 
 ```typescript
-@method foo(proof: SimpleProgram.Proof) {
+@method async foo(proof: SimpleProgram.Proof) {
   proof.verify().assertTrue();
   const output: Field = proof.value;
   // ...the rest of our method.
@@ -154,7 +154,7 @@ const proof2 = await AddOne.step(Field(2), proof1);
 Finally, verify the proof from within a SmartContract like the earlier example:
 
 ```typescript
-@method foo(proof: Proof) {
+@method async foo(proof: Proof) {
   proof.verify().assertTrue();
   /* ... the rest of our method
    * For example using the total value as the fee for some other transaction. */

docs/zkapps/o1js/smart-contracts.mdx

@@ -60,7 +60,7 @@ Interaction with a smart contract happens by calling one or more of its _methods
 
 ```ts
 class HelloWorld extends SmartContract {
-  @method myMethod(x: Field) {
+  @method async myMethod(x: Field) {
     x.mul(2).assertEquals(5);
   }
 }
@@ -124,7 +124,7 @@ A method can modify on-chain state by using `this.<state>.set()`:
 class HelloWorld extends SmartContract {
   @state(Field) x = State<Field>();
 
-  @method setX(x: Field) {
+  @method async setX(x: Field) {
     this.x.set(x);
   }
 }
@@ -140,7 +140,7 @@ This example _reads_ state:
 class HelloWorld extends SmartContract {
   @state(Field) x = State<Field>();
 
-  @method increment() {
+  @method async increment() {
     // read state
     const x = this.x.get();
     this.x.requireEquals(x);
@@ -204,7 +204,7 @@ To modify the `increment()` method to accept a parameter:
 class HelloWorld extends SmartContract {
   @state(Field) x = State<Field>();
 
-  @method increment(xPlus1: Field) {
+  @method async increment(xPlus1: Field) {
     const x = this.x.get();
     this.x.requireEquals(x);
 
@@ -250,7 +250,7 @@ class HelloWorld extends SmartContract {
 
   // ...
 
-  @method incrementSecret(secret: Field) {
+  @method async incrementSecret(secret: Field) {
     const x = this.x.get();
     this.x.requireEquals(x);
 
@@ -299,14 +299,14 @@ A powerful feature of zkApps is that they are composable, just like Ethereum sma
 
 ```ts
 class HelloWorld extends SmartContract {
-  @method myMethod(otherAddress: PublicKey) {
+  @method async myMethod(otherAddress: PublicKey) {
     const calledContract = new OtherContract(otherAddress);
     calledContract.otherMethod();
   }
 }
 
 class OtherContract extends SmartContract {
-  @method otherMethod() {}
+  @method async otherMethod() {}
 }
 ```
 
@@ -327,7 +327,7 @@ To ensure other methods can use a return value of your `@method`, you must annot
 Here's an example of returning a `Bool` called `isSuccess`:
 
 ```ts
-@method otherMethod(): Bool { // annotated return type
+@method async otherMethod(): Bool { // annotated return type
   // ...
   return isSuccess;
 }
@@ -363,11 +363,11 @@ For example, the following smart contract uses the `Point` struct defined earlie
 export class Grid extends SmartContract {
   @state(Point) p = State<Point>();
 
-  @method init() {
+  @method async init() {
     this.p.set(new Point({ x: Field(1), y: Field(2) }));
   }
 
-  @method move(newPoint: Point) {
+  @method async move(newPoint: Point) {
     const point = this.p.get();
     this.p.requireEquals(point);