test: add Backup tests + utils

Author: parketh

test/ETHPrivateBank.test.ts

@@ -3,8 +3,10 @@ import { ethers } from 'hardhat'
 import {
   generateDeposit,
   generateProof,
+  packBackupData,
   randomBigInt,
   toSolidityInput,
+  unpackBackupData,
   verifyProof,
 } from '../utils/PrivateBank.utils'
 import { SignerWithAddress } from '@nomiclabs/hardhat-ethers/signers'
@@ -21,6 +23,7 @@ import {
 } from '../utils/types.utils'
 import { poseidon } from '@iden3/js-crypto'
 import { FIELD_P } from '../utils/keccak.utils'
+import { decrypt, encrypt, generateEncryptionKey } from '../utils/aes256.utils'
 
 describe('ETHPrivateBank', function () {
   const ZERO = '0x29319238daf40223d6021718c846ac2a0c0ef028ecc765972e999a8ac79662a8'
@@ -291,6 +294,77 @@ describe('ETHPrivateBank', function () {
     expect(isSpent).to.be.true
   })
 
+  it('backup(): should backup note and emit event, be able to withdraw using the note', async () => {
+    // generate deposit
+    const deposit = generateDeposit()
+
+    // encrypt backup data
+    const plainText = packBackupData(deposit.secret, deposit.nullifier)
+    const encryptionKey = generateEncryptionKey()
+    const encryptedData = encrypt(encryptionKey, plainText)
+
+    // setup tree
+    const hashMiMCSponge = await getMiMCSpongeHasher()
+    const tree = new FixedMerkleTree(HEIGHT, [], {
+      hashFunction: hashMiMCSponge,
+      zeroElement: ZERO,
+    })
+    tree.insert(deposit.commitment)
+
+    // deposit to contract
+    await expect(privateBank.connect(sender).deposit(deposit.commitment, { value: DEPOSIT_AMOUNT }))
+      .to.not.be.reverted
+
+    // backup note
+    const tx = await privateBank.connect(sender).backup(encryptedData)
+    const receipt = await tx.wait()
+    const backupEvt = receipt.events[0]
+    expect(backupEvt.event).to.equal('Backup')
+    expect(backupEvt.args.user).to.equal(sender.address)
+    expect(backupEvt.args.encryptedData).to.equal(encryptedData)
+
+    // calculate relayer fee
+    const gasPrice = await ethers.provider.getGasPrice()
+    const gasFee = relayerFeeGasUsed.mul(gasPrice)
+    const relayerFee = DEPOSIT_AMOUNT.mul(relayerFeePct)
+      .div(relayerFeePctBase)
+      .add(gasFee)
+      .toBigInt()
+
+    // retrieve backed up data
+    const decrypted = decrypt(backupEvt.args.encryptedData, encryptionKey)
+    const { secret: retrievedSecret, nullifier: retrievedNullifier } = unpackBackupData(decrypted)
+
+    // generate proof
+    const rawInput = {
+      root: tree.root,
+      nullifierHash: poseidon.hash([retrievedNullifier]),
+      nullifier: retrievedNullifier,
+      relayer: relayer.address,
+      recipient: recipient.address,
+      relayerFee,
+      gasRefund,
+      secret: retrievedSecret,
+      pathElements: tree.path(0).pathElements,
+      pathIndices: tree.path(0).pathIndices,
+    }
+    const input = utils.stringifyBigInts(rawInput)
+    const proofData = await generateProof(input)
+    const proof = toSolidityInput(proofData)
+
+    // withdraw
+    const inputs = {
+      root: padHex(rawInput.root as string),
+      nullifierHash: bigintToHex(rawInput.nullifierHash),
+      nullifier: bigintToHex(rawInput.nullifier),
+      recipient: recipient.address,
+      relayer: relayer.address,
+      relayerFee: bigintToHex(rawInput.relayerFee),
+      gasRefund: bigintToHex(rawInput.gasRefund),
+    }
+    await expect(privateBank.connect(relayer).withdraw(proof.proof, inputs)).to.not.be.reverted
+  })
+
   it('withdraw(): should prevent double spend', async () => {
     // generate deposit
     const deposit = generateDeposit()

tsconfig.json

@@ -7,7 +7,7 @@
     "strict": true,
     "skipLibCheck": true,
     "resolveJsonModule": true,
-    "types": ["chai", "mocha"],
+    "types": ["node", "chai", "mocha"],
     "typeRoots": ["./types", "./node_modules/@types"]
   }
 }

utils/PrivateBank.utils.ts

@@ -16,6 +16,16 @@ export const generateDeposit = (seed?: string) => {
   return deposit
 }
 
+export const packBackupData = (secret: Buffer, nullifier: Buffer) => {
+  return secret.toString('hex').padStart(64, '0') + nullifier.toString('hex').padStart(64, '0')
+}
+
+export const unpackBackupData = (backupData: string) => {
+  const secret = BigInt('0x' + backupData.slice(0, 64))
+  const nullifier = BigInt('0x' + backupData.slice(64, 128))
+  return { secret, nullifier }
+}
+
 export const randomBigInt = (numBytes: number, seed?: string) => {
   let bytes: Buffer
   if (seed) {

utils/aes256.utils.ts

@@ -0,0 +1,44 @@
+import crypto from 'crypto'
+
+const KEY_BITS = 256
+const IV_LEN = 16
+
+export const generateEncryptionKey = () => {
+  return crypto.randomBytes(KEY_BITS / 8)
+}
+
+export const encrypt = (encryptionKey: Buffer, plainText: string) => {
+  const iv = crypto.randomBytes(IV_LEN)
+  const cipher = crypto.createCipheriv(`aes-${KEY_BITS}-cbc`, encryptionKey, iv)
+
+  let cipherText = cipher.update(plainText, 'utf8', 'hex')
+  cipherText += cipher.final('hex')
+
+  const ivString = iv.toString('hex')
+  const encryptedData = `0x${ivString}${cipherText}`
+  return encryptedData
+}
+
+export const decrypt = (encryptedData: string, encryptionKey: Buffer) => {
+  const withoutPrefix = encryptedData.startsWith('0x') ? encryptedData.slice(2) : encryptedData
+  const ivString = withoutPrefix.slice(0, 32)
+  const cipherText = withoutPrefix.slice(32)
+  const iv = Buffer.from(ivString, 'hex')
+  const decipher = crypto.createDecipheriv(`aes-${KEY_BITS}-cbc`, encryptionKey, iv)
+  let decrypted = decipher.update(cipherText, 'hex', 'utf8')
+  decrypted += decipher.final('utf8')
+  return decrypted
+}
+
+// EXAMPLE
+
+// const example = () => {
+//   const encryptionKey = generateEncryptionKey()
+//   const plainText =
+//     '657cee92c25a700343dbfef8501d5d2952f5f20206f827dac22af39f974ca7b085f978041c8be47cd250821d1512bd9c60576da0f6d42a012c5f75180b02'
+//   const encryptedData = encrypt(encryptionKey, plainText)
+//   const decrypted = decrypt(encryptedData, encryptionKey)
+//   console.log({ decrypted })
+// }
+
+// example()