cleanup

4 files changed, 44 insertions, 10 deletions

diff --git a/src/lib/ark.ts b/src/lib/ark.ts
index b1098ee3..d0f16d78 100644
--- a/src/lib/ark.ts
+++ b/src/lib/ark.ts
@@ -1,14 +1,17 @@
 import { persistLocal } from "$lib/store";
 import { post } from "$lib/utils";
-import { SingleKey, Wallet } from "@arkade-os/sdk";
 import { get } from "svelte/store";
 
 export const arkServerUrl = "http://localhost:7070";
 export const arkkey = persistLocal("arkkey", "");
 
+let arkSdkPromise: Promise<typeof import("@arkade-os/sdk")> | undefined;
+const loadArkSdk = () => (arkSdkPromise ||= import("@arkade-os/sdk"));
+
 export const getWallet = async () => {
 	const key = get(arkkey);
 	if (!key) return;
+	const { SingleKey, Wallet } = await loadArkSdk();
 	const identity = SingleKey.fromHex(key);
 
 	return Wallet.create({
diff --git a/src/lib/nostr.ts b/src/lib/nostr.ts
index 6343bc9e..85c90051 100644
--- a/src/lib/nostr.ts
+++ b/src/lib/nostr.ts
@@ -21,10 +21,18 @@ import { decrypt as nip44decrypt, getConversationKey } from "nostr-tools/nip44";
 import { Relay } from "nostr-tools/relay";
 import { get } from "svelte/store";
 
-import {
-	decrypt as nip49decrypt,
-	encrypt as nip49encrypt,
-} from "nostr-tools/nip49";
+let nostrToolsPromise:
+	| Promise<typeof import("nostr-tools")>
+	| undefined;
+let nip44Promise: Promise<typeof import("nostr-tools/nip44")> | undefined;
+let relayPromise: Promise<typeof import("nostr-tools/relay")> | undefined;
+let nip49Promise: Promise<typeof import("nostr-tools/nip49")> | undefined;
+
+const loadNostrTools = () =>
+	(nostrToolsPromise ||= import("nostr-tools"));
+const loadNip44 = () => (nip44Promise ||= import("nostr-tools/nip44"));
+const loadRelay = () => (relayPromise ||= import("nostr-tools/relay"));
+const loadNip49 = () => (nip49Promise ||= import("nostr-tools/nip49"));
 
 type User = {
 	[key: string]: any;
@@ -38,6 +46,7 @@ type EncryptParams = {
 
 export const encrypt = async ({ message, recipient, user }: EncryptParams) => {
 	const sk = await getPrivateKey(user);
+	const { nip04 } = await loadNostrTools();
 	return nip04.encrypt(sk, recipient, message);
 };
 
@@ -48,6 +57,7 @@ export const decrypt = async ({ event, user }) => {
 		if (cache[id]) return cache[id];
 		if (pubkey === user.pubkey) pubkey = event.tags[0][1];
 
+		const { nip04 } = await loadNostrTools();
 		const message = await nip04.decrypt(
 			await getPrivateKey(user),
 			pubkey,
@@ -68,6 +78,7 @@ export const getPrivateKey = async (user: User): Promise<Uint8Array> => {
 	if (browser) {
 		k = localStorage.getItem("nsec");
 		if (k) {
+			const { nip19 } = await loadNostrTools();
 			return nip19.decode(k).data as Uint8Array;
 		}
 	}
@@ -75,38 +86,45 @@ export const getPrivateKey = async (user: User): Promise<Uint8Array> => {
 	const { nsec } = user;
 
 	if (nsec) {
+		const { decrypt: nip49decrypt } = await loadNip49();
 		k = nip49decrypt(nsec, await getPassword());
 	} else {
 		throw new Error("nsec not available");
 	}
 
+	const { nip19 } = await loadNostrTools();
 	localStorage.setItem("nsec", nip19.nsecEncode(k));
 	return k;
 };
 
-const decodeNsec = (nsec: string): Uint8Array => {
+const decodeNsec = async (nsec: string): Promise<Uint8Array> => {
+	const { nip19 } = await loadNostrTools();
 	const { type, data } = nip19.decode(nsec);
 	if (type === "nsec" && data instanceof Uint8Array) return data;
 	throw new Error("invalid nsec");
 };
 
 export const getNsec = async (user: User) => {
+	const { nip19 } = await loadNostrTools();
 	return nip19.nsecEncode(await getPrivateKey(user));
 };
 
 export const setNsec = async (user: User, nsec: string) => {
-	user.pubkey = getPublicKey(decodeNsec(nsec));
+	const { getPublicKey } = await loadNostrTools();
+	user.pubkey = getPublicKey(await decodeNsec(nsec));
 	user.nsec = await encryptNsec(nsec);
 };
 
 export const encryptNsec = async (nsec: string) => {
-	const d = decodeNsec(nsec);
+	const { encrypt: nip49encrypt } = await loadNip49();
+	const d = await decodeNsec(nsec);
 	return nip49encrypt(d, await getPassword());
 };
 
 export const sign = async (event, user) => {
 	if (user?.nsec && !get($signer)?.ready) {
 		const sk = await getPrivateKey(user);
+		const { getPublicKey } = await loadNostrTools();
 
 		$signer.set({
 			method: "nsec",
@@ -154,6 +172,7 @@ const signingMethods = {
 			params: [JSON.stringify(event)],
 		};
 
+		const { nip04, finalizeEvent } = await loadNostrTools();
 		const content = await nip04.encrypt(sk, pk, JSON.stringify(signEvent));
 
 		const signedSignEvent = finalizeEvent(
@@ -167,6 +186,7 @@ const signingMethods = {
 			sk,
 		);
 
+		const { Relay } = await loadRelay();
 		const relay = await Relay.connect(nostrConnectRelay);
 		relay.publish(signedSignEvent);
 
@@ -177,8 +197,11 @@ const signingMethods = {
 					try {
 						let response;
 						try {
+							const { nip04 } = await loadNostrTools();
 							response = JSON.parse(await nip04.decrypt(sk, pk, event.content));
 						} catch (e) {
+							const { getConversationKey, decrypt: nip44decrypt } =
+								await loadNip44();
 							const ck = await getConversationKey(sk, pk);
 							response = JSON.parse(await nip44decrypt(event.content, ck));
 						}
@@ -193,6 +216,7 @@ const signingMethods = {
 	},
 
 	async nsec(event, { sk }) {
+		const { finalizeEvent } = await loadNostrTools();
 		return finalizeEvent(event, sk);
 	},
 
@@ -202,6 +226,7 @@ const signingMethods = {
 
 	async signer(event, { pubkey, sig }) {
 		event.pubkey = pubkey;
+		const { getEventHash } = await loadNostrTools();
 		const signedEvent = {
 			...event,
 			id: getEventHash(event),
diff --git a/src/lib/parse.ts b/src/lib/parse.ts
index bbcab429..8520c27a 100644
--- a/src/lib/parse.ts
+++ b/src/lib/parse.ts
@@ -2,7 +2,12 @@ import { PUBLIC_DOMAIN } from "$env/static/public";
 import { decode } from "$lib/bip21";
 import { auth, get, isLiquid, post, sats } from "$lib/utils";
 import { redirect } from "@sveltejs/kit";
-import { validate } from "bitcoin-address-validation";
+
+let validatePromise:
+	| Promise<typeof import("bitcoin-address-validation")>
+	| undefined;
+const loadValidate = () =>
+	(validatePromise ||= import("bitcoin-address-validation"));
 
 export default async (s, host, cookies) => {
 	if (!s) return;
@@ -49,6 +54,7 @@ export default async (s, host, cookies) => {
 		} = decode(t));
 	}
 
+	const { validate } = await loadValidate();
 	if (validate(t) || isLiquid(t)) {
 		let r = `/send/bitcoin/${t}`;
 		if (amount) r += `/${Math.round(amount * sats)}`;
diff --git a/src/lib/utils.ts b/src/lib/utils.ts
index d3333280..33737b50 100644
--- a/src/lib/utils.ts
+++ b/src/lib/utils.ts
@@ -11,7 +11,6 @@ import {
 	differenceInMinutes,
 	differenceInSeconds,
 } from "date-fns";
-import { decrypt } from "nostr-tools/nip49";
 import { get as getStore } from "svelte/store";
 
 export function scroll(section: any) {
@@ -207,6 +206,7 @@ export const login = async (
 	cookies.set("token", token, opts);
 	if (u.nsec) {
 		try {
+			const { decrypt } = await import("nostr-tools/nip49");
 			cookies.set("sk", bytesToHex(decrypt(u.nsec, user.password)), {
 				...opts,
 				httpOnly: false,