diff options
Diffstat (limited to 'packages/taler-wallet-embedded/src')
-rw-r--r-- | packages/taler-wallet-embedded/src/wallet-qjs.ts | 310 |
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"); +} |