feat: add nonces

yarn-project/acir-simulator/src/client/private_execution.ts

@@ -161,15 +161,16 @@ export class PrivateFunctionExecution {
         return Promise.resolve(ZERO_ACVM_FIELD);
       },
       enqueuePublicFunctionCall: async ([acvmContractAddress], [acvmFunctionSelector], [acvmArgsHash]) => {
+        const selector = frToAztecAddress(fromACVMField(acvmContractAddress));
         const enqueuedRequest = await this.enqueuePublicFunctionCall(
-          frToAztecAddress(fromACVMField(acvmContractAddress)),
+          selector,
           FunctionSelector.fromField(fromACVMField(acvmFunctionSelector)),
           this.context.packedArgsCache.unpack(fromACVMField(acvmArgsHash)),
           this.callContext,
         );
 
         this.log(
-          `Enqueued call to public function (with side-effect counter #${enqueuedRequest.sideEffectCounter}) ${acvmContractAddress}:${acvmFunctionSelector}`,
+          `Enqueued call to public function (with side-effect counter #${enqueuedRequest.sideEffectCounter}) ${acvmContractAddress}:${selector}`,
         );
         enqueuedPublicFunctionCalls.push(enqueuedRequest);
         return toAcvmEnqueuePublicFunctionResult(enqueuedRequest);

yarn-project/acir-simulator/src/public/executor.ts

@@ -126,10 +126,11 @@ export class PublicExecutor {
       },
       callPublicFunction: async ([address], [functionSelector], [argsHash]) => {
         const args = packedArgs.unpack(fromACVMField(argsHash));
-        this.log(`Public function call: addr=${address} selector=${functionSelector} args=${args.join(',')}`);
+        const selector = FunctionSelector.fromField(fromACVMField(functionSelector));
+        this.log(`Public function call: addr=${address} selector=${selector} args=${args.join(',')}`);
         const childExecutionResult = await this.callPublicFunction(
           frToAztecAddress(fromACVMField(address)),
-          FunctionSelector.fromField(fromACVMField(functionSelector)),
+          selector,
           args,
           execution.callContext,
           globalVariables,

yarn-project/noir-contracts/src/contracts/token_contract/src/main.nr

@@ -7,6 +7,7 @@ mod util;
 // The designated caller is ALWAYS used here, and not based on a flag as cross-chain.
 // message hash = H([caller, selector, , ...args])
 // To be read as `caller` calls function defined by `selector` with `args`
+// Including a nonce in the message hash ensures that the message can only be used once.
 
 contract Token {
     // Libs
@@ -35,9 +36,7 @@ contract Token {
 
     use crate::types::{AztecAddress, TransparentNote, TransparentNoteMethods, TRANSPARENT_NOTE_LEN};
     use crate::account_interface::AccountContract;
-    use crate::util::compute_message_hash;
-
-
+    use crate::util::{compute_message_hash};
 
     struct Storage {
         admin: PublicState<Field, FIELD_SERIALISED_LEN>,
@@ -169,13 +168,18 @@ contract Token {
         from: AztecAddress,
         amount: Field,
         secret_hash: Field,
+        nonce: Field,
     ) -> Field {
         let storage = Storage::init(Option::none(), Option::some(&mut context));
 
         if (from.address != context.msg_sender()) {
-            let selector = compute_selector("shield((Field),Field,Field)");
-            let message_field = compute_message_hash([context.msg_sender(), selector, from.address, amount, secret_hash]);
+            // The redeem is only spendable once, so we need to ensure that you cannot insert multiple shields from the same message.
+            let selector = compute_selector("shield((Field),Field,Field,Field)");
+            let message_field = compute_message_hash([context.msg_sender(), selector, from.address, amount, secret_hash, nonce]);
             assert(AccountContract::at(from.address).is_valid(Option::none(), Option::some(context), message_field) == 0xe86ab4ff, "invalid call");
+            context.push_new_nullifier(message_field, 0);
+        } else {
+            assert(nonce == 0, "invalid nonce");
         }
 
         let amount = SafeU120::new(amount);
@@ -194,13 +198,17 @@ contract Token {
         from: AztecAddress,
         to: AztecAddress,
         amount: Field,
+        nonce: Field,
     ) -> Field {
         let storage = Storage::init(Option::none(), Option::some(&mut context));
 
         if (from.address != context.msg_sender()) {
-            let selector = compute_selector("transfer_public((Field),(Field),Field)");
-            let message_field = compute_message_hash([context.msg_sender(), selector, from.address, to.address, amount]);
+            let selector = compute_selector("transfer_public((Field),(Field),Field,Field)");
+            let message_field = compute_message_hash([context.msg_sender(), selector, from.address, to.address, amount, nonce]);
             assert(AccountContract::at(from.address).is_valid(Option::none(), Option::some(context), message_field) == 0xe86ab4ff, "invalid call");
+            context.push_new_nullifier(message_field, 0);
+        } else {
+            assert(nonce == 0, "invalid nonce");
         }
 
         let amount = SafeU120::new(amount);
@@ -232,13 +240,17 @@ contract Token {
         from: AztecAddress,
         to: AztecAddress,
         amount: Field,
+        nonce: Field,
     ) -> Field {
         let storage = Storage::init(Option::some(&mut context), Option::none());
 
         if (from.address != context.msg_sender()) {
-            let selector = compute_selector("unshield((Field),(Field),Field)");
-            let message_field = compute_message_hash([context.msg_sender(), selector, from.address, to.address, amount]);
+            let selector = compute_selector("unshield((Field),(Field),Field,Field)");
+            let message_field = compute_message_hash([context.msg_sender(), selector, from.address, to.address, amount, nonce]);
             assert(AccountContract::at(from.address).is_valid(Option::some(&mut context), Option::none(), message_field) == 0xe86ab4ff, "invalid call");
+            context.push_new_nullifier(message_field, 0);
+        } else {
+            assert(nonce == 0, "invalid nonce");
         }
 
         let from_balance = storage.balances.at(from.address);
@@ -253,13 +265,17 @@ contract Token {
         from: AztecAddress,
         to: AztecAddress,
         amount: Field,
+        nonce: Field,
     ) -> Field {
         let storage = Storage::init(Option::some(&mut context), Option::none());
 
         if (from.address != context.msg_sender()) {
-            let selector = compute_selector("transfer((Field),(Field),Field)");
-            let message_field = compute_message_hash([context.msg_sender(), selector, from.address, to.address, amount]);
+            let selector = compute_selector("transfer((Field),(Field),Field,Field)");
+            let message_field = compute_message_hash([context.msg_sender(), selector, from.address, to.address, amount, nonce]);
             assert(AccountContract::at(from.address).is_valid(Option::some(&mut context), Option::none(), message_field) == 0xe86ab4ff, "invalid call");
+            context.push_new_nullifier(message_field, 0);
+        } else {
+            assert(nonce == 0, "invalid nonce");
         }
 
         let from_balance = storage.balances.at(from.address);

yarn-project/sequencer-client/src/sequencer/sequencer.ts

@@ -282,8 +282,16 @@ export class Sequencer {
     const allTxs = [...txs, ...times(emptyTxCount, () => emptyTx)];
     this.log(`Building block ${globalVariables.blockNumber}`);
 
-    const [block] = await this.blockBuilder.buildL2Block(globalVariables, allTxs, newL1ToL2Messages);
-    return block;
+    // If the block is invalid, drop the transactions
+    try {
+      const [block] = await this.blockBuilder.buildL2Block(globalVariables, allTxs, newL1ToL2Messages);
+      return block;
+    } catch (err) {
+      const hashes = txs.map(tx => tx.hash);
+      this.log.error(`Dropping failed txs ${hashes.join(', ')}`);
+      await this.p2pClient.deleteTxs(hashes);
+      throw err;
+    }
   }
 
   /**