@neo-one/node-levelup/dist/index.js

NEO•ONE levelup node storage.

'use strict';

function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }

var clientCore = require('@neo-one/client-core');
var nodeCore = require('@neo-one/node-core');
var utils = require('@neo-one/utils');
var bytewise = _interopDefault(require('bytewise'));
var operators = require('rxjs/operators');
var Observable = require('rxjs/Observable');

function _asyncToGenerator(fn) {
  return function () {
    var self = this,
        args = arguments;
    return new Promise(function (resolve, reject) {
      var gen = fn.apply(self, args);

      function step(key, arg) {
        try {
          var info = gen[key](arg);
          var value = info.value;
        } catch (error) {
          reject(error);
          return;
        }

        if (info.done) {
          resolve(value);
        } else {
          Promise.resolve(value).then(_next, _throw);
        }
      }

      function _next(value) {
        step("next", value);
      }

      function _throw(err) {
        step("throw", err);
      }

      _next();
    });
  };
}

function _classCallCheck(instance, Constructor) {
  if (!(instance instanceof Constructor)) {
    throw new TypeError("Cannot call a class as a function");
  }
}

function _inherits(subClass, superClass) {
  if (typeof superClass !== "function" && superClass !== null) {
    throw new TypeError("Super expression must either be null or a function");
  }

  subClass.prototype = Object.create(superClass && superClass.prototype, {
    constructor: {
      value: subClass,
      enumerable: false,
      writable: true,
      configurable: true
    }
  });
  if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
}

function _possibleConstructorReturn(self, call) {
  if (call && (typeof call === "object" || typeof call === "function")) {
    return call;
  }

  if (self === void 0) {
    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  }

  return self;
}

function _toConsumableArray(arr) {
  if (Array.isArray(arr)) {
    for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];

    return arr2;
  } else {
    return Array.from(arr);
  }
}

var NotFoundError =
/*#__PURE__*/
function (_CustomError) {
  _inherits(NotFoundError, _CustomError);

  function NotFoundError() {
    var _this;

    _classCallCheck(this, NotFoundError);
    _this = _possibleConstructorReturn(this, (NotFoundError.__proto__ || Object.getPrototypeOf(NotFoundError)).call(this, 'Not found'));
    _this.code = 'NOT_FOUND';
    return _this;
  }

  return NotFoundError;
}(utils.CustomError);
var UnknownTypeError =
/*#__PURE__*/
function (_CustomError2) {
  _inherits(UnknownTypeError, _CustomError2);

  function UnknownTypeError() {
    var _this2;

    _classCallCheck(this, UnknownTypeError);
    _this2 = _possibleConstructorReturn(this, (UnknownTypeError.__proto__ || Object.getPrototypeOf(UnknownTypeError)).call(this, 'Unknown type'));
    _this2.code = 'UNKNOWN_TYPE';
    return _this2;
  }

  return UnknownTypeError;
}(utils.CustomError);
var KeyNotFoundError =
/*#__PURE__*/
function (_CustomError3) {
  _inherits(KeyNotFoundError, _CustomError3);

  function KeyNotFoundError(keyString) {
    var _this3;

    _classCallCheck(this, KeyNotFoundError);
    _this3 = _possibleConstructorReturn(this, (KeyNotFoundError.__proto__ || Object.getPrototypeOf(KeyNotFoundError)).call(this, "Key ".concat(keyString, " not found in database")));
    _this3.code = 'KEY_NOT_FOUND';
    return _this3;
  }

  return KeyNotFoundError;
}(utils.CustomError);

var serializeHeaderHash = function serializeHeaderHash(hash) {
  return clientCore.common.uInt256ToBuffer(hash);
};
var deserializeHeaderHash = function deserializeHeaderHash(hash) {
  return clientCore.common.bufferToUInt256(hash);
};
var serializeBlockHash = function serializeBlockHash(hash) {
  return clientCore.common.uInt256ToBuffer(hash);
};
var deserializeBlockHash = function deserializeBlockHash(hash) {
  return clientCore.common.bufferToUInt256(hash);
};

var accountKeyPrefix = 'account';
var actionKeyPrefix = 'action';
var assetKeyPrefix = 'asset';
var blockKeyPrefix = 'block';
var blockSystemFeeKeyPrefix = 'blockSystemFee';
var headerKeyPrefix = 'header';
var headerHashKeyPrefix = 'header-index';
var transactionKeyPrefix = 'transaction';
var outputKeyPrefix = 'output';
var transactionSpentCoinsKeyPrefix = 'transactionSpentCoins';
var contractKeyPrefix = 'contract';
var storageItemKeyPrefix = 'storageItem';
var validatorKeyPrefix = 'validator';
var invocationDataKeyPrefix = 'invocationData';
var settingsPrefix = 'settings';
var serializeHeaderIndexHashKey = function serializeHeaderIndexHashKey(index) {
  return bytewise.encode([headerHashKeyPrefix, index]);
};

var maxHeaderHashKey = bytewise.encode([settingsPrefix, 'max-header-hash']);
var maxBlockHashKey = bytewise.encode([settingsPrefix, 'max-block-hash']);

var serializeStorageItemKey = function serializeStorageItemKey(_ref) {
  var hash = _ref.hash,
      key = _ref.key;
  return bytewise.encode([storageItemKeyPrefix, clientCore.common.uInt160ToBuffer(hash), key]);
};

var serializeStorageItemKeyString = function serializeStorageItemKeyString(_ref2) {
  var hash = _ref2.hash,
      key = _ref2.key;
  return "".concat(storageItemKeyPrefix, ":") + "".concat(clientCore.common.uInt160ToString(hash), ":") + "".concat(key.toString('hex'));
};

var getStorageItemKeyMin = function getStorageItemKeyMin(_ref3) {
  var hash = _ref3.hash;
  return bytewise.encode(hash == null ? bytewise.sorts.array.bound.lower([storageItemKeyPrefix]) : bytewise.sorts.array.bound.lower([storageItemKeyPrefix, clientCore.common.uInt160ToBuffer(hash)]));
};
var getStorageItemKeyMax = function getStorageItemKeyMax(_ref4) {
  var hash = _ref4.hash;
  return bytewise.encode(hash == null ? bytewise.sorts.array.bound.upper([storageItemKeyPrefix]) : bytewise.sorts.array.bound.upper([storageItemKeyPrefix, clientCore.common.uInt160ToBuffer(hash)]));
};
var serializeActionKey = function serializeActionKey(_ref5) {
  var blockIndex = _ref5.blockIndex,
      transactionIndex = _ref5.transactionIndex,
      index = _ref5.index;
  return bytewise.encode([actionKeyPrefix, blockIndex, transactionIndex, index]);
};
var serializeActionKeyString = function serializeActionKeyString(_ref6) {
  var blockIndex = _ref6.blockIndex,
      transactionIndex = _ref6.transactionIndex,
      index = _ref6.index;
  return "".concat(actionKeyPrefix, ":") + "".concat(blockIndex, ":") + "".concat(transactionIndex, ":") + "".concat(index);
};
var getActionKeyMin = function getActionKeyMin(_ref7) {
  var blockIndexStart = _ref7.blockIndexStart,
      transactionIndexStart = _ref7.transactionIndexStart,
      indexStart = _ref7.indexStart;
  return bytewise.encode(bytewise.sorts.array.bound.lower([actionKeyPrefix, blockIndexStart, transactionIndexStart, indexStart].filter(function (value) {
    return value != null;
  })));
};
var getActionKeyMax = function getActionKeyMax(_ref8) {
  var blockIndexStop = _ref8.blockIndexStop,
      transactionIndexStop = _ref8.transactionIndexStop,
      indexStop = _ref8.indexStop;
  return bytewise.encode(bytewise.sorts.array.bound.upper([actionKeyPrefix, blockIndexStop == null ? Number.MAX_SAFE_INTEGER : blockIndexStop, transactionIndexStop == null ? Number.MAX_SAFE_INTEGER : transactionIndexStop, indexStop == null ? Number.MAX_SAFE_INTEGER : indexStop]));
};

var serializeValidatorKey = function serializeValidatorKey(_ref9) {
  var publicKey = _ref9.publicKey;
  return bytewise.encode([validatorKeyPrefix, clientCore.common.ecPointToBuffer(publicKey)]);
};

var serializeValidatorKeyString = function serializeValidatorKeyString(_ref10) {
  var publicKey = _ref10.publicKey;
  return "".concat(validatorKeyPrefix, ":").concat(clientCore.common.ecPointToString(publicKey));
};

var validatorMinKey = bytewise.encode(bytewise.sorts.array.bound.lower([validatorKeyPrefix]));
var validatorMaxKey = bytewise.encode(bytewise.sorts.array.bound.upper([validatorKeyPrefix]));

var serializeUInt160Key = function serializeUInt160Key(_ref11) {
  var hash = _ref11.hash;
  return clientCore.common.uInt160ToBuffer(hash);
};

var serializeUInt256Key = function serializeUInt256Key(_ref12) {
  var hash = _ref12.hash;
  return clientCore.common.uInt256ToBuffer(hash);
};

var createSerializeUInt160Key = function createSerializeUInt160Key(prefix) {
  return function (input) {
    return bytewise.encode([prefix, serializeUInt160Key(input)]);
  };
};

var createSerializeUInt256Key = function createSerializeUInt256Key(prefix) {
  return function (input) {
    return bytewise.encode([prefix, serializeUInt256Key(input)]);
  };
};

var createSerializeUInt160KeyString = function createSerializeUInt160KeyString(prefix) {
  return function (input) {
    return "".concat(prefix, ":").concat(clientCore.common.uInt160ToString(input.hash));
  };
};

var createSerializeUInt256KeyString = function createSerializeUInt256KeyString(prefix) {
  return function (input) {
    return "".concat(prefix, ":").concat(clientCore.common.uInt256ToString(input.hash));
  };
};

var accountMinKey = bytewise.encode(bytewise.sorts.array.bound.lower([accountKeyPrefix]));
var accountMaxKey = bytewise.encode(bytewise.sorts.array.bound.upper([accountKeyPrefix]));

var serializeOutputKey = function serializeOutputKey(_ref13) {
  var index = _ref13.index,
      hash = _ref13.hash;
  return bytewise.encode([outputKeyPrefix, serializeUInt256Key({
    hash: hash
  }), index]);
};

var serializeOutputKeyString = function serializeOutputKeyString(_ref14) {
  var index = _ref14.index,
      hash = _ref14.hash;
  return "".concat(outputKeyPrefix, ":").concat(clientCore.common.uInt256ToString(hash), ":").concat(index);
};

var typeKeyToSerializeKey = {
  account: createSerializeUInt160Key(accountKeyPrefix),
  action: serializeActionKey,
  asset: createSerializeUInt256Key(assetKeyPrefix),
  block: createSerializeUInt256Key(blockKeyPrefix),
  blockSystemFee: createSerializeUInt256Key(blockSystemFeeKeyPrefix),
  header: createSerializeUInt256Key(headerKeyPrefix),
  transaction: createSerializeUInt256Key(transactionKeyPrefix),
  output: serializeOutputKey,
  transactionSpentCoins: createSerializeUInt256Key(transactionSpentCoinsKeyPrefix),
  contract: createSerializeUInt160Key(contractKeyPrefix),
  storageItem: serializeStorageItemKey,
  validator: serializeValidatorKey,
  invocationData: createSerializeUInt256Key(invocationDataKeyPrefix)
};
var typeKeyToSerializeKeyString = {
  account: createSerializeUInt160KeyString(accountKeyPrefix),
  action: serializeActionKeyString,
  asset: createSerializeUInt256KeyString(assetKeyPrefix),
  block: createSerializeUInt256KeyString(blockKeyPrefix),
  blockSystemFee: createSerializeUInt256KeyString(blockSystemFeeKeyPrefix),
  header: createSerializeUInt256KeyString(headerKeyPrefix),
  transaction: createSerializeUInt256KeyString(transactionKeyPrefix),
  output: serializeOutputKeyString,
  transactionSpentCoins: createSerializeUInt256KeyString(transactionSpentCoinsKeyPrefix),
  contract: createSerializeUInt160KeyString(contractKeyPrefix),
  storageItem: serializeStorageItemKeyString,
  validator: serializeValidatorKeyString,
  invocationData: createSerializeUInt256KeyString(invocationDataKeyPrefix)
};

var convertAddChange = function convertAddChange(changeIn) {
  var change = changeIn;

  switch (change.type) {
    case 'account':
      return [{
        type: 'put',
        key: typeKeyToSerializeKey.account(change.value),
        value: change.value.serializeWire()
      }];

    case 'action':
      return [{
        type: 'put',
        key: typeKeyToSerializeKey.action({
          blockIndex: change.value.blockIndex,
          transactionIndex: change.value.transactionIndex,
          index: change.value.index
        }),
        value: change.value.serializeWire()
      }];

    case 'asset':
      return [{
        type: 'put',
        key: typeKeyToSerializeKey.asset(change.value),
        value: change.value.serializeWire()
      }];

    case 'block':
      return [{
        type: 'put',
        key: typeKeyToSerializeKey.block(change.value),
        value: change.value.serializeWire()
      }, {
        type: 'put',
        key: maxBlockHashKey,
        value: serializeBlockHash(change.value.hash)
      }];

    case 'blockSystemFee':
      return [{
        type: 'put',
        key: typeKeyToSerializeKey.blockSystemFee(change.value),
        value: change.value.serializeWire()
      }];

    case 'header':
      return [{
        type: 'put',
        key: typeKeyToSerializeKey.header(change.value),
        value: change.value.serializeWire()
      }, {
        type: 'put',
        key: maxHeaderHashKey,
        value: serializeHeaderHash(change.value.hash)
      }, {
        type: 'put',
        key: serializeHeaderIndexHashKey(change.value.index),
        value: serializeHeaderHash(change.value.hash)
      }];

    case 'transaction':
      return [{
        type: 'put',
        key: typeKeyToSerializeKey.transaction(change.value),
        value: change.value.serializeWire()
      }];

    case 'output':
      return [{
        type: 'put',
        key: typeKeyToSerializeKey.output({
          hash: change.value.hash,
          index: change.value.index
        }),
        value: change.value.output.serializeWire()
      }];

    case 'transactionSpentCoins':
      return [{
        type: 'put',
        key: typeKeyToSerializeKey.transactionSpentCoins(change.value),
        value: change.value.serializeWire()
      }];

    case 'contract':
      return [{
        type: 'put',
        key: typeKeyToSerializeKey.contract(change.value),
        value: change.value.serializeWire()
      }];

    case 'storageItem':
      return [{
        type: 'put',
        key: typeKeyToSerializeKey.storageItem({
          hash: change.value.hash,
          key: change.value.key
        }),
        value: change.value.serializeWire()
      }];

    case 'validator':
      return [{
        type: 'put',
        key: typeKeyToSerializeKey.validator({
          publicKey: change.value.publicKey
        }),
        value: change.value.serializeWire()
      }];

    case 'invocationData':
      return [{
        type: 'put',
        key: typeKeyToSerializeKey.invocationData(change.value),
        value: change.value.serializeWire()
      }];

    default:
      // eslint-disable-next-line
      change.type;
      throw new UnknownTypeError();
  }
};

var convertDeleteChange = function convertDeleteChange(change) {
  switch (change.type) {
    case 'account':
      return {
        type: 'del',
        key: typeKeyToSerializeKey.account(change.key)
      };

    case 'contract':
      return {
        type: 'del',
        key: typeKeyToSerializeKey.contract(change.key)
      };

    case 'storageItem':
      return {
        type: 'del',
        key: typeKeyToSerializeKey.storageItem(change.key)
      };

    default:
      // eslint-disable-next-line
      change.type;
      throw new UnknownTypeError();
  }
};

var convertChange = (function (change) {
  if (change.type === 'add') {
    return convertAddChange(change.change);
  } else if (change.type === 'delete') {
    return [convertDeleteChange(change.change)];
  } // eslint-disable-next-line


  change.type; // TODO: Make better

  throw new Error('Bad change type');
});

var streamToObservable = (function (getStream) {
  return Observable.Observable.create(function (observer) {
    var stream = getStream();
    var done = false;

    var cleanup = function cleanup() {
      if (!done) {
        done = true; // eslint-disable-next-line

        stream.removeListener('end', onEnd); // eslint-disable-next-line

        stream.removeListener('error', onError); // eslint-disable-next-line

        stream.removeListener('data', onData);
      }
    };

    var onEnd = function onEnd() {
      cleanup();
      observer.complete();
    };

    var onError = function onError(error) {
      cleanup();
      observer.error(error);
    };

    var onData = function onData(data) {
      return observer.next(data);
    };

    stream.once('error', onError);
    stream.once('end', onEnd);
    stream.on('data', onData);
    return function () {
      return cleanup();
    };
  });
});

function createTryGet(_ref) {
  var get = _ref.get;
  return (
    /*#__PURE__*/
    function () {
      var _ref2 = _asyncToGenerator(
      /*#__PURE__*/
      regeneratorRuntime.mark(function _callee(key) {
        var result;
        return regeneratorRuntime.wrap(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                _context.prev = 0;
                _context.next = 3;
                return get(key);

              case 3:
                result = _context.sent;
                return _context.abrupt("return", result);

              case 7:
                _context.prev = 7;
                _context.t0 = _context["catch"](0);

                if (!(_context.t0.notFound || _context.t0.code === 'KEY_NOT_FOUND')) {
                  _context.next = 11;
                  break;
                }

                return _context.abrupt("return", null);

              case 11:
                throw _context.t0;

              case 12:
              case "end":
                return _context.stop();
            }
          }
        }, _callee, this, [[0, 7]]);
      }));

      return function (_x) {
        return _ref2.apply(this, arguments);
      };
    }()
  );
}
function createTryGetLatest(_ref3) {
  var db = _ref3.db,
      latestKey = _ref3.latestKey,
      deserializeResult = _ref3.deserializeResult,
      get = _ref3.get;
  return (
    /*#__PURE__*/
    _asyncToGenerator(
    /*#__PURE__*/
    regeneratorRuntime.mark(function _callee2() {
      var result, _value;

      return regeneratorRuntime.wrap(function _callee2$(_context2) {
        while (1) {
          switch (_context2.prev = _context2.next) {
            case 0:
              _context2.prev = 0;
              _context2.next = 3;
              return db.get(latestKey);

            case 3:
              result = _context2.sent;
              _context2.next = 6;
              return get(deserializeResult(result));

            case 6:
              _value = _context2.sent;
              return _context2.abrupt("return", _value);

            case 10:
              _context2.prev = 10;
              _context2.t0 = _context2["catch"](0);

              if (!(_context2.t0.notFound || _context2.t0.code === 'KEY_NOT_FOUND')) {
                _context2.next = 14;
                break;
              }

              return _context2.abrupt("return", null);

            case 14:
              throw _context2.t0;

            case 15:
            case "end":
              return _context2.stop();
          }
        }
      }, _callee2, this, [[0, 10]]);
    }))
  );
}
function createReadStorage(_ref5) {
  var db = _ref5.db,
      serializeKey = _ref5.serializeKey,
      serializeKeyString = _ref5.serializeKeyString,
      deserializeValue = _ref5.deserializeValue;

  var get =
  /*#__PURE__*/
  function () {
    var _ref6 = _asyncToGenerator(
    /*#__PURE__*/
    regeneratorRuntime.mark(function _callee3(key) {
      var result;
      return regeneratorRuntime.wrap(function _callee3$(_context3) {
        while (1) {
          switch (_context3.prev = _context3.next) {
            case 0:
              _context3.prev = 0;
              _context3.next = 3;
              return db.get(serializeKey(key));

            case 3:
              result = _context3.sent;
              return _context3.abrupt("return", deserializeValue(result));

            case 7:
              _context3.prev = 7;
              _context3.t0 = _context3["catch"](0);

              if (!(_context3.t0.notFound || _context3.t0.code === 'KEY_NOT_FOUND')) {
                _context3.next = 11;
                break;
              }

              throw new KeyNotFoundError(serializeKeyString(key));

            case 11:
              throw _context3.t0;

            case 12:
            case "end":
              return _context3.stop();
          }
        }
      }, _callee3, this, [[0, 7]]);
    }));

    return function get(_x2) {
      return _ref6.apply(this, arguments);
    };
  }();

  return {
    get: get,
    tryGet: createTryGet({
      get: get
    })
  };
}
function createAll(_ref7) {
  var db = _ref7.db,
      minKey = _ref7.minKey,
      maxKey = _ref7.maxKey,
      deserializeValue = _ref7.deserializeValue;
  return streamToObservable(function () {
    return db.createValueStream({
      gte: minKey,
      lte: maxKey
    });
  }).pipe(operators.map(function (value) {
    return deserializeValue(value);
  }));
}
function createReadAllStorage(_ref8) {
  var db = _ref8.db,
      serializeKey = _ref8.serializeKey,
      serializeKeyString = _ref8.serializeKeyString,
      minKey = _ref8.minKey,
      maxKey = _ref8.maxKey,
      deserializeValue = _ref8.deserializeValue;
  var readStorage = createReadStorage({
    db: db,
    serializeKey: serializeKey,
    serializeKeyString: serializeKeyString,
    deserializeValue: deserializeValue
  });
  return {
    get: readStorage.get,
    tryGet: readStorage.tryGet,
    all: createAll({
      db: db,
      minKey: minKey,
      maxKey: maxKey,
      deserializeValue: deserializeValue
    })
  };
}
function createReadGetAllStorage(_ref9) {
  var db = _ref9.db,
      serializeKey = _ref9.serializeKey,
      serializeKeyString = _ref9.serializeKeyString,
      getMinKey = _ref9.getMinKey,
      getMaxKey = _ref9.getMaxKey,
      deserializeValue = _ref9.deserializeValue;
  var readStorage = createReadStorage({
    db: db,
    serializeKey: serializeKey,
    serializeKeyString: serializeKeyString,
    deserializeValue: deserializeValue
  });
  return {
    get: readStorage.get,
    tryGet: readStorage.tryGet,
    getAll: function getAll(keys) {
      return createAll({
        db: db,
        minKey: getMinKey(keys),
        maxKey: getMaxKey(keys),
        deserializeValue: deserializeValue
      });
    }
  };
}

var levelUpStorage$1 = (function (_ref) {
  var db = _ref.db,
      context = _ref.context;

  var getHash =
  /*#__PURE__*/
  function () {
    var _ref3 = _asyncToGenerator(
    /*#__PURE__*/
    regeneratorRuntime.mark(function _callee(_ref2) {
      var hashOrIndex, hash, result;
      return regeneratorRuntime.wrap(function _callee$(_context) {
        while (1) {
          switch (_context.prev = _context.next) {
            case 0:
              hashOrIndex = _ref2.hashOrIndex;
              hash = hashOrIndex;

              if (!(typeof hash === 'number')) {
                _context.next = 15;
                break;
              }

              _context.prev = 3;
              _context.next = 6;
              return db.get(serializeHeaderIndexHashKey(hash));

            case 6:
              result = _context.sent;
              hash = deserializeHeaderHash(result);
              _context.next = 15;
              break;

            case 10:
              _context.prev = 10;
              _context.t0 = _context["catch"](3);

              if (!_context.t0.notFound) {
                _context.next = 14;
                break;
              }

              throw new KeyNotFoundError("".concat(hash));

            case 14:
              throw _context.t0;

            case 15:
              return _context.abrupt("return", hash);

            case 16:
            case "end":
              return _context.stop();
          }
        }
      }, _callee, this, [[3, 10]]);
    }));

    return function getHash(_x) {
      return _ref3.apply(this, arguments);
    };
  }();

  var headerBase = createReadStorage({
    db: db,
    serializeKey: typeKeyToSerializeKey.header,
    serializeKeyString: typeKeyToSerializeKeyString.header,
    deserializeValue: function deserializeValue(buffer) {
      return clientCore.Header.deserializeWire({
        context: context,
        buffer: buffer
      });
    }
  });

  var getHeader =
  /*#__PURE__*/
  function () {
    var _ref5 = _asyncToGenerator(
    /*#__PURE__*/
    regeneratorRuntime.mark(function _callee2(_ref4) {
      var hashOrIndex, hash;
      return regeneratorRuntime.wrap(function _callee2$(_context2) {
        while (1) {
          switch (_context2.prev = _context2.next) {
            case 0:
              hashOrIndex = _ref4.hashOrIndex;
              _context2.next = 3;
              return getHash({
                hashOrIndex: hashOrIndex
              });

            case 3:
              hash = _context2.sent;
              return _context2.abrupt("return", headerBase.get({
                hash: hash
              }));

            case 5:
            case "end":
              return _context2.stop();
          }
        }
      }, _callee2, this);
    }));

    return function getHeader(_x2) {
      return _ref5.apply(this, arguments);
    };
  }();

  var header = {
    get: getHeader,
    tryGet: createTryGet({
      get: getHeader
    }),
    tryGetLatest: createTryGetLatest({
      db: db,
      latestKey: maxHeaderHashKey,
      deserializeResult: function deserializeResult(result) {
        return {
          hash: deserializeHeaderHash(result)
        };
      },
      get: headerBase.get
    })
  };
  var blockBase = createReadStorage({
    db: db,
    serializeKey: typeKeyToSerializeKey.block,
    serializeKeyString: typeKeyToSerializeKeyString.block,
    deserializeValue: function deserializeValue(buffer) {
      return clientCore.Block.deserializeWire({
        context: context,
        buffer: buffer
      });
    }
  });

  var getBlock =
  /*#__PURE__*/
  function () {
    var _ref7 = _asyncToGenerator(
    /*#__PURE__*/
    regeneratorRuntime.mark(function _callee3(_ref6) {
      var hashOrIndex, hash;
      return regeneratorRuntime.wrap(function _callee3$(_context3) {
        while (1) {
          switch (_context3.prev = _context3.next) {
            case 0:
              hashOrIndex = _ref6.hashOrIndex;
              _context3.next = 3;
              return getHash({
                hashOrIndex: hashOrIndex
              });

            case 3:
              hash = _context3.sent;
              return _context3.abrupt("return", blockBase.get({
                hash: hash
              }));

            case 5:
            case "end":
              return _context3.stop();
          }
        }
      }, _callee3, this);
    }));

    return function getBlock(_x3) {
      return _ref7.apply(this, arguments);
    };
  }();

  var block = {
    get: getBlock,
    tryGet: createTryGet({
      get: getBlock
    }),
    tryGetLatest: createTryGetLatest({
      db: db,
      latestKey: maxBlockHashKey,
      deserializeResult: function deserializeResult(result) {
        return {
          hash: deserializeBlockHash(result)
        };
      },
      get: blockBase.get
    })
  };
  var transaction = createReadStorage({
    db: db,
    serializeKey: typeKeyToSerializeKey.transaction,
    serializeKeyString: typeKeyToSerializeKeyString.transaction,
    deserializeValue: function deserializeValue(buffer) {
      return clientCore.deserializeTransactionWire({
        context: context,
        buffer: buffer
      });
    }
  });
  var output = createReadStorage({
    db: db,
    serializeKey: typeKeyToSerializeKey.output,
    serializeKeyString: typeKeyToSerializeKeyString.output,
    deserializeValue: function deserializeValue(buffer) {
      return clientCore.Output.deserializeWire({
        context: context,
        buffer: buffer
      });
    }
  });
  return {
    header: header,
    block: block,
    blockSystemFee: createReadStorage({
      db: db,
      serializeKey: typeKeyToSerializeKey.blockSystemFee,
      serializeKeyString: typeKeyToSerializeKeyString.blockSystemFee,
      deserializeValue: function deserializeValue(buffer) {
        return nodeCore.BlockSystemFee.deserializeWire({
          context: context,
          buffer: buffer
        });
      }
    }),
    account: createReadAllStorage({
      db: db,
      serializeKey: typeKeyToSerializeKey.account,
      serializeKeyString: typeKeyToSerializeKeyString.account,
      minKey: accountMinKey,
      maxKey: accountMaxKey,
      deserializeValue: function deserializeValue(buffer) {
        return clientCore.Account.deserializeWire({
          context: context,
          buffer: buffer
        });
      }
    }),
    action: createReadGetAllStorage({
      db: db,
      serializeKey: typeKeyToSerializeKey.action,
      serializeKeyString: typeKeyToSerializeKeyString.action,
      getMinKey: getActionKeyMin,
      getMaxKey: getActionKeyMax,
      deserializeValue: function deserializeValue(buffer) {
        return clientCore.deserializeActionWire({
          context: context,
          buffer: buffer
        });
      }
    }),
    asset: createReadStorage({
      db: db,
      serializeKey: typeKeyToSerializeKey.asset,
      serializeKeyString: typeKeyToSerializeKeyString.asset,
      deserializeValue: function deserializeValue(buffer) {
        return clientCore.Asset.deserializeWire({
          context: context,
          buffer: buffer
        });
      }
    }),
    transaction: transaction,
    transactionSpentCoins: createReadStorage({
      db: db,
      serializeKey: typeKeyToSerializeKey.transactionSpentCoins,
      serializeKeyString: typeKeyToSerializeKeyString.transactionSpentCoins,
      deserializeValue: function deserializeValue(buffer) {
        return nodeCore.TransactionSpentCoins.deserializeWire({
          context: context,
          buffer: buffer
        });
      }
    }),
    output: output,
    contract: createReadStorage({
      db: db,
      serializeKey: typeKeyToSerializeKey.contract,
      serializeKeyString: typeKeyToSerializeKeyString.contract,
      deserializeValue: function deserializeValue(buffer) {
        return clientCore.Contract.deserializeWire({
          context: context,
          buffer: buffer
        });
      }
    }),
    storageItem: createReadGetAllStorage({
      db: db,
      serializeKey: typeKeyToSerializeKey.storageItem,
      serializeKeyString: typeKeyToSerializeKeyString.storageItem,
      getMinKey: getStorageItemKeyMin,
      getMaxKey: getStorageItemKeyMax,
      deserializeValue: function deserializeValue(buffer) {
        return clientCore.StorageItem.deserializeWire({
          context: context,
          buffer: buffer
        });
      }
    }),
    validator: createReadAllStorage({
      db: db,
      serializeKey: typeKeyToSerializeKey.validator,
      serializeKeyString: typeKeyToSerializeKeyString.validator,
      minKey: validatorMinKey,
      maxKey: validatorMaxKey,
      deserializeValue: function deserializeValue(buffer) {
        return clientCore.Validator.deserializeWire({
          context: context,
          buffer: buffer
        });
      }
    }),
    invocationData: createReadStorage({
      db: db,
      serializeKey: typeKeyToSerializeKey.invocationData,
      serializeKeyString: typeKeyToSerializeKeyString.invocationData,
      deserializeValue: function deserializeValue(buffer) {
        return clientCore.InvocationData.deserializeWire({
          context: context,
          buffer: buffer
        });
      }
    }),
    close: function () {
      var _close = _asyncToGenerator(
      /*#__PURE__*/
      regeneratorRuntime.mark(function _callee4() {
        return regeneratorRuntime.wrap(function _callee4$(_context4) {
          while (1) {
            switch (_context4.prev = _context4.next) {
              case 0:
                _context4.next = 2;
                return db.close();

              case 2:
              case "end":
                return _context4.stop();
            }
          }
        }, _callee4, this);
      }));

      return function close() {
        return _close.apply(this, arguments);
      };
    }(),
    commit: function () {
      var _commit = _asyncToGenerator(
      /*#__PURE__*/
      regeneratorRuntime.mark(function _callee5(changeSet) {
        var changesList, changes;
        return regeneratorRuntime.wrap(function _callee5$(_context5) {
          while (1) {
            switch (_context5.prev = _context5.next) {
              case 0:
                changesList = changeSet.map(function (change) {
                  return convertChange(change);
                });
                changes = changesList.reduce(function (acc, converted) {
                  acc.push.apply(acc, _toConsumableArray(converted));
                  return acc;
                }, []);
                _context5.next = 4;
                return db.batch(changes);

              case 4:
              case "end":
                return _context5.stop();
            }
          }
        }, _callee5, this);
      }));

      return function commit(_x4) {
        return _commit.apply(this, arguments);
      };
    }()
  };
});

module.exports = levelUpStorage$1;
//# sourceMappingURL=index.js.map