Update Client Service to enable Regulator for transfers

common-files/constants/constants.json

@@ -7,6 +7,7 @@
   "DEPOSIT": "deposit",
   "DEPOSIT_FEE": "depositfee",
   "TRANSFER": "transfer",
+  "TRANSFER_REGULATOR": "transfer_regulator",
   "WITHDRAW": "withdraw",
   "TOKENISE": "tokenise",
   "BURN": "burn",

config/default.js

@@ -117,6 +117,8 @@ module.exports = {
     `ws://${process.env.BLOCKCHAIN_WS_HOST}:${process.env.BLOCKCHAIN_PORT}${
       process.env.BLOCKCHAIN_PATH || ''
     }`,
+  REGULATOR_URL: process.env.REGULATOR_URL,
+  NONCE_ENCRYPTION_BITS: process.env.NONCE_ENCRYPTION_BITS || 48,
   ETH_PRIVATE_KEY: process.env.ETH_PRIVATE_KEY, // owner's/deployer's private key
   ETH_ADDRESS: process.env.ETH_ADDRESS,
   WEB3_OPTIONS: {
@@ -165,6 +167,12 @@ module.exports = {
       isEscrowRequired: false,
       isWithdrawing: false,
     },
+    transfer_regulator: {
+      numberNullifiers: 4,
+      numberCommitments: 3,
+      isEscrowRequired: false,
+      isWithdrawing: false,
+    },
     withdraw: {
       numberNullifiers: 4,
       numberCommitments: 2,

docker/docker-compose.deployment.yml

@@ -52,6 +52,7 @@ services:
       OPTIMIST_PORT: ${OPTIMIST_PORT:-80}
       RABBITMQ_HOST: ${RABBITMQ_HOST:-amqp://rabbitmq}
       RABBITMQ_PORT: ${RABBITMQ_PORT:-5672}
+      REGULATOR_URL: ${REGULATOR_URL}
       STATE_GENESIS_BLOCK: ${STATE_GENESIS_BLOCK:-0}
       USE_EXTERNAL_NODE: ${USE_EXTERNAL_NODE}
     command: ['npm', 'run', 'start']
@@ -91,7 +92,7 @@ services:
       UPGRADE: ${UPGRADE_CONTRACTS}
       USDC_RESTRICT: ${USDC_RESTRICT}
       WHITELISTING: ${WHITELISTING?WHITELISTING-not-set}
-      
+
   mongodb:
     image: mongo:4.4.1-bionic
     hostname: mongodb

docker/docker-compose.yml

@@ -38,7 +38,7 @@ services:
       - mongodb
     environment:
       AUTOSTART_RETRIES: ${AUTOSTART_RETRIES:-600}
-      BLOCKCHAIN_URL: ${BLOCKCHAIN_URL} 
+      BLOCKCHAIN_URL: ${BLOCKCHAIN_URL}
       BLOCKCHAIN_WS_HOST: ${BLOCKCHAIN_WS_HOST:-blockchain}
       BLOCKCHAIN_PORT: ${BLOCKCHAIN_PORT:-8546}
       CIRCOM_WORKER_HOST: ${CIRCOM_WORKER_HOST:-worker}
@@ -56,6 +56,7 @@ services:
       RABBITMQ_PORT: ${RABBITMQ_PORT:-5672}
       OPTIMIST_HOST: ${OPTIMIST_HOST:-optimist}
       OPTIMIST_PORT: ${OPTIMIST_PORT:-80}
+      REGULATOR_URL: ${REGULATOR_URL}
       STATE_GENESIS_BLOCK: ${STATE_GENESIS_BLOCK:-0}
       USE_EXTERNAL_NODE: ${USE_EXTERNAL_NODE}
     command: ['npm', 'run', 'dev']
@@ -99,7 +100,7 @@ services:
       USDC_RESTRICT: ${USDC_RESTRICT}
       UPGRADE: ${UPGRADE_CONTRACTS}
       WHITELISTING: ${WHITELISTING}
-      WETH_RESTRICT: ${WETH_RESTRICT} 
+      WETH_RESTRICT: ${WETH_RESTRICT}
 
   hosted-utils-api-server:
     build:

nightfall-client/src/routes/transfer.mjs

@@ -1,14 +1,24 @@
 /**
 Route for transferring a crypto commitment.
 */
+import config from 'config';
 import express from 'express';
 import transfer from '../services/transfer.mjs';
+import transferRegulator from '../services/transfer-regulator.mjs';
 
+const { REGULATOR_URL } = config;
 const router = express.Router();
 
 router.post('/', async (req, res, next) => {
   try {
-    const { rawTransaction: txDataToSign, transaction } = await transfer(req.body);
+    let txDataToSign;
+    let transaction;
+
+    if (!REGULATOR_URL) {
+      ({ rawTransaction: txDataToSign, transaction } = await transfer(req.body));
+    } else {
+      ({ rawTransaction: txDataToSign, transaction } = await transferRegulator(req.body));
+    }
     res.json({ txDataToSign, transaction });
   } catch (err) {
     res.json({ error: err.message });

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

@@ -3,7 +3,7 @@
 commitmentsync services to decrypt commitments from transaction blockproposed events
 or use clientCommitmentSync to decrypt when new zkpPrivateKey is received.
 */
-
+import config from 'config';
 import logger from '@polygon-nightfall/common-files/utils/logger.mjs';
 import { generalise } from 'general-number';
 import { edwardsDecompress } from '@polygon-nightfall/common-files/utils/curve-maths/curves.mjs';
@@ -15,7 +15,7 @@ import { ZkpKeys } from './keys.mjs';
 import Commitment from '../classes/commitment.mjs';
 
 const { ZERO } = constants;
-
+const { REGULATOR_URL } = config;
 /**
 decrypt commitments for a transaction given zkpPrivateKeys and nullifierKeys.
 */
@@ -30,11 +30,23 @@ export async function decryptCommitment(transaction, zkpPrivateKey, nullifierKey
         transaction.recipientAddress, // It contains the tokenID encrypted (which is a field)
         ...transaction.compressedSecrets,
       ];
-      const [packedErc, unpackedTokenID, ...rest] = decrypt(
-        generalise(key),
-        generalise(edwardsDecompress(transaction.tokenId)), // Compressed public key is stored in token ID
-        generalise(cipherTexts),
-      );
+      let packedErc;
+      let unpackedTokenID;
+      let rest;
+      if (!REGULATOR_URL) {
+        [packedErc, unpackedTokenID, ...rest] = decrypt(
+          generalise(key),
+          generalise(edwardsDecompress(transaction.tokenId)), // Compressed public key is stored in token ID
+          generalise(cipherTexts),
+        );
+      } else {
+        [packedErc, unpackedTokenID, ...rest] = decrypt(
+          generalise(key),
+          generalise(edwardsDecompress(transaction.tokenId)), // Compressed public key is stored in token ID
+          generalise(cipherTexts),
+          BigInt(transaction.value),
+        );
+      }
       const [erc, tokenId] = packSecrets(generalise(packedErc), generalise(unpackedTokenID), 2, 0);
       const plainTexts = generalise([erc, tokenId, ...rest]);
       const commitment = new Commitment({

nightfall-client/src/services/kem-dem.mjs

@@ -1,6 +1,6 @@
 import { scalarMult } from '@polygon-nightfall/common-files/utils/curve-maths/curves.mjs';
 import { randValueLT } from '@polygon-nightfall/common-files/utils/crypto/crypto-random.mjs';
-import { generalise, stitchLimbs } from 'general-number';
+import { generalise, stitchLimbs, GN } from 'general-number';
 import poseidon from '@polygon-nightfall/common-files/utils/crypto/poseidon/poseidon.mjs';
 import constants from '@polygon-nightfall/common-files/constants/index.mjs';
 
@@ -105,19 +105,50 @@ const deDem = (encryptionKey, ciphertexts) => {
   return plainTexts;
 };
 
+/**
+This function generates the transfer key pair for the observers (receiver and regulator)
+@function genTransferKeysForObservers
+@param {GeneralNumber} senderPrivateKey - The private key of the sender
+@param {Array<GeneralNumber>} receiverPublicKey - The public pkd of the recipient
+@returns {Promise<Array<GeneralNumber, Array<BigInt>>>} The private and public key pair
+*/
+const genTransferKeysForObservers = async (senderPrivateKey, receiverPublicKey) => {
+  // We generate a private key derived from sender private key and receiver private key
+  // to be deterministic for the sender
+  let privateKey = await kem(senderPrivateKey, receiverPublicKey).toString(16);
+  privateKey = new GN(`0x${privateKey}`, 'hex');
+  const publicKey = scalarMult(privateKey.bigInt, BABYJUBJUB.GENERATOR);
+  return [privateKey, publicKey];
+};
+
+/**
+This function gets a random nonce between min and max.
+@function randomNonce
+@param {Number} min - Min value of the nonce
+@param {Number} max - Max value of the nonce
+@returns {GeneralNumber} The random hex nonce 
+*/
+const randomNonce = (min, max) => {
+  return BigInt(Math.floor(Math.random() * (max - min + 1) + min));
+};
+
 /**
 This function performs the kem-dem required to encrypt plaintext.
 @function encrypt
 @param {GeneralNumber} ephemeralPrivate - The private key that generates the ephemeralPub
 @param {Array<GeneralNumber>} ephemeralPub - The ephemeralPubKey
 @param {Array<GeneralNumber>} recipientPkds - The public pkd of the recipients
 @param {Array<BigInt>} plaintexts - The array of plain text to be encrypted, the ordering is [ercAddress,tokenId, value, salt]
+@param {BigInt} nonce - Nonce to do XOR. This is used in transfer for regulator so the encryption key has some randomness
 @returns {Array<BigInt>} The encrypted ciphertexts.
 */
-const encrypt = (ephemeralPrivate, recipientPkds, plaintexts) => {
-  const encKey = kem(ephemeralPrivate, recipientPkds);
+const encrypt = (ephemeralPrivate, recipientPkds, plaintexts, nonce) => {
+  let encKey = kem(ephemeralPrivate, recipientPkds);
+  if (nonce) {
+    // eslint-disable-next-line no-bitwise
+    encKey ^= nonce;
+  }
   return dem(encKey, plaintexts);
-  // return cipherTexts;
 };
 
 /**
@@ -126,11 +157,23 @@ This function performs the kem-deDem required to decrypt plaintext.
 @param {GeneralNumber} privateKey - The private key of the recipient pkd
 @param {Array<GeneralNumber>} ephemeralPub - The ephemeralPubKey
 @param {Array<GeneralNumber>} ciphertexts - The array of ciphertexts to be decrypted
+@param {BigInt} nonce - Nonce to do XOR. This is used in transfer for regulator so the encryption key has some randomness
 @returns {Array<GeneralNumber>} The decrypted plaintexts, the ordering is [ercAddress,tokenId, value, salt]
 */
-const decrypt = (privateKey, ephemeralPub, cipherTexts) => {
-  const encKey = kem(privateKey, ephemeralPub);
+const decrypt = (privateKey, ephemeralPub, cipherTexts, nonce) => {
+  let encKey = kem(privateKey, ephemeralPub);
+  if (nonce) {
+    // eslint-disable-next-line no-bitwise
+    encKey ^= nonce;
+  }
   return deDem(encKey, cipherTexts);
 };
 
-export { encrypt, decrypt, genEphemeralKeys, packSecrets };
+export {
+  encrypt,
+  decrypt,
+  genEphemeralKeys,
+  genTransferKeysForObservers,
+  randomNonce,
+  packSecrets,
+};