web_lib

Common web application libraries
git clone https://radroots.dev/git/web_lib.git
Log | Files | Refs | LICENSE

web-nostr.ts (3763B)

      1 import {
      2     err_msg,
      3     handle_err,
      4     IdbClientConfig,
      5     type ResolveError,
      6     type ResultObj,
      7     type ResultPass,
      8     type ResultPublicKey,
      9     type ResultSecretKey,
     10     type ResultsList
     11 } from '@radroots/utils';
     12 import {
     13     nostr_key_generate,
     14     nostr_public_key_from_secret,
     15     nostr_secret_key_validate
     16 } from "@radroots/nostr";
     17 import { cl_keystore_error } from "./error.js";
     18 import type { IClientKeystoreNostr } from './types.js';
     19 import { IDB_CONFIG_KEYSTORE_NOSTR } from "../idb/config.js";
     20 import { WebKeystore } from './web.js';
     21 
     22 export interface IWebKeystoreNostr extends IClientKeystoreNostr {
     23     get_config(): IdbClientConfig;
     24 }
     25 
     26 export class WebKeystoreNostr implements IWebKeystoreNostr {
     27     private keystore_config: IdbClientConfig;
     28     private _keystore: WebKeystore;
     29 
     30     constructor(config?: Partial<IdbClientConfig>) {
     31         const config_base = config ?? {};
     32         this.keystore_config = {
     33             database: config_base.database ?? IDB_CONFIG_KEYSTORE_NOSTR.database,
     34             store: config_base.store ?? IDB_CONFIG_KEYSTORE_NOSTR.store
     35         };
     36         this._keystore = new WebKeystore(this.keystore_config);
     37     }
     38 
     39     private async add_secret_key(secret_key_raw: string): Promise<ResolveError<ResultObj<string>>> {
     40         const secret_key = nostr_secret_key_validate(secret_key_raw);
     41         if (!secret_key) throw new Error(cl_keystore_error.nostr_invalid_secret_key);
     42         const public_key = nostr_public_key_from_secret(secret_key);
     43         return await this._keystore.add(public_key, secret_key);
     44     }
     45 
     46     public get_config(): IdbClientConfig {
     47         return this._keystore.get_config();
     48     }
     49 
     50     public async generate(): Promise<ResolveError<ResultPublicKey>> {
     51         try {
     52             const secret_key = nostr_key_generate();
     53             const resolve = await this.add_secret_key(secret_key);
     54             if ("err" in resolve) return resolve;
     55             return { public_key: resolve.result };
     56         } catch (e) {
     57             return handle_err(e);
     58         }
     59     };
     60 
     61     public async add(secret_key_raw: string): Promise<ResolveError<ResultPublicKey>> {
     62         try {
     63             const resolve = await this.add_secret_key(secret_key_raw);
     64             if ("err" in resolve) return resolve;
     65             return { public_key: resolve.result };
     66         } catch (e) {
     67             return handle_err(e);
     68         }
     69     };
     70 
     71     public async read(public_key?: string): Promise<ResolveError<ResultSecretKey>> {
     72         try {
     73             const resolve = await this._keystore.read(public_key);
     74             if ("err" in resolve) return resolve;
     75             if (!resolve.result) return err_msg(cl_keystore_error.missing_key);
     76             return { secret_key: resolve.result };
     77         } catch (e) {
     78             return handle_err(e);
     79         }
     80     };
     81 
     82     public async keys(): Promise<ResolveError<ResultsList<string>>> {
     83         try {
     84             const resolve = await this._keystore.keys();
     85             if ("err" in resolve) return resolve;
     86             if (resolve.results.length) return resolve;
     87             return err_msg(cl_keystore_error.nostr_no_results);
     88         } catch (e) {
     89             return handle_err(e);
     90         }
     91     };
     92 
     93     public async remove(public_key: string): Promise<ResolveError<ResultObj<string>>> {
     94         try {
     95             const resolve = await this._keystore.remove(public_key);
     96             if ("err" in resolve) return resolve;
     97             return { result: public_key };
     98         } catch (e) {
     99             return handle_err(e);
    100         }
    101     };
    102 
    103     public async reset(): Promise<ResolveError<ResultPass>> {
    104         try {
    105             const resolve = await this._keystore.reset();
    106             return resolve;
    107         } catch (e) {
    108             return handle_err(e);
    109         }
    110     };
    111 }