How to use the leveldown function in leveldown

import LevelDOWN, { Bytes } from 'leveldown';

// Can use new, or not.
const a = new LevelDOWN("/tmp/db");
const b = LevelDOWN("/tmp/db");

const db = new LevelDOWN("/tmp/db");

db.open(() => {
  db.put("key", "value", (err: Error | undefined) => { });
  db.put(Buffer.from([1]), "value", { something: true }, (err: Error | undefined) => { });

  db.get("key", (err: Error | undefined) => { });
  db.get(Buffer.from([1]), { something: true }, (err: Error | undefined, value: Bytes) => { });

  db.close((err: Error | undefined) => { });
});

db.clear((err: Error | undefined) => { });

const filePath = path.resolve(home, "pico-engine.log");
  const log = configuration.log
    ? configuration.log
    : new KrlLogger(getRotatingFileStream(filePath), "");
  const rsRegistry = new RulesetRegistry(home);
  const rsEnvironment = new RulesetEnvironment(log);

  if (configuration.modules) {
    _.each(configuration.modules, function(mod, domain) {
      rsEnvironment.modules[domain] = mod;
    });
  }

  const pf = new PicoFramework({
    leveldown: leveldown(path.resolve(home, "db")) as any,

    environment: rsEnvironment,

    rulesetLoader(rid, version) {
      return rsRegistry.load(rid, version);
    },

    onStartupRulesetInitError(pico, rid, version, config, error) {
      // TODO mark it as not installed and raise an error event
      // throw error;
      console.error("TODO raise error", pico.id, rid, version, config, error);
    },

    onFrameworkEvent(ev) {
      switch (ev.type) {
        case "startup":

public constructor(dbPath: string) {
    // Make sure that the DB directory exists.
    const directory = path.dirname(dbPath);
    mkdirp.sync(directory);

    // Open/create the blocks LevelDB database.
    this.db = levelup.default(leveldown(dbPath));
  }

constructor(filename) {
    this.db = levelup(encode(leveldown(filename), {
      valueEncoding: 'json'
    }));
  }

const node$ = defer(async () => {
    if (environment.telemetry != null) {
      monitor.serveMetrics(environment.telemetry.port);
    }

    const storage = levelUpStorage({
      db: levelup(
        customLeveldown == null
          ? leveldown(dataPath, environment.levelDownOptions)
          : customLeveldown,
      ),
      context: { messageMagic: settings.messageMagic },
    });
    const blockchain = await Blockchain.create({
      settings,
      storage,
      vm,
      monitor,
    });
    if (chainFile != null) {
      await loadChain({
        chain: { format: 'raw', path: chainFile },
        blockchain,
      });
    }

const node$ = defer(async () => {
    if (environment.telemetry !== undefined) {
      monitor.serveMetrics(environment.telemetry.port);
    }

    let levelDown = customLeveldown;
    if (levelDown === undefined) {
      const levelDownToOpen = LevelDOWN(dataPath);
      const { levelDownOptions } = environment;
      if (levelDownOptions !== undefined) {
        await new Promise((resolve, reject) => {
          levelDownToOpen.open(levelDownOptions, (err: Error | undefined) => {
            if (err) {
              reject(err);
            } else {
              resolve();
            }
          });
        });
      }
      levelDown = levelDownToOpen;
    }

    const storage = levelupStorage({

constructor (deps: Injector) {
    this.config = deps(Config)

    let backend
    if (this.config.memdownPersist || this.config.devMode) {
      backend = memdown()
    } else {
      backend = leveldown(resolvePath(this.config.codiusRoot, 'codius.db'))
    }
    this.db = levelup(encode(backend, { valueEncoding: 'json' }))
  }

constructor(path: string) {
    this.path = path;

    mkDirByPathSync(path);

    this.db = (levelup as any)(leveldown(this.path));
  }

...telemetry.jaeger,
          serviceName: 'NEO-ONE',
        });

        const propagation = await getNewPropagation();
        const stopTracing = await startTracing({
          ...telemetry.tracing,
          propagation,
          exporter,
        });

        disposable = composeDisposables(disposable, stopTracing);
      }
    }

    const levelDown = customLeveldown === undefined ? LevelDOWN(dataPath) : customLeveldown;
    disposable = composeDisposables(disposable, async () => {
      await new Promise((resolve, reject) => {
        levelDown.close((err) => {
          if (err) {
            reject(err);
          } else {
            resolve();
          }
        });
      });
    });

    const storage = levelupStorage({
      db: LevelUp(levelDown),
      context: { messageMagic: blockchainSettings.messageMagic },
    });

async setup(model?: FederatedModel) {
    this.db = await LevelUp(
        EncodingDown(LevelDown(this.dataDir), {valueEncoding: 'json'}));
    try {
      this.modelId = await this.db.get('currentModelId');
    } catch {
      const dict = await model.setup();
      await this.writeNewVars(dict.vars as tf.Tensor[]);
    }
  }