applesauce-core 5.0.0 → 5.0.3

package/dist/helpers/keys.d.ts

@@ -1,7 +1,8 @@
-import { Ncryptsec } from "nostr-tools/nip19";
+import { Ncryptsec, NSec } from "nostr-tools/nip19";
 export { generateSecretKey, getPublicKey } from "nostr-tools/pure";
 /** Converts hex to nsec strings into Uint8 secret keys */
-export declare function normalizeToSecretKey(str: string | Uint8Array): Uint8Array;
+export declare function normalizeToSecretKey(str: NSec): Uint8Array;
+export declare function normalizeToSecretKey(str: string | Uint8Array): Uint8Array | null;
 /** Encrypt a secret key using NIP-49 */
 export declare function encryptSecretKey(key: Uint8Array, password: string): Ncryptsec;
 /** Decrypt a secret key using NIP-49 */

package/dist/helpers/keys.js

@@ -1,20 +1,28 @@
 import { decode } from "nostr-tools/nip19";
+import { decrypt, encrypt } from "nostr-tools/nip49";
 import { hexToBytes } from "nostr-tools/utils";
 import { isHexKey } from "./string.js";
-import { encrypt, decrypt } from "nostr-tools/nip49";
 // Re-export types from nostr-tools
 export { generateSecretKey, getPublicKey } from "nostr-tools/pure";
-/** Converts hex to nsec strings into Uint8 secret keys */
 export function normalizeToSecretKey(str) {
-    if (str instanceof Uint8Array)
+    if (str instanceof Uint8Array) {
+        // Ignore invalid lengths
+        if (str.length !== 32)
+            return null;
         return str;
+    }
     else if (isHexKey(str))
         return hexToBytes(str);
     else {
-        const result = decode(str);
-        if (result.type !== "nsec")
-            throw new Error(`Cant get secret key from ${result.type}`);
-        return result.data;
+        try {
+            const result = decode(str);
+            if (result.type !== "nsec")
+                return null;
+            return result.data;
+        }
+        catch {
+            return null;
+        }
     }
 }
 /** Encrypt a secret key using NIP-49 */

package/dist/helpers/pointers.d.ts

@@ -1,8 +1,9 @@
-import { AddressPointer, decode, EventPointer, ProfilePointer } from "nostr-tools/nip19";
+import { AddressPointer, DecodedResult, EventPointer, NAddr, NEvent, NProfile, NPub, ProfilePointer } from "nostr-tools/nip19";
 export type { AddressPointer, EventPointer, ProfilePointer } from "nostr-tools/nip19";
 export { decode as decodePointer, naddrEncode, neventEncode, noteEncode, nprofileEncode, npubEncode, nsecEncode, } from "nostr-tools/nip19";
+export type { NAddr, NEvent, NProfile, NPub } from "nostr-tools/nip19";
 import { NostrEvent } from "./event.js";
-export type DecodeResult = ReturnType<typeof decode>;
+export type DecodeResult = DecodedResult;
 /** Decodes any nip-19 encoded entity to a ProfilePointer */
 export declare function decodeProfilePointer(str: string): ProfilePointer | null;
 /** Decodes an naddr encoded string to an AddressPointer */
@@ -49,9 +50,18 @@ export declare function addRelayHintsToPointer<T extends {
     relays?: string[];
 }>(pointer: T, relays?: Iterable<string>): T;
 /** Gets the hex pubkey from any nip-19 encoded string */
+export declare function normalizeToPubkey(str: NPub): string;
 export declare function normalizeToPubkey(str: string): string | null;
 /** Gets a ProfilePointer from any nip-19 encoded string */
+export declare function normalizeToProfilePointer(str: NProfile): ProfilePointer;
+export declare function normalizeToProfilePointer(str: NPub): ProfilePointer;
 export declare function normalizeToProfilePointer(str: string): ProfilePointer | null;
+/** Gets an AddressPointer from any nip-19 encoded string */
+export declare function normalizeToAddressPointer(str: NAddr): AddressPointer;
+export declare function normalizeToAddressPointer(str: string): AddressPointer | null;
+/** Gets an EventPointer from any nip-19 encoded string */
+export declare function normalizeToEventPointer(str: NEvent): EventPointer;
+export declare function normalizeToEventPointer(str: string): EventPointer | null;
 /** Returns all NIP-19 pointers in a content string */
 export declare function getContentPointers(content: string): DecodeResult[];
 /**

package/dist/helpers/pointers.js

@@ -7,9 +7,20 @@ import { Tokens } from "./regexp.js";
 import { isSafeRelayURL, relaySet } from "./relays.js";
 import { isHexKey } from "./string.js";
 import { normalizeURL } from "./url.js";
+/** Decodes a string and handles errors */
+function safeDecode(str) {
+    try {
+        return decode(str);
+    }
+    catch {
+        return null;
+    }
+}
 /** Decodes any nip-19 encoded entity to a ProfilePointer */
 export function decodeProfilePointer(str) {
-    const result = decode(str);
+    const result = safeDecode(str);
+    if (!result)
+        return null;
     const pubkey = getPubkeyFromDecodeResult(result);
     if (!pubkey)
         return null;
@@ -20,12 +31,16 @@ export function decodeProfilePointer(str) {
 }
 /** Decodes an naddr encoded string to an AddressPointer */
 export function decodeAddressPointer(str) {
-    const result = decode(str);
+    const result = safeDecode(str);
+    if (!result)
+        return null;
     return result.type === "naddr" ? result.data : null;
 }
 /** Decodes a note1 or nevent encoded string to an EventPointer */
 export function decodeEventPointer(str) {
-    const result = decode(str);
+    const result = safeDecode(str);
+    if (!result)
+        return null;
     switch (result.type) {
         case "note":
             return { id: result.data };
@@ -227,24 +242,26 @@ export function addRelayHintsToPointer(pointer, relays) {
     else
         return { ...pointer, relays: relaySet(relays, pointer.relays) };
 }
-/** Gets the hex pubkey from any nip-19 encoded string */
 export function normalizeToPubkey(str) {
     if (isHexKey(str))
         return str.toLowerCase();
     else {
-        const result = decode(str);
+        const result = safeDecode(str);
+        if (!result)
+            return null;
         const pubkey = getPubkeyFromDecodeResult(result);
         if (!pubkey)
             return null;
         return pubkey;
     }
 }
-/** Gets a ProfilePointer from any nip-19 encoded string */
 export function normalizeToProfilePointer(str) {
     if (isHexKey(str))
         return { pubkey: str.toLowerCase() };
     else {
-        const result = decode(str);
+        const result = safeDecode(str);
+        if (!result)
+            return null;
         // Return it if it's a profile pointer
         if (result.type === "nprofile")
             return result.data;
@@ -256,13 +273,42 @@ export function normalizeToProfilePointer(str) {
         return { pubkey, relays };
     }
 }
+export function normalizeToAddressPointer(str) {
+    // Handle <kind>:<pubkey>:<identifier> format
+    if (str.includes(":"))
+        return parseReplaceableAddress(str);
+    // Decode nip-19 encoded string
+    const result = safeDecode(str);
+    if (!result)
+        return null;
+    return result.type === "naddr" ? result.data : null;
+}
+export function normalizeToEventPointer(str) {
+    // Handle <event-id> format
+    if (isHexKey(str))
+        return { id: str.toLowerCase() };
+    // Decode nip-19 encoded string
+    const result = safeDecode(str);
+    if (!result)
+        return null;
+    switch (result.type) {
+        case "nevent":
+            return result.data;
+        case "note":
+            return { id: result.data };
+        default:
+            return null;
+    }
+}
 /** Returns all NIP-19 pointers in a content string */
 export function getContentPointers(content) {
     const mentions = content.matchAll(Tokens.nostrLink);
     const pointers = [];
     for (const [_, $1] of mentions) {
         try {
-            const result = decode($1);
+            const result = safeDecode($1);
+            if (!result)
+                continue;
             pointers.push(result);
         }
         catch (error) { }

package/dist/helpers/url.js

@@ -61,7 +61,7 @@ export function ensureWebSocketURL(url) {
         p.protocol = "ws:";
     else if (p.protocol === "https:")
         p.protocol = "wss:";
-    else
+    else if (p.protocol !== "ws:")
         p.protocol = "wss:";
     // return a string if a string was passed in
     // @ts-expect-error
@@ -74,7 +74,7 @@ export function ensureHttpURL(url) {
         p.protocol = "http:";
     else if (p.protocol === "wss:")
         p.protocol = "https:";
-    else
+    else if (p.protocol !== "http:")
         p.protocol = "https:";
     // return a string if a string was passed in
     // @ts-expect-error

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-core",
-  "version": "5.0.0",
+  "version": "5.0.3",
   "description": "",
   "type": "module",
   "main": "dist/index.js",