summaryrefslogtreecommitdiff
path: root/packages/taler-wallet-embedded/src/wallet-qjs.ts
diff options
context:
space:
mode:
Diffstat (limited to 'packages/taler-wallet-embedded/src/wallet-qjs.ts')
-rw-r--r--packages/taler-wallet-embedded/src/wallet-qjs.ts310
1 files changed, 310 insertions, 0 deletions
diff --git a/packages/taler-wallet-embedded/src/wallet-qjs.ts b/packages/taler-wallet-embedded/src/wallet-qjs.ts
new file mode 100644
index 000000000..01882cc16
--- /dev/null
+++ b/packages/taler-wallet-embedded/src/wallet-qjs.ts
@@ -0,0 +1,310 @@
+/*
+ This file is part of GNU Taler
+ (C) 2019 GNUnet e.V.
+
+ GNU Taler is free software; you can redistribute it and/or modify it under the
+ terms of the GNU General Public License as published by the Free Software
+ Foundation; either version 3, or (at your option) any later version.
+
+ GNU Taler is distributed in the hope that it will be useful, but WITHOUT ANY
+ WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along with
+ GNU Taler; see the file COPYING. If not, see <http://www.gnu.org/licenses/>
+ */
+
+/**
+ * Imports.
+ */
+import {
+ AccessStats,
+ DefaultNodeWalletArgs,
+ getErrorDetailFromException,
+ handleWorkerError,
+ handleWorkerMessage,
+ HttpRequestLibrary,
+ HttpRequestOptions,
+ HttpResponse,
+ openPromise,
+ openTalerDatabase,
+ SetTimeoutTimerAPI,
+ SynchronousCryptoWorkerFactoryPlain,
+ Wallet,
+} from "@gnu-taler/taler-wallet-core";
+
+import {
+ CoreApiEnvelope,
+ CoreApiResponse,
+ CoreApiResponseSuccess,
+ Logger,
+ WalletNotification,
+} from "@gnu-taler/taler-util";
+import { BridgeIDBFactory } from "@gnu-taler/idb-bridge";
+import { MemoryBackend } from "@gnu-taler/idb-bridge";
+import { shimIndexedDB } from "@gnu-taler/idb-bridge";
+import { IDBFactory } from "@gnu-taler/idb-bridge";
+
+export { handleWorkerError, handleWorkerMessage };
+
+const logger = new Logger("taler-wallet-embedded/index.ts");
+
+export class NativeHttpLib implements HttpRequestLibrary {
+ get(
+ url: string,
+ opt?: HttpRequestOptions | undefined,
+ ): Promise<HttpResponse> {
+ throw new Error("Method not implemented.");
+ }
+ postJson(
+ url: string,
+ body: any,
+ opt?: HttpRequestOptions | undefined,
+ ): Promise<HttpResponse> {
+ throw new Error("Method not implemented.");
+ }
+ fetch(
+ url: string,
+ opt?: HttpRequestOptions | undefined,
+ ): Promise<HttpResponse> {
+ throw new Error("Method not implemented.");
+ }
+}
+
+function sendNativeMessage(ev: CoreApiEnvelope): void {
+ // @ts-ignore
+ const sendMessage = globalThis.__native_sendMessage;
+ if (typeof sendMessage !== "function") {
+ const errMsg =
+ "FATAL: cannot install native wallet listener: native functions missing";
+ logger.error(errMsg);
+ throw new Error(errMsg);
+ }
+ const m = JSON.stringify(ev);
+ // @ts-ignore
+ sendMessage(m);
+}
+
+export async function getWallet(args: DefaultNodeWalletArgs = {}): Promise<{
+ wallet: Wallet;
+ getDbStats: () => AccessStats;
+}> {
+ BridgeIDBFactory.enableTracing = false;
+ const myBackend = new MemoryBackend();
+ myBackend.enableTracing = false;
+
+ const storagePath = args.persistentStoragePath;
+ if (storagePath) {
+ // try {
+ // const dbContentStr: string = fs.readFileSync(storagePath, {
+ // encoding: "utf-8",
+ // });
+ // const dbContent = JSON.parse(dbContentStr);
+ // myBackend.importDump(dbContent);
+ // } catch (e: any) {
+ // const code: string = e.code;
+ // if (code === "ENOENT") {
+ // logger.trace("wallet file doesn't exist yet");
+ // } else {
+ // logger.error("could not open wallet database file");
+ // throw e;
+ // }
+ // }
+
+ myBackend.afterCommitCallback = async () => {
+ logger.error("DB commit not implemented");
+ // logger.trace("committing database");
+ // // Allow caller to stop persisting the wallet.
+ // if (args.persistentStoragePath === undefined) {
+ // return;
+ // }
+ // const tmpPath = `${args.persistentStoragePath}-${makeId(5)}.tmp`;
+ // const dbContent = myBackend.exportDump();
+ // fs.writeFileSync(tmpPath, JSON.stringify(dbContent, undefined, 2), {
+ // encoding: "utf-8",
+ // });
+ // // Atomically move the temporary file onto the DB path.
+ // fs.renameSync(tmpPath, args.persistentStoragePath);
+ // logger.trace("committing database done");
+ };
+ }
+
+ BridgeIDBFactory.enableTracing = false;
+
+ const myBridgeIdbFactory = new BridgeIDBFactory(myBackend);
+ const myIdbFactory: IDBFactory = myBridgeIdbFactory as any as IDBFactory;
+
+ let myHttpLib;
+ if (args.httpLib) {
+ myHttpLib = args.httpLib;
+ } else {
+ myHttpLib = new NativeHttpLib();
+ }
+
+ const myVersionChange = (): Promise<void> => {
+ logger.error("version change requested, should not happen");
+ throw Error(
+ "BUG: wallet DB version change event can't happen with memory IDB",
+ );
+ };
+
+ shimIndexedDB(myBridgeIdbFactory);
+
+ const myDb = await openTalerDatabase(myIdbFactory, myVersionChange);
+
+ let workerFactory;
+ workerFactory = new SynchronousCryptoWorkerFactoryPlain();
+
+ const timer = new SetTimeoutTimerAPI();
+
+ const w = await Wallet.create(myDb, myHttpLib, timer, workerFactory);
+
+ if (args.notifyHandler) {
+ w.addNotificationListener(args.notifyHandler);
+ }
+ return {
+ wallet: w,
+ getDbStats: () => myBackend.accessStats,
+ };
+}
+
+class NativeWalletMessageHandler {
+ walletArgs: DefaultNodeWalletArgs | undefined;
+ maybeWallet: Wallet | undefined;
+ wp = openPromise<Wallet>();
+ httpLib = new NativeHttpLib();
+
+ /**
+ * Handle a request from the native wallet.
+ */
+ async handleMessage(
+ operation: string,
+ id: string,
+ args: any,
+ ): Promise<CoreApiResponse> {
+ const wrapResponse = (result: unknown): CoreApiResponseSuccess => {
+ return {
+ type: "response",
+ id,
+ operation,
+ result,
+ };
+ };
+
+ let initResponse: any = {};
+
+ const reinit = async () => {
+ logger.info("in reinit");
+ const wR = await getWallet(this.walletArgs);
+ const w = wR.wallet;
+ this.maybeWallet = w;
+ const resp = await w.handleCoreApiRequest(
+ "initWallet",
+ "native-init",
+ {},
+ );
+ initResponse = resp.type == "response" ? resp.result : resp.error;
+ w.runTaskLoop().catch((e) => {
+ logger.error(
+ `Error during wallet retry loop: ${e.stack ?? e.toString()}`,
+ );
+ });
+ this.wp.resolve(w);
+ };
+
+ switch (operation) {
+ case "init": {
+ this.walletArgs = {
+ notifyHandler: async (notification: WalletNotification) => {
+ sendNativeMessage({ type: "notification", payload: notification });
+ },
+ persistentStoragePath: args.persistentStoragePath,
+ httpLib: this.httpLib,
+ cryptoWorkerType: args.cryptoWorkerType,
+ };
+ await reinit();
+ return wrapResponse({
+ ...initResponse,
+ });
+ }
+ case "startTunnel": {
+ // this.httpLib.useNfcTunnel = true;
+ throw Error("not implemented");
+ }
+ case "stopTunnel": {
+ // this.httpLib.useNfcTunnel = false;
+ throw Error("not implemented");
+ }
+ case "tunnelResponse": {
+ // httpLib.handleTunnelResponse(msg.args);
+ throw Error("not implemented");
+ }
+ case "reset": {
+ const oldArgs = this.walletArgs;
+ this.walletArgs = { ...oldArgs };
+ if (oldArgs && oldArgs.persistentStoragePath) {
+ try {
+ logger.error("FIXME: reset not implemented");
+ // fs.unlinkSync(oldArgs.persistentStoragePath);
+ } catch (e) {
+ logger.error("Error while deleting the wallet db:", e);
+ }
+ // Prevent further storage!
+ this.walletArgs.persistentStoragePath = undefined;
+ }
+ const wallet = await this.wp.promise;
+ wallet.stop();
+ this.wp = openPromise<Wallet>();
+ this.maybeWallet = undefined;
+ await reinit();
+ return wrapResponse({});
+ }
+ default: {
+ const wallet = await this.wp.promise;
+ return await wallet.handleCoreApiRequest(operation, id, args);
+ }
+ }
+ }
+}
+
+export function installNativeWalletListener(): void {
+ const handler = new NativeWalletMessageHandler();
+ const onMessage = async (msgStr: any): Promise<void> => {
+ if (typeof msgStr !== "string") {
+ logger.error("expected string as message");
+ return;
+ }
+ const msg = JSON.parse(msgStr);
+ const operation = msg.operation;
+ if (typeof operation !== "string") {
+ logger.error(
+ "message to native wallet helper must contain operation of type string",
+ );
+ return;
+ }
+ const id = msg.id;
+ logger.info(`native listener: got request for ${operation} (${id})`);
+
+ try {
+ const respMsg = await handler.handleMessage(operation, id, msg.args);
+ logger.info(
+ `native listener: sending success response for ${operation} (${id})`,
+ );
+ sendNativeMessage(respMsg);
+ } catch (e) {
+ const respMsg: CoreApiResponse = {
+ type: "error",
+ id,
+ operation,
+ error: getErrorDetailFromException(e),
+ };
+ sendNativeMessage(respMsg);
+ return;
+ }
+ };
+
+ // @ts-ignore
+ globalThis.__native_onMessage = onMessage;
+
+ logger.info("native wallet listener installed");
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-06-04 16:34:41 +0000