quickjs preparations, clearer worker(-factory) names

packages/taler-wallet-cli/src/bench2.ts

@@ -33,7 +33,7 @@ import {
   findDenomOrThrow,
   NodeHttpLib,
   refreshCoin,
-  SynchronousCryptoWorkerFactory,
+  SynchronousCryptoWorkerFactoryNode,
   withdrawCoin,
 } from "@gnu-taler/taler-wallet-core";
 
@@ -49,7 +49,7 @@ export async function runBench2(configJson: any): Promise<void> {
   // Validate the configuration file for this benchmark.
   const benchConf = codecForBench2Config().decode(configJson);
   const curr = benchConf.currency;
-  const cryptoDisp = new CryptoDispatcher(new SynchronousCryptoWorkerFactory());
+  const cryptoDisp = new CryptoDispatcher(new SynchronousCryptoWorkerFactoryNode());
   const cryptoApi = cryptoDisp.cryptoApi;
 
   const http = new NodeHttpLib();

packages/taler-wallet-cli/src/index.ts

@@ -53,7 +53,7 @@ import {
   NodeHttpLib,
   NodeThreadCryptoWorkerFactory,
   summarizeTalerErrorDetail,
-  SynchronousCryptoWorkerFactory,
+  SynchronousCryptoWorkerFactoryNode,
   Wallet,
   WalletApiOperation,
   WalletCoreApiClient,
@@ -1490,7 +1490,7 @@ testCli
       const cryptoDisp = new CryptoDispatcher(workerFactory);
       cryptoApi = cryptoDisp.cryptoApi;
     } else if (args.cryptoworker.impl === "sync") {
-      const workerFactory = new SynchronousCryptoWorkerFactory();
+      const workerFactory = new SynchronousCryptoWorkerFactoryNode();
       const cryptoDisp = new CryptoDispatcher(workerFactory);
       cryptoApi = cryptoDisp.cryptoApi;
     } else if (args.cryptoworker.impl === "none") {

packages/taler-wallet-cli/src/integrationtests/test-wallet-cryptoworker.ts

@@ -26,7 +26,7 @@ import {
   findDenomOrThrow,
   NodeHttpLib,
   refreshCoin,
-  SynchronousCryptoWorkerFactory,
+  SynchronousCryptoWorkerFactoryNode,
   TalerError,
   topupReserveWithDemobank,
   WalletApiOperation,

packages/taler-wallet-cli/src/integrationtests/test-wallet-dbless.ts

@@ -26,7 +26,7 @@ import {
   findDenomOrThrow,
   NodeHttpLib,
   refreshCoin,
-  SynchronousCryptoWorkerFactory,
+  SynchronousCryptoWorkerFactoryNode,
   TalerError,
   topupReserveWithDemobank,
   withdrawCoin,
@@ -43,7 +43,7 @@ export async function runWalletDblessTest(t: GlobalTestState) {
   const { bank, exchange } = await createSimpleTestkudosEnvironment(t);
 
   const http = new NodeHttpLib();
-  const cryptiDisp = new CryptoDispatcher(new SynchronousCryptoWorkerFactory());
+  const cryptiDisp = new CryptoDispatcher(new SynchronousCryptoWorkerFactoryNode());
   const cryptoApi = cryptiDisp.cryptoApi;
 
   try {

packages/taler-wallet-core/src/crypto/workers/synchronousWorkerFactoryNode.ts

@@ -19,15 +19,15 @@
  */
 import { CryptoWorkerFactory } from "./cryptoDispatcher.js";
 import { CryptoWorker } from "./cryptoWorkerInterface.js";
-import { SynchronousCryptoWorker } from "./synchronousWorkerNode.js";
+import { SynchronousCryptoWorkerNode } from "./synchronousWorkerNode.js";
 
 /**
  * The synchronous crypto worker produced by this factory doesn't run in the
  * background, but actually blocks the caller until the operation is done.
  */
-export class SynchronousCryptoWorkerFactory implements CryptoWorkerFactory {
+export class SynchronousCryptoWorkerFactoryNode implements CryptoWorkerFactory {
   startWorker(): CryptoWorker {
-    return new SynchronousCryptoWorker();
+    return new SynchronousCryptoWorkerNode();
   }
 
   getConcurrency(): number {

packages/taler-wallet-core/src/crypto/workers/synchronousWorkerFactoryPlain.ts

@@ -0,0 +1,36 @@
+/*
+ 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 { CryptoWorkerFactory } from "./cryptoDispatcher.js";
+import { CryptoWorker } from "./cryptoWorkerInterface.js";
+import { SynchronousCryptoWorkerPlain } from "./synchronousWorkerPlain.js";
+
+/**
+ * The synchronous crypto worker produced by this factory doesn't run in the
+ * background, but actually blocks the caller until the operation is done.
+ */
+export class SynchronousCryptoWorkerFactoryPlain implements CryptoWorkerFactory {
+  startWorker(): CryptoWorker {
+    return new SynchronousCryptoWorkerPlain();
+  }
+
+  getConcurrency(): number {
+    return 1;
+  }
+}

packages/taler-wallet-core/src/crypto/workers/synchronousWorkerNode.ts

@@ -31,7 +31,7 @@ const logger = new Logger("synchronousWorker.ts");
  * The node crypto worker can also use IPC to offload cryptographic
  * operations to a helper process (usually written in C / part of taler-exchange).
  */
-export class SynchronousCryptoWorker implements CryptoWorker {
+export class SynchronousCryptoWorkerNode implements CryptoWorker {
   /**
    * Function to be called when we receive a message from the worker thread.
    */

packages/taler-wallet-core/src/crypto/workers/synchronousWorkerPlain.ts

@@ -31,7 +31,7 @@ const logger = new Logger("synchronousWorker.ts");
  * Worker implementation that synchronously executes cryptographic
  * operations.
  */
-export class SynchronousCryptoWorker implements CryptoWorker {
+export class SynchronousCryptoWorkerPlain implements CryptoWorker {
   /**
    * Function to be called when we receive a message from the worker thread.
    */

packages/taler-wallet-core/src/headless/helpers.ts

@@ -33,7 +33,7 @@ import { AccessStats } from "@gnu-taler/idb-bridge";
 import { Logger, WalletNotification } from "@gnu-taler/taler-util";
 import * as fs from "fs";
 import { NodeThreadCryptoWorkerFactory } from "../crypto/workers/nodeThreadWorker.js";
-import { SynchronousCryptoWorkerFactory } from "../crypto/workers/synchronousWorkerFactory.js";
+import { SynchronousCryptoWorkerFactoryNode } from "../crypto/workers/synchronousWorkerFactoryNode.js";
 import { openTalerDatabase } from "../db-utils.js";
 import { HttpRequestLibrary } from "../util/http.js";
 import { SetTimeoutTimerAPI } from "../util/timer.js";
@@ -165,7 +165,7 @@ export async function getDefaultNodeWallet2(
   const cryptoWorkerType = args.cryptoWorkerType ?? "node-worker-thread";
   if (cryptoWorkerType === "sync") {
     logger.info("using synchronous crypto worker");
-    workerFactory = new SynchronousCryptoWorkerFactory();
+    workerFactory = new SynchronousCryptoWorkerFactoryNode();
   } else if (cryptoWorkerType === "node-worker-thread") {
     try {
       // Try if we have worker threads available, fails in older node versions.
@@ -179,7 +179,7 @@ export async function getDefaultNodeWallet2(
       logger.warn(
         "worker threads not available, falling back to synchronous workers",
       );
-      workerFactory = new SynchronousCryptoWorkerFactory();
+      workerFactory = new SynchronousCryptoWorkerFactoryNode();
     }
   } else {
     throw Error(`unsupported crypto worker type '${cryptoWorkerType}'`);

packages/taler-wallet-core/src/index.browser.ts

@@ -15,4 +15,4 @@
  */
 
 export * from "./index.js";
-export { SynchronousCryptoWorker } from "./crypto/workers/synchronousWorkerWeb.js";
+export { SynchronousCryptoWorkerPlain as SynchronousCryptoWorker } from "./crypto/workers/synchronousWorkerPlain.js";

packages/taler-wallet-core/src/index.node.ts

@@ -24,7 +24,7 @@ export {
   DefaultNodeWalletArgs,
 } from "./headless/helpers.js";
 export * from "./crypto/workers/nodeThreadWorker.js";
-export { SynchronousCryptoWorker } from "./crypto/workers/synchronousWorkerNode.js";
+export { SynchronousCryptoWorkerNode as SynchronousCryptoWorker } from "./crypto/workers/synchronousWorkerNode.js";
 
 export type { AccessStats } from "@gnu-taler/idb-bridge";
-export * from "./crypto/workers/synchronousWorkerFactory.js";
+export * from "./crypto/workers/synchronousWorkerFactoryNode.js";

packages/taler-wallet-core/src/index.ts

@@ -66,3 +66,5 @@ export {
 
 export * from "./util/timer.js";
 export * from "./util/denominations.js";
+
+export { SynchronousCryptoWorkerFactoryPlain } from "./crypto/workers/synchronousWorkerFactoryPlain.js";

packages/taler-wallet-embedded/build.mjs

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+/*
+ This file is part of GNU Taler
+ (C) 2022 Taler Systems S.A.
+
+ 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/>
+ */
+
+import esbuild from 'esbuild'
+import path from "path"
+import fs from "fs"
+
+const BASE = process.cwd()
+
+let GIT_ROOT = BASE
+while (!fs.existsSync(path.join(GIT_ROOT, '.git')) && GIT_ROOT !== '/') {
+  GIT_ROOT = path.join(GIT_ROOT, '../')
+}
+if (GIT_ROOT === '/') {
+  console.log("not found")
+  process.exit(1);
+}
+const GIT_HASH = GIT_ROOT === '/' ? undefined : git_hash()
+
+
+let _package = JSON.parse(fs.readFileSync(path.join(BASE, 'package.json')));
+
+function git_hash() {
+  const rev = fs.readFileSync(path.join(GIT_ROOT, '.git', 'HEAD')).toString().trim().split(/.*[: ]/).slice(-1)[0];
+  if (rev.indexOf('/') === -1) {
+    return rev;
+  } else {
+    return fs.readFileSync(path.join(GIT_ROOT, '.git', rev)).toString().trim();
+  }
+}
+
+export const buildConfig = {
+  entryPoints: ["src/wallet-qjs.ts"],
+  outfile: "dist/taler-wallet-core-qjs.mjs",
+  bundle: true,
+  minify: false,
+  target: [
+    'es2020'
+  ],
+  format: 'esm',
+  platform: 'neutral',
+  mainFields: ["module", "main"],
+  sourcemap: true,
+  define: {
+    '__VERSION__': `"${_package.version}"`,
+    '__GIT_HASH__': `"${GIT_HASH}"`,
+  },
+}
+
+esbuild
+  .build(buildConfig)
+  .catch((e) => {
+    console.log(e)
+    process.exit(1)
+  });
+
+

packages/taler-wallet-embedded/package.json

@@ -42,6 +42,7 @@
   },
   "dependencies": {
     "@gnu-taler/taler-util": "workspace:*",
+    "@gnu-taler/idb-bridge": "workspace:*",
     "@gnu-taler/taler-wallet-core": "workspace:*",
     "tslib": "^2.4.0"
   }

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");
+}

pnpm-lock.yaml

@@ -580,6 +580,7 @@ importers:
 
   packages/taler-wallet-embedded:
     specifiers:
+      '@gnu-taler/idb-bridge': workspace:*
       '@gnu-taler/taler-util': workspace:*
       '@gnu-taler/taler-wallet-core': workspace:*
       '@rollup/plugin-commonjs': ^22.0.2
@@ -595,6 +596,7 @@ importers:
       tslib: ^2.4.0
       typescript: ^4.8.4
     dependencies:
+      '@gnu-taler/idb-bridge': link:../idb-bridge
       '@gnu-taler/taler-util': link:../taler-util
       '@gnu-taler/taler-wallet-core': link:../taler-wallet-core
       tslib: 2.4.0