const pair = await SEA.pair()
SEA.pair(callback)
SEA.pair(callback, options)

{
  pub: 'signing_public_key',         // ECDSA public key (x.y format)
  priv: 'signing_private_key',       // ECDSA private key (d value)
  epub: 'encryption_public_key',     // ECDH public key (x.y format)
  epriv: 'encryption_private_key'    // ECDH private key (d value)
}

const pair = await SEA.pair();

console.log('Signing public key:', pair.pub);
console.log('Encryption public key:', pair.epub);
// Never log private keys in production!

SEA.pair((pair) => {
  console.log('Generated key pair:', pair.pub);
});

SEA.pair().then(pair => {
  console.log('Key pair ready:', pair);
}).catch(err => {
  console.error('Failed to generate pair:', err);
});

{
  pub: 'x.y',   // Public key: JWK x and y coordinates joined by '.'
  priv: 'd'     // Private key: JWK d value (scalar)
}

{
  epub: 'x.y',   // Public key: JWK x and y coordinates joined by '.'
  epriv: 'd'     // Private key: JWK d value (scalar)
}

pair.pub  // "Bl8zN..._XyZ.Qa9sT...kLmN"
pair.epub // "Cd3eF..._GhI.Jk1lM...nOpQ"

pair.priv  // "AbC1234...XyZ"
pair.epriv // "DeF5678...UvW"

const pair = await SEA.pair();
user.create(pair, 'password123456', (ack) => {
  console.log('User created with pre-generated keys');
});

// Generate once, store securely
const botPair = await SEA.pair();
secureStorage.save('bot_keys', botPair);

// Later, authenticate the bot
const keys = secureStorage.load('bot_keys');
user.auth(keys);

const pair = await SEA.pair();
const keyId = await SEA.keyid(pair.pub);
console.log('Key ID:', keyId);  // 16-character hex string

// ECDSA keys
const ecdsaKeys = await crypto.subtle.generateKey(
  { name: 'ECDSA', namedCurve: 'P-256' },
  true,
  ['sign', 'verify']
);

// ECDH keys
const ecdhKeys = await crypto.subtle.generateKey(
  { name: 'ECDH', namedCurve: 'P-256' },
  true,
  ['deriveKey']
);

{
  kty: "EC",       // Key Type: Elliptic Curve
  crv: "P-256",    // Curve: P-256
  x: "base64...",  // X coordinate
  y: "base64...",  // Y coordinate
  d: "base64...",  // Private key (only for private keys)
  ext: true,       // Extractable
  key_ops: [...]   // Key operations
}

try {
  const pair = await SEA.pair();
  console.log('Success:', pair.pub);
} catch (err) {
  console.error('Key generation failed:', err);
  // Possible issues:
  // - Web Crypto API not available (need HTTPS)
  // - Browser doesn't support P-256 curve
  // - Insufficient entropy
}

if (window.crypto && window.crypto.subtle) {
  const pair = await SEA.pair();
} else {
  console.error('Web Crypto API not available');
}

// Automatically uses polyfill if native API unavailable
const pair = await SEA.pair();

const pair = await SEA.pair();
const password = 'user_password_from_secure_input';

// Encrypt private keys before storage
const encryptedPriv = await SEA.encrypt(pair.priv, password);
const encryptedEpriv = await SEA.encrypt(pair.epriv, password);

// Store only encrypted versions
secureStorage.set('encrypted_keys', {
  pub: pair.pub,
  epub: pair.epub,
  priv: encryptedPriv,
  epriv: encryptedEpriv
});

const newPair = await SEA.pair();

// Migrate data to new keys
// Sign with old keys to prove ownership
// Transition to new keys

const pairs = await Promise.all([
  SEA.pair(),
  SEA.pair(),
  SEA.pair()
]);

console.log('Generated 3 key pairs');

const pair = await SEA.pair();

// User should backup this securely
const backup = JSON.stringify(pair);
console.log('Backup your keys (keep this VERY safe):', backup);

// Later, import from backup
const restoredPair = JSON.parse(backup);
user.auth(restoredPair);

const pair = await SEA.pair();

// Safe to share publicly
const publicInfo = {
  pub: pair.pub,
  epub: pair.epub
};

gun.get('users').get(username).put(publicInfo);

// Don't do this (generates new keys every time)
setInterval(async () => {
  const pair = await SEA.pair();  // Wasteful!
}, 1000);

// Do this instead (generate once)
const pair = await SEA.pair();
setInterval(() => {
  useExistingPair(pair);  // Efficient
}, 1000);