edge-currency-plugins 1.0.0-rc.1

package/lib/common/utxobased/db/makeBaselets.js

@@ -0,0 +1,123 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _asyncmutex = require('async-mutex');
+
+
+
+
+var _baselet = require('baselet');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _baselet3 = require('./Models/baselet');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ const makeBaselets = async (
+  config
+) => {
+  /* Tables */
+  const addressBases = {
+    addressByScriptPubkey: await _baselet.createOrOpenHashBase.call(void 0, 
+      config.disklet,
+      _baselet3.addressByScriptPubkeyOptions
+    ),
+    scriptPubkeyByPath: await _baselet.createOrOpenCountBase.call(void 0, 
+      config.disklet,
+      _baselet3.scriptPubkeyByPathOptions
+    ),
+    lastUsedByFormatPath: await _baselet.createOrOpenHashBase.call(void 0, 
+      config.disklet,
+      _baselet3.lastUsedByFormatPathOptions
+    )
+  }
+  const txBases = {
+    txById: await _baselet.createOrOpenHashBase.call(void 0, config.disklet, _baselet3.txByIdOptions),
+    txIdsByBlockHeight: await _baselet.createOrOpenRangeBase.call(void 0, 
+      config.disklet,
+      _baselet3.txIdsByBlockHeightOptions
+    ),
+    txIdsByDate: await _baselet.createOrOpenRangeBase.call(void 0, config.disklet, _baselet3.txIdsByDateOptions)
+  }
+  const utxoBases = {
+    utxoById: await _baselet.createOrOpenHashBase.call(void 0, config.disklet, _baselet3.utxoByIdOptions),
+    utxoIdsByScriptPubkey: await _baselet.createOrOpenHashBase.call(void 0, 
+      config.disklet,
+      _baselet3.utxoIdsByScriptPubkeyOptions
+    )
+  }
+
+  const addressMutex = new (0, _asyncmutex.Mutex)()
+  const txMutex = new (0, _asyncmutex.Mutex)()
+  const utxoMutex = new (0, _asyncmutex.Mutex)()
+
+  return {
+    async address(fn) {
+      return await addressMutex.runExclusive(async () => await fn(addressBases))
+    },
+
+    async tx(fn) {
+      return await txMutex.runExclusive(async () => await fn(txBases))
+    },
+
+    async utxo(fn) {
+      return await utxoMutex.runExclusive(async () => await fn(utxoBases))
+    },
+
+    all: {
+      ...addressBases,
+      ...txBases,
+      ...utxoBases
+    }
+  }
+}; exports.makeBaselets = makeBaselets

package/lib/common/utxobased/db/makeMutex.js

@@ -0,0 +1,17 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+ function makeMutex() {
+  let busy = false
+  const queue = []
+  return async function lock(callback) {
+    if (busy) await new Promise(resolve => queue.push(resolve))
+    try {
+      busy = true
+      return callback()
+    } finally {
+      busy = false
+      const resolve = queue.shift()
+      if (resolve != null) resolve({})
+    }
+  }
+} exports.makeMutex = makeMutex;

package/lib/common/utxobased/db/makeProcessor.js

@@ -0,0 +1,554 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }var _baselet = require('baselet');
+var _biggystring = require('biggystring'); var bs = _interopRequireWildcard(_biggystring);
+var _disklet = require('disklet');
+
+
+var _unixTime = require('../../../util/unixTime');
+
+var _makeBaselets = require('./makeBaselets');
+var _baselet3 = require('./Models/baselet');
+
+
+
+
+
+
+
+
+const BASELET_DIR = 'tables'
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ async function makeProcessor(
+  config
+) {
+  const disklet = _disklet.navigateDisklet.call(void 0, config.disklet, BASELET_DIR)
+  let baselets = await _makeBaselets.makeBaselets.call(void 0, { disklet })
+
+  /**
+   * Calculates the transaction value supplied (negative) or received (positive). In order to calculate
+   * a value, the `ourIns` and `ourOuts` of the object must be populated with indices.
+   * @param tx {IProcessorTransaction} A transaction object with `ourIns` and `ourOuts` populated
+   */
+  const calculateTxAmount = (tx) => {
+    
+
+
+    let ourAmount = '0'
+    let txIndexMap = {}
+    for (const input of tx.inputs) {
+      txIndexMap[input.n.toString()] = input
+    }
+    for (const i of tx.ourIns) {
+      const input = txIndexMap[i]
+      ourAmount = bs.sub(ourAmount, input.amount)
+    }
+    txIndexMap = {}
+    for (const output of tx.outputs) {
+      txIndexMap[output.n.toString()] = output
+    }
+    for (const i of tx.ourOuts) {
+      const output = txIndexMap[i]
+      ourAmount = bs.add(ourAmount, output.amount)
+    }
+    return ourAmount
+  }
+
+  const processor = {
+    async clearAll() {
+      await _baselet.clearMemletCache.call(void 0, )
+      // why is this delay needed?
+      await new Promise(resolve => setTimeout(resolve, 0))
+      await disklet.delete('.')
+      baselets = await _makeBaselets.makeBaselets.call(void 0, { disklet })
+    },
+
+    async dumpData() {
+      const allBases = Object.values(baselets.all)
+      return await Promise.all(
+        allBases.map(async base => ({
+          databaseName: base.databaseName,
+          data: (await base.dumpData('')) 
+        }))
+      )
+    },
+
+    async saveUtxo(utxo) {
+      return await baselets.utxo(async tables => {
+        const [utxoIds = []] = await tables.utxoIdsByScriptPubkey.query('', [
+          utxo.scriptPubkey
+        ])
+        if (!utxoIds.includes(utxo.id)) {
+          utxoIds.push(utxo.id)
+          await tables.utxoIdsByScriptPubkey.insert(
+            '',
+            utxo.scriptPubkey,
+            utxoIds
+          )
+        }
+
+        await tables.utxoById.insert('', utxo.id, utxo)
+      })
+    },
+
+    async removeUtxos(utxoIds) {
+      return await baselets.utxo(async tables => {
+        if (utxoIds.length === 0) return
+
+        // To remove utxo from utxoIdsByScriptPubkey table:
+        // 1. Create a map of scriptPubkeys to utxoIds
+        // 2. Use the map to remove utxoIds from the utxoIdsByScriptPubkey table
+        const utxos = (await tables.utxoById.query('', utxoIds)).filter(
+          utxo => utxo != null
+        ) 
+        const utxoIdsMap = {}
+        for (const utxo of utxos) {
+          utxoIdsMap[utxo.scriptPubkey] = [
+            ...(_nullishCoalesce(utxoIdsMap[utxo.scriptPubkey], () => ( []))),
+            utxo.id
+          ]
+        }
+        for (const scriptPubkey of Object.keys(utxoIdsMap)) {
+          const utxoIdsToRemove = utxoIdsMap[scriptPubkey]
+          const [utxoIds = []] = await tables.utxoIdsByScriptPubkey.query('', [
+            scriptPubkey
+          ])
+
+          for (const utxoIdToRemove of utxoIdsToRemove) {
+            utxoIds.splice(utxoIds.indexOf(utxoIdToRemove), 1)
+          }
+
+          // Update utxoIds for entry in table, otherwise delete entry
+          if (utxoIds.length > 0) {
+            await tables.utxoIdsByScriptPubkey.insert('', scriptPubkey, utxoIds)
+          } else {
+            await tables.utxoIdsByScriptPubkey.delete('', [scriptPubkey])
+          }
+        }
+
+        // Remove utxo utxoById table
+        await tables.utxoById.delete('', utxoIds)
+      })
+    },
+
+    async fetchUtxos(args) {
+      const { scriptPubkey, utxoIds = [] } = args
+      return await baselets.utxo(async tables => {
+        if (scriptPubkey != null) {
+          const [
+            utxoIdsByScriptPubkey
+          ] = await tables.utxoIdsByScriptPubkey.query('', [scriptPubkey])
+
+          if (utxoIdsByScriptPubkey != null)
+            utxoIds.push(...utxoIdsByScriptPubkey)
+
+          // Exit early if no utxoIds are found by scriptPubkey
+          if (utxoIds.length === 0) {
+            return []
+          }
+        }
+
+        // Return all UTXOs if no UTXO ids are specified
+        if (utxoIds.length === 0) {
+          const { data } = await tables.utxoById.dumpData('')
+          return Object.values(_nullishCoalesce(data[''], () => ( {})))
+        }
+
+        return await tables.utxoById.query('', utxoIds)
+      })
+    },
+
+    async saveTransaction(
+      args
+    ) {
+      const { scriptPubkeys = [], tx } = args
+      return await baselets.tx(async tables => {
+        // Check if the transaction already exists
+        const processorTx = await tables.txById
+          .query('', [tx.txid])
+          .then(transactions => transactions[0])
+          .catch(_ => undefined)
+
+        // Use the existing transaction if it does exist.
+        const transaction = _nullishCoalesce(processorTx, () => ( tx))
+
+        // Mark the used inputs with the provided script pubkey
+        for (const scriptPubkey of scriptPubkeys) {
+          for (const input of transaction.inputs) {
+            if (input.scriptPubkey === scriptPubkey) {
+              if (!transaction.ourIns.includes(input.n.toString())) {
+                transaction.ourIns.push(input.n.toString())
+              }
+            }
+          }
+          for (const output of transaction.outputs) {
+            if (output.scriptPubkey === scriptPubkey) {
+              if (!transaction.ourOuts.includes(output.n.toString())) {
+                transaction.ourOuts.push(output.n.toString())
+              }
+            }
+          }
+          transaction.ourAmount = calculateTxAmount(transaction)
+        }
+
+        if (transaction.blockHeight !== tx.blockHeight) {
+          // the transaction already exists, so delete it and re-insert at a different blockHeight
+          await tables.txIdsByBlockHeight.delete(
+            '',
+            transaction.blockHeight,
+            transaction.txid
+          )
+          transaction.blockHeight = tx.blockHeight
+          await tables.txIdsByBlockHeight.insert('', {
+            txid: transaction.txid,
+            blockHeight: transaction.blockHeight
+          })
+        } else {
+          // Save tx by blockheight
+          const txIdsByTransactionBlockHeight = await (
+            await tables.txIdsByBlockHeight.query('', transaction.blockHeight)
+          )
+            .reverse()
+            .map(({ txid: id }) => id)
+          if (!txIdsByTransactionBlockHeight.includes(transaction.txid)) {
+            await tables.txIdsByBlockHeight.insert('', {
+              txid: transaction.txid,
+              blockHeight: transaction.blockHeight
+            })
+          }
+        }
+
+        // Save transaction
+        await tables.txById.insert('', transaction.txid, transaction)
+
+        // Save index entry only for first transaction insert
+        if (processorTx == null) {
+          await tables.txIdsByDate.insert('', {
+            txid: tx.txid,
+            date: tx.date
+          })
+        }
+
+        return transaction
+      })
+    },
+
+    numTransactions() {
+      return baselets.all.txIdsByDate.size('')
+    },
+
+    async removeTransaction(_txId) {
+      return
+    },
+
+    async fetchTransactions(
+      args
+    ) {
+      const { blockHeightMax, txId, options } = args
+      let { blockHeight } = args
+      const txs = []
+      await baselets.tx(async tables => {
+        // Fetch transactions by id
+        if (txId != null) {
+          const txById = await tables.txById.query('', [txId])
+          txs.push(...txById)
+        }
+        // Fetch transactions by min block height
+        if (blockHeightMax != null && blockHeight == null) blockHeight = 0
+        if (blockHeight != null) {
+          const txIdsByMinBlockHeight = await (
+            await tables.txIdsByBlockHeight.query(
+              '',
+              blockHeight,
+              blockHeightMax
+            )
+          )
+            .reverse()
+            .map(({ txid: id }) => id)
+
+          const txsById = await tables.txById.query('', txIdsByMinBlockHeight)
+          txs.push(...txsById)
+        }
+        if (options != null) {
+          const {
+            startEntries,
+            startIndex,
+            startDate = new Date(0),
+            endDate = new Date()
+          } = options
+
+          // Fetch transaction IDs ordered by date
+          let txData
+          if (startEntries != null && startIndex != null) {
+            txData = await tables.txIdsByDate.queryByCount(
+              '',
+              startEntries,
+              startIndex
+            )
+          } else {
+            txData = await tables.txIdsByDate.query(
+              '',
+              _unixTime.unixTime.call(void 0, startDate.getTime()),
+              _unixTime.unixTime.call(void 0, endDate.getTime())
+            )
+          }
+          const txIdsByOptions = await txData
+            .reverse()
+            .map(({ txid: id }) => id)
+
+          const txsByOptions = await tables.txById.query('', txIdsByOptions)
+          // Make sure only existing transactions are included
+          txs.push(...txsByOptions.filter(tx => tx != null))
+        }
+      })
+      return txs
+    },
+
+    async saveAddress(address) {
+      await baselets.address(async tables => {
+        const [existingAddress] = await tables.addressByScriptPubkey.query('', [
+          address.scriptPubkey
+        ])
+
+        // save to the path index if available
+        if (address.path != null) {
+          // check if the path already exists with a different script pubkey
+          const [scriptPubkey] = await tables.scriptPubkeyByPath.query(
+            _baselet3.addressPathToPrefix.call(void 0, address.path),
+            address.path.addressIndex
+          )
+          if (scriptPubkey != null && scriptPubkey !== address.scriptPubkey)
+            throw new Error(
+              'Attempted to save address with an existing path, but different script pubkey'
+            )
+
+          await tables.scriptPubkeyByPath.insert(
+            _baselet3.addressPathToPrefix.call(void 0, address.path),
+            address.path.addressIndex,
+            address.scriptPubkey
+          )
+
+          // check if this address is used and if so, whether it has a higher last used index
+          if (address.used || (_nullishCoalesce(_optionalChain([existingAddress, 'optionalAccess', _2 => _2.used]), () => ( false)))) {
+            let [lastUsed] = await tables.lastUsedByFormatPath.query('', [
+              _baselet3.addressPathToPrefix.call(void 0, address.path)
+            ])
+            if (lastUsed == null) lastUsed = -1
+
+            if (lastUsed < address.path.addressIndex) {
+              await tables.lastUsedByFormatPath.insert(
+                '',
+                _baselet3.addressPathToPrefix.call(void 0, address.path),
+                address.path.addressIndex
+              )
+            }
+          }
+        }
+
+        if (existingAddress != null) {
+          // Only update the lastQueriedBlockHeight on the address if one was given and is greater than the existing value
+          if (
+            address.lastQueriedBlockHeight >
+            existingAddress.lastQueriedBlockHeight
+          ) {
+            existingAddress.lastQueriedBlockHeight =
+              address.lastQueriedBlockHeight
+          }
+
+          // Only update the lastQuery value if one was given and is greater than the existing value
+          if (address.lastQuery > existingAddress.lastQuery) {
+            existingAddress.lastQuery = address.lastQuery
+          }
+
+          // Only update the lastTouched value if one was given and is greater than the existing value
+          if (address.lastTouched > existingAddress.lastTouched) {
+            existingAddress.lastTouched = address.lastTouched
+          }
+
+          // Only update the balance field if one was given and does not equal the existing value
+          if (address.balance !== existingAddress.balance) {
+            existingAddress.balance = address.balance
+          }
+
+          // Only update the path field if one was given and currently does not have one
+          // NOTE: Addresses can be stored in the db without a path due to the `EdgeCurrencyEngine.addGapLimitAddresses` function
+          //  Once an address path is known, it should never be updated
+          if (address.path != null && existingAddress.path == null) {
+            existingAddress.path = address.path
+            await tables.scriptPubkeyByPath.insert(
+              _baselet3.addressPathToPrefix.call(void 0, address.path),
+              address.path.addressIndex,
+              address.scriptPubkey
+            )
+          }
+
+          // Only update the used flag if one was given and is true
+          if (address.used && !existingAddress.used) {
+            existingAddress.used = true
+          }
+
+          // check if the lastUsed changed by the update
+          if (existingAddress.path != null && existingAddress.used) {
+            let [lastUsed] = await tables.lastUsedByFormatPath.query('', [
+              _baselet3.addressPathToPrefix.call(void 0, existingAddress.path)
+            ])
+            if (lastUsed == null) lastUsed = -1
+
+            if (lastUsed < existingAddress.path.addressIndex) {
+              await tables.lastUsedByFormatPath.insert(
+                '',
+                _baselet3.addressPathToPrefix.call(void 0, existingAddress.path),
+                existingAddress.path.addressIndex
+              )
+            }
+          }
+          await tables.addressByScriptPubkey.insert(
+            '',
+            existingAddress.scriptPubkey,
+            existingAddress
+          )
+          return
+        }
+        await tables.addressByScriptPubkey.insert(
+          '',
+          address.scriptPubkey,
+          address
+        )
+      })
+    },
+
+    numAddressesByFormatPath(path) {
+      return baselets.all.scriptPubkeyByPath.length(_baselet3.addressPathToPrefix.call(void 0, path))
+    },
+
+    async lastUsedIndexByFormatPath(path) {
+      const [addressIndex] = await baselets.address(async tables => {
+        return await tables.lastUsedByFormatPath.query('', [
+          _baselet3.addressPathToPrefix.call(void 0, path)
+        ])
+      })
+      return _nullishCoalesce(addressIndex, () => ( -1))
+    },
+
+    async fetchAddress(
+      fetchAddressArg
+    ) {
+      return await baselets.address(async tables => {
+        if (typeof fetchAddressArg === 'string') {
+          // if it is a string, it is a scriptPubkey
+          const scriptPubkey = fetchAddressArg
+          const [address] = await tables.addressByScriptPubkey.query('', [
+            scriptPubkey
+          ])
+          return address
+        }
+
+        // since it is not a string, it has to be an AddressPath
+        const path = fetchAddressArg
+        // fetch addresses by provided path
+        const [scriptPubkeyFromPath] = await tables.scriptPubkeyByPath.query(
+          _baselet3.addressPathToPrefix.call(void 0, path),
+          path.addressIndex
+        )
+
+        // return if the address by path was not found
+        if (scriptPubkeyFromPath == null) return
+
+        const [address] = await tables.addressByScriptPubkey.query('', [
+          scriptPubkeyFromPath
+        ])
+
+        return address
+      })
+    }
+  }
+  return processor
+} exports.makeProcessor = makeProcessor;