interface KeyStorage {
  put(keyId: string, blob: Buffer): Promise<void>;
  get(keyId: string): Promise<Buffer | null>;
  remove(keyId: string): Promise<void>;
  list(): Promise<string[]>;
}

import {
  EmbeddedAgent,
  Curve,
  InMemoryKeyStorage,
  RecoveryKind,
} from '@zafeguard/mpc-sdk';

const storage = new InMemoryKeyStorage();
const signer = new EmbeddedAgent({
  agents: [{ baseUrl: NODE_URL, apiKey: API_KEY }],
  threshold: 2,
  curve: Curve.Secp256k1,
});

const loaded = await signer.create({
  keyId: 'test-signer',
  recovery: { kind: RecoveryKind.Noop },
  passphrase: 'demo-passphrase',
});
await storage.put('test-signer', loaded.exportedBlob!);

// Later in the same process:
const blob = await storage.get('test-signer');
const restored = await signer.load({
  keyId: 'test-signer',
  blob: blob!,
  passphrase: 'demo-passphrase',
});

import {
  EmbeddedAgent,
  Curve,
  EncryptedFileStorage,
  RecoveryKind,
} from '@zafeguard/mpc-sdk';

const storage = new EncryptedFileStorage({ dir: './signer-state' });

const signer = new EmbeddedAgent({
  agents: [{ baseUrl: NODE_URL, apiKey: API_KEY }],
  threshold: 2,
  curve: Curve.Secp256k1,
});

const loaded = await signer.create({
  keyId: 'production-wallet',
  recovery: { kind: RecoveryKind.Noop },
  passphrase: 'demo-passphrase',
});
await storage.put('production-wallet', loaded.exportedBlob!);

// Later — fresh process, same directory + same passphrase:
const blob = await storage.get('production-wallet');
const restored = await signer.load({
  keyId: 'production-wallet',
  blob: blob!,
  passphrase: 'demo-passphrase',
});

import {
  EncryptedFileStorage,
  EmbeddedAgent,
  Curve,
  RecoveryKind,
} from '@zafeguard/mpc-sdk';

const storage = new EncryptedFileStorage({
  dir: './signer-state',
  passphrase: 'device-unlock-passphrase',
});

// The signer-level passphrase and the storage-level passphrase are
// independent. You can rotate the storage passphrase by reading +
// re-writing every entry; rotating the signer passphrase requires
// LoadedKeyShare.recover().
const signer = new EmbeddedAgent({
  agents: [{ baseUrl: NODE_URL, apiKey: API_KEY }],
  threshold: 2,
  curve: Curve.Secp256k1,
});

const loaded = await signer.create({
  keyId: 'wallet-eth',
  recovery: { kind: RecoveryKind.Noop },
  passphrase: 'demo-passphrase',
});
await storage.put('wallet-eth', loaded.exportedBlob!);

// Each file on disk is the storage-encrypted form of the
// signer-encrypted blob. Open requires BOTH the storage passphrase
// (to get the export blob out of the file) AND the signer passphrase
// (to decrypt the export blob into a LoadedKeyShare).
const blob = await storage.get('wallet-eth');
const restored = await signer.load({
  keyId: 'wallet-eth',
  blob: blob!,
  passphrase: 'demo-passphrase',
});

const storage = new EncryptedFileStorage({
  dir: './signer-state',
  passphrase: 'device-unlock-passphrase',
  scryptN: 8192,                       // cheaper scrypt for batch puts
});

import {
  HardwareWrappedStorage,
  InMemoryKeyStorage,
  EmbeddedAgent,
  Curve,
  RecoveryKind,
} from '@zafeguard/mpc-sdk';

const storage = new HardwareWrappedStorage({
  sealer: mySecureEnclaveSealer,       // implements OpaqueSealer — see below
  backend: new InMemoryKeyStorage(),
  additionalAad: Buffer.from('licenseFingerprint:abc...', 'utf-8'),
});

const signer = new EmbeddedAgent({
  agents: [{ baseUrl: NODE_URL, apiKey: API_KEY }],
  threshold: 2,
  curve: Curve.Secp256k1,
});

const loaded = await signer.create({
  keyId: 'mobile-wallet',
  recovery: { kind: RecoveryKind.Noop },
  passphrase: 'demo-passphrase',
});
await storage.put('mobile-wallet', loaded.exportedBlob!);

export interface OpaqueSealer {
  /**
   * Identifier for the underlying key material — surfaced in audit logs
   * and used by the integrator's UI to ask "which Secure Enclave key
   * did this share get sealed against?". Opaque to the SDK.
   */
  readonly id: string;

  /**
   * Seal `plaintext` under the hardware key. `aad` is optional but
   * recommended: bind a domain-separation context (license fingerprint,
   * keyId, epoch) so a sealed blob cannot be replayed against a
   * different logical key or rotation.
   */
  seal(plaintext: Uint8Array, aad?: Uint8Array): Promise<Uint8Array>;

  /**
   * Inverse of `seal`. The contract is "open with the same AAD that
   * was used at seal time" — mismatched AAD MUST fail to open.
   */
  open(ciphertext: Uint8Array, aad?: Uint8Array): Promise<Uint8Array>;
}

import {
  EmbeddedAgent,
  HardwareWrappedStorage,
  P256Plugin,
  Mpc,
  Curve,
  RecoveryKind,
  type KeyStorage,
} from '@zafeguard/mpc-sdk';
import * as SecureStore from 'expo-secure-store';
import SecureEnclave from 'react-native-secure-enclave-operations';

const SE_KEY_TAG = 'com.yourapp.mpc.share-wrap-key.v1';

// 1) Provision a Secure Enclave key once at app install. The private
//    key lives in the Enclave; only the public point is returned.
async function ensureEnclaveKey(): Promise<Uint8Array> {
  const exists = await SecureEnclave.keyExists(SE_KEY_TAG);
  if (!exists) {
    await SecureEnclave.generateKey({
      tag: SE_KEY_TAG,
      accessControl: 'biometryCurrentSet',  // Face ID / Touch ID on every use
    });
  }
  return SecureEnclave.getPublicKey(SE_KEY_TAG);
}

// 2) Implement KeyStorage backed by expo-secure-store. The blobs are
//    already SE-sealed by HardwareWrappedStorage — SecureStore adds
//    OS-level confidentiality on top of the cryptographic seal.
class ExpoSecureBlobStorage implements KeyStorage {
  async put(label: string, blob: Uint8Array): Promise<void> {
    await SecureStore.setItemAsync(label, Buffer.from(blob).toString('base64'), {
      keychainAccessible: SecureStore.WHEN_UNLOCKED_THIS_DEVICE_ONLY,
    });
  }
  async get(label: string): Promise<Uint8Array | null> {
    const v = await SecureStore.getItemAsync(label);
    return v ? Buffer.from(v, 'base64') : null;
  }
  async remove(label: string): Promise<void> {
    await SecureStore.deleteItemAsync(label);
  }
  async list(): Promise<string[]> {
    // expo-secure-store doesn't expose a list API; track labels
    // separately in app state (e.g. a plain AsyncStorage index).
    throw new Error('list() not supported by expo-secure-store; track labels yourself');
  }
}

// 3) Wire P256Plugin to the SE bridge. Mpc.init returns the license
//    fingerprint that pins the wrap to this licensee.
const license = await Mpc.init(process.env.ZAFEGUARD_LICENSE_CERT!);
const sePublicKey = await ensureEnclaveKey();

const sealer = new P256Plugin({
  publicKeyBytes: sePublicKey,            // 33-byte compressed or 65-byte SEC1
  licenseFingerprint: license.fingerprint,
  unwrap: ({ ciphertext, licenseFingerprint }) =>
    SecureEnclave.ecdhUnwrap(SE_KEY_TAG, ciphertext, licenseFingerprint),
  // ↑ This is the only line that talks to native code. The bridge does
  //   ECDH inside the Enclave (triggering Face ID), derives the AES key,
  //   decrypts under the license-bound AAD, returns plaintext bytes.
});

// 4) Compose sealer + storage backend. HardwareWrappedStorage is
//    transparent — `EmbeddedAgent.create/load` only sees a KeyStorage.
const storage = new HardwareWrappedStorage({
  sealer,
  backend: new ExpoSecureBlobStorage(),
  // Optional extra AAD — bind to your app + epoch so a stolen blob
  // can't be replayed after wrap-key rotation.
  additionalAad: Buffer.from('app:com.yourapp/epoch:2026.1', 'utf-8'),
});

const signer = new EmbeddedAgent({
  agents: [{ baseUrl: 'https://node-1.example', apiKey: '...' }],
  threshold: 2,
  curve: Curve.Secp256k1,
});
const loaded = await signer.create({
  keyId: 'mobile-wallet',
  recovery: { kind: RecoveryKind.Noop },
  passphrase: 'demo-passphrase',
});

// On every put, iOS prompts for Face ID / Touch ID, the Enclave
// wraps the share's blob, expo-secure-store persists ciphertext.
await storage.put('mobile-wallet', loaded.exportedBlob!);

export interface OpaqueSealer {
  readonly id: string;
  seal(plaintext: Uint8Array, aad?: Uint8Array): Promise<Uint8Array>;
  open(ciphertext: Uint8Array, aad?: Uint8Array): Promise<Uint8Array>;
}

export interface KeyStorage {
  put(label: string, blob: Uint8Array): Promise<void>;
  get(label: string): Promise<Uint8Array | null>;
  remove(label: string): Promise<void>;
  list(): Promise<string[]>;
}