@lnurlcash/kit 0.14.0-rc.0 → 0.14.2

package/README.md

@@ -82,8 +82,9 @@ 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).
+not be published from a maintainer workstation. The release process and
+trusted-publisher configuration are documented in
+[RELEASING.md](./RELEASING.md).
 
 ## Licence
 

package/RELEASING.md

@@ -3,27 +3,13 @@
 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
+## Trusted publisher
 
-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:
+The one-time scoped-package bootstrap was completed with `0.14.0-rc.0`, then
+`0.14.0` was published by the reviewed OIDC release workflow. Do not repeat the
+manual bootstrap for later releases.
 
-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:
+The trusted publisher for `@lnurlcash/kit` is configured as:
 
 - provider: GitHub Actions
 - organisation or user: `lnurlcash`
@@ -32,26 +18,31 @@ An npm package owner must configure the trusted publisher for
 - 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.
+The GitHub `npm-publish` environment restricts deployments to tags matching
+`v*.*.*` and requires 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. A missing or mismatched trusted publisher should fail closed.
 
 ## 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.
+The version is never hand-bumped in `package.json` - `src/lib/package.json`'s
+own checked-in `version` (`0.0.0-dev`) is a placeholder, overwritten by
+`release-kit.yml`'s own `npm version "${RELEASE_TAG#v}" --no-git-tag-version`
+step from whichever tag actually triggered the run. This mirrors how the
+wallet's own displayed version already works (`scripts/git-version.mjs` -
+`git describe --tags`, no hand-bumped field either): cutting a release is just
+tagging a commit, nothing to remember to keep in sync first.
+
+1. (Optional but recommended) Add a `CHANGELOG.md` entry summarising what's
+   new, 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`.
+3. Merge, then create the shared `vX.Y.Z` tag at that exact merge commit -
+   any valid semver works, npm itself rejects anything else.
 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`.
+   deployed at `X.Y.Z`; `release-kit.yml` independently sets the package
+   version from the tag, 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.
 

package/dist/addresses.d.ts

@@ -0,0 +1,16 @@
+import { type HashWithdrawRequestInfo } from './request.js';
+import { type Cx1 } from './recoverableNotes.js';
+export declare const registerUsername: (server: string, username: string, cx1: string, indexZeroSecretKey: Uint8Array, npub?: string) => Promise<void>;
+export declare const unregisterUsername: (server: string, username: string, indexZeroSecretKey: Uint8Array) => Promise<void>;
+export type AddressScanResult = {
+    index: number;
+    cp1: string;
+    info: HashWithdrawRequestInfo;
+};
+export type AddressScanOptions = {
+    gapLimit?: number;
+    startIndex?: number;
+    onFound?: (result: AddressScanResult) => void;
+    rateLimitBackoffMs?: number;
+};
+export declare const scanForAddressNotes: (withdrawUrl: string, branch: Cx1, opts?: AddressScanOptions) => Promise<AddressScanResult[]>;

package/dist/bolt11.d.ts

@@ -0,0 +1,8 @@
+export declare const sameInvoice: (a: string, b: string) => boolean;
+export declare const isPreimage: (value: string) => boolean;
+export declare const isBolt11Invoice: (value: string) => boolean;
+export declare const encodeBolt11AmountSuffix: (amountMsat: number) => string;
+export declare const decodeBolt11AmountSuffix: (suffix: string) => number | null;
+export declare const decodeBolt11AmountMsat: (pr: string) => number | null;
+export declare const decodeBolt11PaymentHash: (pr: string) => string | null;
+export declare const verifyMeltPreimage: (pr: string, preimage: string) => boolean;

package/dist/errors.d.ts

@@ -0,0 +1,20 @@
+export declare class AmbiguousMintError extends Error {
+}
+export declare class AmbiguousMutationError extends AmbiguousMintError {
+    readonly newSecrets: string[];
+    constructor(message: string, newSecrets: string[]);
+}
+export declare class ServiceError extends Error {
+    readonly reason: string;
+    constructor(reason: string);
+}
+export declare class PendingNoteError extends Error {
+    constructor();
+}
+export declare class NoteSpentError extends Error {
+    constructor(reason: string);
+}
+export declare class NoteUnknownError extends Error {
+    constructor(reason: string);
+}
+export declare const classifyNoteError: (err: Error) => Error;

package/dist/fees.d.ts

@@ -0,0 +1,14 @@
+export type MintFee = {
+    baseFeeMsat: number;
+    feePpm: number;
+};
+export declare const MIN_COMMENT_LENGTH_FOR_SECRET = 64;
+export type PayRequestCommentInfo = {
+    commentAllowed?: number;
+};
+export declare const canUseMintComment: (info: PayRequestCommentInfo) => boolean;
+export declare const requireMintComment: (info: PayRequestCommentInfo) => void;
+export declare const parseMintFee: (metadata: string) => MintFee | null;
+export declare const applyMintFee: (grossMsat: number, fee: MintFee) => number;
+export declare const withinMintFeeBand: (grossMsat: number, netMsat: number, fee: MintFee) => boolean;
+export declare const grossUpForMintFee: (netMsat: number, fee: MintFee) => number;

package/dist/index.d.ts

@@ -1,275 +1,12 @@
-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 };
+export * from './errors.js';
+export * from './urls.js';
+export * from './bolt11.js';
+export * from './signature.js';
+export * from './fees.js';
+export * from './net.js';
+export * from './request.js';
+export * from './mintRequest.js';
+export * from './addresses.js';
+export * from './internalTransfer.js';
+export * from './recoverableNotes.js';
+export { configureSecretProvider, type SecretProvider, configurePubkeySecretProvider, type PubkeySecretProvider } from './secrets.js';

package/dist/index.js

@@ -1,8 +1,3 @@
-import { bech32, bech32m } from '@scure/base';
-import { sha256 } from '@noble/hashes/sha2.js';
-import { utf8ToBytes, bytesToHex, hexToBytes } from '@noble/hashes/utils.js';
-import { schnorr, secp256k1 } from '@noble/curves/secp256k1.js';
-
 // errors.ts
 var AmbiguousMintError = class extends Error {
 };
@@ -50,6 +45,14 @@ var classifyNoteError = (err) => {
   if (/unknown|not found/i.test(reason)) return new NoteUnknownError(reason);
   return err;
 };
+
+// urls.ts
+import { bech32 as bech322 } from "@scure/base";
+
+// bolt11.ts
+import { bech32 } from "@scure/base";
+import { sha256 } from "@noble/hashes/sha2.js";
+import { bytesToHex, hexToBytes } from "@noble/hashes/utils.js";
 var sameInvoice = (a, b) => a.trim().toLowerCase() === b.trim().toLowerCase();
 var isPreimage = (value) => /^[0-9a-fA-F]{64}$/.test(value.trim());
 var isBolt11Invoice = (value) => /^ln(bc|tb|bcrt|tbs|sb)[0-9]*[munp]?1[a-z0-9]+$/.test(
@@ -123,6 +126,11 @@ var verifyMeltPreimage = (pr, preimage) => {
   if (!expected) return false;
   return bytesToHex(sha256(hexToBytes(preimage))) === expected;
 };
+
+// recoverableNotes.ts
+import { bech32m } from "@scure/base";
+import { bytesToHex as bytesToHex2, hexToBytes as hexToBytes2 } from "@noble/hashes/utils.js";
+import { schnorr } from "@noble/curves/secp256k1.js";
 var encodeFixed = (hrp, bytes, length) => {
   if (bytes.length !== length) {
     throw new Error(`${hrp}1... payload must be exactly ${length} bytes`);
@@ -176,8 +184,8 @@ var ser32BE = (index) => {
   new DataView(bytes.buffer).setUint32(0, index, false);
   return bytes;
 };
-var bytesToNumberBE = (bytes) => BigInt(`0x${bytesToHex(bytes)}`);
-var numberToBytesBE = (n, length) => hexToBytes(n.toString(16).padStart(length * 2, "0"));
+var bytesToNumberBE = (bytes) => BigInt(`0x${bytesToHex2(bytes)}`);
+var numberToBytesBE = (n, length) => hexToBytes2(n.toString(16).padStart(length * 2, "0"));
 var CURVE_ORDER = schnorr.Point.CURVE().n;
 var tweakScalar = (branchPubkeyXOnly, chainCode, index) => {
   const t = schnorr.utils.taggedHash(
@@ -208,17 +216,17 @@ var deriveNoteSecretKey = (branchPrivateKey, chainCode, index) => {
 var isBech32Lnurl = (data) => data.trim().toUpperCase().startsWith("LNURL1");
 var toBech32Lnurl = (url) => {
   const bytes = new TextEncoder().encode(url);
-  return bech32.encode("lnurl", bech32.toWords(bytes), 2048).toUpperCase();
+  return bech322.encode("lnurl", bech322.toWords(bytes), 2048).toUpperCase();
 };
 var fromBech32Lnurl = (data) => {
   const safe = data.trim().toUpperCase();
   if (!safe.startsWith("LNURL1")) return null;
   try {
-    const decoded = bech32.decode(
+    const decoded = bech322.decode(
       `LNURL1${safe.slice(6)}`,
       2048
     );
-    return new TextDecoder().decode(bech32.fromWords(decoded.words));
+    return new TextDecoder().decode(bech322.fromWords(decoded.words));
   } catch {
     return null;
   }
@@ -329,10 +337,14 @@ var requireNoteK1 = (url) => {
 };
 var noteDeclaredAmount = (url) => {
   try {
-    const raw = new URL(url).searchParams.get("amount");
-    if (raw === null) return null;
-    const n = Number(raw);
-    return Number.isFinite(n) ? n : null;
+    const parsed = new URL(url);
+    const raw = parsed.searchParams.get("amount");
+    if (raw !== null) {
+      const n = Number(raw);
+      return Number.isFinite(n) ? n : null;
+    }
+    const sig = parsed.searchParams.get("sig");
+    return sig ? decodeCs1WithAmount(sig)?.amountMsat ?? null : null;
   } catch {
     return null;
   }
@@ -360,10 +372,15 @@ var buildNoteUrl = (withdrawLink, k1, amountMsat) => {
   }
   return url.toString();
 };
+var amountIsImpliedBySignature = (signature) => Boolean(signature) && isCs1WithAmount(signature);
 var withNewK1 = (url, k1, amountMsat, signature) => {
   const newUrl = new URL(url);
   newUrl.searchParams.set("k1", k1);
-  newUrl.searchParams.set("amount", String(amountMsat));
+  if (amountIsImpliedBySignature(signature)) {
+    newUrl.searchParams.delete("amount");
+  } else {
+    newUrl.searchParams.set("amount", String(amountMsat));
+  }
   if (signature) newUrl.searchParams.set("sig", signature);
   else newUrl.searchParams.delete("sig");
   return newUrl.toString();
@@ -371,13 +388,22 @@ var withNewK1 = (url, k1, amountMsat, signature) => {
 var withoutK1 = (url, amountMsat, signature) => {
   const newUrl = new URL(url);
   newUrl.searchParams.delete("k1");
-  newUrl.searchParams.set("amount", String(amountMsat));
+  if (amountIsImpliedBySignature(signature)) {
+    newUrl.searchParams.delete("amount");
+  } else {
+    newUrl.searchParams.set("amount", String(amountMsat));
+  }
   if (signature) newUrl.searchParams.set("sig", signature);
   else newUrl.searchParams.delete("sig");
   return newUrl.toString();
 };
 var withoutSignature = (url) => {
   const newUrl = new URL(url);
+  const sig = newUrl.searchParams.get("sig");
+  if (sig && !newUrl.searchParams.has("amount")) {
+    const decoded = decodeCs1WithAmount(sig);
+    if (decoded) newUrl.searchParams.set("amount", String(decoded.amountMsat));
+  }
   newUrl.searchParams.delete("sig");
   return newUrl.toString();
 };
@@ -409,6 +435,11 @@ var noteEndpointOf = (url) => {
     return serverOf(url);
   }
 };
+
+// signature.ts
+import { sha256 as sha2562 } from "@noble/hashes/sha2.js";
+import { secp256k1 } from "@noble/curves/secp256k1.js";
+import { bytesToHex as bytesToHex3, hexToBytes as hexToBytes3, utf8ToBytes } from "@noble/hashes/utils.js";
 var MINT_PUBKEY_PATTERN = /^0[23][0-9a-f]{64}$/i;
 var NOTE_SIGNATURE_PATTERN = /^[0-9a-f]{130}$/i;
 var parseMintKey = (body) => {
@@ -419,7 +450,7 @@ var parseMintKey = (body) => {
   }
   return { mintPubkey: body.mintPubkey.toLowerCase() };
 };
-var hashK1 = (k1) => bytesToHex(sha256(hexToBytes(k1)));
+var hashK1 = (k1) => bytesToHex3(sha2562(hexToBytes3(k1)));
 var LIGHTNING_SIGNED_MESSAGE_PREFIX = utf8ToBytes("Lightning Signed Message:");
 var noteSignatureDigestForHash = (h, amountMsat) => {
   if (!/^[0-9a-fA-F]{64}$/.test(h.trim())) {
@@ -428,22 +459,22 @@ var noteSignatureDigestForHash = (h, amountMsat) => {
   const message = utf8ToBytes(
     `LNURLcash:${amountMsat}:${h.trim().toLowerCase()}`
   );
-  return sha256(
-    sha256(new Uint8Array([...LIGHTNING_SIGNED_MESSAGE_PREFIX, ...message]))
+  return sha2562(
+    sha2562(new Uint8Array([...LIGHTNING_SIGNED_MESSAGE_PREFIX, ...message]))
   );
 };
 var noteSignatureDigest = (k1, amountMsat) => noteSignatureDigestForHash(hashK1(k1), amountMsat);
 var normalizeSignatureHex = (signature) => {
   if (NOTE_SIGNATURE_PATTERN.test(signature)) return signature.toLowerCase();
   const decoded = decodeAnyCs1(signature);
-  return decoded ? bytesToHex(decoded) : null;
+  return decoded ? bytesToHex3(decoded) : null;
 };
 var verifyNoteSignatureDigest = (digest, signature, mintPubkeyHex) => {
   const signatureHex = normalizeSignatureHex(signature);
   if (!signatureHex) return false;
   let wireSig;
   try {
-    wireSig = hexToBytes(signatureHex);
+    wireSig = hexToBytes3(signatureHex);
   } catch {
     return false;
   }
@@ -456,7 +487,7 @@ var verifyNoteSignatureDigest = (digest, signature, mintPubkeyHex) => {
       const recovered = secp256k1.recoverPublicKey(candidate, digest, {
         prehash: false
       });
-      if (bytesToHex(recovered) === target) return true;
+      if (bytesToHex3(recovered) === target) return true;
     } catch {
     }
   }
@@ -467,7 +498,7 @@ var verifyNoteSignature = (k1, amountMsat, signatureHex, mintPubkeyHex) => {
     const signatureBytes = decodeCk1(k1);
     const pubkey = signatureBytes ? recoverNoteOwnershipPubkey(signatureBytes) : null;
     return pubkey ? verifyNoteSignatureHash(
-      bytesToHex(pubkey),
+      bytesToHex3(pubkey),
       amountMsat,
       signatureHex,
       mintPubkeyHex
@@ -495,8 +526,8 @@ var verifyNoteSignatureHash = (h, amountMsat, signatureHex, mintPubkeyHex) => {
   }
 };
 var NOTE_OWNERSHIP_MESSAGE = utf8ToBytes("LNURLcash");
-var noteOwnershipDigest = () => sha256(
-  sha256(
+var noteOwnershipDigest = () => sha2562(
+  sha2562(
     new Uint8Array([
       ...LIGHTNING_SIGNED_MESSAGE_PREFIX,
       ...NOTE_OWNERSHIP_MESSAGE
@@ -529,8 +560,8 @@ var recoverNoteOwnershipPubkey = (signature) => {
 };
 var addressProofDigest = (action, username) => {
   const message = utf8ToBytes(`LNURLcash:${action}:${username}`);
-  return sha256(
-    sha256(new Uint8Array([...LIGHTNING_SIGNED_MESSAGE_PREFIX, ...message]))
+  return sha2562(
+    sha2562(new Uint8Array([...LIGHTNING_SIGNED_MESSAGE_PREFIX, ...message]))
   );
 };
 var signAddressProof = (branchIndexZeroSecretKey, action, username) => {
@@ -654,7 +685,10 @@ var lnurlFetch = async (url, method = "GET") => {
   }
   return body;
 };
-var defaultSecretProvider = () => bytesToHex(crypto.getRandomValues(new Uint8Array(32)));
+
+// secrets.ts
+import { bytesToHex as bytesToHex4 } from "@noble/hashes/utils.js";
+var defaultSecretProvider = () => bytesToHex4(crypto.getRandomValues(new Uint8Array(32)));
 var secretProvider = defaultSecretProvider;
 var configureSecretProvider = (provider) => {
   secretProvider = provider;
@@ -1025,6 +1059,9 @@ var payInternalTransfer = async (callback, k1s, amountMsat, totalInputMsat, hint
     `${domain} kept reporting every index tried as already in use - could not complete the internal transfer.`
   );
 };
+
+// mintRequest.ts
+import { bytesToHex as bytesToHex5 } from "@noble/hashes/utils.js";
 var fetchPayRequest = async (url) => {
   const body = await lnurlFetch(url);
   if (body?.tag !== "payRequest" || typeof body.callback !== "string") {
@@ -1044,12 +1081,12 @@ var normalizeNoteId = (value) => {
   const trimmed = value.trim().toLowerCase();
   if (/^[0-9a-f]{64}$/.test(trimmed)) return trimmed;
   const decoded = decodeCp1(trimmed);
-  return decoded ? bytesToHex(decoded) : null;
+  return decoded ? bytesToHex5(decoded) : null;
 };
 var normalizeSignature = (value) => {
   if (/^[0-9a-f]{130}$/i.test(value)) return value.toLowerCase();
   const decoded = decodeAnyCs1(value);
-  return decoded ? bytesToHex(decoded) : null;
+  return decoded ? bytesToHex5(decoded) : null;
 };
 var parseBoundMintCommitment = (value) => {
   if (!value || typeof value !== "object") return void 0;
@@ -1160,17 +1197,21 @@ var validateBoundMintReceipt = (invoice, verification, expectedH, expectedAmount
   }
   return { ...receipt, signature: receipt.signature };
 };
+
+// addresses.ts
+import { bytesToHex as bytesToHex6 } from "@noble/hashes/utils.js";
 var addressProofUrl = (server, username, indexZeroSecretKey, action) => {
   const url = new URL(`/p/${encodeURIComponent(username)}`, server);
   url.searchParams.set(
     "sig",
-    bytesToHex(signAddressProof(indexZeroSecretKey, action, username))
+    bytesToHex6(signAddressProof(indexZeroSecretKey, action, username))
   );
   return url;
 };
-var registerUsername = async (server, username, cx1, indexZeroSecretKey) => {
+var registerUsername = async (server, username, cx1, indexZeroSecretKey, npub) => {
   const url = addressProofUrl(server, username, indexZeroSecretKey, "register");
   url.searchParams.set("cx1", cx1);
+  if (npub) url.searchParams.set("npub", npub);
   const body = await lnurlFetch(url, "POST");
   if (body?.status !== "OK") {
     throw new Error("SERVICE did not confirm the registration.");
@@ -1227,5 +1268,113 @@ var scanForAddressNotes = async (withdrawUrl, branch, opts = {}) => {
   }
   return found;
 };
-
-export { AmbiguousMintError, AmbiguousMutationError, MINT_PUBKEY_PATTERN, MIN_COMMENT_LENGTH_FOR_SECRET, NOTE_SIGNATURE_PATTERN, NoteSpentError, NoteUnknownError, PendingNoteError, ServiceError, 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 };
+export {
+  AmbiguousMintError,
+  AmbiguousMutationError,
+  MINT_PUBKEY_PATTERN,
+  MIN_COMMENT_LENGTH_FOR_SECRET,
+  NOTE_SIGNATURE_PATTERN,
+  NoteSpentError,
+  NoteUnknownError,
+  PendingNoteError,
+  ServiceError,
+  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
+};

package/dist/internalTransfer.d.ts

@@ -0,0 +1,18 @@
+import { type Cx1 } from './recoverableNotes.js';
+export type InternalTransferHint = {
+    cx1: Cx1;
+    startIndex: number;
+};
+export declare const parseInternalTransferHint: (metadata: string) => InternalTransferHint | null;
+export type InternalTransferResult = {
+    kind: 'merge';
+    index: number;
+    signature: string;
+} | {
+    kind: 'split';
+    index: number;
+    signature: string;
+    change: string;
+    changeSignature: string;
+};
+export declare const payInternalTransfer: (callback: string, k1s: string[], amountMsat: number, totalInputMsat: number, hint: InternalTransferHint) => Promise<InternalTransferResult>;

package/dist/mintRequest.d.ts

@@ -0,0 +1,38 @@
+import type { MintFee } from './fees.js';
+import type { InternalTransferHint } from './internalTransfer.js';
+export type PayRequestInfo = {
+    tag: 'payRequest';
+    callback: string;
+    minSendable: number;
+    maxSendable: number;
+    metadata: string;
+    withdrawLink?: string;
+    mintPubkey?: string;
+    mintFee?: MintFee;
+    commentAllowed?: number;
+    mintToHash?: boolean;
+    internalTransfer?: InternalTransferHint;
+};
+export declare const fetchPayRequest: (url: string) => Promise<PayRequestInfo>;
+export type BoundMintCommitment = {
+    h: string;
+    amountMsat: number;
+    signature?: string;
+};
+export type InvoiceResult = {
+    pr: string;
+    verify?: string;
+    disposable: boolean;
+    mintToHash: boolean;
+    mint?: BoundMintCommitment;
+};
+export declare const requestInvoice: (payCallback: string, amountMsat: number, outputHash?: string) => Promise<InvoiceResult>;
+export type VerifyResult = {
+    settled: boolean;
+    preimage: string | null;
+    pr: string;
+    mint?: BoundMintCommitment;
+};
+export declare const fetchInvoiceVerification: (verifyUrl: string) => Promise<VerifyResult>;
+export declare const requireBoundMintQuote: (invoice: InvoiceResult, expectedH: string, grossMsat: number, fee?: MintFee) => BoundMintCommitment;
+export declare const validateBoundMintReceipt: (invoice: InvoiceResult, verification: VerifyResult, expectedH: string, expectedAmountMsat: number, mintPubkey: string) => Required<BoundMintCommitment>;

package/dist/net.d.ts

@@ -0,0 +1,5 @@
+export type NetworkGuard = () => void;
+export declare const configureNetworkGuard: (guard: NetworkGuard) => void;
+export type Transport = (url: string, signal: AbortSignal, method: string) => Promise<Response>;
+export declare const configureTransport: (next: Transport) => void;
+export declare const lnurlFetch: (url: string | URL, method?: string) => Promise<any>;

package/dist/recoverableNotes.d.ts

@@ -0,0 +1,26 @@
+export declare const encodeCp1: (pubkeyXOnly: Uint8Array) => string;
+export declare const decodeCp1: (value: string) => Uint8Array | null;
+export declare const isCp1: (value: string) => boolean;
+export declare const encodeCk1: (signature: Uint8Array) => string;
+export declare const decodeCk1: (value: string) => Uint8Array | null;
+export declare const isCk1: (value: string) => boolean;
+export declare const encodeCs1: (signature: Uint8Array) => string;
+export declare const decodeCs1: (value: string) => Uint8Array | null;
+export declare const isCs1: (value: string) => boolean;
+export declare const encodeCs1WithAmount: (amountMsat: number, signature: Uint8Array) => string;
+export declare const decodeCs1WithAmount: (value: string) => {
+    amountMsat: number;
+    signature: Uint8Array;
+} | null;
+export declare const isCs1WithAmount: (value: string) => boolean;
+export declare const decodeAnyCs1: (value: string) => Uint8Array | null;
+export declare const isAnyCs1: (value: string) => boolean;
+export type Cx1 = {
+    pubkeyXOnly: Uint8Array;
+    chainCode: Uint8Array;
+};
+export declare const encodeCx1: (pubkeyXOnly: Uint8Array, chainCode: Uint8Array) => string;
+export declare const decodeCx1: (value: string) => Cx1 | null;
+export declare const isCx1: (value: string) => boolean;
+export declare const deriveNotePubkey: (branchPubkeyXOnly: Uint8Array, chainCode: Uint8Array, index: number) => Uint8Array;
+export declare const deriveNoteSecretKey: (branchPrivateKey: Uint8Array, chainCode: Uint8Array, index: number) => Uint8Array;

package/dist/request.d.ts

@@ -0,0 +1,78 @@
+export type WithdrawRequestInfo = {
+    tag: 'withdrawRequest';
+    callback: string;
+    k1: string;
+    minWithdrawable: number;
+    maxWithdrawable: number;
+    defaultDescription?: string;
+    mintPubkey: string;
+    sig?: string;
+};
+export type HashWithdrawRequestInfo = Omit<WithdrawRequestInfo, 'k1'>;
+export declare const fetchNoteInfoByHash: (url: string, h: string) => Promise<HashWithdrawRequestInfo>;
+export declare const fetchNoteInfoByPubkey: (url: string, cp1Value: string) => Promise<HashWithdrawRequestInfo>;
+export declare const fetchNoteInfo: (url: string) => Promise<WithdrawRequestInfo>;
+export declare const probeBurnedNote: (url: string) => Promise<'live' | 'gone' | 'unknown'>;
+export 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;
+};
+export declare const fetchMintAddress: (url: string) => Promise<MintAddressInfo>;
+export type WithdrawSuccessResponse = {
+    status: 'OK';
+    sig?: string;
+    sig2?: string;
+    pr?: string;
+    verify?: string;
+};
+export type MeltResult = {
+    verify?: string;
+    pr?: string;
+};
+export declare const meltNote: (callback: string, k1: string, pr: string) => Promise<MeltResult>;
+export type HashedMutationResult = {
+    signature: string;
+};
+export declare const rotateNoteWithHash: (callback: string, k1: string, h: string) => Promise<HashedMutationResult>;
+export type HashedSplitResult = {
+    signature: string;
+    changeSignature: string;
+};
+export declare const splitNoteWithHash: (callback: string, k1s: string[], amountMsat: number, h: string, h2: string) => Promise<HashedSplitResult>;
+export declare const mergeNotesWithHash: (callback: string, k1s: string[], h: string) => Promise<HashedMutationResult>;
+export type RotateResult = {
+    k1: string;
+    signature: string;
+};
+export declare const generateOutputSecret: (domain: string, preferPubkey: boolean) => string;
+export declare const disclosedValue: (secret: string) => string;
+export declare const rotateNote: (callback: string, k1: string) => Promise<RotateResult>;
+export type SplitResult = {
+    k1: string;
+    signature: string;
+    change: string;
+    changeSignature: string;
+};
+export declare const splitNote: (callback: string, k1s: string[], amountMsat: number) => Promise<SplitResult>;
+export declare const mergeNotes: (callback: string, k1s: string[]) => Promise<RotateResult>;
+export type SettledNote = {
+    k1: string;
+    amountMsat: number;
+    signature?: string;
+    callback: string;
+};
+export declare const settleNote: (baseUrl: string, k1: string, expectedAmountMsat: number, signature: string | undefined) => Promise<SettledNote>;

package/dist/secrets.d.ts

@@ -0,0 +1,6 @@
+export type SecretProvider = (domain: string) => string;
+export declare const configureSecretProvider: (provider: SecretProvider) => void;
+export declare const generateSecret: (domain: string) => string;
+export type PubkeySecretProvider = (domain: string) => string | null;
+export declare const configurePubkeySecretProvider: (provider: PubkeySecretProvider) => void;
+export declare const generatePubkeySecret: (domain: string) => string | null;

package/dist/signature.d.ts

@@ -0,0 +1,14 @@
+export declare const MINT_PUBKEY_PATTERN: RegExp;
+export declare const NOTE_SIGNATURE_PATTERN: RegExp;
+export declare const parseMintKey: (body: any) => {
+    mintPubkey: string;
+};
+export declare const hashK1: (k1: string) => string;
+export declare const verifyNoteSignature: (k1: string, amountMsat: number, signatureHex: string, mintPubkeyHex: string) => boolean;
+export declare const verifyNoteSignatureHash: (h: string, amountMsat: number, signatureHex: string, mintPubkeyHex: string) => boolean;
+export declare const signNoteOwnership: (secretKey: Uint8Array) => Uint8Array;
+export declare const recoverNoteOwnershipPubkey: (signature: Uint8Array) => Uint8Array | null;
+export type AddressProofAction = 'register' | 'unregister';
+export declare const signAddressProof: (branchIndexZeroSecretKey: Uint8Array, action: AddressProofAction, username: string) => Uint8Array;
+export declare const cp1FromCk1: (ck1: string) => string | null;
+export declare const requireMutationSignature: (body: any, field: 'sig' | 'sig2') => string;

package/dist/urls.d.ts

@@ -0,0 +1,26 @@
+export declare const isBech32Lnurl: (data: string) => boolean;
+export declare const toBech32Lnurl: (url: string) => string;
+export declare const fromBech32Lnurl: (data: string) => string | null;
+export declare const defaultSchemeFor: (hostish: string) => 'http' | 'https';
+export declare const isAllowedServiceUrl: (value: string) => boolean;
+export declare const fromLud17: (url: string) => string;
+export declare const toLud17w: (url: string) => string;
+export declare const isLightningAddress: (value: string) => boolean;
+export declare const resolveMintInput: (value: string) => string | null;
+export declare const mintAddressUrl: (payUrl: string) => string | null;
+export declare const lightningAddressUsername: (payUrl: string) => string | null;
+export declare const resolveLnurlInput: (value: string) => string | null;
+export declare const noteK1: (url: string) => string | null;
+export declare const requireNoteK1: (url: string) => string;
+export declare const noteDeclaredAmount: (url: string) => number | null;
+export declare const noteSignature: (url: string) => string | null;
+export declare const isValidK1: (value: string) => boolean;
+export declare const resolveNoteInput: (value: string) => string | null;
+export declare const isValidNoteInput: (value: string) => boolean;
+export declare const buildNoteUrl: (withdrawLink: string, k1: string, amountMsat?: number) => string;
+export declare const withNewK1: (url: string, k1: string, amountMsat: number, signature?: string) => string;
+export declare const withoutK1: (url: string, amountMsat: number, signature?: string) => string;
+export declare const withoutSignature: (url: string) => string;
+export declare const serverOf: (url: string) => string;
+export declare const serviceOriginOf: (value: string) => string;
+export declare const noteEndpointOf: (url: string) => string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lnurlcash/kit",
-  "version": "0.14.0-rc.0",
+  "version": "0.14.2",
   "description": "LNURLcash (LUD-25) protocol client for TypeScript",
   "author": "dni",
   "contributors": [
@@ -51,7 +51,7 @@
     }
   },
   "scripts": {
-    "build": "tsup",
+    "build": "node build.mjs",
     "test": "vitest run",
     "typecheck": "tsc --noEmit",
     "check": "npm run typecheck && npm run test && npm run build",
@@ -64,8 +64,8 @@
   },
   "devDependencies": {
     "@types/node": "^26.2.0",
-    "tsup": "^8.5.0",
-    "typescript": "^5.7.0",
+    "esbuild": "^0.27.7",
+    "typescript": "^7.0.2",
     "vitest": "^5.0.0"
   }
 }