@dynamic-labs-sdk/client 0.17.1 → 0.17.2

package/dist/{getNetworkProviderFromNetworkId-BJR1GciB.cjs.js → getNetworkProviderFromNetworkId-CllkC31J.cjs.js}

@@ -1,11 +1,87 @@
-const require_InvalidParamError = require('./InvalidParamError-zIxsXkiH.cjs.js');
-const require_getVerifiedCredentialForWalletAccount = require('./getVerifiedCredentialForWalletAccount-D25Vyxub.cjs.js');
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+const require_InvalidParamError = require('./InvalidParamError-z_h8HyKL.cjs.js');
+const require_getVerifiedCredentialForWalletAccount = require('./getVerifiedCredentialForWalletAccount-BK4IBZlH.cjs.js');
 let _dynamic_labs_sdk_api_core = require("@dynamic-labs/sdk-api-core");
 let zod_mini = require("zod/mini");
-zod_mini = require_InvalidParamError.__toESM(zod_mini);
+zod_mini = __toESM(zod_mini);
+let buffer = require("buffer");
 let eventemitter3 = require("eventemitter3");
-eventemitter3 = require_InvalidParamError.__toESM(eventemitter3);
+eventemitter3 = __toESM(eventemitter3);
+
+//#region src/utils/isEqualShallow/isEqualShallow.ts
+/**
+* Shallow compare two objects.
+*
+* Source: https://github.com/pmndrs/zustand/blob/main/src/vanilla/shallow.ts
+*/
+const isEqualShallow = (objA, objB) => {
+	if (Object.is(objA, objB)) return true;
+	if (typeof objA !== "object" || objA === null || typeof objB !== "object" || objB === null) return objA === objB;
+	if (objA instanceof Map && objB instanceof Map) {
+		if (objA.size !== objB.size) return false;
+		for (const [key, value] of objA) if (!Object.is(value, objB.get(key))) return false;
+		return true;
+	}
+	if (objA instanceof Set && objB instanceof Set) {
+		if (objA.size !== objB.size) return false;
+		for (const value of objA) if (!objB.has(value)) return false;
+		return true;
+	}
+	const keysA = Object.keys(objA);
+	if (keysA.length !== Object.keys(objB).length) return false;
+	for (const keyA of keysA) if (!Object.prototype.hasOwnProperty.call(objB, keyA) || !Object.is(objA[keyA], objB[keyA])) return false;
+	if (objA.constructor !== objB.constructor) return false;
+	return true;
+};
 
+//#endregion
+//#region src/utils/observable/subscribeWithSelector/subscribeWithSelector.ts
+/**
+* Allows subscribing to a slice of the state.
+* The slice is a computation of the states.
+*
+* The callback will only be called when the slice has changed.
+* Change is determined by shallow comparison.
+*
+* Returns a function to unsubscribe the callback.
+*/
+const subscribeWithSelector = (observable, selector) => (callback) => {
+	let lastSlice = selector(observable.get());
+	return observable.subscribe((value) => {
+		const nextSlice = selector(value);
+		if (isEqualShallow(nextSlice, lastSlice)) return;
+		lastSlice = nextSlice;
+		callback(nextSlice);
+	});
+};
+
+//#endregion
 //#region src/services/storage/createLocalStorageAdapter/createLocalStorageAdapter.ts
 /**
 * Creates a localStorage adapter
@@ -106,79 +182,23 @@ const createStorage = ({ prefix = "", storageAdapter }) => {
 };
 
 //#endregion
-//#region src/utils/isEqualShallow/isEqualShallow.ts
-/**
-* Shallow compare two objects.
-*
-* Source: https://github.com/pmndrs/zustand/blob/main/src/vanilla/shallow.ts
-*/
-const isEqualShallow = (objA, objB) => {
-	if (Object.is(objA, objB)) return true;
-	if (typeof objA !== "object" || objA === null || typeof objB !== "object" || objB === null) return objA === objB;
-	if (objA instanceof Map && objB instanceof Map) {
-		if (objA.size !== objB.size) return false;
-		for (const [key, value] of objA) if (!Object.is(value, objB.get(key))) return false;
-		return true;
-	}
-	if (objA instanceof Set && objB instanceof Set) {
-		if (objA.size !== objB.size) return false;
-		for (const value of objA) if (!objB.has(value)) return false;
-		return true;
-	}
-	const keysA = Object.keys(objA);
-	if (keysA.length !== Object.keys(objB).length) return false;
-	for (const keyA of keysA) if (!Object.prototype.hasOwnProperty.call(objB, keyA) || !Object.is(objA[keyA], objB[keyA])) return false;
-	if (objA.constructor !== objB.constructor) return false;
-	return true;
-};
-
-//#endregion
-//#region src/utils/observable/subscribeWithSelector/subscribeWithSelector.ts
-/**
-* Allows subscribing to a slice of the state.
-* The slice is a computation of the states.
-*
-* The callback will only be called when the slice has changed.
-* Change is determined by shallow comparison.
-*
-* Returns a function to unsubscribe the callback.
-*/
-const subscribeWithSelector = (observable, selector) => (callback) => {
-	let lastSlice = selector(observable.get());
-	return observable.subscribe((value) => {
-		const nextSlice = selector(value);
-		if (isEqualShallow(nextSlice, lastSlice)) return;
-		lastSlice = nextSlice;
-		callback(nextSlice);
-	});
+//#region src/services/storage/createStorageKeySchema/createStorageKeySchema.ts
+const createStorageKeySchema = (params) => {
+	return params;
 };
 
 //#endregion
 //#region src/modules/sessionKeys/generateSessionKeys/generateSessionKeys.ts
 const generateSessionKeys = async (client) => {
-	const { private: privateKey, public: publicKey, privateJwk: privateKeyJwk } = await require_InvalidParamError.p256Keygen();
 	const core = require_InvalidParamError.getCore(client);
-	const stringifiedSessionKeys = JSON.stringify({
-		privateKey,
-		privateKeyJwk,
-		publicKey,
-		registered: false
-	});
-	const encodedSessionKeys = require_InvalidParamError.getBuffer().from(stringifiedSessionKeys).toString("base64");
-	core.state.set({ sessionKeys: encodedSessionKeys });
-	return {
-		privateKey,
-		privateKeyJwk,
-		publicKey
-	};
+	const publicKey = await core.keychain.generateKey("session");
+	core.state.set({ sessionKeys: publicKey });
+	return { publicKey };
 };
 
 //#endregion
-//#region src/modules/initializeClient/consts.ts
-const REFRESH_USER_STATE_FROM_COOKIE_TRACKER_KEY = "refresh-user-state-from-cookie";
-const INITIALIZE_STORAGE_SYNC_TRACKER_KEY = "initialize-storage-sync";
-const FETCH_PROJECT_SETTINGS_TRACKER_KEY = "fetch-project-settings";
-const GENERATE_SESSION_KEYS_TRACKER_KEY = "generate-session-keys";
+//#region src/utils/getBuffer/getBuffer.ts
+const getBuffer = () => typeof Buffer !== "undefined" ? Buffer : buffer.Buffer;
 
 //#endregion
 //#region src/utils/isServerSideRendering/isServerSideRendering.ts
@@ -187,6 +207,13 @@ const GENERATE_SESSION_KEYS_TRACKER_KEY = "generate-session-keys";
 */
 const isServerSideRendering = () => typeof window === "undefined";
 
+//#endregion
+//#region src/modules/initializeClient/consts.ts
+const REFRESH_USER_STATE_FROM_COOKIE_TRACKER_KEY = "refresh-user-state-from-cookie";
+const INITIALIZE_STORAGE_SYNC_TRACKER_KEY = "initialize-storage-sync";
+const FETCH_PROJECT_SETTINGS_TRACKER_KEY = "fetch-project-settings";
+const GENERATE_SESSION_KEYS_TRACKER_KEY = "generate-session-keys";
+
 //#endregion
 //#region src/utils/deferredPromise/createDeferredPromise.ts
 const createDeferredPromise = () => {
@@ -311,6 +338,312 @@ const createLogger = (options = {}) => {
 	};
 };
 
+//#endregion
+//#region src/utils/bufferToHex/bufferToHex.ts
+/**
+* Converts an ArrayBuffer or Uint8Array to a hex-encoded string
+*/
+const bufferToHex = (buffer$1) => [...buffer$1 instanceof Uint8Array ? buffer$1 : new Uint8Array(buffer$1)].map((x) => x.toString(16).padStart(2, "0")).join("");
+
+//#endregion
+//#region src/utils/compressRawPublicKey/compressRawPublicKey.ts
+/**
+* Accepts a public key array buffer, and returns a buffer with the compressed version of the public key
+*/
+const compressRawPublicKey = (rawPublicKey) => {
+	const rawPublicKeyBytes = new Uint8Array(rawPublicKey);
+	const len = rawPublicKeyBytes.byteLength;
+	const compressedBytes = rawPublicKeyBytes.slice(0, 1 + len >>> 1);
+	compressedBytes[0] = 2 | rawPublicKeyBytes[len - 1] & 1;
+	return compressedBytes.buffer;
+};
+
+//#endregion
+//#region src/services/keychain/createIndexedDBKeychainService/KeyNotFoundError.ts
+var KeyNotFoundError = class extends require_InvalidParamError.BaseError {
+	constructor(keyName) {
+		super({
+			cause: null,
+			code: "key_not_found",
+			docsUrl: null,
+			name: "KeyNotFoundError",
+			shortMessage: `Key "${keyName}" not found in keychain`
+		});
+	}
+};
+
+//#endregion
+//#region src/services/keychain/createIndexedDBKeychainService/utils/constants.ts
+const STORE_NAME = "keys";
+
+//#endregion
+//#region src/services/keychain/createIndexedDBKeychainService/utils/deleteIndexedDBItem.ts
+const deleteIndexedDBItem = (db, keyName) => new Promise((resolve, reject) => {
+	const request = db.transaction(STORE_NAME, "readwrite").objectStore(STORE_NAME).delete(keyName);
+	request.onsuccess = () => resolve();
+	request.onerror = () => reject(request.error);
+});
+
+//#endregion
+//#region src/services/keychain/createIndexedDBKeychainService/utils/getIndexedDBItem.ts
+const getIndexedDBItem = (db, keyName) => new Promise((resolve, reject) => {
+	const request = db.transaction(STORE_NAME, "readonly").objectStore(STORE_NAME).get(keyName);
+	request.onsuccess = () => resolve(request.result);
+	request.onerror = () => reject(request.error);
+});
+
+//#endregion
+//#region src/services/keychain/createIndexedDBKeychainService/utils/openDatabase.ts
+const openDatabase = (dbName) => new Promise((resolve, reject) => {
+	const request = indexedDB.open(dbName, 1);
+	request.onupgradeneeded = () => {
+		const db = request.result;
+		if (!db.objectStoreNames.contains(STORE_NAME)) db.createObjectStore(STORE_NAME, { keyPath: "keyName" });
+	};
+	request.onsuccess = () => resolve(request.result);
+	request.onerror = () => reject(request.error);
+});
+
+//#endregion
+//#region src/services/keychain/createIndexedDBKeychainService/utils/setIndexedDBItem.ts
+const setIndexedDBItem = (db, entry) => new Promise((resolve, reject) => {
+	const request = db.transaction(STORE_NAME, "readwrite").objectStore(STORE_NAME).put(entry);
+	request.onsuccess = () => resolve();
+	request.onerror = () => reject(request.error);
+});
+
+//#endregion
+//#region src/services/keychain/createIndexedDBKeychainService/createIndexedDBKeychainService.ts
+const DEFAULT_DB_NAME = "dynamic_keychain";
+const createIndexedDBKeychainService = (params) => {
+	const dbName = params?.dbName ?? DEFAULT_DB_NAME;
+	let dbPromise;
+	const getDb = () => {
+		dbPromise ??= openDatabase(dbName);
+		return dbPromise;
+	};
+	const generateKey = async (keyName) => {
+		const keyPair = await crypto.subtle.generateKey({
+			name: "ECDSA",
+			namedCurve: "P-256"
+		}, false, ["sign"]);
+		const publicKeyHex = bufferToHex(compressRawPublicKey(await crypto.subtle.exportKey("raw", keyPair.publicKey)));
+		await setIndexedDBItem(await getDb(), {
+			keyName,
+			privateKey: keyPair.privateKey,
+			publicKeyHex
+		});
+		return publicKeyHex;
+	};
+	const importKey = async (keyName, jwk) => {
+		const privateKey = await crypto.subtle.importKey("jwk", jwk, {
+			name: "ECDSA",
+			namedCurve: "P-256"
+		}, false, ["sign"]);
+		const publicJwk = {
+			crv: jwk.crv,
+			kty: jwk.kty,
+			x: jwk.x,
+			y: jwk.y
+		};
+		const publicCryptoKey = await crypto.subtle.importKey("jwk", publicJwk, {
+			name: "ECDSA",
+			namedCurve: "P-256"
+		}, true, ["verify"]);
+		const publicKeyHex = bufferToHex(compressRawPublicKey(await crypto.subtle.exportKey("raw", publicCryptoKey)));
+		await setIndexedDBItem(await getDb(), {
+			keyName,
+			privateKey,
+			publicKeyHex
+		});
+		return publicKeyHex;
+	};
+	const getPublicKey = async (keyName) => {
+		return (await getIndexedDBItem(await getDb(), keyName))?.publicKeyHex ?? null;
+	};
+	const sign = async (keyName, message) => {
+		const entry = await getIndexedDBItem(await getDb(), keyName);
+		if (!entry) throw new KeyNotFoundError(keyName);
+		const data = new TextEncoder().encode(message);
+		return bufferToHex(await crypto.subtle.sign({
+			hash: { name: "SHA-256" },
+			name: "ECDSA"
+		}, entry.privateKey, data));
+	};
+	const hasKey = async (keyName) => {
+		return await getIndexedDBItem(await getDb(), keyName) !== void 0;
+	};
+	const removeKey = async (keyName) => {
+		await deleteIndexedDBItem(await getDb(), keyName);
+	};
+	return {
+		generateKey,
+		getPublicKey,
+		hasKey,
+		importKey,
+		removeKey,
+		sign
+	};
+};
+
+//#endregion
+//#region src/errors/InvalidRealtimePublishError.ts
+var InvalidRealtimePublishError = class extends require_InvalidParamError.BaseError {
+	constructor({ channel }) {
+		super({
+			cause: null,
+			code: "invalid_realtime_publish",
+			docsUrl: null,
+			metaMessages: [`channel: ${channel}`],
+			name: "InvalidRealtimePublishError",
+			shortMessage: "Tried to publish data that does not match the channel schema"
+		});
+	}
+};
+
+//#endregion
+//#region src/errors/RealtimeNotConnectedError.ts
+var RealtimeNotConnectedError = class extends require_InvalidParamError.BaseError {
+	constructor() {
+		super({
+			cause: null,
+			code: "realtime_not_connected_error",
+			docsUrl: null,
+			name: "RealtimeNotConnectedError",
+			shortMessage: "Realtime service is not connected. Call connect() before subscribing or publishing."
+		});
+	}
+};
+
+//#endregion
+//#region src/services/realtime/createRealtimeService/createRealtimeService.ts
+const ABLY_STATE_TO_REALTIME_STATE = {
+	closed: "closed",
+	closing: "closing",
+	connected: "connected",
+	connecting: "connecting",
+	disconnected: "disconnected",
+	failed: "failed",
+	initialized: "idle",
+	suspended: "suspended"
+};
+const mapAblyState = (ablyState) => ABLY_STATE_TO_REALTIME_STATE[ablyState] ?? "idle";
+/**
+* Creates a realtime pub/sub service backed by Ably.
+*
+* The service starts idle. Call `connect({ client })` to establish
+* a connection, passing the DynamicClient explicitly.
+*
+* SSR environments receive a no-op implementation.
+*/
+const createRealtimeService = () => {
+	if (isServerSideRendering()) return {
+		connect: () => Promise.resolve(),
+		disconnect: () => {},
+		getConnectionState: () => "idle",
+		off: () => {},
+		on: () => {},
+		publish: () => Promise.resolve(),
+		subscribe: () => Promise.resolve(),
+		unsubscribe: () => {}
+	};
+	const eventEmitter = new eventemitter3.default();
+	const channels = /* @__PURE__ */ new Map();
+	const handlerMap = /* @__PURE__ */ new WeakMap();
+	let ablyClient;
+	let connectionState = "idle";
+	let isConnecting = false;
+	const setConnectionState = (state) => {
+		connectionState = state;
+		eventEmitter.emit("connectionStateChange", state);
+	};
+	const getOrCreateChannel = (channelName) => {
+		const existing = channels.get(channelName);
+		if (existing) return existing;
+		if (!ablyClient) throw new RealtimeNotConnectedError();
+		const channel = ablyClient.channels.get(channelName);
+		channels.set(channelName, channel);
+		return channel;
+	};
+	const connect = async ({ client }) => {
+		if (isConnecting) return;
+		isConnecting = true;
+		try {
+			const core = require_InvalidParamError.getCore(client);
+			if (ablyClient) {
+				ablyClient.close();
+				channels.clear();
+			}
+			const { BaseRealtime: AblyBaseRealtime, FetchRequest, WebSocketTransport } = await import("ably/modular");
+			ablyClient = new AblyBaseRealtime({
+				authCallback: (_tokenParams, callback) => {
+					require_InvalidParamError.createApiClient({}, client).getRealtimeAuthToken({ environmentId: core.environmentId }).then((response) => {
+						callback(null, response.token);
+					}).catch((err) => {
+						callback(err instanceof Error ? err.message : String(err), null);
+					});
+				},
+				autoConnect: false,
+				plugins: {
+					FetchRequest,
+					WebSocketTransport
+				}
+			});
+			ablyClient.connection.on((stateChange) => {
+				setConnectionState(mapAblyState(stateChange.current));
+			});
+			ablyClient.connect();
+		} finally {
+			isConnecting = false;
+		}
+	};
+	const disconnect = () => {
+		if (!ablyClient) return;
+		for (const channel of channels.values()) channel.detach().catch(() => {});
+		channels.clear();
+		ablyClient.close();
+		ablyClient = void 0;
+	};
+	const subscribe = async ({ channelSchema, callback }) => {
+		const channel = getOrCreateChannel(channelSchema.channel);
+		const handler = (message) => {
+			const parsed = channelSchema.schema.safeParse(message.data);
+			if (!parsed.success) return;
+			callback({ data: parsed.data });
+		};
+		handlerMap.set(callback, handler);
+		await channel.subscribe(handler);
+	};
+	const unsubscribe = ({ channelSchema, callback }) => {
+		const channel = channels.get(channelSchema.channel);
+		if (!channel) return;
+		const handler = handlerMap.get(callback);
+		if (handler) {
+			channel.unsubscribe(handler);
+			handlerMap.delete(callback);
+		}
+	};
+	const publish = async ({ channelSchema, data }) => {
+		const parsed = channelSchema.schema.safeParse(data);
+		if (!parsed.success) throw new InvalidRealtimePublishError({ channel: channelSchema.channel });
+		await getOrCreateChannel(channelSchema.channel).publish("message", parsed.data);
+	};
+	return {
+		connect,
+		disconnect,
+		getConnectionState: () => connectionState,
+		off: (event, callback) => {
+			eventEmitter.off(event, callback);
+		},
+		on: (event, callback) => {
+			eventEmitter.on(event, callback);
+		},
+		publish,
+		subscribe,
+		unsubscribe
+	};
+};
+
 //#endregion
 //#region src/errors/NoNetworkProvidersError.ts
 var NoNetworkProvidersError = class extends require_InvalidParamError.BaseError {
@@ -700,6 +1033,12 @@ Object.defineProperty(exports, 'WalletAlreadyLinkedToAnotherUserError', {
     return WalletAlreadyLinkedToAnotherUserError;
   }
 });
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});
 Object.defineProperty(exports, 'consumeCaptchaToken', {
   enumerable: true,
   get: function () {
@@ -718,6 +1057,12 @@ Object.defineProperty(exports, 'createDeferredPromise', {
     return createDeferredPromise;
   }
 });
+Object.defineProperty(exports, 'createIndexedDBKeychainService', {
+  enumerable: true,
+  get: function () {
+    return createIndexedDBKeychainService;
+  }
+});
 Object.defineProperty(exports, 'createLocalStorageAdapter', {
   enumerable: true,
   get: function () {
@@ -730,6 +1075,12 @@ Object.defineProperty(exports, 'createLogger', {
     return createLogger;
   }
 });
+Object.defineProperty(exports, 'createRealtimeService', {
+  enumerable: true,
+  get: function () {
+    return createRealtimeService;
+  }
+});
 Object.defineProperty(exports, 'createSignInMessageStatement', {
   enumerable: true,
   get: function () {
@@ -742,6 +1093,12 @@ Object.defineProperty(exports, 'createStorage', {
     return createStorage;
   }
 });
+Object.defineProperty(exports, 'createStorageKeySchema', {
+  enumerable: true,
+  get: function () {
+    return createStorageKeySchema;
+  }
+});
 Object.defineProperty(exports, 'createVisit', {
   enumerable: true,
   get: function () {
@@ -760,6 +1117,12 @@ Object.defineProperty(exports, 'generateSessionKeys', {
     return generateSessionKeys;
   }
 });
+Object.defineProperty(exports, 'getBuffer', {
+  enumerable: true,
+  get: function () {
+    return getBuffer;
+  }
+});
 Object.defineProperty(exports, 'getNetworkProviderBuilderRegistry', {
   enumerable: true,
   get: function () {
@@ -844,4 +1207,4 @@ Object.defineProperty(exports, 'verifyMessageSignatureOwnership', {
     return verifyMessageSignatureOwnership;
   }
 });
-//# sourceMappingURL=getNetworkProviderFromNetworkId-BJR1GciB.cjs.js.map
+//# sourceMappingURL=getNetworkProviderFromNetworkId-CllkC31J.cjs.js.map