async function createClient(config?: ClientConfig): Promise<HyperAuthClient>

static async create(
  plugin: WasmPlugin,
  config?: ClientConfig,
  core?: VaultWorkerCore,
): Promise<HyperAuthClient>

interface ClientConfig {
  wasmUrl?: string;
  wasmBytes?: Uint8Array;
  logger?: Pick<Console, 'log' | 'error' | 'warn' | 'info' | 'debug'>;
  debug?: boolean;
  autoLockTimeout?: number;
  contracts?: ContractsConfig;
}

interface ContractsConfig {
  chainId: number;
  entryPoint: string;
  didRegistry: string;
  accountHelper: string;
  sessionSBT: string;
  hyperAuthFactory: string;
}

async generate(credential: string, options?: GenerateOptions): Promise<GenerateResult>

interface GenerateOptions {
  identifier?: string;
  channel?: string;
  verification_proof?: string;
  encryptionKey?: string;
}

interface GenerateResult {
  success: boolean;
  did: string;
  address: string;
  shares: EncryptedShares & { enclave_id: string };
  parsed_credential: Record<string, unknown>;
}

async ping(message?: string): Promise<PingResult>

interface PingResult {
  success: boolean;
  message: string;
  echo?: string;
}

async sign(encryptedShares: EncryptedShares, data: number[]): Promise<SignResult>

interface SignResult {
  signature: number[];
}

async deriveAddress(publicKeyHex: string, chain: string): Promise<DeriveAddressResult>

interface DeriveAddressResult {
  address: string;
  chain: string;
}

async mintUcan(encryptedShares: EncryptedShares, ucanPayload: Record<string, unknown>): Promise<MintUcanResult>

interface MintUcanResult {
  signed_dag_cbor: number[];
}

async parseWebAuthn(credential: Record<string, unknown>): Promise<ParseWebAuthnResult>

interface ParseWebAuthnResult {
  parsed: Record<string, unknown>;
}

async load(source: Uint8Array | number[]): Promise<LoadOutput>

async lock(): Promise<LockOutput>

async unlock(source: Uint8Array | number[], encryptionKey?: string): Promise<UnlockOutput>

async status(): Promise<StatusOutput>

async isLocked(): Promise<boolean>

async query(did?: string): Promise<QueryOutput>

interface QueryOutput {
  did: string;
  controller: string;
  verification_methods: VerificationMethod[];
  accounts: Account[];
  credentials: Credential[];
}

interface Account {
  address: string;
  chain_id: string;
  coin_type: number;
  account_index: number;
  address_index: number;
  label: string;
  is_default: boolean;
}

async exportVault(options: VaultExportOptions): Promise<Uint8Array>

interface VaultExportOptions {
  password: string;
}

async importVault(options: VaultImportOptions): Promise<VaultImportOutput>

interface VaultImportOptions {
  data: Uint8Array | number[];
  password: string;
}

async createRegistration(input: CreateRegistrationInput): Promise<RegistrationResult>

interface CreateRegistrationInput {
  sender: string;
  alias: string;
  cid?: string;
  did?: string;
}

interface RegistrationResult {
  user_op: UserOp | null;
  did_hash: string;
  alias_hash: string;
  metadata_cid: string;
  call_data: string;
  entry_point: string;
  registry_addr: string;
}

async signUserOp(userOp: UserOp, token?: string): Promise<SignUserOpResult>

interface SignUserOpResult {
  signature: string;
  user_op_hash: string;
  enclave_id: string;
  public_key: string;
}

async execute<T = unknown>(
  resource: Resource,
  action: string,
  options?: { subject?: string; token?: string },
): Promise<ExecOutput<T>>

type Resource =
  | 'accounts'
  | 'credentials'
  | 'sessions'
  | 'grants'
  | 'enclaves'
  | 'delegations'
  | 'ucans'
  | 'verification_methods'
  | 'services'
  | 'service_configs'
  | 'tokens'
  | 'invocations'
  | 'sync'
  | 'oidc'

interface ExecOutput<T = unknown> {
  success: boolean;
  result?: T;
  error?: string;
}

async submitPayment(params: PaymentParams): Promise<PaymentResult>

interface PaymentParams {
  to: string;
  amount: string;
  token: string;
  chainId: number;
  ucan?: string;
  label?: string;
}

interface PaymentResult {
  txHash: string;
  userOpHash: string;
  chain: number;
  token: string;
  explorerUrl: string;
}

async registerPaymentHandler(options?: PaymentHandlerOptions): Promise<PaymentHandlerRegistration>

interface PaymentHandlerOptions {
  swUrl?: string;
  scope?: string;
  methodUrl?: string;
}

interface PaymentHandlerRegistration {
  success: boolean;
  scope: string;
  error?: string;
}

async function computeAliasHash(alias: string, keccak256?: Keccak256Fn): Promise<`0x${string}`>

type Keccak256Fn = (value: Uint8Array | `0x${string}`) => `0x${string}`

async function lookupAlias(aliasHash: string, indexerUrl?: string): Promise<IndexerAlias>

interface IndexerAlias {
  found: boolean;
  alias_hash?: string;
  did_hash?: string;
  active?: boolean;
  controller?: string;
}

async function lookupDid(didHash: string, indexerUrl?: string): Promise<IndexerDid>

interface IndexerDid {
  found: boolean;
  did_hash?: string;
  controller?: string;
  metadata_cid?: string;
  active?: boolean;
  block_number?: string;
  tx_hash?: string;
}

async function lookupAccount(address: string, indexerUrl?: string): Promise<IndexerAccount>

interface IndexerAccount {
  found: boolean;
  account_address?: string;
  owner_address?: string;
  block_number?: string;
  tx_hash?: string;
}

async function fetchStats(indexerUrl?: string): Promise<IndexerStats>

interface IndexerStats {
  total_dids: number;
  active_dids: number;
  total_aliases: number;
  total_accounts: number;
  last_block_number: number;
}

async function fetchHealth(indexerUrl?: string): Promise<IndexerHealth>

interface IndexerHealth {
  ok: boolean;
  chain: number;
}

async function createPasskey(
  handle: string,
  capabilities?: DeviceCapabilities,
  options?: CreatePasskeyOptions,
): Promise<CreatePasskeyResult>

interface CreatePasskeyOptions {
  rpName?: string;
  rpId?: string;
  timeout?: number;
  excludeCredentials?: { id: BufferSource; type: 'public-key'; transports?: AuthenticatorTransport[] }[];
}

interface CreatePasskeyResult {
  credential: string;
  credentialId: string;
}

async function authenticatePasskey(rpId?: string): Promise<string>

interface DeviceCapabilities {
  webAuthnSupported: boolean;
  platformAuthAvailable: boolean;
  conditionalMediationAvailable: boolean;
}

async syncInit(label?: string, expiresIn?: number): Promise<SyncInitResult>

async syncRespond(sessionId: string, remotePublicKey: string): Promise<SyncRespondResult>

async syncComplete(sessionId: string, remotePublicKey?: string): Promise<SyncCompleteResult>

async delegate(options: DelegationOptions): Promise<ExecOutput<void>>

interface DelegationOptions {
  to: string;
  command: string;
  expiration?: number;
  caveats?: Record<string, unknown>;
}

async createInvocation(options: InvocationOptions): Promise<ExecOutput<void>>

interface InvocationOptions {
  command: string;
  args?: Record<string, unknown>;
  token?: string;
}

async getBootStatus(): Promise<BootStatus>

interface BootStatus {
  enclave: boolean;
  helia: boolean;
  libp2p: boolean;
  ready: boolean;
}

async hasPersistedVault(): Promise<boolean>

async snapshotVault(): Promise<{ cid: string } | { error: string }>

async persistNow(): Promise<{ success: boolean; error?: string }>

get hasCorebridge(): boolean

setAutoLockCallback(callback: (database: number[]) => void): void

setAutoLockTimeout(ms: number): void

async reset(): Promise<void>

async close(): Promise<void>

async function sendUserOp(
  userOp: UserOp,
  entryPoint?: string,
  bundlerUrl?: string,
): Promise<string>

async function getUserOpReceipt(
  userOpHash: string,
  bundlerUrl?: string,
): Promise<UserOpReceipt | null>

interface UserOpReceipt {
  userOpHash: string;
  sender: string;
  nonce: string;
  success: boolean;
  actualGasCost: string;
  actualGasUsed: string;
  receipt: {
    transactionHash: string;
    blockNumber: string;
    status: string;
  };
}

async function waitForReceipt(
  userOpHash: string,
  options?: { timeout?: number; interval?: number; bundlerUrl?: string },
): Promise<UserOpReceipt>

async function getSupportedEntryPoints(bundlerUrl?: string): Promise<string[]>

async function estimateUserOpGas(
  userOp: UserOp,
  entryPoint?: string,
  bundlerUrl?: string,
): Promise<GasEstimate>

async function sponsorUserOp(
  userOp: UserOp,
  entryPoint?: string,
  bundlerUrl?: string,
): Promise<UserOp>

async function getSmartAccountAddress(input: GetSmartAccountAddressInput): Promise<string>

interface GetSmartAccountAddressInput {
  pubKeyX: string;
  pubKeyY: string;
  salt?: string | number | bigint;
  vaultUrl?: string;
}

async function getAccountState(input: GetAccountStateInput): Promise<AccountState>

interface GetAccountStateInput {
  account: string;
  vaultUrl?: string;
}

interface AccountState {
  nonce: string;
  did: string;
  isActive: boolean;
  pubKeyX: string;
  pubKeyY: string;
}

async function computeUserOpHash(
  userOp: UserOp,
  entryPoint: string,
  chainId: number,
): Promise<`0x${string}`>

function binaryToBytes(value: BinaryPayload): Uint8Array
function normalizeHex(hex: string): `0x${string}`
function hexToBytes(hex: string): Uint8Array
function bytesToHex(bytes: Uint8Array): `0x${string}`

type BinaryPayload = number[] | string

interface EncryptedShares {
  public_key: BinaryPayload;
  public_key_hex?: string;
  val_share: BinaryPayload;
  user_share: BinaryPayload;
  nonce: BinaryPayload;
  curve: string;
  pubkey_x?: string;
  pubkey_y?: string;
}