Westlad/fix restart nightfall

cli/lib/nf3.mjs

@@ -570,6 +570,25 @@ class Nf3 {
     );
   }
 
+  /**
+  Registers a proposer locally with the Optimist instance only.  This will cause
+  Optimist to make blocks when this proposer is current but these will revert if
+  the proposer isn't registered on the blockchain too.  This method is useful only
+  if the proposer is already registered on the blockchain (has paid their bond) and
+  for some reason the Optimist instance does not know about them, e.g. a new instance
+  has been created. The method 'registerProposer' will both register the proposer
+  with the blockchain and register locally with the optimist instance. So, if
+  that method has been used successfully, there is no need to also call this method
+  @method
+  @async
+  @returns {Promise} A promise that resolves to the Ethereum transaction receipt.
+  */
+  async registerProposerLocally() {
+    return axios.post(`${this.optimistBaseUrl}/proposer/registerlocally`, {
+      address: this.ethereumAddress,
+    });
+  }
+
   /**
   De-registers an existing proposer.
   It will use the address of the Ethereum Signing key that is holds to de-register

common-files/utils/contract.mjs

@@ -104,7 +104,6 @@ export async function waitForContract(contractName) {
     try {
       error = undefined;
       const address = await getContractAddress(contractName); // eslint-disable-line no-await-in-loop
-      logger.debug(`${contractName} contract address is ${address}`);
       if (address === undefined) throw new Error(`${contractName} contract address was undefined`);
       instance = getContractInstance(contractName, address);
       return instance;

config/default.js

@@ -3,7 +3,8 @@ const { DOMAIN_NAME = '' } = process.env;
 module.exports = {
   COMMITMENTS_DB: 'nightfall_commitments',
   OPTIMIST_DB: 'optimist_data',
-  METADATA_COLLECTION: 'metadata',
+  PROPOSER_COLLECTION: 'proposers',
+  CHALLENGER_COLLECTION: 'challengers',
   TRANSACTIONS_COLLECTION: 'transactions',
   SUBMITTED_BLOCKS_COLLECTION: 'blocks',
   NULLIFIER_COLLECTION: 'nullifiers',

nightfall-client/src/event-handlers/subscribe.mjs

@@ -15,15 +15,14 @@ const { STATE_CONTRACT_NAME, RETRIES } = config;
  * This is useful in case nightfall-client comes up before the contract
  * is fully deployed.
  */
-async function waitForContract(contractName) {
+export async function waitForContract(contractName) {
   let errorCount = 0;
   let error;
   let instance;
   while (errorCount < RETRIES) {
     try {
       error = undefined;
       const address = await getContractAddress(contractName);
-      logger.debug(`${contractName} contract address is ${address}`);
       if (address === undefined) throw new Error(`${contractName} contract address was undefined`);
       instance = getContractInstance(contractName, address);
       return instance;

nightfall-client/src/services/database.mjs

@@ -109,7 +109,8 @@ export async function saveBlock(_block) {
   if (!existing || !existing.blockNumber) {
     return db.collection(SUBMITTED_BLOCKS_COLLECTION).updateOne(query, update, { upsert: true });
   }
-  throw new Error('Attempted to replay existing layer 2 block');
+  logger.warn('Attempted to replay existing layer 2 block.  This is expected if we are syncing');
+  return true;
 }
 
 /**

nightfall-client/src/services/state-sync.mjs

@@ -5,21 +5,20 @@ their local commitments databsae.
 
 import config from 'config';
 import logger from 'common-files/utils/logger.mjs';
-import { getContractInstance } from 'common-files/utils/contract.mjs';
 import mongo from 'common-files/utils/mongo.mjs';
+import { waitForContract } from '../event-handlers/subscribe.mjs';
 import blockProposedEventHandler from '../event-handlers/block-proposed.mjs';
 import rollbackEventHandler from '../event-handlers/rollback.mjs';
 
 const { MONGO_URL, COMMITMENTS_DB, COMMITMENTS_COLLECTION, STATE_CONTRACT_NAME } = config;
 
 const syncState = async (fromBlock = 'earliest', toBlock = 'latest', eventFilter = 'allEvents') => {
-  const stateContractInstance = await getContractInstance(STATE_CONTRACT_NAME); // Rollback, BlockProposed
+  const stateContractInstance = await waitForContract(STATE_CONTRACT_NAME); // Rollback, BlockProposed
 
   const pastStateEvents = await stateContractInstance.getPastEvents(eventFilter, {
     fromBlock,
     toBlock,
   });
-  logger.info(`pastStateEvents: ${JSON.stringify(pastStateEvents)}`);
 
   for (let i = 0; i < pastStateEvents.length; i++) {
     switch (pastStateEvents[i].event) {
@@ -46,8 +45,6 @@ const genGetCommitments = async (query = {}, proj = {}) => {
 // eslint-disable-next-line import/prefer-default-export
 export const initialClientSync = async () => {
   const allCommitments = await genGetCommitments();
-  if (allCommitments.length === 0) return {};
-
   const commitmentBlockNumbers = allCommitments.map(a => a.blockNumber).filter(n => n >= 0);
   logger.info(`commitmentBlockNumbers: ${commitmentBlockNumbers}`);
   const firstSeenBlockNumber = Math.min(...commitmentBlockNumbers);

nightfall-deployer/src/index.mjs

@@ -1,12 +1,21 @@
 import Web3 from 'common-files/utils/web3.mjs';
+import logger from 'common-files/utils/logger.mjs';
 import circuits from './circuit-setup.mjs';
 import setupContracts from './contract-setup.mjs';
 
 // TODO these can be paralleled
 async function main() {
   await circuits.waitForZokrates();
   await circuits.setupCircuits();
-  await setupContracts();
+  try {
+    await setupContracts();
+  } catch (err) {
+    if (err.message.includes('Transaction has been reverted by the EVM'))
+      logger.warn(
+        'Writing contract addresses to the State contract failed. This is probably because they are aready set. Did you already run deployer?',
+      );
+    else throw new Error(err);
+  }
   Web3.disconnect();
 }
 

nightfall-optimist/src/event-handlers/subscribe.mjs

@@ -32,7 +32,6 @@ export async function waitForContract(contractName) {
     try {
       error = undefined;
       const address = await getContractAddress(contractName);
-      logger.debug(`${contractName} contract address is ${address}`);
       if (address === undefined) throw new Error(`${contractName} contract address was undefined`);
       instance = getContractInstance(contractName, address);
       return instance;

nightfall-optimist/src/index.mjs

@@ -16,10 +16,12 @@ import {
 import { setChallengeWebSocketConnection } from './services/challenges.mjs';
 import initialBlockSync from './services/state-sync.mjs';
 import { setInstantWithdrawalWebSocketConnection } from './services/instant-withdrawal.mjs';
+import { setProposer } from './routes/proposer.mjs';
 
 const main = async () => {
   try {
     const proposer = new Proposer();
+    setProposer(proposer); // passes the proposer instance int the proposer routes
     // subscribe to WebSocket events first
     await subscribeToBlockAssembledWebSocketConnection(setBlockAssembledWebSocketConnection);
     await subscribeToChallengeWebSocketConnection(setChallengeWebSocketConnection);

nightfall-optimist/src/routes/proposer.mjs

@@ -8,6 +8,7 @@ import config from 'config';
 import Timber from 'common-files/classes/timber.mjs';
 import logger from 'common-files/utils/logger.mjs';
 import { getContractInstance } from 'common-files/utils/contract.mjs';
+import { enqueueEvent } from 'common-files/utils/event-queue.mjs';
 import Block from '../classes/block.mjs';
 import { Transaction, TransactionError } from '../classes/index.mjs';
 import {
@@ -21,6 +22,11 @@ import transactionSubmittedEventHandler from '../event-handlers/transaction-subm
 const router = express.Router();
 const { STATE_CONTRACT_NAME, PROPOSERS_CONTRACT_NAME, SHIELD_CONTRACT_NAME, ZERO } = config;
 
+let proposer;
+export function setProposer(p) {
+  proposer = p;
+}
+
 /**
  * Function to return a raw transaction that registers a proposer.  This just
  * provides the tx data, the user will need to append the registration bond
@@ -34,12 +40,52 @@ router.post('/register', async (req, res, next) => {
     const proposersContractInstance = await getContractInstance(PROPOSERS_CONTRACT_NAME);
     const txDataToSign = await proposersContractInstance.methods.registerProposer().encodeABI();
     logger.debug('returning raw transaction data');
-    logger.silly(`raw transaction is ${JSON.stringify(txDataToSign, null, 2)}`);
     res.json({ txDataToSign });
-    setRegisteredProposerAddress(address); // save the registration address
+    await setRegisteredProposerAddress(address); // save the registration address
   } catch (err) {
-    logger.error(err);
-    next(err);
+    if (err.message.includes('E11000 duplicate key error'))
+      // if we get a duplicate key error then the EVM will have reverted so we don't need to handle this separately
+      logger.warn(
+        'Duplicate key detected. You are probably trying to to register the proposer twice. Second attempt ignored',
+      );
+    else {
+      logger.error(err);
+      next(err);
+    }
+  }
+});
+
+/**
+ * Function to locally register a proposer with optimist. This call is similar to
+ * /register but it won't touch the blockchain. It will just cause optimist to make
+ * blocks when this proposer is the current proposer.  It's useful if you are starting
+ * a new optimist instance but your proposer address is already registed with the blockchain
+ * It's idempotent:  attempting to re-register a proposer will have no effect.
+ */
+router.post('/registerlocally', async (req, res, next) => {
+  logger.debug(
+    `local register proposer endpoint received POST ${JSON.stringify(req.body, null, 2)}`,
+  );
+  const { address } = req.body;
+  try {
+    await setRegisteredProposerAddress(address); // save the registration address
+    // we should also check if we're the current proposer because we're registered on
+    // the blockchain so we could be
+    const stateContractInstance = await getContractInstance(STATE_CONTRACT_NAME);
+    const currentProposer = await stateContractInstance.methods.getCurrentProposer().call();
+    if (address === currentProposer.thisAddress) {
+      proposer.isMe = true;
+      await enqueueEvent(() => logger.info('Start Queue'), 0); // kickstart the queue
+    }
+    res.sendStatus(200);
+  } catch (err) {
+    if (err.message.includes('duplicate key')) {
+      logger.warn(`Proposer ${address} is already registered locally`);
+      res.sendStatus(200);
+    } else {
+      logger.error(err);
+      next(err);
+    }
   }
 });
 
@@ -58,9 +104,9 @@ router.get('/proposers', async (req, res, next) => {
     // Loop through the circular list until we run back into the currentProposer.
     do {
       // eslint-disable-next-line no-await-in-loop
-      const proposer = await proposersContractInstance.methods.proposers(thisPtr).call();
-      proposers.push(proposer);
-      thisPtr = proposer.nextAddress;
+      const prop = await proposersContractInstance.methods.proposers(thisPtr).call();
+      proposers.push(prop);
+      thisPtr = prop.nextAddress;
     } while (thisPtr !== currentProposer.thisAddress);
 
     logger.debug('returning raw transaction data');
@@ -157,12 +203,12 @@ router.post('/propose', async (req, res, next) => {
   logger.debug(`propose endpoint received POST`);
   logger.silly(`With content ${JSON.stringify(req.body, null, 2)}`);
   try {
-    const { transactions, proposer, currentLeafCount } = req.body;
+    const { transactions, proposer: prop, currentLeafCount } = req.body;
     // use the information we've been POSTED to assemble a block
     // we use a Builder pattern because an async constructor is bad form
     const block = await Block.build({
       transactions,
-      proposer,
+      proposer: prop,
       currentLeafCount,
     });
     logger.debug(`New block assembled ${JSON.stringify(block, null, 2)}`);

nightfall-optimist/src/services/database.mjs

@@ -12,7 +12,8 @@ const {
   MONGO_URL,
   OPTIMIST_DB,
   TRANSACTIONS_COLLECTION,
-  METADATA_COLLECTION,
+  PROPOSER_COLLECTION,
+  CHALLENGER_COLLECTION,
   SUBMITTED_BLOCKS_COLLECTION,
   NULLIFIER_COLLECTION,
   COMMIT_COLLECTION,
@@ -54,7 +55,7 @@ export async function addChallengerAddress(address) {
   const db = connection.db(OPTIMIST_DB);
   logger.debug(`Saving challenger address ${address}`);
   const data = { challenger: address };
-  return db.collection(METADATA_COLLECTION).insertOne(data);
+  return db.collection(CHALLENGER_COLLECTION).insertOne(data);
 }
 
 /**
@@ -67,7 +68,7 @@ export async function removeChallengerAddress(address) {
   const db = connection.db(OPTIMIST_DB);
   logger.debug(`Removing challenger address ${address}`);
   const data = { challenger: address };
-  return db.collection(METADATA_COLLECTION).deleteOne(data);
+  return db.collection(CHALLENGER_COLLECTION).deleteOne(data);
 }
 
 /**
@@ -76,7 +77,7 @@ Function to tell us if an address used to commit to a challenge belongs to us
 export async function isChallengerAddressMine(address) {
   const connection = await mongo.connection(MONGO_URL);
   const db = connection.db(OPTIMIST_DB);
-  const metadata = await db.collection(METADATA_COLLECTION).findOne({ challenger: address });
+  const metadata = await db.collection(CHALLENGER_COLLECTION).findOne({ challenger: address });
   return metadata !== null;
 }
 
@@ -218,8 +219,8 @@ export async function setRegisteredProposerAddress(address) {
   const connection = await mongo.connection(MONGO_URL);
   const db = connection.db(OPTIMIST_DB);
   logger.debug(`Saving proposer address ${address}`);
-  const data = { proposer: address };
-  return db.collection(METADATA_COLLECTION).insertOne(data);
+  const data = { _id: address };
+  return db.collection(PROPOSER_COLLECTION).insertOne(data);
 }
 
 /**
@@ -229,7 +230,7 @@ thus it should start assembling blocks of transactions.
 export async function isRegisteredProposerAddressMine(address) {
   const connection = await mongo.connection(MONGO_URL);
   const db = connection.db(OPTIMIST_DB);
-  const metadata = await db.collection(METADATA_COLLECTION).findOne({ proposer: address });
+  const metadata = await db.collection(PROPOSER_COLLECTION).findOne({ _id: address });
   logger.silly(`found registered proposer ${JSON.stringify(metadata, null, 2)}`);
   return metadata;
 }

test/e2e/protocol/challenger.test.mjs

@@ -21,7 +21,7 @@ describe('Basic Challenger tests', () => {
     await nf3Challenger.init(mnemonics.challenger);
     // Challenger registration
     await nf3Challenger.registerChallenger();
-    // Chalenger listening for incoming events
+    // Challenger listening for incoming events
     nf3Challenger.startChallenger();
   });