applesauce-wallet-connect 0.0.0-next-20250808173123 → 0.0.0-next-20250815164532

package/dist/helpers/animated-qr.js

@@ -1,71 +0,0 @@
-import { getEncodedTokenV4 } from "@cashu/cashu-ts";
-import { UR, URDecoder, UREncoder } from "@gandlaf21/bc-ur/dist/lib/es6/index.js";
-import { defer, filter, interval, map, Observable, shareReplay } from "rxjs";
-/** Preset speeds for the animated qr code */
-export const ANIMATED_QR_INTERVAL = {
-    SLOW: 500,
-    MEDIUM: 250,
-    FAST: 150,
-};
-/** Presets for fragment length for animated qr code */
-export const ANIMATED_QR_FRAGMENTS = {
-    SHORT: 50,
-    MEDIUM: 100,
-    LONG: 150,
-};
-/** Creates an observable that iterates through a multi-part animated qr code */
-export function sendAnimated(token, options) {
-    // start the stream as soon as there is subscriber
-    return defer(() => {
-        let str = typeof token === "string" ? token : getEncodedTokenV4(token);
-        let utf8 = new TextEncoder();
-        let buffer = utf8.encode(str);
-        let ur = UR.from(buffer);
-        let encoder = new UREncoder(ur, options?.fragmentLength ?? 100, 0);
-        return interval(options?.interval ?? ANIMATED_QR_INTERVAL.FAST).pipe(map(() => encoder.nextPart()));
-    });
-}
-/** An operator that decodes UR, emits progress percent and completes with final result or error */
-function urDecoder() {
-    return (source) => new Observable((observer) => {
-        const decoder = new URDecoder();
-        return source.subscribe((part) => {
-            decoder.receivePart(part);
-            if (decoder.isComplete() && decoder.isSuccess()) {
-                // emit progress
-                const progress = decoder.estimatedPercentComplete();
-                observer.next(progress);
-                // emit result
-                const ur = decoder.resultUR();
-                const decoded = ur.decodeCBOR();
-                const utf8 = new TextDecoder();
-                const tokenStr = utf8.decode(decoded);
-                observer.next(tokenStr);
-                // complete
-                observer.complete();
-            }
-            else if (decoder.isError()) {
-                // emit error
-                const reason = decoder.resultError();
-                observer.error(new Error(reason));
-            }
-            else {
-                // emit progress
-                const progress = decoder.estimatedPercentComplete();
-                observer.next(progress);
-            }
-        });
-    });
-}
-/** Creates an observable that completes with decoded token */
-export function receiveAnimated(input) {
-    return input.pipe(
-    // convert to lower case
-    map((str) => str.toLowerCase()), 
-    // filter out non UR parts
-    filter((str) => str.startsWith("ur:bytes")), 
-    // decode UR and complete
-    urDecoder(), 
-    // only run one decoder
-    shareReplay(1));
-}

package/dist/helpers/history.d.ts

@@ -1,26 +0,0 @@
-import { HiddenContentSigner } from "applesauce-core/helpers";
-import { NostrEvent } from "nostr-tools";
-export declare const WALLET_HISTORY_KIND = 7376;
-export type HistoryDirection = "in" | "out";
-export type HistoryContent = {
-    /** The direction of the transaction, in = received, out = sent */
-    direction: HistoryDirection;
-    /** The amount of the transaction */
-    amount: number;
-    /** An array of token event ids created */
-    created: string[];
-    /** The mint that was spent from */
-    mint?: string;
-    /** The fee paid */
-    fee?: number;
-};
-export declare const HistoryContentSymbol: unique symbol;
-/** returns an array of redeemed event ids in a history event */
-export declare function getHistoryRedeemed(history: NostrEvent): string[];
-/** Checks if the history contents are locked */
-export declare function isHistoryContentLocked(history: NostrEvent): boolean;
-/** Returns the parsed content of a 7376 history event */
-export declare function getHistoryContent(history: NostrEvent): HistoryContent | undefined;
-/** Decrypts a wallet history event */
-export declare function unlockHistoryContent(history: NostrEvent, signer: HiddenContentSigner): Promise<HistoryContent>;
-export declare function lockHistoryContent(history: NostrEvent): void;

package/dist/helpers/history.js

@@ -1,47 +0,0 @@
-import { getHiddenTags, getOrComputeCachedValue, isETag, isHiddenContentLocked, isHiddenTagsLocked, lockHiddenTags, setHiddenTagsEncryptionMethod, unlockHiddenTags, } from "applesauce-core/helpers";
-export const WALLET_HISTORY_KIND = 7376;
-// Enable hidden content for wallet history kind
-setHiddenTagsEncryptionMethod(WALLET_HISTORY_KIND, "nip44");
-export const HistoryContentSymbol = Symbol.for("history-content");
-/** returns an array of redeemed event ids in a history event */
-export function getHistoryRedeemed(history) {
-    return history.tags.filter((t) => isETag(t) && t[3] === "redeemed").map((t) => t[1]);
-}
-/** Checks if the history contents are locked */
-export function isHistoryContentLocked(history) {
-    return isHiddenTagsLocked(history);
-}
-/** Returns the parsed content of a 7376 history event */
-export function getHistoryContent(history) {
-    if (isHistoryContentLocked(history))
-        return undefined;
-    return getOrComputeCachedValue(history, HistoryContentSymbol, () => {
-        const tags = getHiddenTags(history);
-        if (!tags)
-            throw new Error("History event is locked");
-        const direction = tags.find((t) => t[0] === "direction")?.[1];
-        if (!direction)
-            throw new Error("History event missing direction");
-        const amountStr = tags.find((t) => t[0] === "amount")?.[1];
-        if (!amountStr)
-            throw new Error("History event missing amount");
-        const amount = parseInt(amountStr);
-        if (!Number.isFinite(amount))
-            throw new Error("Failed to parse amount");
-        const mint = tags.find((t) => t[0] === "mint")?.[1];
-        const feeStr = tags.find((t) => t[0] === "fee")?.[1];
-        const fee = feeStr ? parseInt(feeStr) : undefined;
-        const created = tags.filter((t) => isETag(t) && t[3] === "created").map((t) => t[1]);
-        return { direction, amount, created, mint, fee };
-    });
-}
-/** Decrypts a wallet history event */
-export async function unlockHistoryContent(history, signer) {
-    if (isHiddenContentLocked(history))
-        await unlockHiddenTags(history, signer);
-    return getHistoryContent(history);
-}
-export function lockHistoryContent(history) {
-    Reflect.deleteProperty(history, HistoryContentSymbol);
-    lockHiddenTags(history);
-}

package/dist/helpers/info.d.ts

@@ -1,34 +0,0 @@
-import { NostrEvent } from "nostr-tools";
-import { EncryptionMethods } from "./encryption.js";
-import { WalletMethods } from "./methods.js";
-import { NotificationTypes } from "./notification.js";
-export declare const WALLET_INFO_KIND = 13194;
-/** A symbol used to cache the wallet info on the event */
-export declare const WalletInfoSymbol: unique symbol;
-/** Wallet service capabilities and information */
-export interface WalletFeatures {
-    /** List of supported methods for this wallet service */
-    methods: WalletMethods[];
-    /** List of supported encryption methods */
-    encryption: EncryptionMethods[];
-    /** List of supported notifications, optional */
-    notifications?: NotificationTypes[];
-}
-/** Gets the wallet info from a kind 13194 event */
-export declare function getWalletFeatures(info: NostrEvent): WalletFeatures | null;
-/** Gets the encryption methods from a wallet info event */
-export declare function getEncryptionMethods(info: NostrEvent | WalletFeatures): EncryptionMethods[];
-/** Checks if the wallet service supports a specific encryption method */
-export declare function supportsEncryption(info: NostrEvent | WalletFeatures, encryption: EncryptionMethods): boolean;
-/** Gets the preferred encryption method (nip44_v2 preferred over nip04) */
-export declare function getPreferredEncryption(info: NostrEvent | WalletFeatures): EncryptionMethods;
-/** Checks if the wallet service supports a specific method */
-export declare function supportsMethod(info: NostrEvent | WalletFeatures, method: WalletMethods): boolean;
-/** Checks if the wallet service supports notifications */
-export declare function supportsNotifications(info: NostrEvent | WalletFeatures): boolean;
-/** Checks if the wallet service supports a specific notification type */
-export declare function supportsNotificationType(info: NostrEvent | WalletFeatures, notificationType: NotificationTypes): boolean;
-/** Gets all supported methods from the wallet info */
-export declare function getSupportedMethods(info: NostrEvent | WalletFeatures): WalletMethods[];
-/** Gets all supported notifications from the wallet info */
-export declare function getSupportedNotifications(info: NostrEvent | WalletFeatures): NotificationTypes[];

package/dist/helpers/info.js

@@ -1,97 +0,0 @@
-import { getOrComputeCachedValue, getTagValue, isEvent } from "applesauce-core/helpers";
-export const WALLET_INFO_KIND = 13194;
-/** A symbol used to cache the wallet info on the event */
-export const WalletInfoSymbol = Symbol("wallet-info");
-/** Gets the wallet info from a kind 13194 event */
-export function getWalletFeatures(info) {
-    if (info.kind !== WALLET_INFO_KIND)
-        return null;
-    return getOrComputeCachedValue(info, WalletInfoSymbol, () => {
-        const content = info.content.trim();
-        if (!content)
-            return null;
-        // Parse methods from content (space-separated)
-        const contentParts = content.split(/\s+/);
-        const methods = contentParts
-            .filter((part) => [
-            "pay_invoice",
-            "multi_pay_invoice",
-            "pay_keysend",
-            "multi_pay_keysend",
-            "make_invoice",
-            "lookup_invoice",
-            "list_transactions",
-            "get_balance",
-            "get_info",
-            "notifications",
-        ].includes(part))
-            .filter((part) => part !== "notifications");
-        // Parse encryption methods from encryption tag
-        const encryptionTag = getTagValue(info, "encryption");
-        const encryption = encryptionTag
-            ? encryptionTag
-                .split(/\s+/)
-                .filter((method) => method === "nip44_v2" || method === "nip04")
-            : ["nip04"]; // Default to nip04 if no encryption tag is present
-        // Parse notifications from notifications tag
-        const notificationsTag = getTagValue(info, "notifications");
-        const notifications = notificationsTag
-            ? notificationsTag
-                .split(/\s+/)
-                .filter((notif) => notif === "payment_received" || notif === "payment_sent")
-            : undefined;
-        return {
-            methods,
-            encryption,
-            notifications,
-        };
-    });
-}
-/** Gets the encryption methods from a wallet info event */
-export function getEncryptionMethods(info) {
-    const walletInfo = isEvent(info) ? getWalletFeatures(info) : info;
-    return walletInfo?.encryption ?? [];
-}
-/** Checks if the wallet service supports a specific encryption method */
-export function supportsEncryption(info, encryption) {
-    const encryptionMethods = getEncryptionMethods(info);
-    return encryptionMethods.includes(encryption);
-}
-/** Gets the preferred encryption method (nip44_v2 preferred over nip04) */
-export function getPreferredEncryption(info) {
-    const encryptionMethods = getEncryptionMethods(info);
-    if (encryptionMethods.length === 0)
-        return "nip04";
-    // Prefer nip44_v2 over nip04
-    if (encryptionMethods.includes("nip44_v2"))
-        return "nip44_v2";
-    if (encryptionMethods.includes("nip04"))
-        return "nip04";
-    // Absence of this tag implies that the wallet only supports nip04.
-    return "nip04";
-}
-/** Checks if the wallet service supports a specific method */
-export function supportsMethod(info, method) {
-    const walletInfo = isEvent(info) ? getWalletFeatures(info) : info;
-    return walletInfo?.methods.includes(method) ?? false;
-}
-/** Checks if the wallet service supports notifications */
-export function supportsNotifications(info) {
-    const walletInfo = isEvent(info) ? getWalletFeatures(info) : info;
-    return (walletInfo?.notifications?.length ?? 0) > 0;
-}
-/** Checks if the wallet service supports a specific notification type */
-export function supportsNotificationType(info, notificationType) {
-    const walletInfo = isEvent(info) ? getWalletFeatures(info) : info;
-    return walletInfo?.notifications?.includes(notificationType) ?? false;
-}
-/** Gets all supported methods from the wallet info */
-export function getSupportedMethods(info) {
-    const walletInfo = isEvent(info) ? getWalletFeatures(info) : info;
-    return walletInfo?.methods ?? [];
-}
-/** Gets all supported notifications from the wallet info */
-export function getSupportedNotifications(info) {
-    const walletInfo = isEvent(info) ? getWalletFeatures(info) : info;
-    return walletInfo?.notifications ?? [];
-}

package/dist/helpers/methods.d.ts

@@ -1 +0,0 @@
-export type WalletMethods = "pay_invoice" | "multi_pay_invoice" | "pay_keysend" | "multi_pay_keysend" | "make_invoice" | "lookup_invoice" | "list_transactions" | "get_balance" | "get_info";

package/dist/helpers/methods.js

@@ -1 +0,0 @@
-export {};

package/dist/helpers/nutzap.d.ts

@@ -1,27 +0,0 @@
-import { Proof } from "@cashu/cashu-ts";
-import { NostrEvent } from "nostr-tools";
-import { AddressPointer, EventPointer } from "nostr-tools/nip19";
-export declare const NUTZAP_KIND = 9321;
-export declare const NutzapProofsSymbol: unique symbol;
-export declare const NutzapAmountSymbol: unique symbol;
-export declare const NutzapMintSymbol: unique symbol;
-/** Returns the cashu proofs from a kind:9321 nutzap event */
-export declare function getNutzapProofs(event: NostrEvent): Proof[];
-/** Returns the mint URL from a kind:9321 nutzap event */
-export declare function getNutzapMint(event: NostrEvent): string | undefined;
-/** Returns the recipient pubkey from a kind:9321 nutzap event */
-export declare function getNutzapRecipient(event: NostrEvent): string | undefined;
-/** Returns the event ID being nutzapped from a kind:9321 nutzap event */
-export declare function getNutzapEventPointer(event: NostrEvent): EventPointer | undefined;
-/** Returns the event ID being nutzapped from a kind:9321 nutzap event */
-export declare function getNutzapAddressPointer(event: NostrEvent): AddressPointer | undefined;
-/** Returns the EventPointer or AddressPointer from a kind:9321 nutzap event */
-export declare function getNutzapPointer(event: NostrEvent): EventPointer | AddressPointer | undefined;
-/** Returns the comment from a kind:9321 nutzap event */
-export declare function getNutzapComment(event: NostrEvent): string | undefined;
-/** Calculates the total amount of sats in a kind:9321 nutzap event */
-export declare function getNutzapAmount(event: NostrEvent): number;
-/** Checks if a nutzap is valid according to NIP-61 requirements */
-export declare function isValidNutzap(nutzap: NostrEvent): boolean;
-/** Checks if a nutzap event has already been redeemed based on kind:7376 wallet history events */
-export declare function isNutzapRedeemed(nutzapId: string, history: NostrEvent[]): boolean;

package/dist/helpers/nutzap.js

@@ -1,66 +0,0 @@
-import { getAddressPointerFromATag, getEventPointerFromETag, getOrComputeCachedValue, getTagValue, processTags, safeParse, } from "applesauce-core/helpers";
-import { getHistoryRedeemed } from "./history.js";
-export const NUTZAP_KIND = 9321;
-// Symbols for caching computed values
-export const NutzapProofsSymbol = Symbol.for("nutzap-proofs");
-export const NutzapAmountSymbol = Symbol.for("nutzap-amount");
-export const NutzapMintSymbol = Symbol.for("nutzap-mint");
-/** Returns the cashu proofs from a kind:9321 nutzap event */
-export function getNutzapProofs(event) {
-    return getOrComputeCachedValue(event, NutzapProofsSymbol, () => {
-        return processTags(event.tags, (tag) => (tag[0] === "proof" ? safeParse(tag[1]) : undefined));
-    });
-}
-/** Returns the mint URL from a kind:9321 nutzap event */
-export function getNutzapMint(event) {
-    return getOrComputeCachedValue(event, NutzapMintSymbol, () => {
-        const url = getTagValue(event, "u");
-        return url && URL.canParse(url) ? url : undefined;
-    });
-}
-/** Returns the recipient pubkey from a kind:9321 nutzap event */
-export function getNutzapRecipient(event) {
-    return getTagValue(event, "p");
-}
-/** Returns the event ID being nutzapped from a kind:9321 nutzap event */
-export function getNutzapEventPointer(event) {
-    const tag = event.tags.find((t) => t[0] === "e");
-    if (!tag)
-        return;
-    return getEventPointerFromETag(tag);
-}
-/** Returns the event ID being nutzapped from a kind:9321 nutzap event */
-export function getNutzapAddressPointer(event) {
-    const tag = event.tags.find((t) => t[0] === "a");
-    if (!tag)
-        return;
-    return getAddressPointerFromATag(tag);
-}
-/** Returns the EventPointer or AddressPointer from a kind:9321 nutzap event */
-export function getNutzapPointer(event) {
-    return getNutzapEventPointer(event) ?? getNutzapAddressPointer(event);
-}
-/** Returns the comment from a kind:9321 nutzap event */
-export function getNutzapComment(event) {
-    return event.content || undefined;
-}
-/** Calculates the total amount of sats in a kind:9321 nutzap event */
-export function getNutzapAmount(event) {
-    return getOrComputeCachedValue(event, NutzapAmountSymbol, () => {
-        const proofs = getNutzapProofs(event);
-        return proofs.reduce((total, proof) => total + (proof.amount || 0), 0);
-    });
-}
-/** Checks if a nutzap is valid according to NIP-61 requirements */
-export function isValidNutzap(nutzap) {
-    const mint = getNutzapMint(nutzap);
-    const recipient = getNutzapRecipient(nutzap);
-    const proofs = getNutzapProofs(nutzap);
-    if (!mint || !recipient || proofs.length === 0)
-        return false;
-    return true;
-}
-/** Checks if a nutzap event has already been redeemed based on kind:7376 wallet history events */
-export function isNutzapRedeemed(nutzapId, history) {
-    return history.some((entry) => getHistoryRedeemed(entry).includes(nutzapId));
-}

package/dist/helpers/tokens.d.ts

@@ -1,58 +0,0 @@
-import { Proof, Token } from "@cashu/cashu-ts";
-import { HiddenContentSigner } from "applesauce-core/helpers";
-import { NostrEvent } from "nostr-tools";
-export declare const WALLET_TOKEN_KIND = 7375;
-/** Internal method for creating a unique id for each proof */
-export declare function getProofUID(proof: Proof): string;
-/** Internal method to filter out duplicate proofs */
-export declare function ignoreDuplicateProofs(seen?: Set<string>): (proof: Proof) => boolean;
-export type TokenContent = {
-    /** Cashu mint for the proofs */
-    mint: string;
-    /** Cashu proofs */
-    proofs: {
-        amount: number;
-        secret: string;
-        C: string;
-        id: string;
-    }[];
-    /** The cashu unit */
-    unit?: string;
-    /** tokens that were destroyed in the creation of this token (helps on wallet state transitions) */
-    del: string[];
-};
-export declare const TokenContentSymbol: unique symbol;
-/**
- * Returns the decrypted and parsed details of a 7375 token event
- * @throws
- */
-export declare function getTokenContent(token: NostrEvent): TokenContent | undefined;
-/** Returns if token details are locked */
-export declare function isTokenContentLocked(token: NostrEvent): boolean;
-/** Decrypts a k:7375 token event */
-export declare function unlockTokenContent(token: NostrEvent, signer: HiddenContentSigner): Promise<TokenContent>;
-/** Removes the unencrypted hidden content */
-export declare function lockTokenContent(token: NostrEvent): void;
-/**
- * Gets the totaled amount of proofs in a token event
- * @param token The token event to calculate the total
- */
-export declare function getTokenProofsTotal(token: NostrEvent): number | undefined;
-/**
- * Selects oldest tokens and proofs that total up to more than the min amount
- * @throws
- */
-export declare function dumbTokenSelection(tokens: NostrEvent[], minAmount: number, mint?: string): {
-    events: NostrEvent[];
-    proofs: Proof[];
-};
-/**
- * Returns a decoded cashu token inside an unicode emoji
- * @see https://github.com/cashubtc/cashu.me/blob/1194a7b9ee2f43305e38304de7bef8839601ff4d/src/components/ReceiveTokenDialog.vue#L387
- */
-export declare function decodeTokenFromEmojiString(str: string): Token | undefined;
-/**
- * Encodes a token into an emoji char
- * @see https://github.com/cashubtc/cashu.me/blob/1194a7b9ee2f43305e38304de7bef8839601ff4d/src/components/SendTokenDialog.vue#L710
- */
-export declare function encodeTokenToEmoji(token: Token | string, emoji?: string): string;

package/dist/helpers/tokens.js

@@ -1,162 +0,0 @@
-import { getDecodedToken, getEncodedToken } from "@cashu/cashu-ts";
-import { getHiddenContent, getOrComputeCachedValue, isHiddenContentLocked, isHiddenTagsLocked, lockHiddenContent, setHiddenContentEncryptionMethod, unlockHiddenContent, } from "applesauce-core/helpers";
-export const WALLET_TOKEN_KIND = 7375;
-// Enable hidden content for wallet token kind
-setHiddenContentEncryptionMethod(WALLET_TOKEN_KIND, "nip44");
-/** Internal method for creating a unique id for each proof */
-export function getProofUID(proof) {
-    return proof.id + proof.amount + proof.C + proof.secret;
-}
-/** Internal method to filter out duplicate proofs */
-export function ignoreDuplicateProofs(seen = new Set()) {
-    return (proof) => {
-        const id = getProofUID(proof);
-        if (seen.has(id))
-            return false;
-        else {
-            seen.add(id);
-            return true;
-        }
-    };
-}
-export const TokenContentSymbol = Symbol.for("token-content");
-/**
- * Returns the decrypted and parsed details of a 7375 token event
- * @throws
- */
-export function getTokenContent(token) {
-    if (isHiddenTagsLocked(token))
-        return undefined;
-    return getOrComputeCachedValue(token, TokenContentSymbol, () => {
-        const plaintext = getHiddenContent(token);
-        if (!plaintext)
-            throw new Error("Token is locked");
-        const details = JSON.parse(plaintext);
-        if (!details.mint)
-            throw new Error("Token missing mint");
-        if (!details.proofs)
-            throw new Error("Token missing proofs");
-        if (!details.del)
-            details.del = [];
-        return details;
-    });
-}
-/** Returns if token details are locked */
-export function isTokenContentLocked(token) {
-    return isHiddenContentLocked(token);
-}
-/** Decrypts a k:7375 token event */
-export async function unlockTokenContent(token, signer) {
-    if (isHiddenContentLocked(token))
-        await unlockHiddenContent(token, signer);
-    return getTokenContent(token);
-}
-/** Removes the unencrypted hidden content */
-export function lockTokenContent(token) {
-    Reflect.deleteProperty(token, TokenContentSymbol);
-    lockHiddenContent(token);
-}
-/**
- * Gets the totaled amount of proofs in a token event
- * @param token The token event to calculate the total
- */
-export function getTokenProofsTotal(token) {
-    if (isTokenContentLocked(token))
-        return undefined;
-    const content = getTokenContent(token);
-    return content.proofs.reduce((t, p) => t + p.amount, 0);
-}
-/**
- * Selects oldest tokens and proofs that total up to more than the min amount
- * @throws
- */
-export function dumbTokenSelection(tokens, minAmount, mint) {
-    // sort newest to oldest
-    const sorted = tokens
-        .filter((token) => !isTokenContentLocked(token) && (mint ? getTokenContent(token).mint === mint : true))
-        .sort((a, b) => b.created_at - a.created_at);
-    let amount = 0;
-    const seen = new Set();
-    const selectedTokens = [];
-    const selectedProofs = [];
-    while (amount < minAmount) {
-        const token = sorted.pop();
-        if (!token)
-            throw new Error("Insufficient funds");
-        const proofs = getTokenContent(token).proofs.filter(ignoreDuplicateProofs(seen));
-        const total = proofs.reduce((t, p) => t + p.amount, 0);
-        selectedTokens.push(token);
-        selectedProofs.push(...proofs);
-        amount += total;
-    }
-    return { events: selectedTokens, proofs: selectedProofs };
-}
-/**
- * Returns a decoded cashu token inside an unicode emoji
- * @see https://github.com/cashubtc/cashu.me/blob/1194a7b9ee2f43305e38304de7bef8839601ff4d/src/components/ReceiveTokenDialog.vue#L387
- */
-export function decodeTokenFromEmojiString(str) {
-    try {
-        let decoded = [];
-        const chars = Array.from(str);
-        if (!chars.length)
-            return undefined;
-        const fromVariationSelector = function (char) {
-            const codePoint = char.codePointAt(0);
-            if (codePoint === undefined)
-                return null;
-            // Handle Variation Selectors (VS1-VS16): U+FE00 to U+FE0F
-            if (codePoint >= 0xfe00 && codePoint <= 0xfe0f) {
-                // Maps FE00->0, FE01->1, ..., FE0F->15
-                const byteValue = codePoint - 0xfe00;
-                return String.fromCharCode(byteValue);
-            }
-            // Handle Variation Selectors Supplement (VS17-VS256): U+E0100 to U+E01EF
-            if (codePoint >= 0xe0100 && codePoint <= 0xe01ef) {
-                // Maps E0100->16, E0101->17, ..., E01EF->255
-                const byteValue = codePoint - 0xe0100 + 16;
-                return String.fromCharCode(byteValue);
-            }
-            // No Variation Selector
-            return null;
-        };
-        // Check all input chars for peanut data
-        for (const char of chars) {
-            let byte = fromVariationSelector(char);
-            if (byte === null && decoded.length > 0) {
-                break;
-            }
-            else if (byte === null) {
-                continue;
-            }
-            decoded.push(byte); // got some
-        }
-        // Switch out token if we found peanut data
-        let decodedString = decoded.join("");
-        return getDecodedToken(decodedString);
-    }
-    catch (error) {
-        return undefined;
-    }
-}
-/**
- * Encodes a token into an emoji char
- * @see https://github.com/cashubtc/cashu.me/blob/1194a7b9ee2f43305e38304de7bef8839601ff4d/src/components/SendTokenDialog.vue#L710
- */
-export function encodeTokenToEmoji(token, emoji = "🥜") {
-    return (emoji +
-        Array.from(typeof token === "string" ? token : getEncodedToken(token))
-            .map((char) => {
-            const byteValue = char.charCodeAt(0);
-            // For byte values 0-15, use Variation Selectors (VS1-VS16): U+FE00 to U+FE0F
-            if (byteValue >= 0 && byteValue <= 15) {
-                return String.fromCodePoint(0xfe00 + byteValue);
-            }
-            // For byte values 16-255, use Variation Selectors Supplement (VS17-VS256): U+E0100 to U+E01EF
-            if (byteValue >= 16 && byteValue <= 255) {
-                return String.fromCodePoint(0xe0100 + (byteValue - 16));
-            }
-            return "";
-        })
-            .join(""));
-}

package/dist/helpers/wallet.d.ts

@@ -1,15 +0,0 @@
-import { HiddenContentSigner } from "applesauce-core/helpers";
-import { NostrEvent } from "nostr-tools";
-export declare const WALLET_KIND = 17375;
-export declare const WALLET_BACKUP_KIND = 375;
-export declare const WalletPrivateKeySymbol: unique symbol;
-export declare const WalletMintsSymbol: unique symbol;
-/** Returns if a wallet is locked */
-export declare function isWalletLocked(wallet: NostrEvent): boolean;
-/** Unlocks a wallet and returns the hidden tags */
-export declare function unlockWallet(wallet: NostrEvent, signer: HiddenContentSigner): Promise<string[][]>;
-export declare function lockWallet(wallet: NostrEvent): void;
-/** Returns the wallets mints */
-export declare function getWalletMints(wallet: NostrEvent): string[];
-/** Returns the wallets private key as a string */
-export declare function getWalletPrivateKey(wallet: NostrEvent): Uint8Array | undefined;

package/dist/helpers/wallet.js

@@ -1,41 +0,0 @@
-import { hexToBytes } from "@noble/hashes/utils";
-import { getHiddenTags, getOrComputeCachedValue, isHiddenTagsLocked, lockHiddenTags, setHiddenTagsEncryptionMethod, unlockHiddenTags, } from "applesauce-core/helpers";
-export const WALLET_KIND = 17375;
-export const WALLET_BACKUP_KIND = 375;
-// Enable hidden content for wallet kinds
-setHiddenTagsEncryptionMethod(WALLET_KIND, "nip44");
-setHiddenTagsEncryptionMethod(WALLET_BACKUP_KIND, "nip44");
-export const WalletPrivateKeySymbol = Symbol.for("wallet-private-key");
-export const WalletMintsSymbol = Symbol.for("wallet-mints");
-/** Returns if a wallet is locked */
-export function isWalletLocked(wallet) {
-    return isHiddenTagsLocked(wallet);
-}
-/** Unlocks a wallet and returns the hidden tags */
-export async function unlockWallet(wallet, signer) {
-    return await unlockHiddenTags(wallet, signer);
-}
-export function lockWallet(wallet) {
-    Reflect.deleteProperty(wallet, WalletPrivateKeySymbol);
-    Reflect.deleteProperty(wallet, WalletMintsSymbol);
-    lockHiddenTags(wallet);
-}
-/** Returns the wallets mints */
-export function getWalletMints(wallet) {
-    return getOrComputeCachedValue(wallet, WalletMintsSymbol, () => {
-        const tags = getHiddenTags(wallet);
-        if (!tags)
-            throw new Error("Wallet is locked");
-        return tags.filter((t) => t[0] === "mint").map((t) => t[1]);
-    });
-}
-/** Returns the wallets private key as a string */
-export function getWalletPrivateKey(wallet) {
-    return getOrComputeCachedValue(wallet, WalletPrivateKeySymbol, () => {
-        const tags = getHiddenTags(wallet);
-        if (!tags)
-            throw new Error("Wallet is locked");
-        const key = tags.find((t) => t[0] === "privkey" && t[1])?.[1];
-        return key ? hexToBytes(key) : undefined;
-    });
-}