@lnurlcash/kit 0.14.0-rc.0

package/CHANGELOG.md

@@ -0,0 +1,16 @@
+# Changelog
+
+## 0.14.0 - unreleased
+
+- Publish the protocol library maintained and exercised by `lnurl-wallet`
+  directly from the wallet repository.
+- Include LN address registration and recovery scanning, Part 2 public-key
+  notes, configurable transports, offline note verification, fee handling,
+  and bound mint receipts.
+- Replace the separate pre-0.14 `lnurlcash-kit` implementation with the scoped
+  `@lnurlcash/kit` package. This is an intentional package-name and API
+  boundary: callers must change their dependency and imports, then review the
+  exported surface before upgrading from `lnurlcash-kit@0.13.x`.
+
+Existing `lnurlcash-kit` installations are unaffected and do not select the
+new scoped package.

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 dni
+Copyright (c) 2026 TheCryptoDonkey
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/MIGRATION-0.14.md

@@ -0,0 +1,63 @@
+# Migrating from 0.13
+
+Version 0.14 makes the protocol layer maintained by `lnurl-wallet` the npm
+package implementation. It is published as `@lnurlcash/kit`; npm treats that
+as a different package from `lnurlcash-kit`. Upgrade only after changing the
+dependency and imports, adapting the API and testing the caller.
+
+```sh
+npm uninstall lnurlcash-kit
+npm install --save-exact @lnurlcash/kit@0.14.0
+```
+
+## Configuration
+
+The old package accepted `LnurlcashOptions` on each request and offered
+`createClient(options)`. Version 0.14 configures its process-wide hooks once:
+
+```ts
+import {
+  configureNetworkGuard,
+  configureTransport,
+  configureSecretProvider,
+  configurePubkeySecretProvider
+} from '@lnurlcash/kit'
+```
+
+Do this during application startup, before any request. The defaults use
+platform `fetch`, admit requests, generate legacy outputs using Web Crypto and
+do not generate Part 2 public-key outputs.
+
+## Removed high-level helpers
+
+The following 0.13 APIs are not part of the wallet protocol layer and are not
+exported by 0.14:
+
+- `createClient` and `LnurlcashOptions`
+- `settleNoteForValue`
+- `restoreNotes` and `restoreFromSeed`
+- seed/root derivation helpers from `cash.ts`
+- payment-request encoding and decoding from the old `request.ts`
+- UI fee strings `formatFeePercent` and `describeMintFee`
+
+Keep `lnurlcash-kit@0.13.x` pinned if a caller still depends on them. Seed
+persistence, restoration and UI wording remain wallet policy rather than
+protocol-package policy.
+
+## Errors and mutations
+
+The wallet implementation exports `ServiceError`, `AmbiguousMintError` and
+`AmbiguousMutationError` alongside typed spent, unknown and pending errors.
+Review existing error handling instead of matching messages or assuming the
+old class hierarchy.
+
+Mutation functions use the configured secret providers and return the wallet's
+current result shapes. Re-test every path that persists replacement outputs,
+especially ambiguous results, before moving value with 0.14.
+
+## New surface
+
+Version 0.14 adds the wallet's current Part 2 and LN address work, including
+`fetchNoteInfoByPubkey`, cp1/ck1/cs1/cx1 codecs and derivation,
+`registerUsername`, `scanForAddressNotes`, `configureTransport` and
+bound-mint receipt validation.

package/README.md

@@ -0,0 +1,90 @@
+# @lnurlcash/kit
+
+The LNURLcash protocol client used by
+[`lnurl-wallet`](https://github.com/lnurlcash/lnurl-wallet). It is published
+from the wallet repository so the reference wallet and the npm package share
+the same implementation and test suite.
+
+LUD-25 is still a draft. Pin an exact version and review the changelog before
+upgrading software that can spend bearer notes.
+
+Version 0.14 replaces the separate `lnurlcash-kit` 0.13 implementation under a
+new scoped package name. Existing consumers should read
+[MIGRATION-0.14.md](./MIGRATION-0.14.md) before upgrading.
+
+## Install
+
+```sh
+npm install --save-exact @lnurlcash/kit
+```
+
+Node 22 or newer is required. The package is ESM-only and also targets modern
+browsers with Web Crypto and `AbortSignal.timeout`.
+
+## Use
+
+```ts
+import {fetchNoteInfo, rotateNote} from '@lnurlcash/kit'
+
+const info = await fetchNoteInfo(noteUrl)
+const replacement = await rotateNote(info.callback, info.k1)
+```
+
+`fetchNoteInfo` first uses a secret-free hash or public-key lookup. It sends a
+raw legacy `k1` only when an older service explicitly says that `k1` is
+required. Mutations generate and name replacement outputs locally.
+
+Configuration is process-wide. Call `configureNetworkGuard`,
+`configureTransport`, `configureSecretProvider` and
+`configurePubkeySecretProvider` once during application startup, before any
+requests are made. The defaults use the platform `fetch` and secure random
+bytes; the wallet overrides them for offline mode, recoverable outputs and
+host-provided transports.
+
+## Public modules
+
+The root export includes:
+
+- LNURL and note parsing in `urls.ts`
+- BOLT-11 amount, hash and preimage checks in `bolt11.ts`
+- offline note signatures and Part 2 ownership proofs in `signature.ts`
+- fee parsing and arithmetic in `fees.ts`
+- guarded network access in `net.ts`
+- note lookup, melt, rotate, split, merge and settlement in `request.ts`
+- mint invoice and bound-receipt checks in `mintRequest.ts`
+- LN address registration and gap-limit recovery scans in `addresses.ts`
+- cp1, ck1, cs1 and cx1 codecs and derivation in `recoverableNotes.ts`
+- injectable output-secret providers in `secrets.ts`
+
+The implementation has no dependency on Solid, browser storage or any other
+wallet module. Wallet policy stays in the parent `src/lnurlcash.ts` adapter.
+
+## Errors and ambiguous mutations
+
+LNURLcash mutations move bearer value. A timeout or unreadable response does
+not prove that a callback failed. Preserve every replacement secret carried by
+an `AmbiguousMutationError` and reconcile the input and outputs before retrying.
+Do not turn transport uncertainty into an automatic retry.
+
+See [THREAT-MODEL.md](./THREAT-MODEL.md) before integrating the package and
+[SECURITY.md](./SECURITY.md) before reporting a vulnerability.
+
+## Development
+
+From `src/lib` in the wallet checkout:
+
+```sh
+npm ci
+npm run check
+npm pack --dry-run
+```
+
+The package and wallet share a version. A wallet tag named `vX.Y.Z` publishes
+`@lnurlcash/kit@X.Y.Z` from the same commit through
+`.github/workflows/release-kit.yml` and npm trusted publishing; releases must
+not be published from a maintainer workstation. The one-time scoped-package
+bootstrap is documented in [RELEASING.md](./RELEASING.md).
+
+## Licence
+
+MIT

package/RELEASING.md

@@ -0,0 +1,64 @@
+# Releasing @lnurlcash/kit
+
+The final package is published from `lnurlcash/lnurl-wallet`, not from a
+workstation and not from the old standalone kit repository.
+
+## One-time scoped-package bootstrap
+
+npm cannot configure a trusted publisher until the package exists. After this
+package source has been reviewed and merged, an `lnurlcash` npm organisation
+owner must make the one exceptional manual publish:
+
+1. Build, test and pack the merged source from a disposable clean checkout,
+   changing only its package version to `0.14.0-rc.0`.
+2. Publish that tarball as a public prerelease with
+   `npm publish --access public --tag next <tarball>`.
+3. Verify that npm shows `@lnurlcash/kit@0.14.0-rc.0` under the `next` tag and
+   that no `latest` tag has been created.
+
+Do not manually publish `0.14.0`: that version is reserved for the reviewed
+OIDC release. The prerelease only creates the scoped package so its trusted
+publisher can be configured; do not recommend it to production consumers.
+
+## One-time trusted-publisher setup
+
+An npm package owner must configure the trusted publisher for
+`@lnurlcash/kit` as:
+
+- provider: GitHub Actions
+- organisation or user: `lnurlcash`
+- repository: `lnurl-wallet`
+- workflow: `release-kit.yml`
+- environment: `npm-publish`
+- allowed actions: enable direct `npm publish`
+
+A GitHub repository or organisation administrator should create the
+`npm-publish` environment, restrict it to `v*` tags and require a maintainer
+review. No npm token or GPG key belongs in GitHub secrets; npm uses the
+workflow's short-lived OIDC identity and records provenance.
+
+Do not create a final release until both sides are configured. A missing or
+mismatched trusted publisher should fail closed, but it is not a useful release
+rehearsal.
+
+## Each release
+
+1. Choose the next version for both the wallet and kit, then update the kit's
+   `package.json` and `CHANGELOG.md` in a reviewed pull request.
+2. Require the wallet CI and the independent `src/lib` package gate to pass.
+3. Merge, then create the shared `vX.Y.Z` tag at that exact merge commit. The
+   tag must exactly equal `v` plus the version in `src/lib/package.json`.
+4. Pushing the tag starts both release workflows. The wallet is tested and
+   deployed at `X.Y.Z`; `release-kit.yml` independently rebuilds and tests the
+   package, packs one tarball, performs a dry-run publish and uploads that same
+   tarball through npm OIDC as `@lnurlcash/kit@X.Y.Z`.
+5. Verify the workflow, npm version, repository metadata and provenance before
+   announcing the release.
+
+There is no separate package release train: the wallet tag is the compatibility
+signal for both artefacts. A manual workflow dispatch validates only by default;
+its separate `publish` input must be deliberately enabled to reach npm.
+
+Version 0.14 is a package-name and API boundary from the old standalone
+implementation. Check `MIGRATION-0.14.md` and test each consumer before
+replacing its pinned dependency.

package/SECURITY.md

@@ -0,0 +1,14 @@
+# Security policy
+
+Only the latest release is supported while LUD-25 remains a draft. Consumers
+should pin an exact package version and review protocol changes before
+upgrading.
+
+Report vulnerabilities privately through the
+[lnurl-wallet security advisory form](https://github.com/lnurlcash/lnurl-wallet/security/advisories/new).
+Do not open a public issue for anything that could leak, steal, duplicate or
+destroy a note.
+
+Include the affected version, a minimal reproduction and the consequence where
+possible. Protocol concerns should also be raised on the
+[LUD-25 proposal](https://github.com/lnurl/luds/pull/301).

package/THREAT-MODEL.md

@@ -0,0 +1,44 @@
+# Threat model
+
+`@lnurlcash/kit` handles LNURLcash protocol data. It does not provide custody,
+secret storage, routing, channel management or a guarantee that a mint will
+honour its liabilities.
+
+## Assets and trust boundaries
+
+- A note secret is a bearer instrument. Anyone who obtains it can spend it.
+- A replacement secret may be the only authority over an output after an
+  ambiguous mutation. Callers must persist it before treating a request as
+  safely retryable.
+- A mint public key is not secret, but accepting the wrong key defeats offline
+  verification. Applications must pin and review service identity changes.
+- The mint is trusted with custody. Its signed statements prove what it said;
+  they do not prove reserves, settlement or future redemption.
+
+## Defences in this package
+
+- Mutations name replacement outputs by hash or derived public key rather than
+  disclosing the replacement secret.
+- Network admission rejects unsafe service URLs and applies the configured
+  guard before requests are made.
+- Informational responses are checked against the requested note identity.
+- Mint signatures bind note identity and value for offline verification.
+- Amounts, invoices, preimages, fees and bound-mint receipts are validated
+  before their results are accepted.
+- Ambiguous request outcomes remain distinct from requests known not to have
+  left the process.
+
+## Caller responsibilities
+
+- Encrypt note secrets and backups at rest, exclude them from logs, analytics
+  and crash reports, and use a cryptographically secure secret provider.
+- Treat callback requests as mutations. Do not retry after a timeout or an
+  unreadable response until the newly named outputs have been reconciled.
+- Pin trusted service origins and signing keys outside this stateless package.
+- Route traffic appropriately if service-side timing and address correlation
+  are a concern.
+- Rotate newly minted bearer notes promptly: invoice preimages may have been
+  visible to the service or to anyone able to observe invoice verification.
+
+The complete wallet adds storage, recovery and user-confirmation policy around
+these primitives. Those controls are not part of the npm package.

package/dist/index.d.ts

@@ -0,0 +1,275 @@
+declare class AmbiguousMintError extends Error {
+}
+declare class AmbiguousMutationError extends AmbiguousMintError {
+    readonly newSecrets: string[];
+    constructor(message: string, newSecrets: string[]);
+}
+declare class ServiceError extends Error {
+    readonly reason: string;
+    constructor(reason: string);
+}
+declare class PendingNoteError extends Error {
+    constructor();
+}
+declare class NoteSpentError extends Error {
+    constructor(reason: string);
+}
+declare class NoteUnknownError extends Error {
+    constructor(reason: string);
+}
+declare const classifyNoteError: (err: Error) => Error;
+
+declare const isBech32Lnurl: (data: string) => boolean;
+declare const toBech32Lnurl: (url: string) => string;
+declare const fromBech32Lnurl: (data: string) => string | null;
+declare const defaultSchemeFor: (hostish: string) => "http" | "https";
+declare const isAllowedServiceUrl: (value: string) => boolean;
+declare const fromLud17: (url: string) => string;
+declare const toLud17w: (url: string) => string;
+declare const isLightningAddress: (value: string) => boolean;
+declare const resolveMintInput: (value: string) => string | null;
+declare const mintAddressUrl: (payUrl: string) => string | null;
+declare const lightningAddressUsername: (payUrl: string) => string | null;
+declare const resolveLnurlInput: (value: string) => string | null;
+declare const noteK1: (url: string) => string | null;
+declare const requireNoteK1: (url: string) => string;
+declare const noteDeclaredAmount: (url: string) => number | null;
+declare const noteSignature: (url: string) => string | null;
+declare const isValidK1: (value: string) => boolean;
+declare const resolveNoteInput: (value: string) => string | null;
+declare const isValidNoteInput: (value: string) => boolean;
+declare const buildNoteUrl: (withdrawLink: string, k1: string, amountMsat?: number) => string;
+declare const withNewK1: (url: string, k1: string, amountMsat: number, signature?: string) => string;
+declare const withoutK1: (url: string, amountMsat: number, signature?: string) => string;
+declare const withoutSignature: (url: string) => string;
+declare const serverOf: (url: string) => string;
+declare const serviceOriginOf: (value: string) => string;
+declare const noteEndpointOf: (url: string) => string;
+
+declare const sameInvoice: (a: string, b: string) => boolean;
+declare const isPreimage: (value: string) => boolean;
+declare const isBolt11Invoice: (value: string) => boolean;
+declare const encodeBolt11AmountSuffix: (amountMsat: number) => string;
+declare const decodeBolt11AmountSuffix: (suffix: string) => number | null;
+declare const decodeBolt11AmountMsat: (pr: string) => number | null;
+declare const decodeBolt11PaymentHash: (pr: string) => string | null;
+declare const verifyMeltPreimage: (pr: string, preimage: string) => boolean;
+
+declare const MINT_PUBKEY_PATTERN: RegExp;
+declare const NOTE_SIGNATURE_PATTERN: RegExp;
+declare const parseMintKey: (body: any) => {
+    mintPubkey: string;
+};
+declare const hashK1: (k1: string) => string;
+declare const verifyNoteSignature: (k1: string, amountMsat: number, signatureHex: string, mintPubkeyHex: string) => boolean;
+declare const verifyNoteSignatureHash: (h: string, amountMsat: number, signatureHex: string, mintPubkeyHex: string) => boolean;
+declare const signNoteOwnership: (secretKey: Uint8Array) => Uint8Array;
+declare const recoverNoteOwnershipPubkey: (signature: Uint8Array) => Uint8Array | null;
+type AddressProofAction = 'register' | 'unregister';
+declare const signAddressProof: (branchIndexZeroSecretKey: Uint8Array, action: AddressProofAction, username: string) => Uint8Array;
+declare const cp1FromCk1: (ck1: string) => string | null;
+declare const requireMutationSignature: (body: any, field: "sig" | "sig2") => string;
+
+type MintFee = {
+    baseFeeMsat: number;
+    feePpm: number;
+};
+declare const MIN_COMMENT_LENGTH_FOR_SECRET = 64;
+type PayRequestCommentInfo = {
+    commentAllowed?: number;
+};
+declare const canUseMintComment: (info: PayRequestCommentInfo) => boolean;
+declare const requireMintComment: (info: PayRequestCommentInfo) => void;
+declare const parseMintFee: (metadata: string) => MintFee | null;
+declare const applyMintFee: (grossMsat: number, fee: MintFee) => number;
+declare const withinMintFeeBand: (grossMsat: number, netMsat: number, fee: MintFee) => boolean;
+declare const grossUpForMintFee: (netMsat: number, fee: MintFee) => number;
+
+type NetworkGuard = () => void;
+declare const configureNetworkGuard: (guard: NetworkGuard) => void;
+type Transport = (url: string, signal: AbortSignal, method: string) => Promise<Response>;
+declare const configureTransport: (next: Transport) => void;
+declare const lnurlFetch: (url: string | URL, method?: string) => Promise<any>;
+
+type WithdrawRequestInfo = {
+    tag: 'withdrawRequest';
+    callback: string;
+    k1: string;
+    minWithdrawable: number;
+    maxWithdrawable: number;
+    defaultDescription?: string;
+    mintPubkey: string;
+    sig?: string;
+};
+type HashWithdrawRequestInfo = Omit<WithdrawRequestInfo, 'k1'>;
+declare const fetchNoteInfoByHash: (url: string, h: string) => Promise<HashWithdrawRequestInfo>;
+declare const fetchNoteInfoByPubkey: (url: string, cp1Value: string) => Promise<HashWithdrawRequestInfo>;
+declare const fetchNoteInfo: (url: string) => Promise<WithdrawRequestInfo>;
+declare const probeBurnedNote: (url: string) => Promise<"live" | "gone" | "unknown">;
+type MintAddressInfo = {
+    tag: 'withdrawRequest';
+    callback: string;
+    minWithdrawable: number;
+    maxWithdrawable: number;
+    defaultDescription?: string;
+    mintPubkey: string;
+    nodePubkey?: string;
+    payLink: string;
+    nodeAlias?: string;
+    nodeUri?: string;
+    nodeColor?: string;
+    nodeCapacityMsat?: number;
+    nodeNumChannels?: number;
+    nodeNumPeers?: number;
+    sunsetDate?: string;
+    outstandingNotesMsat?: number;
+};
+declare const fetchMintAddress: (url: string) => Promise<MintAddressInfo>;
+type WithdrawSuccessResponse = {
+    status: 'OK';
+    sig?: string;
+    sig2?: string;
+    pr?: string;
+    verify?: string;
+};
+type MeltResult = {
+    verify?: string;
+    pr?: string;
+};
+declare const meltNote: (callback: string, k1: string, pr: string) => Promise<MeltResult>;
+type HashedMutationResult = {
+    signature: string;
+};
+declare const rotateNoteWithHash: (callback: string, k1: string, h: string) => Promise<HashedMutationResult>;
+type HashedSplitResult = {
+    signature: string;
+    changeSignature: string;
+};
+declare const splitNoteWithHash: (callback: string, k1s: string[], amountMsat: number, h: string, h2: string) => Promise<HashedSplitResult>;
+declare const mergeNotesWithHash: (callback: string, k1s: string[], h: string) => Promise<HashedMutationResult>;
+type RotateResult = {
+    k1: string;
+    signature: string;
+};
+declare const generateOutputSecret: (domain: string, preferPubkey: boolean) => string;
+declare const disclosedValue: (secret: string) => string;
+declare const rotateNote: (callback: string, k1: string) => Promise<RotateResult>;
+type SplitResult = {
+    k1: string;
+    signature: string;
+    change: string;
+    changeSignature: string;
+};
+declare const splitNote: (callback: string, k1s: string[], amountMsat: number) => Promise<SplitResult>;
+declare const mergeNotes: (callback: string, k1s: string[]) => Promise<RotateResult>;
+type SettledNote = {
+    k1: string;
+    amountMsat: number;
+    signature?: string;
+    callback: string;
+};
+declare const settleNote: (baseUrl: string, k1: string, expectedAmountMsat: number, signature: string | undefined) => Promise<SettledNote>;
+
+declare const encodeCp1: (pubkeyXOnly: Uint8Array) => string;
+declare const decodeCp1: (value: string) => Uint8Array | null;
+declare const isCp1: (value: string) => boolean;
+declare const encodeCk1: (signature: Uint8Array) => string;
+declare const decodeCk1: (value: string) => Uint8Array | null;
+declare const isCk1: (value: string) => boolean;
+declare const encodeCs1: (signature: Uint8Array) => string;
+declare const decodeCs1: (value: string) => Uint8Array | null;
+declare const isCs1: (value: string) => boolean;
+declare const encodeCs1WithAmount: (amountMsat: number, signature: Uint8Array) => string;
+declare const decodeCs1WithAmount: (value: string) => {
+    amountMsat: number;
+    signature: Uint8Array;
+} | null;
+declare const isCs1WithAmount: (value: string) => boolean;
+declare const decodeAnyCs1: (value: string) => Uint8Array | null;
+declare const isAnyCs1: (value: string) => boolean;
+type Cx1 = {
+    pubkeyXOnly: Uint8Array;
+    chainCode: Uint8Array;
+};
+declare const encodeCx1: (pubkeyXOnly: Uint8Array, chainCode: Uint8Array) => string;
+declare const decodeCx1: (value: string) => Cx1 | null;
+declare const isCx1: (value: string) => boolean;
+declare const deriveNotePubkey: (branchPubkeyXOnly: Uint8Array, chainCode: Uint8Array, index: number) => Uint8Array;
+declare const deriveNoteSecretKey: (branchPrivateKey: Uint8Array, chainCode: Uint8Array, index: number) => Uint8Array;
+
+type InternalTransferHint = {
+    cx1: Cx1;
+    startIndex: number;
+};
+declare const parseInternalTransferHint: (metadata: string) => InternalTransferHint | null;
+type InternalTransferResult = {
+    kind: 'merge';
+    index: number;
+    signature: string;
+} | {
+    kind: 'split';
+    index: number;
+    signature: string;
+    change: string;
+    changeSignature: string;
+};
+declare const payInternalTransfer: (callback: string, k1s: string[], amountMsat: number, totalInputMsat: number, hint: InternalTransferHint) => Promise<InternalTransferResult>;
+
+type PayRequestInfo = {
+    tag: 'payRequest';
+    callback: string;
+    minSendable: number;
+    maxSendable: number;
+    metadata: string;
+    withdrawLink?: string;
+    mintPubkey?: string;
+    mintFee?: MintFee;
+    commentAllowed?: number;
+    mintToHash?: boolean;
+    internalTransfer?: InternalTransferHint;
+};
+declare const fetchPayRequest: (url: string) => Promise<PayRequestInfo>;
+type BoundMintCommitment = {
+    h: string;
+    amountMsat: number;
+    signature?: string;
+};
+type InvoiceResult = {
+    pr: string;
+    verify?: string;
+    disposable: boolean;
+    mintToHash: boolean;
+    mint?: BoundMintCommitment;
+};
+declare const requestInvoice: (payCallback: string, amountMsat: number, outputHash?: string) => Promise<InvoiceResult>;
+type VerifyResult = {
+    settled: boolean;
+    preimage: string | null;
+    pr: string;
+    mint?: BoundMintCommitment;
+};
+declare const fetchInvoiceVerification: (verifyUrl: string) => Promise<VerifyResult>;
+declare const requireBoundMintQuote: (invoice: InvoiceResult, expectedH: string, grossMsat: number, fee?: MintFee) => BoundMintCommitment;
+declare const validateBoundMintReceipt: (invoice: InvoiceResult, verification: VerifyResult, expectedH: string, expectedAmountMsat: number, mintPubkey: string) => Required<BoundMintCommitment>;
+
+declare const registerUsername: (server: string, username: string, cx1: string, indexZeroSecretKey: Uint8Array) => Promise<void>;
+declare const unregisterUsername: (server: string, username: string, indexZeroSecretKey: Uint8Array) => Promise<void>;
+type AddressScanResult = {
+    index: number;
+    cp1: string;
+    info: HashWithdrawRequestInfo;
+};
+type AddressScanOptions = {
+    gapLimit?: number;
+    startIndex?: number;
+    onFound?: (result: AddressScanResult) => void;
+    rateLimitBackoffMs?: number;
+};
+declare const scanForAddressNotes: (withdrawUrl: string, branch: Cx1, opts?: AddressScanOptions) => Promise<AddressScanResult[]>;
+
+type SecretProvider = (domain: string) => string;
+declare const configureSecretProvider: (provider: SecretProvider) => void;
+type PubkeySecretProvider = (domain: string) => string | null;
+declare const configurePubkeySecretProvider: (provider: PubkeySecretProvider) => void;
+
+export { type AddressProofAction, type AddressScanOptions, type AddressScanResult, AmbiguousMintError, AmbiguousMutationError, type BoundMintCommitment, type Cx1, type HashWithdrawRequestInfo, type HashedMutationResult, type HashedSplitResult, type InternalTransferHint, type InternalTransferResult, type InvoiceResult, MINT_PUBKEY_PATTERN, MIN_COMMENT_LENGTH_FOR_SECRET, type MeltResult, type MintAddressInfo, type MintFee, NOTE_SIGNATURE_PATTERN, type NetworkGuard, NoteSpentError, NoteUnknownError, type PayRequestCommentInfo, type PayRequestInfo, PendingNoteError, type PubkeySecretProvider, type RotateResult, type SecretProvider, ServiceError, type SettledNote, type SplitResult, type Transport, type VerifyResult, type WithdrawRequestInfo, type WithdrawSuccessResponse, applyMintFee, buildNoteUrl, canUseMintComment, classifyNoteError, configureNetworkGuard, configurePubkeySecretProvider, configureSecretProvider, configureTransport, cp1FromCk1, decodeAnyCs1, decodeBolt11AmountMsat, decodeBolt11AmountSuffix, decodeBolt11PaymentHash, decodeCk1, decodeCp1, decodeCs1, decodeCs1WithAmount, decodeCx1, defaultSchemeFor, deriveNotePubkey, deriveNoteSecretKey, disclosedValue, encodeBolt11AmountSuffix, encodeCk1, encodeCp1, encodeCs1, encodeCs1WithAmount, encodeCx1, fetchInvoiceVerification, fetchMintAddress, fetchNoteInfo, fetchNoteInfoByHash, fetchNoteInfoByPubkey, fetchPayRequest, fromBech32Lnurl, fromLud17, generateOutputSecret, grossUpForMintFee, hashK1, isAllowedServiceUrl, isAnyCs1, isBech32Lnurl, isBolt11Invoice, isCk1, isCp1, isCs1, isCs1WithAmount, isCx1, isLightningAddress, isPreimage, isValidK1, isValidNoteInput, lightningAddressUsername, lnurlFetch, meltNote, mergeNotes, mergeNotesWithHash, mintAddressUrl, noteDeclaredAmount, noteEndpointOf, noteK1, noteSignature, parseInternalTransferHint, parseMintFee, parseMintKey, payInternalTransfer, probeBurnedNote, recoverNoteOwnershipPubkey, registerUsername, requestInvoice, requireBoundMintQuote, requireMintComment, requireMutationSignature, requireNoteK1, resolveLnurlInput, resolveMintInput, resolveNoteInput, rotateNote, rotateNoteWithHash, sameInvoice, scanForAddressNotes, serverOf, serviceOriginOf, settleNote, signAddressProof, signNoteOwnership, splitNote, splitNoteWithHash, toBech32Lnurl, toLud17w, unregisterUsername, validateBoundMintReceipt, verifyMeltPreimage, verifyNoteSignature, verifyNoteSignatureHash, withNewK1, withinMintFeeBand, withoutK1, withoutSignature };