Stealth API

const meta = client.getMetaAddressHex();

const r = await client.resolveRecipient("alice.opq.eth");
// { metaAddressHex, source, input }

// The named entry point if you only want the meta-address:
const meta = await client.resolveOpaqueMetaAddress("alice.opqtest.eth");

// Ethereum (authoritative immediately; mirror follows after Wormhole relay):
const txHash = await client.registerOpaqueName("alice");

// Solana-only claim (PROVISIONAL until the canonical registry confirms):
const { signature, name } = await client.claimOpaqueName("bob");

// Track a claim through pending / confirmed / lost / expired:
const { state } = await client.getOpaqueNameStatus("bob.opqtest.eth");

// Close a finished claim and reclaim the provisional rent:
await client.reconcileOpaqueName("bob.opqtest.eth");

import { createPublicClient, http } from "viem";
import { mainnet } from "viem/chains";

const client = await OpaqueClient.create({
  // ...
  ens: { client: createPublicClient({ chain: mainnet, transport: http(ensRpcUrl) }) },
});

// Or a custom reader (tests, alternative resolvers):
ens: { getText: async (name, key) => myResolver.text(name, key) }

ipfs: {
  gateways: ["https://my-gateway.example"],   // optional override
  fetch: myFetch,                              // optional (e.g. a local node / Helia loader)
}

const res = await client.resolveRecipientMetaAddress("0xRecipient...");
// { recipientAddress, registered, metaAddressHex? }

const req = client.buildRegisterMetaAddressTransaction();
// { to, data, chainId, metaAddressHex }
await walletClient.sendTransaction({ to: req.to, data: req.data });

const { txHash, metaAddressHex, chain } = await client.registerMetaAddress("ethereum");

const registered = await client.isMetaAddressRegistered("solana");

const send = client.prepareStealthSend(metaAddressHex);
/*
  schemeId, stealthAddress, viewTag,
  ephemeralPublicKey, ephemeralPrivateKey,
  metadata, stealthPubKey
*/

import { parseEther } from "viem";

const result = await client.sendStealthPayment({
  chain: "ethereum",
  recipient: "0x...",        // anything resolveRecipient accepts: EOA, meta-address,
                             // Solana pubkey, ipfs:// DID, or *.eth name
  amount: parseEther("0.01"),
  announce: true,            // default
  relay: false,              // set true for cross-chain UAB
  delayAnnouncement: 60_000, // optional ms; see anonymity utilities below
  token: undefined,          // ERC-20 address / SPL mint; omit for the native asset
  gasDrop: undefined,        // optional native top-up to the stealth address with a token send
  batchId: undefined,        // Solana Wormhole nonce when relay: true
});

const starknetSend = await client.buildStarknetStealthSend({
  recipient,   // anything resolveRecipient accepts
  amount,      // STRK amount
});
// Unsigned transfer + announce calls for the connected Starknet account to broadcast.

const ghost = client.prepareGhostReceive();
// Store ghost.ephemeralPrivateKey securely

const req = client.buildAnnounceTransactionRequest(send);
// { to, data, chainId, summary }

const req = client.buildAnnounceTransactionRequestForGhost(storedEphemeralPriv);

const result = await client.sendStealthPayment({
  chain: "ethereum",
  recipient,
  amount: parseEther("0.01"),
  delayAnnouncement: 5 * 60_000,  // announce 5 minutes after the transfer
});

console.log("transfer:", result.txHash);
// result.announceTxHash is undefined; the pending announce is a promise:
const announceTx = await result.announcePromise;

const dummies = client.generateDummyAnnouncements(5);
// DummyAnnouncement[]: PrepareStealthSendResult + the throwaway metaAddressHex

for (const tx of client.buildDummyAnnouncementTransactions(3)) {
  await walletClient.sendTransaction({ to: tx.to, data: tx.data });
}

const rows = await client.fetchAnnouncementRows("ethereum", {
  fromBlock: 5_000_000n, // EVM lower bound; omit to scan from the adapter default
  toBlock: undefined,    // EVM upper bound; omit for chain tip
  solanaLimit: 1000,     // max Solana signatures (when chain is "solana")
});
// IndexerAnnouncement[]

const owned = await client.filterOwnedAnnouncements(indexerRows);
// OwnedStealthOutput[]

const inbox = await client.scan({
  chains: ["ethereum", "solana", "starknet"],
  fromBlock: 5_000_000n,
  toBlock: undefined,
  solanaLimit: 1000,
  includeCrossChain: true,
});
// UnifiedOwnedOutput[], tagged with chain, chainId, source

const totals = await client.getBalancesFromAnnouncements(rows);
// TokenBalanceSummary[]

const balances = await client.getBalancesForOutputs(inbox);
// OutputBalance[]

const { chain, tx } = await client.sweep({
  output: inbox[0],
  chain: "ethereum",
  destination: "0xFresh...",
  token: "0xUSDC...",   // omit for native; ERC-20 sweep needs native gas at the stealth address
});

const starknetSweep = client.buildStarknetSweep({
  output,        // a Starknet UnifiedOwnedOutput
  destination,   // fresh Starknet address
  amount,
});
// Broadcast with the connected Starknet account (starknet.js EthSigner).

const priv = client.getStealthSignerPrivateKey({ ephemeralPublicKey: output.ephemeralPublicKey });

const priv = client.getStealthSignerPrivateKeyFromEphemeralPrivateKey(ghost.ephemeralPrivateKey);