/** A Dilithium3 public key. ~1952 bytes. */
type Dilithium3PublicKey = Uint8Array;
/** A Dilithium3 secret key. ~4032 bytes. */
type Dilithium3SecretKey = Uint8Array;
/** A Dilithium3 signature. ~3309 bytes. */
type Dilithium3Signature = Uint8Array;
/** A Dilithium3 keypair. */
interface Dilithium3Keypair {
    publicKey: Dilithium3PublicKey;
    secretKey: Dilithium3SecretKey;
}
/**
 * Generate a new Dilithium3 keypair.
 *
 * @param seed - Optional 32-byte seed for deterministic generation. If omitted,
 *               a cryptographically secure random seed is used.
 */
declare function generateKeypair(seed?: Uint8Array): Dilithium3Keypair;
/**
 * Sign a message with a Dilithium3 secret key.
 *
 * In practice the caller should sign the BLAKE3 hash of a structured message
 * (transaction body, block header, vote payload) rather than raw application
 * data, but Dilithium3 can handle arbitrary-length input.
 */
declare function sign(message: Uint8Array, secretKey: Dilithium3SecretKey): Dilithium3Signature;
/**
 * Verify a Dilithium3 signature.
 *
 * @returns `true` if the signature is valid for the message under the given
 *          public key, `false` otherwise. Never throws on invalid input —
 *          returns `false` instead.
 */
declare function verify(message: Uint8Array, signature: Dilithium3Signature, publicKey: Dilithium3PublicKey): boolean;

/**
 * BLAKE3 hash. Returns 32 bytes by default. Length can be customized via
 * `dkLen` — useful for address derivation (20 bytes) or extended output.
 */
declare function blake3(data: Uint8Array, dkLen?: number): Uint8Array;
/**
 * SHA-256 hash. Returns 32 bytes. Provided for Ethereum compatibility surfaces
 * only — AsentumChain consensus and state hashing use BLAKE3.
 */
declare function sha256(data: Uint8Array): Uint8Array;

/** A 20-byte address, displayed as `0x` + 40 hex characters with checksum. */
type Address = string;
/**
 * Derive the raw 20 address bytes from a Dilithium3 public key.
 *
 * Use this when you need `Uint8Array`-typed addresses for on-chain logic
 * (state keys, transaction `to` fields, etc). For user-facing display, use
 * `addressFromPublicKey` which returns a checksummed hex string instead.
 */
declare function addressBytesFromPublicKey(publicKey: Dilithium3PublicKey): Uint8Array;
/**
 * Derive a 20-byte address from a Dilithium3 public key.
 *
 * Returns a `0x`-prefixed mixed-case hex string with the EIP-55-style
 * checksum applied.
 */
declare function addressFromPublicKey(publicKey: Dilithium3PublicKey): Address;
/**
 * Apply the EIP-55-style mixed-case checksum to a hex address.
 *
 * Accepts either `0x`-prefixed or bare hex input, any case. Always returns a
 * `0x`-prefixed, checksummed result. Throws on invalid length or non-hex
 * characters.
 */
declare function toChecksumAddress(address: string): Address;
/**
 * Check whether a string is a syntactically valid AsentumChain address.
 *
 * Verifies length, `0x` prefix, and hex charset. Does NOT verify the
 * checksum — an all-lowercase or all-uppercase address is considered valid.
 * Use `toChecksumAddress(addr) === addr` to enforce a checksummed form.
 */
declare function isValidAddress(address: string): boolean;

export { type Address, type Dilithium3Keypair, type Dilithium3PublicKey, type Dilithium3SecretKey, type Dilithium3Signature, addressBytesFromPublicKey, addressFromPublicKey, blake3, generateKeypair, isValidAddress, sha256, sign, toChecksumAddress, verify };
