path: root/packages/taler-harness/src/integrationtests/test-revocation.ts

/*
 This file is part of GNU Taler
 (C) 2020 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/>
 */

/**
 * Imports.
 */
import { WalletApiOperation } from "@gnu-taler/taler-wallet-core";
import { CoinConfig } from "../harness/denomStructures.js";
import {
  GlobalTestState,
  ExchangeService,
  MerchantService,
  WalletCli,
  setupDb,
  BankService,
  delayMs,
  generateRandomPayto,
  WalletClient,
} from "../harness/harness.js";
import {
  SimpleTestEnvironmentNg,
  createWalletDaemonWithClient,
  makeTestPaymentV2,
  withdrawViaBankV2,
} from "../harness/helpers.js";

async function revokeAllWalletCoins(req: {
  walletClient: WalletClient;
  exchange: ExchangeService;
  merchant: MerchantService;
}): Promise<void> {
  const { walletClient, exchange, merchant } = req;
  const coinDump = await walletClient.call(WalletApiOperation.DumpCoins, {});
  console.log(coinDump);
  const usedDenomHashes = new Set<string>();
  for (const coin of coinDump.coins) {
    usedDenomHashes.add(coin.denom_pub_hash);
  }
  for (const x of usedDenomHashes.values()) {
    await exchange.revokeDenomination(x);
  }
  await delayMs(1000);
  await exchange.keyup();
  await delayMs(1000);
  await merchant.stop();
  await merchant.start();
  await merchant.pingUntilAvailable();
}

async function createTestEnvironment(
  t: GlobalTestState,
): Promise<SimpleTestEnvironmentNg> {
  const db = await setupDb(t);

  const bank = await BankService.create(t, {
    allowRegistrations: true,
    currency: "TESTKUDOS",
    database: db.connStr,
    httpPort: 8082,
  });

  const exchange = ExchangeService.create(t, {
    name: "testexchange-1",
    currency: "TESTKUDOS",
    httpPort: 8081,
    database: db.connStr,
  });

  const merchant = await MerchantService.create(t, {
    name: "testmerchant-1",
    currency: "TESTKUDOS",
    httpPort: 8083,
    database: db.connStr,
  });

  const exchangeBankAccount = await bank.createExchangeAccount(
    "myexchange",
    "x",
  );
  exchange.addBankAccount("1", exchangeBankAccount);

  bank.setSuggestedExchange(exchange, exchangeBankAccount.accountPaytoUri);

  await bank.start();

  await bank.pingUntilAvailable();

  const coin_u1: CoinConfig = {
    cipher: "RSA" as const,
    durationLegal: "3 years",
    durationSpend: "2 years",
    durationWithdraw: "7 days",
    rsaKeySize: 1024,
    name: `TESTKUDOS_u1`,
    value: `TESTKUDOS:1`,
    feeDeposit: `TESTKUDOS:0`,
    feeRefresh: `TESTKUDOS:0`,
    feeRefund: `TESTKUDOS:0`,
    feeWithdraw: `TESTKUDOS:0`,
  };

  exchange.addCoinConfigList([coin_u1]);

  await exchange.start();
  await exchange.pingUntilAvailable();

  merchant.addExchange(exchange);

  await merchant.start();
  await merchant.pingUntilAvailable();

  await merchant.addInstanceWithWireAccount({
    id: "default",
    name: "Default Instance",
    paytoUris: [generateRandomPayto("merchant-default")],
  });

  await merchant.addInstanceWithWireAccount({
    id: "minst1",
    name: "minst1",
    paytoUris: [generateRandomPayto("minst1")],
  });

  console.log("setup done!");

  const wallet = new WalletCli(t);

  const { walletService, walletClient } = await createWalletDaemonWithClient(
    t,
    {
      name: "default",
    },
  );

  return {
    commonDb: db,
    exchange,
    merchant,
    walletClient,
    walletService,
    bank,
    exchangeBankAccount,
  };
}

/**
 * Basic time travel test.
 */
export async function runRevocationTest(t: GlobalTestState) {
  // Set up test environment

  const { walletClient, bank, exchange, merchant } =
    await createTestEnvironment(t);

  // Withdraw digital cash into the wallet.

  const wres = await withdrawViaBankV2(t, {
    walletClient,
    bank,
    exchange,
    amount: "TESTKUDOS:15",
  });
  await wres.withdrawalFinishedCond;

  console.log("revoking first time");
  await revokeAllWalletCoins({ walletClient, exchange, merchant });

  // FIXME: this shouldn't be necessary once https://bugs.taler.net/n/6565
  // is implemented.
  await walletClient.call(WalletApiOperation.UpdateExchangeEntry, {
    exchangeBaseUrl: exchange.baseUrl,
  });
  await walletClient.call(WalletApiOperation.TestingWaitTransactionsFinal, {});
  const bal = await walletClient.call(WalletApiOperation.GetBalances, {});
  console.log("wallet balance", bal);

  const order = {
    summary: "Buy me!",
    amount: "TESTKUDOS:10",
    fulfillment_url: "taler://fulfillment-success/thx",
  };

  await makeTestPaymentV2(t, { walletClient, merchant, order });

  await walletClient.call(WalletApiOperation.ClearDb, {});

  await withdrawViaBankV2(t, {
    walletClient,
    bank,
    exchange,
    amount: "TESTKUDOS:15",
  });

  const coinDump = await walletClient.call(WalletApiOperation.DumpCoins, {});
  console.log(coinDump);
  const coinPubList = coinDump.coins.map((x) => x.coin_pub);
  await walletClient.call(WalletApiOperation.ForceRefresh, {
    coinPubList,
  });
  await walletClient.call(WalletApiOperation.TestingWaitTransactionsFinal, {});

  console.log("revoking second time");
  await revokeAllWalletCoins({ walletClient, exchange, merchant });

  // FIXME: this shouldn't be necessary once https://bugs.taler.net/n/6565
  // is implemented.
  await walletClient.call(WalletApiOperation.UpdateExchangeEntry, {
    exchangeBaseUrl: exchange.baseUrl,
  });
  await walletClient.call(WalletApiOperation.TestingWaitTransactionsFinal, {});
  {
    const bal = await walletClient.call(WalletApiOperation.GetBalances, {});
    console.log("wallet balance", bal);
  }

  await makeTestPaymentV2(t, { walletClient, merchant, order });
}

runRevocationTest.timeoutMs = 120000;
runRevocationTest.suites = ["wallet"];
runRevocationTest.experimental = true;