;(async function(){
  const SDK = await import("hyper-sdk");
  const createSwarm = (await import('hyper-nostr')).default;
  const { generatePrivateKey, getPublicKey, getEventHash, signEvent } = require('nostr-tools');
  const goodbye = require('graceful-goodbye');
  

  const yourStorageFolder = './missed-events';
  
  const sdk = await SDK.create({
    storage: yourStorageFolder,
    autoJoin: true
  });
  goodbye(_ => sdk.close());
  
  const bob = await createSwarm(sdk, 'missed-events'); // <--- error is here 
})();

;(async function(){
  const SDK = await import("hyper-sdk");
  const createSwarm = (await import('hyper-nostr')).default;
  const { generatePrivateKey, getPublicKey, getEventHash, signEvent } = require('nostr-tools');
  const goodbye = require('graceful-goodbye');

  const yourStorageFolder = './dictionary';
  
  const sdk = await SDK.create({
      storage: yourStorageFolder,
      autoJoin: true
  });
  goodbye(_ => sdk.close());
  
  const dictionary = await createSwarm(sdk, 'dictionary');
  const dictionary.priv = generatePrivateKey();
  const dictionary.pub = getPublicKey(dictionary.priv);

  dictionary.sendEvent('REQ', 'ac', {}); // get the shard with only words that start with 'ac'

  await dictionary.update();

  let ev = {
    kind: 1000, // normal (see nip 1)
    created_at: (+new Date() / 1000),
    pubkey: dictionary.pub, 
    word: 'acid',
    definition: 'An acid is a molecule or ion capable of either donating a proton, known as a Brønsted–Lowry acid, or forming a covalent bond with an electron pair, known as a Lewis acid. The first category of acids are the proton donors, or Brønsted–Lowry acids.',
    tags: []
  };

  ev.id = getEventHash(ev);
  ev.sign = signEvent(ev, dictionary.priv);

  dictionary.sendEvent('EVENT', ev); 
  await dictionary.update();

  dictionary.sendEvent('REQ', 'mo', {});  // get the shard with only words that start with 'mo'

  const result = await dictionary.queryEvents({word: 'moose'});

  console.log(result);

  /* // has more than one result
  [
    {
      kind: 1000, // normal (see nip 1)
      created_at: 1234567890000,
      publicKey: 'tvf76dru6r76r7f', 
      word: 'moose',
      definition: 'The moose or elk is the only species in the genus Alces. The moose is the tallest and second-largest land mammal in North America, only falling short of the American buffalo in terms of mass. It is the largest and heaviest extant species of deer.',
      tags: []
    },
    {
      kind: 1000, // normal (see nip 1)
      created_at: 1234567890000,
      publicKey: '675r7vr75eww',
      word: 'moose',
      definition: '(Alces alces), largest member of the deer family Cervidae (order Artiodactyla). Moose are striking in appearance because of their towering size, black colour, long legs, pendulous muzzle, and dangling hairy dewlap (called a bell) and the immense, wide, flat antlers of old bulls.',
      tags: []
    }
  ]
  */
  
  dictionary.sendEvent('CLOSE', 'mo'); // we don't need 'mo' shard at the moment on our computer

})();

const me = await createSwarm(sdk, 'topic');

me.sendEvent('REQ', 'news', {});

# or with filters

me.sendEvent('REQ', 'news', {
  id: '<32-bytes lowercase hex-encoded sha256 of the serialized event data>', // see nostr-tools module
  pubkey: '<32-bytes lowercase hex-encoded public key of the event creator>', // see nostr-tools module
  created_at: '<unix timestamp in seconds>',
  kind: '<integer between 0 and 65535>',
  tags: [
    ['<arbitrary string>...'],
    ...
  ],
  content: '<arbitrary string>',
  sig: '<64-bytes lowercase hex of the signature of the sha256 hash of the serialized event data, which is the same as the "id" field>' // see nostr-tools module
});

const me = await createSwarm(sdk, 'topic');

me.sendEvent('CLOSE', 'news');

;(async function(){
  const SDK = await import("hyper-sdk");
  const createSwarm = (await import('hyper-nostr')).default;
  const { generatePrivateKey, getPublicKey, getEventHash, signEvent } = require('nostr-tools');
  const goodbye = require('graceful-goodbye');

  const yourStorageFolder = './test';
  
  const sdk = await SDK.create({
      storage: yourStorageFolder,
      autoJoin: true
  });
  goodbye(_ => sdk.close());
  
  const me = await createSwarm(sdk, 'test');

  await me.update();

  const userPrivK = generatePrivateKey(); // or string from previous generation
  const userPubK = getPublicKey(userPrivK);

  let event = {
    kind: 1000, // normal (see nip 1)
    content: 'hello', // can be json?
    created_at: Math.floor(+new Date() / 1000), // seconds
    pubkey: userPubK,
    tags: []
  };

  event.id = getEventHash(deleteEvent);
  event.sign = signEvent(deleteEvent, userPrivK);

  await me.sendEvent('EVENT', event);
  await me.update();

})();

;(async function(){
  const SDK = await import("hyper-sdk");
  const createSwarm = (await import('hyper-nostr')).default;
  const { generatePrivateKey, getPublicKey, getEventHash, signEvent } = require('nostr-tools');
  const goodbye = require('graceful-goodbye');

  const yourStorageFolder = './test';
  
  const sdk = await SDK.create({
      storage: yourStorageFolder,
      autoJoin: true
  });
  goodbye(_ => sdk.close());
  
  const me = await createSwarm(sdk, 'test');

  await me.update();

  const userPrivK = generatePrivateKey(); // or string from previous generation
  const userPubK = getPublicKey(userPrivK);

  let deleteEvent = await me.queryEvents({id: 'xyz'});

  deleteEvent = {
    kind: 5, // this means delete (see nip 9)
    content: '',
    created_at: Math.floor(+new Date() / 1000), // seconds
    pubkey: userPubK,
    tags: [
      ['e', deleteEvent.id]
    ]
  };

  deleteEvent.id = getEventHash(deleteEvent);
  deleteEvent.sign = signEvent(deleteEvent, userPrivK);

  await me.sendEvent('EVENT', deleteEvent);
  await me.update();

})();

const me = await createSwarm(sdk, 'test');
await me.update();

;(async function(){
  const SDK = await import("hyper-sdk");
  const createSwarm = await import('hyper-nostr');
  const { generatePrivateKey, getPublicKey, getEventHash, signEvent } = require('nostr-tools');
  const goodbye = require('graceful-goodbye');

  const yourStorageFolder1 = './missed-events1';
  const yourStorageFolder2 = './missed-events1';
  
  const sdk1 = await SDK.create({
    storage: yourStorageFolder1,
    autoJoin: true
  });
  
  const sdk2 = await SDK.create({
    storage: yourStorageFolder2,
    autoJoin: true
  });
  
  goodbye(() => {
    sdk1.close();
    sdk2.close();
  });
  
  const bob = await createSwarm(sdk1, 'missed-events'); // an online user bob, who knows that alice is offline
  bob.priv = generatePrivateKey();
  bob.pub = getPublicKey(bob.priv);
  
  
  let ev = {
    kind: 1000, // regular (see nip 1)
    created_at: Math.floor(+new Date() / 1000), // seconds
    pubkey: bob.pub,
    content: {
      type: 'payment',
      currency: 'usd',
      amount: '59.74043',
      for: 'art shop painting 63'
    },
    tags: [
      ['p', 'alice']
    ]
  };
  
  ev.id = getEventHash(ev);
  ev.sign = signEvent(ev, bob.priv);
  
  bob.sendEvent('EVENT', ev);

  await bob.update();

  console.log(await bob.queryEvents([{ '#p': ['alice'] }]));






  // ... later alice comes back online ...

  const alice = await createSwarm(sdk2, 'missed-events');
  alice.priv = generatePrivateKey();
  alice.pub = getPublicKey(alice.priv);

  await alice.update();

  let result = await alice.queryEvents([{ '#p': ['alice'] }]);
  
  // alice sees this:
  /*
  [ // a list
    {
      id: '57e75e7de7e75e65yghfh546',
      kind: 1000, // regular (see nip 1)
      created_at: 1239455461100,
      pubkey: 'd75d7dutdy5ehtbgeguyjgfu'
      content: {
        type: 'payment',
        currency: 'usd',
        amount: '59.74043',
        for: 'art shop painting 63'
      },
      tags: [
        ['p', 'alice']
      ]
    }
  ]
  */

  ev = {
    kind: 5, // delete (see nip 9)
    content: '',
    created_at: Math.floor(+new Date() / 1000), // seconds
    pubkey: alice.pub,
    tags: [
      ['e', result[0].id]
    ]
  };
  
  ev.id = getEventHash(ev);
  ev.sign = signEvent(ev, alice.priv);
  
  alice.sendEvent('EVENT', ev);
  
  await alice.update();

})();

const prefix = 'hyper-nostr-'

export default async function createSwarm (sdk, _topic, opts) {
  if (!opts) opts = {}; 
  const topic = (opts.prefix) ? opts.prefix + _topic : prefix + _topic
  ...

createSwarm(sdk, topic); // normal hyper-nostr- known to any users on nostr
// or
createSwarm(sdk, topic, { prefix: '' }); // totally isolated to the current app
// or
createSwarm(sdk, topic, { prefix: 'myapp-' }); // isolated to a network namespace on any apps who know the namespace
// or
createSwarm(sdk, topic, { prefix: `nike-${ authKey }-` }); // protected by the nike network apps
// or
createSwarm(sdk, topic, { prefix: `${aes.decode('71a936f2a1e6bbad750933436343519983d34eecfef00d7a97b32b1103dbb0db')}-` }); // known by none / hard-coded

;(async function(){
  const SDK = await import("hyper-sdk");
  const createSwarm = (await import('hyper-nostr')).default;
  const { generatePrivateKey, getPublicKey, getEventHash, signEvent } = require('nostr-tools');
  const goodbye = require('graceful-goodbye');

  const yourStorageFolder = './all-users';
  
  const sdk = await SDK.create({
      storage: yourStorageFolder,
      autoJoin: true
  });
  goodbye(_ => sdk.close());
  
  const bob = await createSwarm(sdk, 'all-users');
  const bob.priv = generatePrivateKey();
  const bob.pub = getPublicKey(bob.priv);

  let ev = {
    kind: 30000,  // keep only latest (see nip 1)
    created_at: (+new Date() / 1000),
    pubkey: bob.pub,
    content: 'bob',
    tags: []
  };
  ev.id = getEventHash(ev);
  ev.sign = signEvent(ev, bob.priv);

  bob.sendEvent('EVENT', ev); // bob joins the shared list of users

  await bob.update();

  // bob's sponsor is going to be alice! Let's check the db to see if alice is really a user ...
  
  let sponsor = await bob.queryEvent({ content: 'alice' });

  if (sponsor) {
    console.log(sponsor); // yay!
    /*
    {
      kind: 30000, // keep only latest (see nip 1)
      created_at: 1234567890000,
      pubkey: 'r6d0ds6wtyt4y4gtydrt',
      content: 'alice',
      tags: []
    }
    */
  }
  else {
    console.log('No alice here! Please choose a different sponsor.');
  }

})();