quickjs preparations, clearer worker(-factory) names

3 files changed, 382 insertions, 0 deletions

diff --git a/packages/taler-wallet-embedded/build.mjs b/packages/taler-wallet-embedded/build.mjs
new file mode 100755
index 000000000..3507480c6
--- /dev/null
+++ b/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)
+  });
+
+
diff --git a/packages/taler-wallet-embedded/package.json b/packages/taler-wallet-embedded/package.json
index dc312c6de..5d1c501a6 100644
--- a/packages/taler-wallet-embedded/package.json
+++ b/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"
   }
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");
+}