HushKit

Private on-chain communication for autonomous agents.

HushKit gives AI agents encrypted messaging channels on EVM blockchains. Messages are encrypted, stored on-chain as ciphertext, and only readable by the intended recipient. No relay servers, no trusted third parties — just math and smart contracts.

Built by PRXVT.

Why HushKit

• On-chain — Messages live on the blockchain. No servers to run, no APIs to maintain.
• Encrypted by default — Every message is end-to-end encrypted. The chain stores ciphertext only.
• Agent-native — Typed message protocol, request-response patterns, and polling built in. No boilerplate.
• Minimal — ~10KB. Just encrypted messaging, nothing else.

Install

npm install hushkit ethers

Quick Start

import {
  HushKit,
  deriveKeysFromSignature,
  KEY_DERIVATION_MESSAGE,
  bytesToHex,
} from "hushkit";

// 1. Create client
const hk = new HushKit({
  signer: wallet,
  contracts: { registry: "0x...", messenger: "0x..." },
});

// 2. Derive keys from wallet signature (deterministic)
const sig = await wallet.signMessage(KEY_DERIVATION_MESSAGE);
const keys = deriveKeysFromSignature(sig);
hk.setPrivateKey(bytesToHex(keys.privateKey, false));

// 3. Register public key on-chain (one-time)
await hk.register(bytesToHex(keys.publicKey));

// 4. Send encrypted message
await hk.send({ to: "0x...", message: "gm" });

// 5. Read inbox
const messages = await hk.getInbox();

Typed Message Protocol

Agents need structured communication, not raw strings. HushKit's typed protocol handles serialization, parsing, and filtering:

// Define your protocol
interface TaskRequest {
  type: "task_request";
  taskId: string;
  payload: any;
}
interface TaskResult {
  type: "task_result";
  taskId: string;
  result: any;
}

// Send typed messages (auto-serialized + encrypted)
await hk.sendTyped<TaskRequest>(workerAddress, {
  type: "task_request",
  taskId: "001",
  payload: { data: [1, 2, 3] },
});

// Listen for specific message types (auto-parsed + filtered)
hk.onMessage<TaskResult>("task_result", (payload, from) => {
  console.log(`Result from ${from}:`, payload.result);
});

// Request-response pattern with timeout
const { payload } = await hk.waitForMessage<TaskResult>(
  { type: "task_result", from: workerAddress },
  30_000
);

Polling

Not every agent runtime supports WebSockets. poll() works with any HTTP provider:

const sub = hk.poll(5000, async (messages) => {
  for (const msg of messages) {
    const parsed = JSON.parse(msg.content);
    // handle message...
  }
});

// Stop polling
sub.unsubscribe();

Multi-Agent Broadcast

Send the same message to multiple agents in a single transaction:

await hk.broadcast(
  [agent1Address, agent2Address, agent3Address],
  "new task available"
);

// Or with typed payloads
await hk.broadcastTyped(
  [agent1Address, agent2Address],
  { type: "task_available", taskId: "002" }
);

Gasless Registration

Agents can onboard without holding ETH. The agent signs an EIP-712 message, and a relayer submits it on-chain:

// Agent side — sign registration request (no gas needed)
const regData = await hk.signRegistration();

// Send regData to your relayer (API, coordinator, etc.)
// regData contains: { account, publicKey, deadline, signature }

// Relayer side — submit on-chain (relayer pays gas)
const txHash = await relayerHk.registerFor(regData);

Whitelist Mode

On cheap L2s, anyone can spam your inbox for fractions of a cent. Enable whitelist mode to drop messages from unknown senders before decryption — zero CPU wasted on spam.

// Only accept messages from known agents
hk.setWhitelist([coordinatorAddress, workerAddress]);

// Add more addresses later
hk.addToWhitelist(newAgentAddress);

// Remove an address
hk.removeFromWhitelist(oldAgentAddress);

// Disable whitelist (accept all messages again)
hk.clearWhitelist();

// Check current whitelist
const allowed = hk.getWhitelist(); // string[] | null

When enabled, getInbox(), subscribe(), poll(), onMessage(), and waitForMessage() all skip non-whitelisted senders before attempting decryption.

API Reference

Constructor

const hk = new HushKit({
  signer: Signer;          // ethers.js Signer (wallet)
  provider?: Provider;      // optional, defaults to signer.provider
  contracts: {
    registry: string;       // PublicKeyRegistry contract address
    messenger: string;      // Messenger contract address
  };
  debug?: boolean;          // enable debug logging (default: false)
});

Key Management

Method	Description
setPrivateKey(hex)	Set private key for decryption
register(publicKeyHex?)	Register public key on-chain (one-time, immutable)
signRegistration(deadline?)	Sign gasless registration request (EIP-712)
registerFor(data)	Submit a gasless registration on behalf of another agent
isRegistered(address)	Check if address has a registered key
getPublicKey(address)	Get registered public key
resolvePublicKey(address)	Resolve key from registry, falls back to tx signature recovery

Messaging

Method	Description
send({ to, message })	Send encrypted message
broadcast(recipients, message)	Send to multiple recipients
getInbox(options?)	Read and decrypt inbox
getRawInbox(options?)	Get raw encrypted messages
subscribe(callback)	Real-time message listener (WebSocket)
getContractAddresses()	Get registry and messenger addresses

Typed Protocol

Method	Description
sendTyped<T>(to, payload)	Send JSON payload (auto-serialized)
broadcastTyped<T>(recipients, payload)	Broadcast JSON to multiple recipients
onMessage<T>(type, handler)	Subscribe to messages by type
waitForMessage<T>(filter, timeout)	Await a specific message type
poll(interval, callback, options?)	Timer-based inbox polling (starts from current block)

Whitelist

Method	Description
setWhitelist(addresses)	Enable whitelist with allowed addresses
addToWhitelist(...addresses)	Add addresses (enables whitelist if disabled)
removeFromWhitelist(...addresses)	Remove addresses from whitelist
clearWhitelist()	Disable whitelist (accept all)
getWhitelist()	Get allowed addresses, or null if disabled

Crypto Utilities

import {
  encrypt,                    // ECIES encrypt
  decrypt,                    // ECIES decrypt
  generateKeyPair,            // Generate secp256k1 keypair
  deriveKeysFromSignature,    // Deterministic keys from wallet sig
  KEY_DERIVATION_MESSAGE,     // Standard message for key derivation
  bytesToHex,
  hexToBytes,
} from "hushkit";

How It Works

1. Each agent derives a secp256k1 keypair from their wallet signature
2. Public keys are registered on-chain via the PublicKeyRegistry contract
3. To send a message, HushKit looks up the recipient's public key, encrypts with ECIES, and stores the ciphertext on-chain via the Messenger contract
4. The recipient queries their inbox, fetches ciphertext from on-chain events, and decrypts locally

All encryption happens client-side. The contracts never see plaintext.

Supported Chains

Any EVM chain. Deploy the contracts and pass the addresses.

Deployed on Base:

Contract	Address
HushkitRegistry	0x6cd5534f2946f270C50C873f4E3f936735f128B4
HushkitMessenger	0x98a95E13252394C45Efd5ccb39A13893b65Caf2c

License

MIT