import { webcrypto } from '@substrate-system/one-webcrypto'
import {
    createFrostConfig,
    split,
    recover,
    sign
} from '@substrate-system/frost'

// 1. Generate or use existing Ed25519 keypair
const keyPair = await webcrypto.subtle.generateKey(
    { name: 'Ed25519' },
    true,  // extractable so we can split the private key
    ['sign', 'verify']
)

// 2. Split into 3 shares (require 2 to recover)
const config = createFrostConfig(2, 3)
const { groupPublicKey, keyPackages } = await split(
    keyPair.privateKey,
    config
)

// 3. Distribute shares to different locations
// - Share 1: USB drive in safe
// - Share 2: Cloud backup (encrypted)
// - Share 3: Paper backup

// 4. Later, recover using any 2 of 3 shares
const availableShares = [keyPackages[0], keyPackages[2]]
const recoveredKey = recover(availableShares, config)

// 5. Use the recovered key to sign
const message = new TextEncoder().encode('Important message')
const signature = await sign(recoveredKey, message, config)

// 6. Verify the signature with the original public key
const isValid = await webcrypto.subtle.verify(
    'Ed25519',
    keyPair.publicKey,
    signature,
    message
)

import {
  createFrostConfig,
  generateKeys,
  thresholdSign
} from '@substrate-system/frost'

// 1. Alice creates a 3-of-4 FROST setup
const config = createFrostConfig(3, 4)  // Need 3 out of 4 to sign
const { groupPublicKey, keyPackages } = generateKeys(config)

// 2. Distribute key packages to participants
const [aliceKey, bobKey, carolKey, desmondKey] = keyPackages

// 3. Later, any 3 participants can create a signature
const message = new TextEncoder().encode('Hello, FROST!')
const signature = await thresholdSign(
    [bobKey, carolKey, desmondKey],  // Any 3 participants
    message,
    groupPublicKey,
    config
)

// 4. Verify signature
const isValid = await crypto.subtle.verify(
    'Ed25519',
    new Uint8Array(groupPublicKey.point),
    signature,
    message
)

function createFrostConfig (
  minSigners: number,
  maxSigners: number
): FrostConfig

const config = createFrostConfig(2, 3)  // 2-of-3 threshold

async function split (
  privateKey: CryptoKey | Uint8Array,
  config: FrostConfig
): Promise<Signers>

const { groupPublicKey, keyPackages } = await split(keyPair.privateKey, config)

function recover (
  keyPackages: KeyPackage[],
  config: FrostConfig
): Uint8Array

const recoveredKey = recover(keyPackages.slice(0, 2), config)

async function sign (
  recoveredKey:Uint8Array,
  message:Uint8Array,
  config:FrostConfig
):Promise<Uint8Array<ArrayBuffer>>

const signature = await sign(recoveredKey, message, config)

async function thresholdSign (
  keyPackages:KeyPackage[],
  message:Uint8Array,
  groupPublicKey:GroupElement,
  config:FrostConfig
):Promise<Uint8Array>

const signature = await thresholdSign(
    [aliceKey, bobKey, carolKey],  // Participant key packages
    message,
    groupPublicKey,
    config
)

function generateKeys (config:FrostConfig):Signers

const { groupPublicKey, keyPackages } = generateKeys(config)
// groupPublicKey: The collective public key
// keyPackages: Individual key packages for each participant

function verifyKeyPackage (
  keyPackage:KeyPackage,
  config:FrostConfig
):boolean

const isValid = verifyKeyPackage(keyPackage, config)

const signer = new FrostSigner(keyPackage, config)

// Round 1: Generate nonce commitments
const round1 = signer.sign_round1()

// Round 2: Generate signature share
const round2 = signer.sign_round2(signingPackage, round1.nonces)

const coordinator = new FrostCoordinator(config)

// Create signing package
const signingPackage = coordinator.createSigningPackage(
    message,
    commitmentShares,
    participantIds
)

// Aggregate signature shares
const signature = coordinator.aggregateSignatures(
    signingPackage,
    signatureShares
)

// Verify signature
const isValid = coordinator.verify(signature, message, groupPublicKey)

// Generate keys for all participants
const { groupPublicKey, keyPackages } = generateKeys(config)

// Distribute key packages to participants securely

const round1Results = signers.map(signer => signer.sign_round1())

const signingPackage = coordinator.createSigningPackage(
    message, commitmentShares, participantIds
)

const signatureShares = signers.map((signer, i) =>
    signer.sign_round2(signingPackage, round1Results[i].nonces)
)

const signature = coordinator.aggregateSignatures(
    signingPackage,
    signatureShares.map(r => r.signatureShare)
)

import {
    createFrostConfig,
    generateKeys,
    FrostCoordinator,
    FrostSigner
} from '@substrate-system/frost'

// Alice decides she wants a 3-of-4 threshold scheme
const config = createFrostConfig(3, 4)  // Need 3 out of 4 to sign
const { groupPublicKey, keyPackages } = generateKeys(config)

// Distribute key shares to Alice, Bob, Carol, and Desmond
const [aliceKey, bobKey, carolKey, desmondKey] = keyPackages

// Alice chooses Carol and Desmond to help (any 3 would work)
const participants = [aliceKey, carolKey, desmondKey]
const signers = participants.map(pkg => new FrostSigner(pkg, config))
const coordinator = new FrostCoordinator(config)

const message = new TextEncoder().encode('Alice\'s important message')

// Round 1: Each participant generates commitments
const round1 = signers.map(s => s.sign_round1())
const commitmentShares = round1.map((r, i) => ({
    participantId: participants[i].participantId,
    commitment: r.commitment
}))

// Create the signing package
const participantIds = participants.map(p => p.participantId)
const signingPackage = await coordinator.createSigningPackage(
    message,
    commitmentShares,
    participantIds
)

// Round 2: Generate signature shares
const signatureShares = []
for (let i = 0; i < signers.length; i++) {
    const res = await signers[i].sign_round2(signingPackage, round1[i].nonces)
    signatureShares.push(res.signatureShare)
}

// Combine into final signature
const finalSignature = coordinator.aggregateSignatures(
  signingPackage,
  signatureShares
)

// Verify it worked
const valid = await coordinator.verify(finalSignature, message, groupPublicKey)
console.log('Threshold signature valid:', valid)  // Should be true