[taler-wallet-core] branch master updated (d43313f7 -> a576fdfb)

[gnunet]

This is an automated email from the git hooks/post-receive script.

dold pushed a change to branch master
in repository wallet-core.

    from d43313f7 Revert "testing: reset exchange tables before start"
     new f5a8ae33 cleanup / formatting
     new a576fdfb backup

The 2 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails.  The revisions
listed as "add" were already present in the repository and have only
been added to this reference.


Summary of changes:
 .../src/integrationtests/harness.ts                | 14 ++--
 .../taler-wallet-cli/src/integrationtests/sync.ts  |  1 -
 .../src/integrationtests/test-revocation.ts        |  2 +-
 .../src/integrationtests/test-tipping.ts           |  2 +-
 packages/taler-wallet-cli/tsconfig.json            |  2 +-
 .../src/operations/backup/index.ts                 | 98 +++++++++++-----------
 .../taler-wallet-core/src/operations/refresh.ts    |  4 +-
 7 files changed, 62 insertions(+), 61 deletions(-)

diff --git a/packages/taler-wallet-cli/src/integrationtests/harness.ts 
b/packages/taler-wallet-cli/src/integrationtests/harness.ts
index fef4c27c..10b93b33 100644
--- a/packages/taler-wallet-cli/src/integrationtests/harness.ts
+++ b/packages/taler-wallet-cli/src/integrationtests/harness.ts
@@ -76,8 +76,8 @@ export async function delayMs(ms: number): Promise<void> {
 }
 
 export interface WithAuthorization {
-  Authorization?: string,
-} ;
+  Authorization?: string;
+}
 
 interface WaitResult {
   code: number | null;
@@ -1220,7 +1220,9 @@ export namespace MerchantPrivateApi {
   ): Promise<PostOrderResponse> {
     const baseUrl = merchantService.makeInstanceBaseUrl(instanceName);
     let url = new URL("private/orders", baseUrl);
-    const resp = await axios.post(url.href, req, { headers: withAuthorization 
});
+    const resp = await axios.post(url.href, req, {
+      headers: withAuthorization,
+    });
     return codecForPostOrderResponse().decode(resp.data);
   }
 
@@ -1395,10 +1397,8 @@ export class MerchantService implements 
MerchantServiceInterface {
     }
   }
 
-  async start(
-    withResetTables: boolean = true, // eventually, this should become a named 
parameter
-  ): Promise<void> {
-    await exec(`taler-merchant-dbinit ${withResetTables ? "-r" : ""} -c 
"${this.configFilename}"`);
+  async start(): Promise<void> {
+    await exec(`taler-merchant-dbinit -c "${this.configFilename}"`);
 
     this.proc = this.globalState.spawnService(
       "taler-merchant-httpd",
diff --git a/packages/taler-wallet-cli/src/integrationtests/sync.ts 
b/packages/taler-wallet-cli/src/integrationtests/sync.ts
index 73d3c9dd..90e6c139 100644
--- a/packages/taler-wallet-cli/src/integrationtests/sync.ts
+++ b/packages/taler-wallet-cli/src/integrationtests/sync.ts
@@ -17,7 +17,6 @@
 /**
  * Imports.
  */
-import axios from "axios";
 import { URL } from "@gnu-taler/taler-util";
 import * as fs from "fs";
 import * as util from "util";
diff --git a/packages/taler-wallet-cli/src/integrationtests/test-revocation.ts 
b/packages/taler-wallet-cli/src/integrationtests/test-revocation.ts
index 0b5c4755..fc1ffb26 100644
--- a/packages/taler-wallet-cli/src/integrationtests/test-revocation.ts
+++ b/packages/taler-wallet-cli/src/integrationtests/test-revocation.ts
@@ -53,7 +53,7 @@ async function revokeAllWalletCoins(req: {
   await exchange.keyup();
   await delayMs(1000);
   await merchant.stop();
-  await merchant.start(false); // 'false' prevents DB reset
+  await merchant.start();
   await merchant.pingUntilAvailable();
 }
 
diff --git a/packages/taler-wallet-cli/src/integrationtests/test-tipping.ts 
b/packages/taler-wallet-cli/src/integrationtests/test-tipping.ts
index 3eb8109e..2421b462 100644
--- a/packages/taler-wallet-cli/src/integrationtests/test-tipping.ts
+++ b/packages/taler-wallet-cli/src/integrationtests/test-tipping.ts
@@ -64,7 +64,7 @@ export async function runTippingTest(t: GlobalTestState) {
   await exchange.runWirewatchOnce();
 
   await merchant.stop();
-  await merchant.start(false);
+  await merchant.start();
   await merchant.pingUntilAvailable();
 
   const r = await MerchantPrivateApi.queryTippingReserves(merchant, "default");
diff --git a/packages/taler-wallet-cli/tsconfig.json 
b/packages/taler-wallet-cli/tsconfig.json
index 5ded91d7..94516117 100644
--- a/packages/taler-wallet-cli/tsconfig.json
+++ b/packages/taler-wallet-cli/tsconfig.json
@@ -2,7 +2,7 @@
   "compileOnSave": true,
   "compilerOptions": {
     "composite": true,
-    "target": "ES6",
+    "target": "ES2018",
     "module": "ESNext",
     "moduleResolution": "node",
     "sourceMap": true,
diff --git a/packages/taler-wallet-core/src/operations/backup/index.ts 
b/packages/taler-wallet-core/src/operations/backup/index.ts
index 3799741e..b3b98fe1 100644
--- a/packages/taler-wallet-core/src/operations/backup/index.ts
+++ b/packages/taler-wallet-core/src/operations/backup/index.ts
@@ -242,11 +242,7 @@ function deriveBlobSecret(bc: WalletBackupConfState): 
Uint8Array {
 }
 
 interface BackupForProviderArgs {
-  backupConfig: WalletBackupConfState;
-  provider: BackupProviderRecord;
-  currentBackupHash: ArrayBuffer;
-  encBackup: ArrayBuffer;
-  backupJson: WalletBackupContentV1;
+  backupProviderBaseUrl: string;
 
   /**
    * Should we attempt one more upload after trying
@@ -267,13 +263,22 @@ async function runBackupCycleForProvider(
   ws: InternalWalletState,
   args: BackupForProviderArgs,
 ): Promise<void> {
-  const {
-    backupConfig,
-    provider,
-    currentBackupHash,
-    encBackup,
-    backupJson,
-  } = args;
+  const provider = await ws.db
+    .mktx((x) => ({ backupProviders: x.backupProviders }))
+    .runReadOnly(async (tx) => {
+      return tx.backupProviders.get(args.backupProviderBaseUrl);
+    });
+
+  if (!provider) {
+    logger.warn("provider disappeared");
+    return;
+  }
+
+  const backupJson = await exportBackup(ws);
+  const backupConfig = await provideBackupState(ws);
+  const encBackup = await encryptBackup(backupConfig, backupJson);
+  const currentBackupHash = hash(encBackup);
+
   const accountKeyPair = deriveAccountKeyPair(backupConfig, provider.baseUrl);
 
   const newHash = encodeCrock(currentBackupHash);
@@ -301,11 +306,11 @@ async function runBackupCycleForProvider(
     headers: {
       "content-type": "application/octet-stream",
       "sync-signature": syncSig,
-      "if-none-match": encodeCrock(currentBackupHash),
+      "if-none-match": newHash,
       ...(provider.lastBackupHash
         ? {
-          "if-match": provider.lastBackupHash,
-        }
+            "if-match": provider.lastBackupHash,
+          }
         : {}),
     },
   });
@@ -366,7 +371,11 @@ async function runBackupCycleForProvider(
         provRec.currentPaymentProposalId = proposalId;
         // FIXME: allocate error code for this!
         await tx.backupProviders.put(provRec);
-        await incrementBackupRetryInTx(tx, args.provider.baseUrl, undefined);
+        await incrementBackupRetryInTx(
+          tx,
+          args.backupProviderBaseUrl,
+          undefined,
+        );
       });
 
     if (doPay) {
@@ -418,6 +427,7 @@ async function runBackupCycleForProvider(
       .runReadWrite(async (tx) => {
         const prov = await tx.backupProvider.get(provider.baseUrl);
         if (!prov) {
+          logger.warn("backup provider not found anymore");
           return;
         }
         prov.lastBackupHash = encodeCrock(hash(backupEnc));
@@ -446,7 +456,7 @@ async function runBackupCycleForProvider(
   await ws.db
     .mktx((x) => ({ backupProviders: x.backupProviders }))
     .runReadWrite(async (tx) => {
-      incrementBackupRetryInTx(tx, args.provider.baseUrl, err);
+      incrementBackupRetryInTx(tx, args.backupProviderBaseUrl, err);
     });
 }
 
@@ -504,17 +514,8 @@ export async function processBackupForProvider(
     incrementBackupRetry(ws, backupProviderBaseUrl, err);
 
   const run = async () => {
-    const backupJson = await exportBackup(ws);
-    const backupConfig = await provideBackupState(ws);
-    const encBackup = await encryptBackup(backupConfig, backupJson);
-    const currentBackupHash = hash(encBackup);
-
     await runBackupCycleForProvider(ws, {
-      provider,
-      backupJson,
-      backupConfig,
-      encBackup,
-      currentBackupHash,
+      backupProviderBaseUrl: provider.baseUrl,
       retryAfterPayment: true,
     });
   };
@@ -531,16 +532,20 @@ export const codecForRemoveBackupProvider = (): 
Codec<RemoveBackupProviderReques
     .property("provider", codecForString())
     .build("RemoveBackupProviderRequest");
 
-export async function removeBackupProvider(ws: InternalWalletState, req: 
RemoveBackupProviderRequest): Promise<void> {
-  await ws.db.mktx(({ backupProviders }) => ({ backupProviders }))
+export async function removeBackupProvider(
+  ws: InternalWalletState,
+  req: RemoveBackupProviderRequest,
+): Promise<void> {
+  await ws.db
+    .mktx(({ backupProviders }) => ({ backupProviders }))
     .runReadWrite(async (tx) => {
-      await tx.backupProviders.delete(req.provider)
-    })
+      await tx.backupProviders.delete(req.provider);
+    });
 }
 
 export interface RunBackupCycleRequest {
   /**
-   * List of providers to backup or empty for all known providers. 
+   * List of providers to backup or empty for all known providers.
    */
   providers?: Array<string>;
 }
@@ -557,28 +562,25 @@ export const codecForRunBackupCycle = (): 
Codec<RunBackupCycleRequest> =>
  * 2. Download, verify and import backups from connected sync accounts.
  * 3. Upload the updated backup blob.
  */
-export async function runBackupCycle(ws: InternalWalletState, req: 
RunBackupCycleRequest): Promise<void> {
+export async function runBackupCycle(
+  ws: InternalWalletState,
+  req: RunBackupCycleRequest,
+): Promise<void> {
   const providers = await ws.db
     .mktx((x) => ({ backupProviders: x.backupProviders }))
     .runReadOnly(async (tx) => {
       if (req.providers) {
-        const rs = await Promise.all(req.providers.map(id => 
tx.backupProviders.get(id)))
-        return rs.filter(notEmpty)
+        const rs = await Promise.all(
+          req.providers.map((id) => tx.backupProviders.get(id)),
+        );
+        return rs.filter(notEmpty);
       }
-      return await tx.backupProviders.iter(req.providers).toArray();
+      return await tx.backupProviders.iter().toArray();
     });
-  const backupJson = await exportBackup(ws);
-  const backupConfig = await provideBackupState(ws);
-  const encBackup = await encryptBackup(backupConfig, backupJson);
-  const currentBackupHash = hash(encBackup);
 
   for (const provider of providers) {
     await runBackupCycleForProvider(ws, {
-      provider,
-      backupJson,
-      backupConfig,
-      encBackup,
-      currentBackupHash,
+      backupProviderBaseUrl: provider.baseUrl,
       retryAfterPayment: true,
     });
   }
@@ -645,7 +647,7 @@ export async function addBackupProvider(
         return;
       }
     });
-  const termsUrl = new URL("terms", canonUrl);
+  const termsUrl = new URL("config", canonUrl);
   const resp = await ws.http.get(termsUrl.href);
   const terms = await readSuccessResponseJsonOrThrow(
     resp,
@@ -680,7 +682,7 @@ export async function addBackupProvider(
     });
 }
 
-export async function restoreFromRecoverySecret(): Promise<void> { }
+export async function restoreFromRecoverySecret(): Promise<void> {}
 
 /**
  * Information about one provider.
@@ -907,7 +909,7 @@ async function backupRecoveryTheirs(
         if (!existingProv) {
           await tx.backupProviders.put({
             baseUrl: prov.url,
-            name: 'not-defined',
+            name: "not-defined",
             paymentProposalIds: [],
             state: {
               tag: BackupProviderStateTag.Ready,
diff --git a/packages/taler-wallet-core/src/operations/refresh.ts 
b/packages/taler-wallet-core/src/operations/refresh.ts
index 2e6e7d80..5c4ed4f7 100644
--- a/packages/taler-wallet-core/src/operations/refresh.ts
+++ b/packages/taler-wallet-core/src/operations/refresh.ts
@@ -186,8 +186,8 @@ async function refreshCreateSession(
     logger.trace(`printing selected denominations for refresh`);
     logger.trace(`current time: ${stringifyTimestamp(getTimestampNow())}`);
     for (const denom of newCoinDenoms.selectedDenoms) {
-      console.log(`denom ${denom.denom}, count ${denom.count}`);
-      console.log(
+      logger.trace(`denom ${denom.denom}, count ${denom.count}`);
+      logger.trace(
         `withdrawal expiration ${stringifyTimestamp(
           denom.denom.stampExpireWithdraw,
         )}`,

-- 
To stop receiving notification emails like this one, please contact
gnunet@gnunet.org.