wallet: support both protocol versions

24 files changed, 623 insertions, 231 deletions

diff --git a/packages/taler-util/src/codec.ts b/packages/taler-util/src/codec.ts
index 8605ff335..2ea64a249 100644
--- a/packages/taler-util/src/codec.ts
+++ b/packages/taler-util/src/codec.ts
@@ -417,3 +417,26 @@ export function codecOptional<V>(innerCodec: Codec<V>): Codec<V | undefined> {
     },
   };
 }
+
+export type CodecType<T> = T extends Codec<infer X> ? X : any;
+
+export function codecForEither<T extends Array<Codec<unknown>>>(
+  ...alts: [...T]
+): Codec<CodecType<T[number]>> {
+  return {
+    decode(x: any, c?: Context): any {
+      for (const alt of alts) {
+        try {
+          return alt.decode(x, c);
+        } catch (e) {
+          continue;
+        }
+      }
+      throw new DecodingError(
+        `No alternative matched at at ${renderContext(c)}`,
+      );
+    },
+  };
+}
+
+const x = codecForEither(codecForString(), codecForNumber());
diff --git a/packages/taler-util/src/libtool-version.ts b/packages/taler-util/src/libtool-version.ts
index 17d2bbbdc..ed11a4e95 100644
--- a/packages/taler-util/src/libtool-version.ts
+++ b/packages/taler-util/src/libtool-version.ts
@@ -27,14 +27,15 @@ export interface VersionMatchResult {
    * Is the first version compatible with the second?
    */
   compatible: boolean;
+
   /**
-   * Is the first version older (-1), newser (+1) or
+   * Is the first version older (-1), newer (+1) or
    * identical (0)?
    */
   currentCmp: number;
 }
 
-interface Version {
+export interface Version {
   current: number;
   revision: number;
   age: number;
@@ -64,7 +65,7 @@ export namespace LibtoolVersion {
     return { compatible, currentCmp };
   }
 
-  function parseVersion(v: string): Version | undefined {
+  export function parseVersion(v: string): Version | undefined {
     const [currentStr, revisionStr, ageStr, ...rest] = v.split(":");
     if (rest.length !== 0) {
       return undefined;
diff --git a/packages/taler-util/src/logging.ts b/packages/taler-util/src/logging.ts
index 8b9de1ab0..117664d8c 100644
--- a/packages/taler-util/src/logging.ts
+++ b/packages/taler-util/src/logging.ts
@@ -55,7 +55,7 @@ export function setGlobalLogLevelFromString(logLevelStr: string) {
       break;
     default:
       if (isNode) {
-        process.stderr.write(`Invalid log level, defaulting to WARNING`);
+        process.stderr.write(`Invalid log level, defaulting to WARNING\n`);
       } else {
         console.warn(`Invalid log level, defaulting to WARNING`);
       }
@@ -143,6 +143,7 @@ export class Logger {
       case LogLevel.Info:
       case LogLevel.Warn:
       case LogLevel.Error:
+        return true;
       case LogLevel.None:
         return false;
     }
diff --git a/packages/taler-util/src/talerCrypto.ts b/packages/taler-util/src/talerCrypto.ts
index c20ce72a6..d96c23236 100644
--- a/packages/taler-util/src/talerCrypto.ts
+++ b/packages/taler-util/src/talerCrypto.ts
@@ -349,18 +349,25 @@ export function hash(d: Uint8Array): Uint8Array {
   return nacl.hash(d);
 }
 
+/**
+ * Hash a denomination public key according to the
+ * algorithm of exchange protocol v10.
+ */
 export function hashDenomPub(pub: DenominationPubKey): Uint8Array {
-  if (pub.cipher !== DenomKeyType.Rsa) {
-    throw Error("unsupported cipher");
+  if (pub.cipher === DenomKeyType.Rsa) {
+    const pubBuf = decodeCrock(pub.rsa_public_key);
+    const hashInputBuf = new ArrayBuffer(pubBuf.length + 4 + 4);
+    const uint8ArrayBuf = new Uint8Array(hashInputBuf);
+    const dv = new DataView(hashInputBuf);
+    dv.setUint32(0, pub.age_mask ?? 0);
+    dv.setUint32(4, pub.cipher);
+    uint8ArrayBuf.set(pubBuf, 8);
+    return nacl.hash(uint8ArrayBuf);
+  } else if (pub.cipher === DenomKeyType.LegacyRsa) {
+    return hash(decodeCrock(pub.rsa_public_key));
+  } else {
+    throw Error(`unsupported cipher (${pub.cipher}), unable to hash`);
   }
-  const pubBuf = decodeCrock(pub.rsa_public_key);
-  const hashInputBuf = new ArrayBuffer(pubBuf.length + 4 + 4);
-  const uint8ArrayBuf = new Uint8Array(hashInputBuf);
-  const dv = new DataView(hashInputBuf);
-  dv.setUint32(0, pub.age_mask ?? 0);
-  dv.setUint32(4, pub.cipher);
-  uint8ArrayBuf.set(pubBuf, 8);
-  return nacl.hash(uint8ArrayBuf);
 }
 
 export function eddsaSign(msg: Uint8Array, eddsaPriv: Uint8Array): Uint8Array {
diff --git a/packages/taler-util/src/talerTypes.ts b/packages/taler-util/src/talerTypes.ts
index bd9c67d7e..15dc88ca5 100644
--- a/packages/taler-util/src/talerTypes.ts
+++ b/packages/taler-util/src/talerTypes.ts
@@ -38,6 +38,7 @@ import {
   codecForConstNumber,
   buildCodecForUnion,
   codecForConstString,
+  codecForEither,
 } from "./codec.js";
 import {
   Timestamp,
@@ -50,7 +51,7 @@ import { codecForAmountString } from "./amounts.js";
 /**
  * Denomination as found in the /keys response from the exchange.
  */
-export class Denomination {
+export class ExchangeDenomination {
   /**
    * Value of one coin of the denomination.
    */
@@ -58,8 +59,11 @@ export class Denomination {
 
   /**
    * Public signing key of the denomination.
+   *
+   * The "string" alternative is for the old exchange protocol (v9) that
+   * only supports RSA keys.
    */
-  denom_pub: DenominationPubKey;
+  denom_pub: DenominationPubKey | string;
 
   /**
    * Fee for withdrawing.
@@ -128,7 +132,7 @@ export class AuditorDenomSig {
 /**
  * Auditor information as given by the exchange in /keys.
  */
-export class Auditor {
+export class ExchangeAuditor {
   /**
    * Auditor's public key.
    */
@@ -157,8 +161,10 @@ export interface RecoupRequest {
 
   /**
    * Signature over the coin public key by the denomination.
+   * 
+   * The string variant is for the legacy exchange protocol.
    */
-  denom_sig: UnblindedSignature;
+  denom_sig: UnblindedSignature | string;
 
   /**
    * Coin public key of the coin we want to refund.
@@ -198,11 +204,20 @@ export interface RecoupConfirmation {
   old_coin_pub?: string;
 }
 
-export interface UnblindedSignature {
+export type UnblindedSignature =
+  | RsaUnblindedSignature
+  | LegacyRsaUnblindedSignature;
+
+export interface RsaUnblindedSignature {
   cipher: DenomKeyType.Rsa;
   rsa_signature: string;
 }
 
+export interface LegacyRsaUnblindedSignature {
+  cipher: DenomKeyType.LegacyRsa;
+  rsa_signature: string;
+}
+
 /**
  * Deposit permission for a single coin.
  */
@@ -211,18 +226,25 @@ export interface CoinDepositPermission {
    * Signature by the coin.
    */
   coin_sig: string;
+
   /**
    * Public key of the coin being spend.
    */
   coin_pub: string;
+
   /**
    * Signature made by the denomination public key.
+   *
+   * The string variant is for legacy protocol support.
    */
-  ub_sig: UnblindedSignature;
+
+  ub_sig: UnblindedSignature | string;
+
   /**
    * The denomination public key associated with this coin.
    */
   h_denom: string;
+
   /**
    * The amount that is subtracted from this coin with this payment.
    */
@@ -359,6 +381,11 @@ export interface ContractTerms {
   h_wire: string;
 
   /**
+   * Legacy wire hash, used for deposit operations with an older exchange.
+   */
+  h_wire_legacy?: string;
+
+  /**
    * Hash of the merchant's wire details.
    */
   auto_refund?: Duration;
@@ -662,7 +689,7 @@ export class ExchangeKeysJson {
   /**
    * List of offered denominations.
    */
-  denoms: Denomination[];
+  denoms: ExchangeDenomination[];
 
   /**
    * The exchange's master public key.
@@ -672,7 +699,7 @@ export class ExchangeKeysJson {
   /**
    * The list of auditors (partially) auditing the exchange.
    */
-  auditors: Auditor[];
+  auditors: ExchangeAuditor[];
 
   /**
    * Timestamp when this response was issued.
@@ -802,6 +829,7 @@ export class TipPickupGetResponse {
 export enum DenomKeyType {
   Rsa = 1,
   ClauseSchnorr = 2,
+  LegacyRsa = 3,
 }
 
 export interface RsaBlindedDenominationSignature {
@@ -809,18 +837,25 @@ export interface RsaBlindedDenominationSignature {
   blinded_rsa_signature: string;
 }
 
+export interface LegacyRsaBlindedDenominationSignature {
+  cipher: DenomKeyType.LegacyRsa;
+  blinded_rsa_signature: string;
+}
+
 export interface CSBlindedDenominationSignature {
   cipher: DenomKeyType.ClauseSchnorr;
 }
 
 export type BlindedDenominationSignature =
   | RsaBlindedDenominationSignature
-  | CSBlindedDenominationSignature;
+  | CSBlindedDenominationSignature
+  | LegacyRsaBlindedDenominationSignature;
 
 export const codecForBlindedDenominationSignature = () =>
   buildCodecForUnion<BlindedDenominationSignature>()
     .discriminateOn("cipher")
     .alternative(1, codecForRsaBlindedDenominationSignature())
+    .alternative(3, codecForLegacyRsaBlindedDenominationSignature())
     .build("BlindedDenominationSignature");
 
 export const codecForRsaBlindedDenominationSignature = () =>
@@ -829,8 +864,17 @@ export const codecForRsaBlindedDenominationSignature = () =>
     .property("blinded_rsa_signature", codecForString())
     .build("RsaBlindedDenominationSignature");
 
+export const codecForLegacyRsaBlindedDenominationSignature = () =>
+  buildCodecForObject<LegacyRsaBlindedDenominationSignature>()
+    .property("cipher", codecForConstNumber(1))
+    .property("blinded_rsa_signature", codecForString())
+    .build("LegacyRsaBlindedDenominationSignature");
+
 export class WithdrawResponse {
-  ev_sig: BlindedDenominationSignature;
+  /**
+   * The string variant is for legacy protocol support.
+   */
+  ev_sig: BlindedDenominationSignature | string;
 }
 
 /**
@@ -925,7 +969,10 @@ export interface ExchangeMeltResponse {
 }
 
 export interface ExchangeRevealItem {
-  ev_sig: BlindedDenominationSignature;
+  /**
+   * The string variant is for the legacy v9 protocol.
+   */
+  ev_sig: BlindedDenominationSignature | string;
 }
 
 export interface ExchangeRevealResponse {
@@ -1044,7 +1091,15 @@ export interface BankWithdrawalOperationPostResponse {
   transfer_done: boolean;
 }
 
-export type DenominationPubKey = RsaDenominationPubKey | CsDenominationPubKey;
+export type DenominationPubKey =
+  | RsaDenominationPubKey
+  | CsDenominationPubKey
+  | LegacyRsaDenominationPubKey;
+
+export interface LegacyRsaDenominationPubKey {
+  cipher: DenomKeyType.LegacyRsa;
+  rsa_public_key: string;
+}
 
 export interface RsaDenominationPubKey {
   cipher: DenomKeyType.Rsa;
@@ -1061,6 +1116,7 @@ export const codecForDenominationPubKey = () =>
   buildCodecForUnion<DenominationPubKey>()
     .discriminateOn("cipher")
     .alternative(1, codecForRsaDenominationPubKey())
+    .alternative(3, codecForLegacyRsaDenominationPubKey())
     .build("DenominationPubKey");
 
 export const codecForRsaDenominationPubKey = () =>
@@ -1069,6 +1125,12 @@ export const codecForRsaDenominationPubKey = () =>
     .property("rsa_public_key", codecForString())
     .build("DenominationPubKey");
 
+export const codecForLegacyRsaDenominationPubKey = () =>
+  buildCodecForObject<LegacyRsaDenominationPubKey>()
+    .property("cipher", codecForConstNumber(3))
+    .property("rsa_public_key", codecForString())
+    .build("LegacyRsaDenominationPubKey");
+
 export const codecForBankWithdrawalOperationPostResponse = (): Codec<BankWithdrawalOperationPostResponse> =>
   buildCodecForObject<BankWithdrawalOperationPostResponse>()
     .property("transfer_done", codecForBoolean())
@@ -1080,10 +1142,13 @@ export type EddsaSignatureString = string;
 export type EddsaPublicKeyString = string;
 export type CoinPublicKeyString = string;
 
-export const codecForDenomination = (): Codec<Denomination> =>
-  buildCodecForObject<Denomination>()
+export const codecForDenomination = (): Codec<ExchangeDenomination> =>
+  buildCodecForObject<ExchangeDenomination>()
     .property("value", codecForString())
-    .property("denom_pub", codecForDenominationPubKey())
+    .property(
+      "denom_pub",
+      codecForEither(codecForDenominationPubKey(), codecForString()),
+    )
     .property("fee_withdraw", codecForString())
     .property("fee_deposit", codecForString())
     .property("fee_refresh", codecForString())
@@ -1101,8 +1166,8 @@ export const codecForAuditorDenomSig = (): Codec<AuditorDenomSig> =>
     .property("auditor_sig", codecForString())
     .build("AuditorDenomSig");
 
-export const codecForAuditor = (): Codec<Auditor> =>
-  buildCodecForObject<Auditor>()
+export const codecForAuditor = (): Codec<ExchangeAuditor> =>
+  buildCodecForObject<ExchangeAuditor>()
     .property("auditor_pub", codecForString())
     .property("auditor_url", codecForString())
     .property("denomination_keys", codecForList(codecForAuditorDenomSig()))
@@ -1261,7 +1326,7 @@ export const codecForExchangeKeysJson = (): Codec<ExchangeKeysJson> =>
     .property("signkeys", codecForList(codecForExchangeSigningKey()))
     .property("version", codecForString())
     .property("reserve_closing_delay", codecForDuration)
-    .build("KeysJson");
+    .build("ExchangeKeysJson");
 
 export const codecForWireFeesJson = (): Codec<WireFeesJson> =>
   buildCodecForObject<WireFeesJson>()
@@ -1327,7 +1392,10 @@ export const codecForRecoupConfirmation = (): Codec<RecoupConfirmation> =>
 
 export const codecForWithdrawResponse = (): Codec<WithdrawResponse> =>
   buildCodecForObject<WithdrawResponse>()
-    .property("ev_sig", codecForBlindedDenominationSignature())
+    .property(
+      "ev_sig",
+      codecForEither(codecForBlindedDenominationSignature(), codecForString()),
+    )
     .build("WithdrawResponse");
 
 export const codecForMerchantPayResponse = (): Codec<MerchantPayResponse> =>
@@ -1345,7 +1413,10 @@ export const codecForExchangeMeltResponse = (): Codec<ExchangeMeltResponse> =>
 
 export const codecForExchangeRevealItem = (): Codec<ExchangeRevealItem> =>
   buildCodecForObject<ExchangeRevealItem>()
-    .property("ev_sig", codecForBlindedDenominationSignature())
+    .property(
+      "ev_sig",
+      codecForEither(codecForBlindedDenominationSignature(), codecForString()),
+    )
     .build("ExchangeRevealItem");
 
 export const codecForExchangeRevealResponse = (): Codec<ExchangeRevealResponse> =>
diff --git a/packages/taler-util/src/walletTypes.ts b/packages/taler-util/src/walletTypes.ts
index f00e2907f..ced30e4db 100644
--- a/packages/taler-util/src/walletTypes.ts
+++ b/packages/taler-util/src/walletTypes.ts
@@ -49,6 +49,7 @@ import {
   codecForContractTerms,
   ContractTerms,
   DenominationPubKey,
+  DenomKeyType,
   UnblindedSignature,
 } from "./talerTypes.js";
 import { OrderShortInfo, codecForOrderShortInfo } from "./transactionsTypes.js";
@@ -515,6 +516,7 @@ export interface DepositInfo {
   merchantPub: string;
   feeDeposit: AmountJson;
   wireInfoHash: string;
+  denomKeyType: DenomKeyType;
   denomPubHash: string;
   denomSig: UnblindedSignature;
 }
diff --git a/packages/taler-wallet-cli/src/harness/harness.ts b/packages/taler-wallet-cli/src/harness/harness.ts
index 9a33d572a..37a192db6 100644
--- a/packages/taler-wallet-cli/src/harness/harness.ts
+++ b/packages/taler-wallet-cli/src/harness/harness.ts
@@ -1173,12 +1173,24 @@ export class ExchangeService implements ExchangeServiceInterface {
   }
 
   async runAggregatorOnce() {
-    await runCommand(
-      this.globalState,
-      `exchange-${this.name}-aggregator-once`,
-      "taler-exchange-aggregator",
-      [...this.timetravelArgArr, "-c", this.configFilename, "-t"],
-    );
+    try {
+      await runCommand(
+        this.globalState,
+        `exchange-${this.name}-aggregator-once`,
+        "taler-exchange-aggregator",
+        [...this.timetravelArgArr, "-c", this.configFilename, "-t", "-y"],
+      );
+    } catch (e) {
+      console.log(
+        "running aggregator with KYC off didn't work, might be old version, running again",
+      );
+      await runCommand(
+        this.globalState,
+        `exchange-${this.name}-aggregator-once`,
+        "taler-exchange-aggregator",
+        [...this.timetravelArgArr, "-c", this.configFilename, "-t"],
+      );
+    }
   }
 
   async runTransferOnce() {
diff --git a/packages/taler-wallet-cli/src/index.ts b/packages/taler-wallet-cli/src/index.ts
index 71431b5eb..b57e73a1c 100644
--- a/packages/taler-wallet-cli/src/index.ts
+++ b/packages/taler-wallet-cli/src/index.ts
@@ -1018,6 +1018,13 @@ const testCli = walletCli.subcommand("testingArgs", "testing", {
   help: "Subcommands for testing.",
 });
 
+testCli.subcommand("logtest", "logtest").action(async (args) => {
+  logger.trace("This is a trace message.");
+  logger.info("This is an info message.");
+  logger.warn("This is an warning message.");
+  logger.error("This is an error message.");
+});
+
 testCli
   .subcommand("listIntegrationtests", "list-integrationtests")
   .action(async (args) => {
diff --git a/packages/taler-wallet-core/src/common.ts b/packages/taler-wallet-core/src/common.ts
index 81c43cf14..90c2afddb 100644
--- a/packages/taler-wallet-core/src/common.ts
+++ b/packages/taler-wallet-core/src/common.ts
@@ -51,9 +51,8 @@ export interface TrustInfo {
   isAudited: boolean;
 }
 
-export interface MerchantInfo {
-  supportsMerchantProtocolV1: boolean;
-  supportsMerchantProtocolV2: boolean;
+export interface MerchantInfo { 
+  protocolVersionCurrent: number;
 }
 
 /**
diff --git a/packages/taler-wallet-core/src/crypto/workers/cryptoApi.ts b/packages/taler-wallet-core/src/crypto/workers/cryptoApi.ts
index e6c0290f1..e88b64c3c 100644
--- a/packages/taler-wallet-core/src/crypto/workers/cryptoApi.ts
+++ b/packages/taler-wallet-core/src/crypto/workers/cryptoApi.ts
@@ -392,6 +392,7 @@ export class CryptoApi {
   }
 
   isValidWireAccount(
+    versionCurrent: number,
     paytoUri: string,
     sig: string,
     masterPub: string,
@@ -399,6 +400,7 @@ export class CryptoApi {
     return this.doRpc<boolean>(
       "isValidWireAccount",
       4,
+      versionCurrent,
       paytoUri,
       sig,
       masterPub,
diff --git a/packages/taler-wallet-core/src/crypto/workers/cryptoImplementation.ts b/packages/taler-wallet-core/src/crypto/workers/cryptoImplementation.ts
index 389b98b22..621105b63 100644
--- a/packages/taler-wallet-core/src/crypto/workers/cryptoImplementation.ts
+++ b/packages/taler-wallet-core/src/crypto/workers/cryptoImplementation.ts
@@ -154,56 +154,63 @@ export class CryptoImplementation {
    * reserve.
    */
   createPlanchet(req: PlanchetCreationRequest): PlanchetCreationResult {
-    if (req.denomPub.cipher !== 1) {
-      throw Error("unsupported cipher");
+    if (
+      req.denomPub.cipher === DenomKeyType.Rsa ||
+      req.denomPub.cipher === DenomKeyType.LegacyRsa
+    ) {
+      const reservePub = decodeCrock(req.reservePub);
+      const reservePriv = decodeCrock(req.reservePriv);
+      const denomPubRsa = decodeCrock(req.denomPub.rsa_public_key);
+      const derivedPlanchet = setupWithdrawPlanchet(
+        decodeCrock(req.secretSeed),
+        req.coinIndex,
+      );
+      const coinPubHash = hash(derivedPlanchet.coinPub);
+      const ev = rsaBlind(coinPubHash, derivedPlanchet.bks, denomPubRsa);
+      const amountWithFee = Amounts.add(req.value, req.feeWithdraw).amount;
+      const denomPubHash = hashDenomPub(req.denomPub);
+      const evHash = hash(ev);
+
+      const withdrawRequest = buildSigPS(
+        TalerSignaturePurpose.WALLET_RESERVE_WITHDRAW,
+      )
+        .put(reservePub)
+        .put(amountToBuffer(amountWithFee))
+        .put(denomPubHash)
+        .put(evHash)
+        .build();
+
+      const sig = eddsaSign(withdrawRequest, reservePriv);
+
+      const planchet: PlanchetCreationResult = {
+        blindingKey: encodeCrock(derivedPlanchet.bks),
+        coinEv: encodeCrock(ev),
+        coinPriv: encodeCrock(derivedPlanchet.coinPriv),
+        coinPub: encodeCrock(derivedPlanchet.coinPub),
+        coinValue: req.value,
+        denomPub: {
+          cipher: req.denomPub.cipher,
+          rsa_public_key: encodeCrock(denomPubRsa),
+        },
+        denomPubHash: encodeCrock(denomPubHash),
+        reservePub: encodeCrock(reservePub),
+        withdrawSig: encodeCrock(sig),
+        coinEvHash: encodeCrock(evHash),
+      };
+      return planchet;
+    } else {
+      throw Error("unsupported cipher, unable to create planchet");
     }
-    const reservePub = decodeCrock(req.reservePub);
-    const reservePriv = decodeCrock(req.reservePriv);
-    const denomPubRsa = decodeCrock(req.denomPub.rsa_public_key);
-    const derivedPlanchet = setupWithdrawPlanchet(
-      decodeCrock(req.secretSeed),
-      req.coinIndex,
-    );
-    const coinPubHash = hash(derivedPlanchet.coinPub);
-    const ev = rsaBlind(coinPubHash, derivedPlanchet.bks, denomPubRsa);
-    const amountWithFee = Amounts.add(req.value, req.feeWithdraw).amount;
-    const denomPubHash = hashDenomPub(req.denomPub);
-    const evHash = hash(ev);
-
-    const withdrawRequest = buildSigPS(
-      TalerSignaturePurpose.WALLET_RESERVE_WITHDRAW,
-    )
-      .put(reservePub)
-      .put(amountToBuffer(amountWithFee))
-      .put(denomPubHash)
-      .put(evHash)
-      .build();
-
-    const sig = eddsaSign(withdrawRequest, reservePriv);
-
-    const planchet: PlanchetCreationResult = {
-      blindingKey: encodeCrock(derivedPlanchet.bks),
-      coinEv: encodeCrock(ev),
-      coinPriv: encodeCrock(derivedPlanchet.coinPriv),
-      coinPub: encodeCrock(derivedPlanchet.coinPub),
-      coinValue: req.value,
-      denomPub: {
-        cipher: 1,
-        rsa_public_key: encodeCrock(denomPubRsa),
-      },
-      denomPubHash: encodeCrock(denomPubHash),
-      reservePub: encodeCrock(reservePub),
-      withdrawSig: encodeCrock(sig),
-      coinEvHash: encodeCrock(evHash),
-    };
-    return planchet;
   }
 
   /**
    * Create a planchet used for tipping, including the private keys.
    */
   createTipPlanchet(req: DeriveTipRequest): DerivedTipPlanchet {
-    if (req.denomPub.cipher !== 1) {
+    if (
+      req.denomPub.cipher !== DenomKeyType.Rsa &&
+      req.denomPub.cipher !== DenomKeyType.LegacyRsa
+    ) {
       throw Error("unsupported cipher");
     }
     const fc = setupTipPlanchet(decodeCrock(req.secretSeed), req.planchetIndex);
@@ -243,15 +250,29 @@ export class CryptoImplementation {
 
     const coinPriv = decodeCrock(coin.coinPriv);
     const coinSig = eddsaSign(p, coinPriv);
-    const paybackRequest: RecoupRequest = {
-      coin_blind_key_secret: coin.blindingKey,
-      coin_pub: coin.coinPub,
-      coin_sig: encodeCrock(coinSig),
-      denom_pub_hash: coin.denomPubHash,
-      denom_sig: coin.denomSig,
-      refreshed: coin.coinSource.type === CoinSourceType.Refresh,
-    };
-    return paybackRequest;
+    if (coin.denomPub.cipher === DenomKeyType.LegacyRsa) {
+      logger.info("creating legacy recoup request");
+      const paybackRequest: RecoupRequest = {
+        coin_blind_key_secret: coin.blindingKey,
+        coin_pub: coin.coinPub,
+        coin_sig: encodeCrock(coinSig),
+        denom_pub_hash: coin.denomPubHash,
+        denom_sig: coin.denomSig.rsa_signature,
+        refreshed: coin.coinSource.type === CoinSourceType.Refresh,
+      };
+      return paybackRequest;
+    } else {
+      logger.info("creating v10 recoup request");
+      const paybackRequest: RecoupRequest = {
+        coin_blind_key_secret: coin.blindingKey,
+        coin_pub: coin.coinPub,
+        coin_sig: encodeCrock(coinSig),
+        denom_pub_hash: coin.denomPubHash,
+        denom_sig: coin.denomSig,
+        refreshed: coin.coinSource.type === CoinSourceType.Refresh,
+      };
+      return paybackRequest;
+    }
   }
 
   /**
@@ -326,15 +347,31 @@ export class CryptoImplementation {
   }
 
   isValidWireAccount(
+    versionCurrent: number,
     paytoUri: string,
     sig: string,
     masterPub: string,
   ): boolean {
-    const paytoHash = hash(stringToBytes(paytoUri + "\0"));
-    const p = buildSigPS(TalerSignaturePurpose.MASTER_WIRE_DETAILS)
-      .put(paytoHash)
-      .build();
-    return eddsaVerify(p, decodeCrock(sig), decodeCrock(masterPub));
+    if (versionCurrent === 10) {
+      const paytoHash = hash(stringToBytes(paytoUri + "\0"));
+      const p = buildSigPS(TalerSignaturePurpose.MASTER_WIRE_DETAILS)
+        .put(paytoHash)
+        .build();
+      return eddsaVerify(p, decodeCrock(sig), decodeCrock(masterPub));
+    } else if (versionCurrent === 9) {
+      const h = kdf(
+        64,
+        stringToBytes("exchange-wire-signature"),
+        stringToBytes(paytoUri + "\0"),
+        new Uint8Array(0),
+      );
+      const p = buildSigPS(TalerSignaturePurpose.MASTER_WIRE_DETAILS)
+        .put(h)
+        .build();
+      return eddsaVerify(p, decodeCrock(sig), decodeCrock(masterPub));
+    } else {
+      throw Error(`unsupported version (${versionCurrent})`);
+    }
   }
 
   isValidContractTermsSignature(
@@ -393,31 +430,64 @@ export class CryptoImplementation {
   signDepositPermission(depositInfo: DepositInfo): CoinDepositPermission {
     // FIXME: put extensions here if used
     const hExt = new Uint8Array(64);
-    const d = buildSigPS(TalerSignaturePurpose.WALLET_COIN_DEPOSIT)
-      .put(decodeCrock(depositInfo.contractTermsHash))
-      .put(hExt)
-      .put(decodeCrock(depositInfo.wireInfoHash))
-      .put(decodeCrock(depositInfo.denomPubHash))
-      .put(timestampRoundedToBuffer(depositInfo.timestamp))
-      .put(timestampRoundedToBuffer(depositInfo.refundDeadline))
-      .put(amountToBuffer(depositInfo.spendAmount))
-      .put(amountToBuffer(depositInfo.feeDeposit))
-      .put(decodeCrock(depositInfo.merchantPub))
-      .build();
+    let d: Uint8Array;
+    if (depositInfo.denomKeyType === DenomKeyType.Rsa) {
+      logger.warn("signing v10 deposit permission");
+      d = buildSigPS(TalerSignaturePurpose.WALLET_COIN_DEPOSIT)
+        .put(decodeCrock(depositInfo.contractTermsHash))
+        .put(hExt)
+        .put(decodeCrock(depositInfo.wireInfoHash))
+        .put(decodeCrock(depositInfo.denomPubHash))
+        .put(timestampRoundedToBuffer(depositInfo.timestamp))
+        .put(timestampRoundedToBuffer(depositInfo.refundDeadline))
+        .put(amountToBuffer(depositInfo.spendAmount))
+        .put(amountToBuffer(depositInfo.feeDeposit))
+        .put(decodeCrock(depositInfo.merchantPub))
+        .build();
+    } else if (depositInfo.denomKeyType === DenomKeyType.LegacyRsa) {
+      logger.warn("signing legacy deposit permission");
+      d = buildSigPS(TalerSignaturePurpose.WALLET_COIN_DEPOSIT)
+        .put(decodeCrock(depositInfo.contractTermsHash))
+        .put(decodeCrock(depositInfo.wireInfoHash))
+        .put(decodeCrock(depositInfo.denomPubHash))
+        .put(timestampRoundedToBuffer(depositInfo.timestamp))
+        .put(timestampRoundedToBuffer(depositInfo.refundDeadline))
+        .put(amountToBuffer(depositInfo.spendAmount))
+        .put(amountToBuffer(depositInfo.feeDeposit))
+        .put(decodeCrock(depositInfo.merchantPub))
+        .put(decodeCrock(depositInfo.coinPub))
+        .build();
+    } else {
+      throw Error("unsupported exchange protocol version");
+    }
     const coinSig = eddsaSign(d, decodeCrock(depositInfo.coinPriv));
 
-    const s: CoinDepositPermission = {
-      coin_pub: depositInfo.coinPub,
-      coin_sig: encodeCrock(coinSig),
-      contribution: Amounts.stringify(depositInfo.spendAmount),
-      h_denom: depositInfo.denomPubHash,
-      exchange_url: depositInfo.exchangeBaseUrl,
-      ub_sig: {
-        cipher: DenomKeyType.Rsa,
-        rsa_signature: depositInfo.denomSig.rsa_signature,
-      },
-    };
-    return s;
+    if (depositInfo.denomKeyType === DenomKeyType.Rsa) {
+      const s: CoinDepositPermission = {
+        coin_pub: depositInfo.coinPub,
+        coin_sig: encodeCrock(coinSig),
+        contribution: Amounts.stringify(depositInfo.spendAmount),
+        h_denom: depositInfo.denomPubHash,
+        exchange_url: depositInfo.exchangeBaseUrl,
+        ub_sig: {
+          cipher: DenomKeyType.Rsa,
+          rsa_signature: depositInfo.denomSig.rsa_signature,
+        },
+      };
+      return s;
+    } else if (depositInfo.denomKeyType === DenomKeyType.LegacyRsa) {
+      const s: CoinDepositPermission = {
+        coin_pub: depositInfo.coinPub,
+        coin_sig: encodeCrock(coinSig),
+        contribution: Amounts.stringify(depositInfo.spendAmount),
+        h_denom: depositInfo.denomPubHash,
+        exchange_url: depositInfo.exchangeBaseUrl,
+        ub_sig: depositInfo.denomSig.rsa_signature,
+      };
+      return s;
+    } else {
+      throw Error("unsupported merchant protocol version");
+    }
   }
 
   async deriveRefreshSession(
@@ -466,10 +536,12 @@ export class CryptoImplementation {
 
     for (const denomSel of newCoinDenoms) {
       for (let i = 0; i < denomSel.count; i++) {
-        if (denomSel.denomPub.cipher !== 1) {
-          throw Error("unsupported cipher");
+        if (denomSel.denomPub.cipher === DenomKeyType.LegacyRsa) {
+          const r = decodeCrock(denomSel.denomPub.rsa_public_key);
+          sessionHc.update(r);
+        } else {
+          sessionHc.update(hashDenomPub(denomSel.denomPub));
         }
-        sessionHc.update(hashDenomPub(denomSel.denomPub));
       }
     }
 
@@ -508,8 +580,11 @@ export class CryptoImplementation {
             blindingFactor = fresh.bks;
           }
           const pubHash = hash(coinPub);
-          if (denomSel.denomPub.cipher !== 1) {
-            throw Error("unsupported cipher");
+          if (
+            denomSel.denomPub.cipher !== DenomKeyType.Rsa &&
+            denomSel.denomPub.cipher !== DenomKeyType.LegacyRsa
+          ) {
+            throw Error("unsupported cipher, can't create refresh session");
           }
           const denomPub = decodeCrock(denomSel.denomPub.rsa_public_key);
           const ev = rsaBlind(pubHash, blindingFactor, denomPub);
diff --git a/packages/taler-wallet-core/src/db.ts b/packages/taler-wallet-core/src/db.ts
index ff47cf30d..2d818f1db 100644
--- a/packages/taler-wallet-core/src/db.ts
+++ b/packages/taler-wallet-core/src/db.ts
@@ -25,7 +25,7 @@ import {
 import {
   AmountJson,
   AmountString,
-  Auditor,
+  ExchangeAuditor,
   CoinDepositPermission,
   ContractTerms,
   DenominationPubKey,
@@ -427,7 +427,7 @@ export interface ExchangeDetailsRecord {
   /**
    * Auditors (partially) auditing the exchange.
    */
-  auditors: Auditor[];
+  auditors: ExchangeAuditor[];
 
   /**
    * Last observed protocol version.
@@ -1136,6 +1136,7 @@ export interface WalletContractData {
   timestamp: Timestamp;
   wireMethod: string;
   wireInfoHash: string;
+  wireInfoLegacyHash?: string;
   maxDepositFee: AmountJson;
 }
 
diff --git a/packages/taler-wallet-core/src/operations/backup/import.ts b/packages/taler-wallet-core/src/operations/backup/import.ts
index 40fa4cdec..564d39797 100644
--- a/packages/taler-wallet-core/src/operations/backup/import.ts
+++ b/packages/taler-wallet-core/src/operations/backup/import.ts
@@ -27,6 +27,7 @@ import {
   BackupRefundState,
   RefreshReason,
   BackupRefreshReason,
+  DenomKeyType,
 } from "@gnu-taler/taler-util";
 import {
   WalletContractData,
@@ -331,7 +332,10 @@ export async function importBackup(
         }
 
         for (const backupDenomination of backupExchangeDetails.denominations) {
-          if (backupDenomination.denom_pub.cipher !== 1) {
+          if (
+            backupDenomination.denom_pub.cipher !== DenomKeyType.Rsa &&
+            backupDenomination.denom_pub.cipher !== DenomKeyType.LegacyRsa
+          ) {
             throw Error("unsupported cipher");
           }
           const denomPubHash =
diff --git a/packages/taler-wallet-core/src/operations/backup/index.ts b/packages/taler-wallet-core/src/operations/backup/index.ts
index 9027625cd..e3950ef90 100644
--- a/packages/taler-wallet-core/src/operations/backup/index.ts
+++ b/packages/taler-wallet-core/src/operations/backup/index.ts
@@ -38,14 +38,15 @@ import {
   codecForString,
   codecOptional,
   ConfirmPayResultType,
+  DenomKeyType,
   durationFromSpec,
   getTimestampNow,
   hashDenomPub,
   HttpStatusCode,
   j2s,
+  LibtoolVersion,
   Logger,
   notEmpty,
-  NotificationType,
   PreparePayResultType,
   RecoveryLoadRequest,
   RecoveryMergeStrategy,
@@ -167,7 +168,10 @@ async function computeBackupCryptoData(
   };
   for (const backupExchangeDetails of backupContent.exchange_details) {
     for (const backupDenom of backupExchangeDetails.denominations) {
-      if (backupDenom.denom_pub.cipher !== 1) {
+      if (
+        backupDenom.denom_pub.cipher !== DenomKeyType.Rsa &&
+        backupDenom.denom_pub.cipher !== DenomKeyType.LegacyRsa
+      ) {
         throw Error("unsupported cipher");
       }
       for (const backupCoin of backupDenom.coins) {
@@ -184,9 +188,25 @@ async function computeBackupCryptoData(
           coinPub,
         };
       }
-      cryptoData.rsaDenomPubToHash[
-        backupDenom.denom_pub.rsa_public_key
-      ] = encodeCrock(hashDenomPub(backupDenom.denom_pub));
+      if (
+        LibtoolVersion.compare(backupExchangeDetails.protocol_version, "9")
+          ?.compatible
+      ) {
+        cryptoData.rsaDenomPubToHash[
+          backupDenom.denom_pub.rsa_public_key
+        ] = encodeCrock(
+          hash(decodeCrock(backupDenom.denom_pub.rsa_public_key)),
+        );
+      } else if (
+        LibtoolVersion.compare(backupExchangeDetails.protocol_version, "10")
+          ?.compatible
+      ) {
+        cryptoData.rsaDenomPubToHash[
+          backupDenom.denom_pub.rsa_public_key
+        ] = encodeCrock(hashDenomPub(backupDenom.denom_pub));
+      } else {
+        throw Error("unsupported exchange protocol version");
+      }
     }
     for (const backupReserve of backupExchangeDetails.reserves) {
       cryptoData.reservePrivToPub[backupReserve.reserve_priv] = encodeCrock(
diff --git a/packages/taler-wallet-core/src/operations/deposits.ts b/packages/taler-wallet-core/src/operations/deposits.ts
index 8fe3702f5..f90172a45 100644
--- a/packages/taler-wallet-core/src/operations/deposits.ts
+++ b/packages/taler-wallet-core/src/operations/deposits.ts
@@ -26,6 +26,7 @@ import {
   CreateDepositGroupRequest,
   CreateDepositGroupResponse,
   decodeCrock,
+  DenomKeyType,
   durationFromSpec,
   getTimestampNow,
   Logger,
@@ -59,6 +60,8 @@ import {
   getCandidatePayCoins,
   getEffectiveDepositAmount,
   getTotalPaymentCost,
+  hashWire,
+  hashWireLegacy,
 } from "./pay.js";
 
 /**
@@ -103,16 +106,6 @@ const codecForDepositSuccess = (): Codec<DepositSuccess> =>
     .property("transaction_base_url", codecOptional(codecForString()))
     .build("DepositSuccess");
 
-function hashWire(paytoUri: string, salt: string): string {
-  const r = kdf(
-    64,
-    stringToBytes(paytoUri + "\0"),
-    decodeCrock(salt),
-    stringToBytes("merchant-wire-signature"),
-  );
-  return encodeCrock(r);
-}
-
 async function resetDepositGroupRetry(
   ws: InternalWalletState,
   depositGroupId: string,
@@ -211,21 +204,50 @@ async function processDepositGroupImpl(
       continue;
     }
     const perm = depositPermissions[i];
+    let requestBody: any;
+    if (
+      typeof perm.ub_sig === "string" ||
+      perm.ub_sig.cipher === DenomKeyType.LegacyRsa
+    ) {
+      // Legacy request
+      logger.info("creating legacy deposit request");
+      const wireHash = hashWireLegacy(
+        depositGroup.wire.payto_uri,
+        depositGroup.wire.salt,
+      );
+      requestBody = {
+        contribution: Amounts.stringify(perm.contribution),
+        wire: depositGroup.wire,
+        h_wire: wireHash,
+        h_contract_terms: depositGroup.contractTermsHash,
+        ub_sig: perm.ub_sig,
+        timestamp: depositGroup.contractTermsRaw.timestamp,
+        wire_transfer_deadline:
+          depositGroup.contractTermsRaw.wire_transfer_deadline,
+        refund_deadline: depositGroup.contractTermsRaw.refund_deadline,
+        coin_sig: perm.coin_sig,
+        denom_pub_hash: perm.h_denom,
+        merchant_pub: depositGroup.merchantPub,
+      };
+    } else {
+      logger.info("creating v10 deposit request");
+      requestBody = {
+        contribution: Amounts.stringify(perm.contribution),
+        merchant_payto_uri: depositGroup.wire.payto_uri,
+        wire_salt: depositGroup.wire.salt,
+        h_contract_terms: depositGroup.contractTermsHash,
+        ub_sig: perm.ub_sig,
+        timestamp: depositGroup.contractTermsRaw.timestamp,
+        wire_transfer_deadline:
+          depositGroup.contractTermsRaw.wire_transfer_deadline,
+        refund_deadline: depositGroup.contractTermsRaw.refund_deadline,
+        coin_sig: perm.coin_sig,
+        denom_pub_hash: perm.h_denom,
+        merchant_pub: depositGroup.merchantPub,
+      };
+    }
     const url = new URL(`coins/${perm.coin_pub}/deposit`, perm.exchange_url);
-    const httpResp = await ws.http.postJson(url.href, {
-      contribution: Amounts.stringify(perm.contribution),
-      merchant_payto_uri: depositGroup.wire.payto_uri,
-      wire_salt: depositGroup.wire.salt,
-      h_contract_terms: depositGroup.contractTermsHash,
-      ub_sig: perm.ub_sig,
-      timestamp: depositGroup.contractTermsRaw.timestamp,
-      wire_transfer_deadline:
-        depositGroup.contractTermsRaw.wire_transfer_deadline,
-      refund_deadline: depositGroup.contractTermsRaw.refund_deadline,
-      coin_sig: perm.coin_sig,
-      denom_pub_hash: perm.h_denom,
-      merchant_pub: depositGroup.merchantPub,
-    });
+    const httpResp = await ws.http.postJson(url.href, requestBody);
     await readSuccessResponseJsonOrThrow(httpResp, codecForDepositSuccess());
     await ws.db
       .mktx((x) => ({ depositGroups: x.depositGroups }))
@@ -358,6 +380,7 @@ export async function createDepositGroup(
   const merchantPair = await ws.cryptoApi.createEddsaKeypair();
   const wireSalt = encodeCrock(getRandomBytes(16));
   const wireHash = hashWire(req.depositPaytoUri, wireSalt);
+  const wireHashLegacy = hashWireLegacy(req.depositPaytoUri, wireSalt);
   const contractTerms: ContractTerms = {
     auditors: [],
     exchanges: exchangeInfos,
@@ -371,7 +394,10 @@ export async function createDepositGroup(
     nonce: noncePair.pub,
     wire_transfer_deadline: timestampRound,
     order_id: "",
+    // This is always the v2 wire hash, as we're the "merchant" and support v2.
     h_wire: wireHash,
+    // Required for older exchanges.
+    h_wire_legacy: wireHashLegacy,
     pay_deadline: timestampAddDuration(
       timestampRound,
       durationFromSpec({ hours: 1 }),
diff --git a/packages/taler-wallet-core/src/operations/exchanges.ts b/packages/taler-wallet-core/src/operations/exchanges.ts
index a10378a8c..16e37fd3e 100644
--- a/packages/taler-wallet-core/src/operations/exchanges.ts
+++ b/packages/taler-wallet-core/src/operations/exchanges.ts
@@ -19,11 +19,11 @@
  */
 import {
   Amounts,
-  Auditor,
+  ExchangeAuditor,
   canonicalizeBaseUrl,
   codecForExchangeKeysJson,
   codecForExchangeWireJson,
-  Denomination,
+  ExchangeDenomination,
   Duration,
   durationFromSpec,
   ExchangeSignKeyJson,
@@ -40,6 +40,9 @@ import {
   Timestamp,
   hashDenomPub,
   LibtoolVersion,
+  codecForAny,
+  DenominationPubKey,
+  DenomKeyType,
 } from "@gnu-taler/taler-util";
 import { decodeCrock, encodeCrock, hash } from "@gnu-taler/taler-util";
 import { CryptoApi } from "../crypto/workers/cryptoApi.js";
@@ -77,11 +80,21 @@ function denominationRecordFromKeys(
   exchangeBaseUrl: string,
   exchangeMasterPub: string,
   listIssueDate: Timestamp,
-  denomIn: Denomination,
+  denomIn: ExchangeDenomination,
 ): DenominationRecord {
-  const denomPubHash = encodeCrock(hashDenomPub(denomIn.denom_pub));
+  let denomPub: DenominationPubKey;
+  // We support exchange protocol v9 and v10.
+  if (typeof denomIn.denom_pub === "string") {
+    denomPub = {
+      cipher: DenomKeyType.LegacyRsa,
+      rsa_public_key: denomIn.denom_pub,
+    };
+  } else {
+    denomPub = denomIn.denom_pub;
+  }
+  const denomPubHash = encodeCrock(hashDenomPub(denomPub));
   const d: DenominationRecord = {
-    denomPub: denomIn.denom_pub,
+    denomPub,
     denomPubHash,
     exchangeBaseUrl,
     exchangeMasterPub,
@@ -205,6 +218,7 @@ export async function acceptExchangeTermsOfService(
 }
 
 async function validateWireInfo(
+  versionCurrent: number,
   wireInfo: ExchangeWireJson,
   masterPublicKey: string,
   cryptoApi: CryptoApi,
@@ -212,6 +226,7 @@ async function validateWireInfo(
   for (const a of wireInfo.accounts) {
     logger.trace("validating exchange acct");
     const isValid = await cryptoApi.isValidWireAccount(
+      versionCurrent,
       a.payto_uri,
       a.master_sig,
       masterPublicKey,
@@ -321,7 +336,7 @@ async function provideExchangeRecord(
 interface ExchangeKeysDownloadResult {
   masterPublicKey: string;
   currency: string;
-  auditors: Auditor[];
+  auditors: ExchangeAuditor[];
   currentDenominations: DenominationRecord[];
   protocolVersion: string;
   signingKeys: ExchangeSignKeyJson[];
@@ -345,14 +360,14 @@ async function downloadKeysInfo(
   const resp = await http.get(keysUrl.href, {
     timeout,
   });
-  const exchangeKeysJson = await readSuccessResponseJsonOrThrow(
+  const exchangeKeysJsonUnchecked = await readSuccessResponseJsonOrThrow(
     resp,
     codecForExchangeKeysJson(),
   );
 
   logger.info("received /keys response");
 
-  if (exchangeKeysJson.denoms.length === 0) {
+  if (exchangeKeysJsonUnchecked.denoms.length === 0) {
     const opErr = makeErrorDetails(
       TalerErrorCode.WALLET_EXCHANGE_DENOMINATIONS_INSUFFICIENT,
       "exchange doesn't offer any denominations",
@@ -363,7 +378,7 @@ async function downloadKeysInfo(
     throw new OperationFailedError(opErr);
   }
 
-  const protocolVersion = exchangeKeysJson.version;
+  const protocolVersion = exchangeKeysJsonUnchecked.version;
 
   const versionRes = LibtoolVersion.compare(
     WALLET_EXCHANGE_PROTOCOL_VERSION,
@@ -382,29 +397,29 @@ async function downloadKeysInfo(
   }
 
   const currency = Amounts.parseOrThrow(
-    exchangeKeysJson.denoms[0].value,
+    exchangeKeysJsonUnchecked.denoms[0].value,
   ).currency.toUpperCase();
 
   return {
-    masterPublicKey: exchangeKeysJson.master_public_key,
+    masterPublicKey: exchangeKeysJsonUnchecked.master_public_key,
     currency,
-    auditors: exchangeKeysJson.auditors,
-    currentDenominations: exchangeKeysJson.denoms.map((d) =>
+    auditors: exchangeKeysJsonUnchecked.auditors,
+    currentDenominations: exchangeKeysJsonUnchecked.denoms.map((d) =>
       denominationRecordFromKeys(
         baseUrl,
-        exchangeKeysJson.master_public_key,
-        exchangeKeysJson.list_issue_date,
+        exchangeKeysJsonUnchecked.master_public_key,
+        exchangeKeysJsonUnchecked.list_issue_date,
         d,
       ),
     ),
-    protocolVersion: exchangeKeysJson.version,
-    signingKeys: exchangeKeysJson.signkeys,
-    reserveClosingDelay: exchangeKeysJson.reserve_closing_delay,
+    protocolVersion: exchangeKeysJsonUnchecked.version,
+    signingKeys: exchangeKeysJsonUnchecked.signkeys,
+    reserveClosingDelay: exchangeKeysJsonUnchecked.reserve_closing_delay,
     expiry: getExpiryTimestamp(resp, {
       minDuration: durationFromSpec({ hours: 1 }),
     }),
-    recoup: exchangeKeysJson.recoup ?? [],
-    listIssueDate: exchangeKeysJson.list_issue_date,
+    recoup: exchangeKeysJsonUnchecked.recoup ?? [],
+    listIssueDate: exchangeKeysJsonUnchecked.list_issue_date,
   };
 }
 
@@ -466,7 +481,14 @@ async function updateExchangeFromUrlImpl(
 
   logger.info("validating exchange /wire info");
 
+  const version = LibtoolVersion.parseVersion(keysInfo.protocolVersion);
+  if (!version) {
+    // Should have been validated earlier.
+    throw Error("unexpected invalid version");
+  }
+
   const wireInfo = await validateWireInfo(
+    version.current,
     wireInfoDownload,
     keysInfo.masterPublicKey,
     ws.cryptoApi,
diff --git a/packages/taler-wallet-core/src/operations/merchants.ts b/packages/taler-wallet-core/src/operations/merchants.ts
index d12417c7c..fd628fa98 100644
--- a/packages/taler-wallet-core/src/operations/merchants.ts
+++ b/packages/taler-wallet-core/src/operations/merchants.ts
@@ -52,15 +52,13 @@ export async function getMerchantInfo(
     `merchant "${canonBaseUrl}" reports protocol ${configResp.version}"`,
   );
 
+  const parsedVersion = LibtoolVersion.parseVersion(configResp.version);
+  if (!parsedVersion) {
+    throw Error("invalid merchant version");
+  }
+
   const merchantInfo: MerchantInfo = {
-    supportsMerchantProtocolV1: !!LibtoolVersion.compare(
-      "1:0:0",
-      configResp.version,
-    )?.compatible,
-    supportsMerchantProtocolV2: !!LibtoolVersion.compare(
-      "2:0:0",
-      configResp.version,
-    )?.compatible,
+    protocolVersionCurrent: parsedVersion.current,
   };
 
   ws.merchantInfoCache[canonBaseUrl] = merchantInfo;
diff --git a/packages/taler-wallet-core/src/operations/pay.ts b/packages/taler-wallet-core/src/operations/pay.ts
index acc592a72..73fc6537c 100644
--- a/packages/taler-wallet-core/src/operations/pay.ts
+++ b/packages/taler-wallet-core/src/operations/pay.ts
@@ -54,6 +54,10 @@ import {
   URL,
   getDurationRemaining,
   HttpStatusCode,
+  DenomKeyType,
+  kdf,
+  stringToBytes,
+  decodeCrock,
 } from "@gnu-taler/taler-util";
 import { encodeCrock, getRandomBytes } from "@gnu-taler/taler-util";
 import {
@@ -108,6 +112,26 @@ import {
  */
 const logger = new Logger("pay.ts");
 
+export function hashWire(paytoUri: string, salt: string): string {
+  const r = kdf(
+    64,
+    stringToBytes(paytoUri + "\0"),
+    decodeCrock(salt),
+    stringToBytes("merchant-wire-signature"),
+  );
+  return encodeCrock(r);
+}
+
+export function hashWireLegacy(paytoUri: string, salt: string): string {
+  const r = kdf(
+    64,
+    stringToBytes(paytoUri + "\0"),
+    stringToBytes(salt + "\0"),
+    stringToBytes("merchant-wire-signature"),
+  );
+  return encodeCrock(r);
+}
+
 /**
  * Compute the total cost of a payment to the customer.
  *
@@ -193,9 +217,9 @@ export async function getEffectiveDepositAmount(
         if (!exchangeDetails) {
           continue;
         }
-	// FIXME/NOTE: the line below _likely_ throws exception
-	// about "find method not found on undefined" when the wireType
-	// is not supported by the Exchange.
+        // FIXME/NOTE: the line below _likely_ throws exception
+        // about "find method not found on undefined" when the wireType
+        // is not supported by the Exchange.
         const fee = exchangeDetails.wireInfo.feesForType[wireType].find((x) => {
           return timestampIsBetween(
             getTimestampNow(),
@@ -669,6 +693,7 @@ export function extractContractData(
     timestamp: parsedContractTerms.timestamp,
     wireMethod: parsedContractTerms.wire_method,
     wireInfoHash: parsedContractTerms.h_wire,
+    wireInfoLegacyHash: parsedContractTerms.h_wire_legacy,
     maxDepositFee: Amounts.parseOrThrow(parsedContractTerms.max_fee),
     merchant: parsedContractTerms.merchant,
     products: parsedContractTerms.products,
@@ -882,7 +907,6 @@ async function startDownloadProposal(
   claimToken: string | undefined,
   noncePriv: string | undefined,
 ): Promise<string> {
-
   const oldProposal = await ws.db
     .mktx((x) => ({ proposals: x.proposals }))
     .runReadOnly(async (tx) => {
@@ -891,20 +915,24 @@ async function startDownloadProposal(
         orderId,
       ]);
     });
-  
+
   /**
    * If we have already claimed this proposal with the same sessionId
    * nonce and claim token, reuse it.
    */
-  if (oldProposal && 
-      oldProposal.downloadSessionId === sessionId &&
-      (!noncePriv || oldProposal.noncePriv === noncePriv) &&
-      oldProposal.claimToken === claimToken) {
+  if (
+    oldProposal &&
+    oldProposal.downloadSessionId === sessionId &&
+    (!noncePriv || oldProposal.noncePriv === noncePriv) &&
+    oldProposal.claimToken === claimToken
+  ) {
     await processDownloadProposal(ws, oldProposal.proposalId);
     return oldProposal.proposalId;
   }
 
-  const { priv, pub } = await (noncePriv ? ws.cryptoApi.eddsaGetPublic(noncePriv) : ws.cryptoApi.createEddsaKeypair());
+  const { priv, pub } = await (noncePriv
+    ? ws.cryptoApi.eddsaGetPublic(noncePriv)
+    : ws.cryptoApi.createEddsaKeypair());
   const proposalId = encodeCrock(getRandomBytes(32));
 
   const proposalRecord: ProposalRecord = {
@@ -1169,6 +1197,11 @@ async function submitPay(
 
   logger.trace("paying with session ID", sessionId);
 
+  const merchantInfo = await ws.merchantOps.getMerchantInfo(
+    ws,
+    purchase.download.contractData.merchantBaseUrl,
+  );
+
   if (!purchase.merchantPaySig) {
     const payUrl = new URL(
       `orders/${purchase.download.contractData.orderId}/pay`,
@@ -1568,11 +1601,21 @@ export async function generateDepositPermissions(
 
   for (let i = 0; i < payCoinSel.coinPubs.length; i++) {
     const { coin, denom } = coinWithDenom[i];
+    let wireInfoHash: string;
+    if (
+      coin.denomPub.cipher === DenomKeyType.LegacyRsa &&
+      contractData.wireInfoLegacyHash
+    ) {
+      wireInfoHash = contractData.wireInfoLegacyHash;
+    } else {
+      wireInfoHash = contractData.wireInfoHash;
+    }
     const dp = await ws.cryptoApi.signDepositPermission({
       coinPriv: coin.coinPriv,
       coinPub: coin.coinPub,
       contractTermsHash: contractData.contractTermsHash,
       denomPubHash: coin.denomPubHash,
+      denomKeyType: coin.denomPub.cipher,
       denomSig: coin.denomSig,
       exchangeBaseUrl: coin.exchangeBaseUrl,
       feeDeposit: denom.feeDeposit,
@@ -1580,7 +1623,7 @@ export async function generateDepositPermissions(
       refundDeadline: contractData.refundDeadline,
       spendAmount: payCoinSel.coinContributions[i],
       timestamp: contractData.timestamp,
-      wireInfoHash: contractData.wireInfoHash,
+      wireInfoHash,
     });
     depositPermissions.push(dp);
   }
@@ -1613,6 +1656,11 @@ export async function confirmPay(
     throw Error("proposal is in invalid state");
   }
 
+  const merchantInfo = await ws.merchantOps.getMerchantInfo(
+    ws,
+    d.contractData.merchantBaseUrl,
+  );
+
   const existingPurchase = await ws.db
     .mktx((x) => ({ purchases: x.purchases }))
     .runReadWrite(async (tx) => {
diff --git a/packages/taler-wallet-core/src/operations/refresh.ts b/packages/taler-wallet-core/src/operations/refresh.ts
index c1e672d63..51eac4a64 100644
--- a/packages/taler-wallet-core/src/operations/refresh.ts
+++ b/packages/taler-wallet-core/src/operations/refresh.ts
@@ -365,18 +365,29 @@ async function refreshMelt(
     `coins/${oldCoin.coinPub}/melt`,
     oldCoin.exchangeBaseUrl,
   );
-  const meltReq = {
-    coin_pub: oldCoin.coinPub,
-    confirm_sig: derived.confirmSig,
-    denom_pub_hash: oldCoin.denomPubHash,
-    denom_sig: oldCoin.denomSig,
-    rc: derived.hash,
-    value_with_fee: Amounts.stringify(derived.meltValueWithFee),
-  };
-  logger.trace(`melt request for coin:`, meltReq);
+  let meltReqBody: any;
+  if (oldCoin.denomPub.cipher === DenomKeyType.LegacyRsa) {
+    meltReqBody = {
+      coin_pub: oldCoin.coinPub,
+      confirm_sig: derived.confirmSig,
+      denom_pub_hash: oldCoin.denomPubHash,
+      denom_sig: oldCoin.denomSig.rsa_signature,
+      rc: derived.hash,
+      value_with_fee: Amounts.stringify(derived.meltValueWithFee),
+    };
+  } else {
+    meltReqBody = {
+      coin_pub: oldCoin.coinPub,
+      confirm_sig: derived.confirmSig,
+      denom_pub_hash: oldCoin.denomPubHash,
+      denom_sig: oldCoin.denomSig,
+      rc: derived.hash,
+      value_with_fee: Amounts.stringify(derived.meltValueWithFee),
+    };
+  }
 
   const resp = await ws.runSequentialized([EXCHANGE_COINS_LOCK], async () => {
-    return await ws.http.postJson(reqUrl.href, meltReq, {
+    return await ws.http.postJson(reqUrl.href, meltReqBody, {
       timeout: getRefreshRequestTimeout(refreshGroup),
     });
   });
@@ -604,15 +615,26 @@ async function refreshReveal(
         continue;
       }
       const pc = derived.planchetsForGammas[norevealIndex][newCoinIndex];
-      if (denom.denomPub.cipher !== 1) {
+      if (
+        denom.denomPub.cipher !== DenomKeyType.Rsa &&
+        denom.denomPub.cipher !== DenomKeyType.LegacyRsa
+      ) {
         throw Error("cipher unsupported");
       }
       const evSig = reveal.ev_sigs[newCoinIndex].ev_sig;
-      if (evSig.cipher !== DenomKeyType.Rsa) {
+      let rsaSig: string;
+      if (typeof evSig === "string") {
+        rsaSig = evSig;
+      } else if (
+        evSig.cipher === DenomKeyType.Rsa ||
+        evSig.cipher === DenomKeyType.LegacyRsa
+      ) {
+        rsaSig = evSig.blinded_rsa_signature;
+      } else {
         throw Error("unsupported cipher");
       }
       const denomSigRsa = await ws.cryptoApi.rsaUnblind(
-        evSig.blinded_rsa_signature,
+        rsaSig,
         pc.blindingKey,
         denom.denomPub.rsa_public_key,
       );
diff --git a/packages/taler-wallet-core/src/operations/tip.ts b/packages/taler-wallet-core/src/operations/tip.ts
index 0253930ea..cf3502ecd 100644
--- a/packages/taler-wallet-core/src/operations/tip.ts
+++ b/packages/taler-wallet-core/src/operations/tip.ts
@@ -314,13 +314,13 @@ async function processTipImpl(
 
   let blindedSigs: BlindedDenominationSignature[] = [];
 
-  if (merchantInfo.supportsMerchantProtocolV2) {
+  if (merchantInfo.protocolVersionCurrent === 2) {
     const response = await readSuccessResponseJsonOrThrow(
       merchantResp,
       codecForMerchantTipResponseV2(),
     );
     blindedSigs = response.blind_sigs.map((x) => x.blind_sig);
-  } else if (merchantInfo.supportsMerchantProtocolV1) {
+  } else if (merchantInfo.protocolVersionCurrent === 1) {
     const response = await readSuccessResponseJsonOrThrow(
       merchantResp,
       codecForMerchantTipResponseV1(),
@@ -347,11 +347,17 @@ async function processTipImpl(
     const planchet = planchets[i];
     checkLogicInvariant(!!planchet);
 
-    if (denom.denomPub.cipher !== DenomKeyType.Rsa) {
+    if (
+      denom.denomPub.cipher !== DenomKeyType.Rsa &&
+      denom.denomPub.cipher !== DenomKeyType.LegacyRsa
+    ) {
       throw Error("unsupported cipher");
     }
 
-    if (blindedSig.cipher !== DenomKeyType.Rsa) {
+    if (
+      blindedSig.cipher !== DenomKeyType.Rsa &&
+      blindedSig.cipher !== DenomKeyType.LegacyRsa
+    ) {
       throw Error("unsupported cipher");
     }
 
diff --git a/packages/taler-wallet-core/src/operations/withdraw.ts b/packages/taler-wallet-core/src/operations/withdraw.ts
index 979bd0e53..8c9178f59 100644
--- a/packages/taler-wallet-core/src/operations/withdraw.ts
+++ b/packages/taler-wallet-core/src/operations/withdraw.ts
@@ -42,6 +42,7 @@ import {
   VersionMatchResult,
   DenomKeyType,
   LibtoolVersion,
+  UnblindedSignature,
 } from "@gnu-taler/taler-util";
 import {
   CoinRecord,
@@ -591,12 +592,28 @@ async function processPlanchetVerifyAndStoreCoin(
   const { planchet, exchangeBaseUrl } = d;
 
   const planchetDenomPub = planchet.denomPub;
-  if (planchetDenomPub.cipher !== DenomKeyType.Rsa) {
-    throw Error("cipher not supported");
+  if (
+    planchetDenomPub.cipher !== DenomKeyType.Rsa &&
+    planchetDenomPub.cipher !== DenomKeyType.LegacyRsa
+  ) {
+    throw Error(`cipher (${planchetDenomPub.cipher}) not supported`);
   }
 
-  const evSig = resp.ev_sig;
-  if (evSig.cipher !== DenomKeyType.Rsa) {
+  let evSig = resp.ev_sig;
+  if (typeof resp.ev_sig === "string") {
+    evSig = {
+      cipher: DenomKeyType.LegacyRsa,
+      blinded_rsa_signature: resp.ev_sig,
+    };
+  } else {
+    evSig = resp.ev_sig;
+  }
+  if (
+    !(
+      evSig.cipher === DenomKeyType.Rsa ||
+      evSig.cipher === DenomKeyType.LegacyRsa
+    )
+  ) {
     throw Error("unsupported cipher");
   }
 
@@ -633,6 +650,19 @@ async function processPlanchetVerifyAndStoreCoin(
     return;
   }
 
+  let denomSig: UnblindedSignature;
+  if (
+    planchet.denomPub.cipher === DenomKeyType.LegacyRsa ||
+    planchet.denomPub.cipher === DenomKeyType.Rsa
+  ) {
+    denomSig = {
+      cipher: planchet.denomPub.cipher,
+      rsa_signature: denomSigRsa,
+    };
+  } else {
+    throw Error("unsupported cipher");
+  }
+
   const coin: CoinRecord = {
     blindingKey: planchet.blindingKey,
     coinPriv: planchet.coinPriv,
@@ -640,10 +670,7 @@ async function processPlanchetVerifyAndStoreCoin(
     currentAmount: planchet.coinValue,
     denomPub: planchet.denomPub,
     denomPubHash: planchet.denomPubHash,
-    denomSig: {
-      cipher: DenomKeyType.Rsa,
-      rsa_signature: denomSigRsa,
-    },
+    denomSig,
     coinEvHash: planchet.coinEvHash,
     exchangeBaseUrl: exchangeBaseUrl,
     status: CoinStatus.Fresh,
diff --git a/packages/taler-wallet-core/src/util/coinSelection.ts b/packages/taler-wallet-core/src/util/coinSelection.ts
index ba26c98fe..bfc481eaf 100644
--- a/packages/taler-wallet-core/src/util/coinSelection.ts
+++ b/packages/taler-wallet-core/src/util/coinSelection.ts
@@ -23,7 +23,12 @@
 /**
  * Imports.
  */
-import { AmountJson, Amounts, DenominationPubKey } from "@gnu-taler/taler-util";
+import {
+  AmountJson,
+  Amounts,
+  DenominationPubKey,
+  DenomKeyType,
+} from "@gnu-taler/taler-util";
 import { strcmp, Logger } from "@gnu-taler/taler-util";
 
 const logger = new Logger("coinSelection.ts");
@@ -215,10 +220,21 @@ function denomPubCmp(
   } else if (p1.cipher > p2.cipher) {
     return +1;
   }
-  if (p1.cipher !== 1 || p2.cipher !== 1) {
+  if (
+    p1.cipher === DenomKeyType.LegacyRsa &&
+    p2.cipher === DenomKeyType.LegacyRsa
+  ) {
+    return strcmp(p1.rsa_public_key, p2.rsa_public_key);
+  } else if (p1.cipher === DenomKeyType.Rsa && p2.cipher === DenomKeyType.Rsa) {
+    if ((p1.age_mask ?? 0) < (p2.age_mask ?? 0)) {
+      return -1;
+    } else if ((p1.age_mask ?? 0) > (p2.age_mask ?? 0)) {
+      return 1;
+    }
+    return strcmp(p1.rsa_public_key, p2.rsa_public_key);
+  } else {
     throw Error("unsupported cipher");
   }
-  return strcmp(p1.rsa_public_key, p2.rsa_public_key);
 }
 
 /**
diff --git a/packages/taler-wallet-core/src/versions.ts b/packages/taler-wallet-core/src/versions.ts
index 7383355ba..9ef298d62 100644
--- a/packages/taler-wallet-core/src/versions.ts
+++ b/packages/taler-wallet-core/src/versions.ts
@@ -19,14 +19,14 @@
  *
  * Uses libtool's current:revision:age versioning.
  */
-export const WALLET_EXCHANGE_PROTOCOL_VERSION = "10:0:0";
+export const WALLET_EXCHANGE_PROTOCOL_VERSION = "10:0:1";
 
 /**
  * Protocol version spoken with the merchant.
  *
  * Uses libtool's current:revision:age versioning.
  */
-export const WALLET_MERCHANT_PROTOCOL_VERSION = "1:0:0";
+export const WALLET_MERCHANT_PROTOCOL_VERSION = "2:0:1";
 
 /**
  * Protocol version spoken with the merchant.
@@ -42,4 +42,4 @@ export const WALLET_BANK_INTEGRATION_PROTOCOL_VERSION = "0:0:0";
  *
  * This is only a temporary measure.
  */
-export const WALLET_CACHE_BREAKER_CLIENT_VERSION = "3";
+export const WALLET_CACHE_BREAKER_CLIENT_VERSION = "4";
diff --git a/packages/taler-wallet-core/src/wallet.ts b/packages/taler-wallet-core/src/wallet.ts
index 576a44597..7233af3af 100644
--- a/packages/taler-wallet-core/src/wallet.ts
+++ b/packages/taler-wallet-core/src/wallet.ts
@@ -390,7 +390,7 @@ async function runTaskLoop(
         } catch (e) {
           if (e instanceof OperationFailedAndReportedError) {
             logger.warn("operation processed resulted in reported error");
-            logger.warn(`reporred error was: ${j2s(e.operationError)}`);
+            logger.warn(`reported error was: ${j2s(e.operationError)}`);
           } else {
             logger.error("Uncaught exception", e);
             ws.notify({
@@ -985,6 +985,8 @@ export async function handleCoreApiRequest(
       e instanceof OperationFailedError ||
       e instanceof OperationFailedAndReportedError
     ) {
+      logger.error("Caught operation failed error");
+      logger.trace((e as any).stack);
       return {
         type: "error",
         operation,