wip

src/utils.js

@@ -1,178 +1,40 @@
-const { isHexStrict, toBN, toWei, BN } = require('web3-utils')
-const { netId, mixers, relayerServiceFee } = require('../config')
+const { instances, netId } = require('../config')
+const { poseidon } = require('circomlib')
+const { toBN } = require('web3-utils')
 
-function isValidProof(proof) {
-  // validator expects `websnarkUtils.toSolidityInput(proof)` output
-
-  if (!proof) {
-    return { valid: false, reason: 'The proof is empty.' }
-  }
-
-  if (!isHexStrict(proof) || proof.length !== 2 + 2 * 8 * 32) {
-    return { valid: false, reason: 'Corrupted proof' }
-  }
-
-  return { valid: true }
-}
-
-function isValidArgs(args) {
-  if (!args) {
-    return { valid: false, reason: 'Args are empty' }
-  }
-
-  if (args.length !== 6) {
-    return { valid: false, reason: 'Length of args is lower than 6' }
-  }
-
-  for (let signal of args) {
-    if (!isHexStrict(signal)) {
-      return { valid: false, reason: `Corrupted signal ${signal}` }
-    }
-  }
-
-  if (
-    args[0].length !== 66 ||
-    args[1].length !== 66 ||
-    args[2].length !== 42 ||
-    args[3].length !== 42 ||
-    args[4].length !== 66 ||
-    args[5].length !== 66
-  ) {
-    return { valid: false, reason: 'The length one of the signals is incorrect' }
-  }
-
-  return { valid: true }
-}
-
-function isKnownContract(contract) {
-  const mixers = getMixers()
-  for (let currency of Object.keys(mixers)) {
-    for (let amount of Object.keys(mixers[currency].mixerAddress)) {
-      if (mixers[currency].mixerAddress[amount] === contract) {
-        return { valid: true, currency, amount }
+function getInstance(address) {
+  const inst = instances[`netId${netId}`]
+  for (const currency of Object.keys(inst)) {
+    for (const amount of Object.keys(inst[currency].instanceAddress)) {
+      if (inst[currency].instanceAddress[amount] === address) {
+        return { currency, amount }
       }
     }
   }
-  return { valid: false }
+  return null
 }
 
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms))
-}
+// async function setSafeInterval(func, interval) {
+//   try {
+//     await func()
+//   } catch (e) {
+//     console.error('Unhandled promise error:', e)
+//   } finally {
+//     setTimeout(() => setSafeInterval(func, interval), interval)
+//   }
+// }
 
-function fromDecimals(value, decimals) {
-  value = value.toString()
-  let ether = value.toString()
-  const base = new BN('10').pow(new BN(decimals))
-  const baseLength = base.toString(10).length - 1 || 1
+const poseidonHash = (items) => toBN(poseidon(items).toString())
+const poseidonHash2 = (a, b) => poseidonHash([a, b])
 
-  const negative = ether.substring(0, 1) === '-'
-  if (negative) {
-    ether = ether.substring(1)
-  }
-
-  if (ether === '.') {
-    throw new Error('[ethjs-unit] while converting number ' + value + ' to wei, invalid value')
-  }
-
-  // Split it into a whole and fractional part
-  const comps = ether.split('.')
-  if (comps.length > 2) {
-    throw new Error('[ethjs-unit] while converting number ' + value + ' to wei,  too many decimal points')
-  }
-
-  let whole = comps[0]
-  let fraction = comps[1]
-
-  if (!whole) {
-    whole = '0'
-  }
-  if (!fraction) {
-    fraction = '0'
-  }
-  if (fraction.length > baseLength) {
-    throw new Error('[ethjs-unit] while converting number ' + value + ' to wei, too many decimal places')
-  }
-
-  while (fraction.length < baseLength) {
-    fraction += '0'
-  }
-
-  whole = new BN(whole)
-  fraction = new BN(fraction)
-  let wei = whole.mul(base).add(fraction)
-
-  if (negative) {
-    wei = wei.mul(negative)
-  }
-
-  return new BN(wei.toString(10), 10)
-}
-
-function isEnoughFee({ gas, gasPrices, currency, amount, refund, ethPrices, fee }) {
-  const { decimals } = mixers[`netId${netId}`][currency]
-  const decimalsPoint =
-    Math.floor(relayerServiceFee) === relayerServiceFee
-      ? 0
-      : relayerServiceFee.toString().split('.')[1].length
-
-  const roundDecimal = 10 ** decimalsPoint
-  const feePercent = toBN(fromDecimals(amount, decimals))
-    .mul(toBN(relayerServiceFee * roundDecimal))
-    .div(toBN(roundDecimal * 100))
-  const expense = toBN(toWei(gasPrices.fast.toString(), 'gwei')).mul(toBN(gas))
-  let desiredFee
-  switch (currency) {
-    case 'eth': {
-      desiredFee = expense.add(feePercent)
-      break
-    }
-    default: {
-      desiredFee = expense
-        .add(refund)
-        .mul(toBN(10 ** decimals))
-        .div(toBN(ethPrices[currency]))
-      desiredFee = desiredFee.add(feePercent)
-      break
-    }
-  }
-  console.log(
-    'sent fee, desired fee, feePercent',
-    fee.toString(),
-    desiredFee.toString(),
-    feePercent.toString()
-  )
-  if (fee.lt(desiredFee)) {
-    return { isEnough: false, reason: 'Not enough fee' }
-  }
-  return { isEnough: true }
-}
-
-function getArgsForOracle() {
-  const tokens = mixers['netId1']
-  const tokenAddresses = []
-  const oneUintAmount = []
-  const currencyLookup = {}
-  Object.entries(tokens).map(([currency, data]) => {
-    if (currency !== 'eth') {
-      tokenAddresses.push(data.tokenAddress)
-      oneUintAmount.push(toBN('10').pow(toBN(data.decimals.toString())).toString())
-      currencyLookup[data.tokenAddress] = currency
-    }
+function setSafeInterval(func, interval) {
+  func().catch(console.error).finally(() => {
+    setTimeout(() => setSafeInterval(func, interval), interval)
   })
-  return { tokenAddresses, oneUintAmount, currencyLookup }
-}
-
-function getMixers() {
-  return mixers[`netId${netId}`]
 }
 
 module.exports = {
-  isValidProof,
-  isValidArgs,
-  sleep,
-  isKnownContract,
-  isEnoughFee,
-  getMixers,
-  getArgsForOracle
+  getInstance,
+  setSafeInterval,
+  poseidonHash2,
 }