new deposit page

packages/taler-wallet-webextension/src/components/SelectList.tsx

@@ -65,8 +65,6 @@ export function SelectList({
               <option selected disabled>
                 <i18n.Translate>Select one option</i18n.Translate>
               </option>
-              // ) : (
-              //   <option selected>{list[value]}</option>
             ))}
           {Object.keys(list)
             // .filter((l) => l !== value)

packages/taler-wallet-webextension/src/wallet/AddAccount/index.ts

@@ -0,0 +1,69 @@
+/*
+ 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 { Loading } from "../../components/Loading.js";
+import { HookError } from "../../hooks/useAsyncAsHook.js";
+import { compose, StateViewMap } from "../../utils/index.js";
+import { LoadingUriView, ReadyView } from "./views.js";
+import * as wxApi from "../../wxApi.js";
+import { useComponentState } from "./state.js";
+import { ButtonHandler, SelectFieldHandler, TextFieldHandler } from "../../mui/handlers.js";
+
+export interface Props {
+  currency: string;
+  onAccountAdded: (uri: string) => void;
+  onCancel: () => void;
+}
+
+export type State = State.Loading | State.LoadingUriError | State.Ready;
+
+export namespace State {
+  export interface Loading {
+    status: "loading";
+    error: undefined;
+  }
+
+  export interface LoadingUriError {
+    status: "loading-error";
+    error: HookError;
+  }
+
+  export interface BaseInfo {
+    error: undefined;
+  }
+  export interface Ready extends BaseInfo {
+    status: "ready";
+    error: undefined;
+    currency: string;
+    accountType: SelectFieldHandler;
+    uri: TextFieldHandler;
+    alias: TextFieldHandler;
+    onAccountAdded: ButtonHandler;
+    onCancel: ButtonHandler;
+  }
+}
+
+const viewMapping: StateViewMap<State> = {
+  loading: Loading,
+  "loading-error": LoadingUriView,
+  ready: ReadyView,
+};
+
+export const AddAccountPage = compose(
+  "AddAccount",
+  (p: Props) => useComponentState(p, wxApi),
+  viewMapping,
+);

packages/taler-wallet-webextension/src/wallet/AddAccount/state.ts

@@ -0,0 +1,101 @@
+/*
+ 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 { parsePaytoUri, stringifyPaytoUri } from "@gnu-taler/taler-util";
+import { useState } from "preact/hooks";
+import { useAsyncAsHook } from "../../hooks/useAsyncAsHook.js";
+import * as wxApi from "../../wxApi.js";
+import { Props, State } from "./index.js";
+
+export function useComponentState({ currency, onAccountAdded, onCancel }: Props, api: typeof wxApi): State {
+  const hook = useAsyncAsHook(async () => {
+    const { accounts } = await api.listKnownBankAccounts(currency);
+    return { accounts };
+  });
+
+  const [payto, setPayto] = useState("")
+  const [alias, setAlias] = useState("")
+  const [type, setType] = useState("")
+
+
+  if (!hook) {
+    return {
+      status: "loading",
+      error: undefined,
+    };
+  }
+  if (hook.hasError) {
+    return {
+      status: "loading-error",
+      error: hook,
+    }
+  }
+
+  const accountType: Record<string, string> = {
+    "": "Choose one account",
+    "iban": "IBAN",
+    "bitcoin": "Bitcoin",
+    "x-taler-bank": "Taler Bank"
+  }
+  const uri = parsePaytoUri(payto)
+  const found = hook.response.accounts.findIndex(a => stringifyPaytoUri(a.uri) === payto) !== -1
+
+  async function addAccount(): Promise<void> {
+    if (!uri || found) return;
+
+    await api.addKnownBankAccounts(uri, currency, alias)
+    onAccountAdded(payto)
+  }
+
+  const paytoUriError = payto === "" ? undefined
+    : !uri ? "the uri is not ok"
+      : found ? "that account is already present"
+        : undefined
+
+  const unableToAdd = !type || !alias || paytoUriError
+
+  return {
+    status: "ready",
+    error: undefined,
+    currency,
+    accountType: {
+      list: accountType,
+      value: type,
+      onChange: async (v) => {
+        setType(v)
+      }
+    },
+    alias: {
+      value: alias,
+      onInput: async (v) => {
+        setAlias(v)
+      },
+    },
+    uri: {
+      value: payto,
+      error: paytoUriError,
+      onInput: async (v) => {
+        setPayto(v)
+      }
+    },
+    onAccountAdded: {
+      onClick: unableToAdd ? undefined : addAccount
+    },
+    onCancel: {
+      onClick: async () => onCancel()
+    }
+  };
+}

packages/taler-wallet-webextension/src/wallet/AddAccount/stories.tsx

@@ -0,0 +1,29 @@
+/*
+ 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/>
+ */
+
+/**
+ *
+ * @author Sebastian Javier Marchano (sebasjm)
+ */
+
+import { createExample } from "../../test-utils.js";
+import { ReadyView } from "./views.js";
+
+export default {
+  title: "example",
+};
+
+export const Ready = createExample(ReadyView, {});

packages/taler-wallet-webextension/src/wallet/AddAccount/test.ts

@@ -0,0 +1,28 @@
+/*
+ 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/>
+ */
+
+/**
+ *
+ * @author Sebastian Javier Marchano (sebasjm)
+ */
+
+import { expect } from "chai";
+
+describe("test description", () => {
+  it("should assert", () => {
+    expect([]).deep.equals([]);
+  });
+});

packages/taler-wallet-webextension/src/wallet/AddAccount/views.tsx

@@ -0,0 +1,203 @@
+/*
+ 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 { parsePaytoUri } from "@gnu-taler/taler-util";
+import { Fragment, h, VNode } from "preact";
+import { useState } from "preact/hooks";
+import { ErrorMessage } from "../../components/ErrorMessage.js";
+import { LoadingError } from "../../components/LoadingError.js";
+import { SelectList } from "../../components/SelectList.js";
+import { Input, LightText, SubTitle } from "../../components/styled/index.js";
+import { useTranslationContext } from "../../context/translation.js";
+import { Button } from "../../mui/Button.js";
+import { TextFieldHandler } from "../../mui/handlers.js";
+import { TextField } from "../../mui/TextField.js";
+import { State } from "./index.js";
+
+export function LoadingUriView({ error }: State.LoadingUriError): VNode {
+  const { i18n } = useTranslationContext();
+
+  return (
+    <LoadingError
+      title={<i18n.Translate>Could not load</i18n.Translate>}
+      error={error}
+    />
+  );
+}
+
+export function ReadyView({
+  currency,
+  error,
+  accountType,
+  alias,
+  onAccountAdded,
+  onCancel,
+  uri,
+}: State.Ready): VNode {
+  const { i18n } = useTranslationContext();
+
+  return (
+    <Fragment>
+      <section>
+        <SubTitle>
+          <i18n.Translate>Add bank account for {currency}</i18n.Translate>
+        </SubTitle>
+        <LightText>
+          <i18n.Translate>
+            Enter the URL of an exchange you trust.
+          </i18n.Translate>
+        </LightText>
+
+        {error && (
+          <ErrorMessage
+            title={<i18n.Translate>Unable add this account</i18n.Translate>}
+            description={error}
+          />
+        )}
+        <p>
+          <Input>
+            <SelectList
+              label={<i18n.Translate>Select account type</i18n.Translate>}
+              list={accountType.list}
+              name="accountType"
+              value={accountType.value}
+              onChange={accountType.onChange}
+            />
+          </Input>
+        </p>
+        {accountType.value === "" ? undefined : (
+          <Fragment>
+            <p>
+              <CustomFieldByAccountType type={accountType.value} field={uri} />
+            </p>
+            <p>
+              <TextField
+                label="Account alias"
+                variant="standard"
+                required
+                fullWidth
+                disabled={accountType.value === ""}
+                value={alias.value}
+                onChange={alias.onInput}
+              />
+            </p>
+          </Fragment>
+        )}
+      </section>
+      <footer>
+        <Button
+          variant="contained"
+          color="secondary"
+          onClick={onCancel.onClick}
+        >
+          <i18n.Translate>Cancel</i18n.Translate>
+        </Button>
+        <Button variant="contained" onClick={onAccountAdded.onClick}>
+          <i18n.Translate>Add</i18n.Translate>
+        </Button>
+      </footer>
+    </Fragment>
+  );
+}
+
+function CustomFieldByAccountType({
+  type,
+  field,
+}: {
+  type: string;
+  field: TextFieldHandler;
+}): VNode {
+  const p = parsePaytoUri(field.value);
+  const parts = !p ? [] : p.targetPath.split("/");
+  const initialPart1 = parts.length > 0 ? parts[0] : "";
+  const initialPart2 = parts.length > 1 ? parts[1] : "";
+  const [part1, setPart1] = useState(initialPart1);
+  const [part2, setPart2] = useState(initialPart2);
+  function updateField(): void {
+    if (part1 && part2) {
+      field.onInput(`payto://${type}/${part1}/${part2}`);
+    } else {
+      if (part1) field.onInput(`payto://${type}/${part1}`);
+    }
+  }
+
+  if (type === "bitcoin") {
+    return (
+      <Fragment>
+        {field.error && <ErrorMessage title={<span>{field.error}</span>} />}
+        <TextField
+          label="Bitcoin address"
+          variant="standard"
+          required
+          fullWidth
+          value={part1}
+          onChange={(v) => {
+            setPart1(v);
+            updateField();
+          }}
+        />
+      </Fragment>
+    );
+  }
+  if (type === "x-taler-bank") {
+    return (
+      <Fragment>
+        {field.error && <ErrorMessage title={<span>{field.error}</span>} />}
+        <TextField
+          label="Bank host"
+          variant="standard"
+          required
+          fullWidth
+          value={part1}
+          onChange={(v) => {
+            setPart1(v);
+            updateField();
+          }}
+        />{" "}
+        <TextField
+          label="Bank account"
+          variant="standard"
+          required
+          fullWidth
+          value={part2}
+          onChange={(v) => {
+            setPart2(v);
+            updateField();
+          }}
+        />
+      </Fragment>
+    );
+  }
+  if (type === "iban") {
+    return (
+      <Fragment>
+        {field.error && <ErrorMessage title={<span>{field.error}</span>} />}
+        <TextField
+          label="IBAN number"
+          variant="standard"
+          required
+          fullWidth
+          value={part1}
+          onChange={(v) => {
+            setPart1(v);
+            updateField();
+          }}
+        />
+      </Fragment>
+    );
+  }
+  return <Fragment />;
+}

packages/taler-wallet-webextension/src/wallet/Application.tsx

@@ -45,7 +45,7 @@ import { DepositPage as DepositPageCTA } from "../cta/Deposit/index.js";
 import { Pages, WalletNavBar } from "../NavigationBar.js";
 import { DeveloperPage } from "./DeveloperPage.js";
 import { BackupPage } from "./BackupPage.js";
-import { DepositPage } from "./DepositPage.js";
+import { DepositPage } from "./DepositPage/index.js";
 import { ExchangeAddPage } from "./ExchangeAddPage.js";
 import { HistoryPage } from "./History.js";
 import { ProviderAddPage } from "./ProviderAddPage.js";

packages/taler-wallet-webextension/src/wallet/DepositPage.stories.tsx

@@ -1,93 +0,0 @@
-/*
- 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/>
- */
-
-/**
- *
- * @author Sebastian Javier Marchano (sebasjm)
- */
-
-import {
-  Amounts,
-  DepositGroupFees,
-  parsePaytoUri,
-} from "@gnu-taler/taler-util";
-import { createExample } from "../test-utils.js";
-import {
-  createLabelsForBankAccount,
-  View as TestedComponent,
-} from "./DepositPage.js";
-
-export default {
-  title: "wallet/deposit",
-  component: TestedComponent,
-  argTypes: {},
-};
-
-async function alwaysReturnFeeToOne(): Promise<DepositGroupFees> {
-  const fee = {
-    currency: "EUR",
-    value: 1,
-    fraction: 0,
-  };
-  return { coin: fee, refresh: fee, wire: fee };
-}
-
-export const WithEmptyAccountList = createExample(TestedComponent, {
-  state: {
-    status: "no-accounts",
-    cancelHandler: {},
-  },
-  // accounts: [],
-  // balances: [
-  //   {
-  //     available: "USD:10",
-  //   } as Balance,
-  // ],
-  // currency: "USD",
-  // onCalculateFee: alwaysReturnFeeToOne,
-});
-
-const ac = parsePaytoUri("payto://iban/ES8877998399652238")!;
-const accountMap = createLabelsForBankAccount([ac]);
-
-export const WithSomeBankAccounts = createExample(TestedComponent, {
-  state: {
-    status: "ready",
-    account: {
-      list: accountMap,
-      value: accountMap[0],
-      onChange: async () => {
-        null;
-      },
-    },
-    currency: "USD",
-    amount: {
-      onInput: async () => {
-        null;
-      },
-      value: "10:USD",
-    },
-    cancelHandler: {},
-    depositHandler: {
-      onClick: async () => {
-        return;
-      },
-    },
-    totalFee: Amounts.getZero("USD"),
-    totalToDeposit: Amounts.parseOrThrow("USD:10"),
-    // onCalculateFee: alwaysReturnFeeToOne,
-  },
-});

packages/taler-wallet-webextension/src/wallet/DepositPage.tsx

@@ -1,404 +0,0 @@
-/*
- 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 { AmountJson, Amounts, DepositGroupFees, PaytoUri } from "@gnu-taler/taler-util";
-import { Fragment, h, VNode } from "preact";
-import { useState } from "preact/hooks";
-import { Loading } from "../components/Loading.js";
-import { LoadingError } from "../components/LoadingError.js";
-import { SelectList } from "../components/SelectList.js";
-import {
-  ErrorText,
-  Input,
-  InputWithLabel,
-  SubTitle,
-  WarningBox,
-} from "../components/styled/index.js";
-import { useTranslationContext } from "../context/translation.js";
-import { HookError, useAsyncAsHook } from "../hooks/useAsyncAsHook.js";
-import { Button } from "../mui/Button.js";
-import {
-  ButtonHandler,
-  SelectFieldHandler,
-  TextFieldHandler,
-} from "../mui/handlers.js";
-import * as wxApi from "../wxApi.js";
-
-interface Props {
-  amount: string;
-  onCancel: (currency: string) => void;
-  onSuccess: (currency: string) => void;
-}
-export function DepositPage({ amount, onCancel, onSuccess }: Props): VNode {
-  const state = useComponentState(amount, onCancel, onSuccess, wxApi);
-
-  return <View state={state} />;
-}
-
-interface ViewProps {
-  state: State;
-}
-
-type State = Loading | NoBalanceState | NoAccountsState | DepositState;
-
-interface Loading {
-  status: "loading";
-  hook: HookError | undefined;
-}
-
-interface NoBalanceState {
-  status: "no-balance";
-}
-interface NoAccountsState {
-  status: "no-accounts";
-  cancelHandler: ButtonHandler;
-}
-interface DepositState {
-  status: "ready";
-  currency: string;
-  amount: TextFieldHandler;
-  account: SelectFieldHandler;
-  totalFee: AmountJson;
-  totalToDeposit: AmountJson;
-  // currentAccount: PaytoUri;
-  // parsedAmount: AmountJson | undefined;
-  cancelHandler: ButtonHandler;
-  depositHandler: ButtonHandler;
-}
-
-async function getFeeForAmount(
-  p: PaytoUri,
-  a: AmountJson,
-  api: typeof wxApi,
-): Promise<DepositGroupFees> {
-  const account = `payto://${p.targetType}/${p.targetPath}`;
-  const amount = Amounts.stringify(a);
-  return await api.getFeeForDeposit(account, amount);
-}
-
-export function useComponentState(
-  amountOrCurrency: string,
-  onCancel: (currency: string) => void,
-  onSuccess: (currency: string) => void,
-  api: typeof wxApi,
-): State {
-  const parsed = Amounts.parse(amountOrCurrency);
-  const currency = parsed !== undefined ? parsed.currency : amountOrCurrency;
-
-  const hook = useAsyncAsHook(async () => {
-    const { balances } = await api.getBalance();
-    const { accounts: accountMap } = await api.listKnownBankAccounts(currency);
-    const accounts = Object.values(accountMap);
-    const defaultSelectedAccount =
-      accounts.length > 0 ? accounts[0] : undefined;
-    return { accounts, balances, defaultSelectedAccount };
-  });
-
-  const initialValue =
-    parsed !== undefined ? Amounts.stringifyValue(parsed) : "0";
-  const [accountIdx, setAccountIdx] = useState(0);
-  const [amount, setAmount] = useState(initialValue);
-
-  const [selectedAccount, setSelectedAccount] = useState<
-    PaytoUri | undefined
-  >();
-
-  const parsedAmount = Amounts.parse(`${currency}:${amount}`);
-
-  const [fee, setFee] = useState<DepositGroupFees | undefined>(undefined);
-
-  if (!hook || hook.hasError) {
-    return {
-      status: "loading",
-      hook,
-    };
-  }
-
-  const { accounts, balances, defaultSelectedAccount } = hook.response;
-  const currentAccount = selectedAccount ?? defaultSelectedAccount;
-
-  const bs = balances.filter((b) => b.available.startsWith(currency));
-  const balance =
-    bs.length > 0
-      ? Amounts.parseOrThrow(bs[0].available)
-      : Amounts.getZero(currency);
-
-  if (Amounts.isZero(balance)) {
-    return {
-      status: "no-balance",
-    };
-  }
-
-  if (!currentAccount) {
-    return {
-      status: "no-accounts",
-      cancelHandler: {
-        onClick: async () => {
-          onCancel(currency);
-        },
-      },
-    };
-  }
-  const accountMap = createLabelsForBankAccount(accounts);
-
-  async function updateAccount(accountStr: string): Promise<void> {
-    const idx = parseInt(accountStr, 10);
-    const newSelected = accounts.length > idx ? accounts[idx] : undefined;
-    if (accountIdx === idx || !newSelected) return;
-
-    if (!parsedAmount) {
-      setAccountIdx(idx);
-      setSelectedAccount(newSelected);
-    } else {
-      const result = await getFeeForAmount(newSelected, parsedAmount, api);
-      setAccountIdx(idx);
-      setSelectedAccount(newSelected);
-      setFee(result);
-    }
-  }
-
-  async function updateAmount(numStr: string): Promise<void> {
-    // const num = parseFloat(numStr);
-    // const newAmount = Number.isNaN(num) ? 0 : num;
-    if (amount === numStr || !currentAccount) return;
-    const parsed = Amounts.parse(`${currency}:${numStr}`);
-    if (!parsed) {
-      setAmount(numStr);
-    } else {
-      const result = await getFeeForAmount(currentAccount, parsed, api);
-      setAmount(numStr);
-      setFee(result);
-    }
-  }
-
-  const totalFee =
-    fee !== undefined
-      ? Amounts.sum([fee.wire, fee.coin, fee.refresh]).amount
-      : Amounts.getZero(currency);
-
-  const totalToDeposit = parsedAmount
-    ? Amounts.sub(parsedAmount, totalFee).amount
-    : Amounts.getZero(currency);
-
-  const isDirty = amount !== initialValue;
-  const amountError = !isDirty
-    ? undefined
-    : !parsedAmount
-    ? "Invalid amount"
-    : Amounts.cmp(balance, parsedAmount) === -1
-    ? `Too much, your current balance is ${Amounts.stringifyValue(balance)}`
-    : undefined;
-
-  const unableToDeposit =
-    !parsedAmount ||
-    Amounts.isZero(totalToDeposit) ||
-    fee === undefined ||
-    amountError !== undefined;
-
-  async function doSend(): Promise<void> {
-    if (!currentAccount || !parsedAmount) return;
-
-    const account = `payto://${currentAccount.targetType}/${currentAccount.targetPath}`;
-    const amount = Amounts.stringify(parsedAmount);
-    await api.createDepositGroup(account, amount);
-    onSuccess(currency);
-  }
-
-  return {
-    status: "ready",
-    currency,
-    amount: {
-      value: String(amount),
-      onInput: updateAmount,
-      error: amountError,
-    },
-    account: {
-      list: accountMap,
-      value: String(accountIdx),
-      onChange: updateAccount,
-    },
-    cancelHandler: {
-      onClick: async () => {
-        onCancel(currency);
-      },
-    },
-    depositHandler: {
-      onClick: unableToDeposit ? undefined : doSend,
-    },
-    totalFee,
-    totalToDeposit,
-    // currentAccount,
-    // parsedAmount,
-  };
-}
-
-export function View({ state }: ViewProps): VNode {
-  const { i18n } = useTranslationContext();
-
-  if (state === undefined) return <Loading />;
-
-  if (state.status === "loading") {
-    if (!state.hook) return <Loading />;
-    return (
-      <LoadingError
-        title={<i18n.Translate>Could not load deposit balance</i18n.Translate>}
-        error={state.hook}
-      />
-    );
-  }
-
-  if (state.status === "no-balance") {
-    return (
-      <div>
-        <i18n.Translate>no balance</i18n.Translate>
-      </div>
-    );
-  }
-  if (state.status === "no-accounts") {
-    return (
-      <Fragment>
-        <WarningBox>
-          <p>
-            <i18n.Translate>
-              There is no known bank account to send money to
-            </i18n.Translate>
-          </p>
-        </WarningBox>
-        <footer>
-          <Button
-            variant="contained"
-            color="secondary"
-            onClick={state.cancelHandler.onClick}
-          >
-            <i18n.Translate>Cancel</i18n.Translate>
-          </Button>
-        </footer>
-      </Fragment>
-    );
-  }
-
-  return (
-    <Fragment>
-      <SubTitle>
-        <i18n.Translate>Send {state.currency} to your account</i18n.Translate>
-      </SubTitle>
-      <section>
-        <Input>
-          <SelectList
-            label={<i18n.Translate>Bank account IBAN number</i18n.Translate>}
-            list={state.account.list}
-            name="account"
-            value={state.account.value}
-            onChange={state.account.onChange}
-          />
-        </Input>
-        <InputWithLabel invalid={!!state.amount.error}>
-          <label>
-            <i18n.Translate>Amount</i18n.Translate>
-          </label>
-          <div>
-            <span>{state.currency}</span>
-            <input
-              type="number"
-              value={state.amount.value}
-              onInput={(e) => state.amount.onInput(e.currentTarget.value)}
-            />
-          </div>
-          {state.amount.error && <ErrorText>{state.amount.error}</ErrorText>}
-        </InputWithLabel>
-        {
-          <Fragment>
-            <InputWithLabel>
-              <label>
-                <i18n.Translate>Deposit fee</i18n.Translate>
-              </label>
-              <div>
-                <span>{state.currency}</span>
-                <input
-                  type="number"
-                  disabled
-                  value={Amounts.stringifyValue(state.totalFee)}
-                />
-              </div>
-            </InputWithLabel>
-
-            <InputWithLabel>
-              <label>
-                <i18n.Translate>Total deposit</i18n.Translate>
-              </label>
-              <div>
-                <span>{state.currency}</span>
-                <input
-                  type="number"
-                  disabled
-                  value={Amounts.stringifyValue(state.totalToDeposit)}
-                />
-              </div>
-            </InputWithLabel>
-          </Fragment>
-        }
-      </section>
-      <footer>
-        <Button
-          variant="contained"
-          color="secondary"
-          onClick={state.cancelHandler.onClick}
-        >
-          <i18n.Translate>Cancel</i18n.Translate>
-        </Button>
-        {!state.depositHandler.onClick ? (
-          <Button variant="contained" disabled>
-            <i18n.Translate>Deposit</i18n.Translate>
-          </Button>
-        ) : (
-          <Button variant="contained" onClick={state.depositHandler.onClick}>
-            <i18n.Translate>
-              Deposit&nbsp;{Amounts.stringifyValue(state.totalToDeposit)}{" "}
-              {state.currency}
-            </i18n.Translate>
-          </Button>
-        )}
-      </footer>
-    </Fragment>
-  );
-}
-
-export function createLabelsForBankAccount(
-  knownBankAccounts: Array<PaytoUri>,
-): {
-  [label: number]: string;
-} {
-  if (!knownBankAccounts) return {};
-  return knownBankAccounts.reduce((prev, cur, i) => {
-    let label = cur.targetPath;
-    if (cur.isKnown) {
-      switch (cur.targetType) {
-        case "x-taler-bank": {
-          label = cur.account;
-          break;
-        }
-        case "iban": {
-          label = cur.iban;
-          break;
-        }
-      }
-    }
-    return {
-      ...prev,
-      [i]: label,
-    };
-  }, {} as { [label: number]: string });
-}

packages/taler-wallet-webextension/src/wallet/DepositPage/index.ts

@@ -0,0 +1,112 @@
+/*
+ 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 { Loading } from "../../components/Loading.js";
+import { HookError } from "../../hooks/useAsyncAsHook.js";
+import { compose, StateViewMap } from "../../utils/index.js";
+import { AmountOrCurrencyErrorView, LoadingErrorView, NoAccountToDepositView, NoEnoughBalanceView, ReadyView } from "./views.js";
+import * as wxApi from "../../wxApi.js";
+import { useComponentState } from "./state.js";
+import { AmountJson, PaytoUri } from "@gnu-taler/taler-util";
+import { ButtonHandler, SelectFieldHandler, TextFieldHandler, ToggleHandler } from "../../mui/handlers.js";
+import { AddAccountPage } from "../AddAccount/index.js";
+
+export interface Props {
+  amount?: string;
+  currency?: string;
+  onCancel: (currency: string) => void;
+  onSuccess: (currency: string) => void;
+}
+
+export type State = State.Loading
+  | State.LoadingUriError
+  | State.AmountOrCurrencyError
+  | State.NoEnoughBalance
+  | State.Ready
+  | State.NoAccounts
+  | State.AddingAccount;
+
+export namespace State {
+  export interface Loading {
+    status: "loading";
+    error: undefined;
+  }
+
+  export interface LoadingUriError {
+    status: "loading-error";
+    error: HookError;
+  }
+
+  export interface AddingAccount {
+    status: "adding-account";
+    error: undefined;
+    currency: string;
+    onAccountAdded: (p: string) => void;
+    onCancel: () => void;
+  }
+
+  export interface AmountOrCurrencyError {
+    status: "amount-or-currency-error";
+    error: undefined;
+  }
+
+  export interface BaseInfo {
+    error: undefined;
+  }
+
+  export interface NoEnoughBalance extends BaseInfo {
+    status: "no-enough-balance";
+    currency: string;
+  }
+
+  export interface NoAccounts extends BaseInfo {
+    status: "no-accounts";
+    currency: string;
+    onAddAccount: ButtonHandler;
+  }
+
+  export interface Ready extends BaseInfo {
+    status: "ready";
+    error: undefined;
+    currency: string;
+
+    selectedAccount: PaytoUri | undefined;
+    totalFee: AmountJson;
+    totalToDeposit: AmountJson;
+
+    amount: TextFieldHandler;
+    account: SelectFieldHandler;
+    cancelHandler: ButtonHandler;
+    depositHandler: ButtonHandler;
+    onAddAccount: ButtonHandler;
+  }
+}
+
+const viewMapping: StateViewMap<State> = {
+  loading: Loading,
+  "loading-error": LoadingErrorView,
+  "amount-or-currency-error": AmountOrCurrencyErrorView,
+  "no-enough-balance": NoEnoughBalanceView,
+  "no-accounts": NoAccountToDepositView,
+  "adding-account": AddAccountPage,
+  ready: ReadyView,
+};
+
+export const DepositPage = compose(
+  "DepositPage",
+  (p: Props) => useComponentState(p, wxApi),
+  viewMapping,
+);

packages/taler-wallet-webextension/src/wallet/DepositPage/state.ts

@@ -0,0 +1,240 @@
+/*
+ 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 { AmountJson, Amounts, DepositGroupFees, KnownBankAccountsInfo, parsePaytoUri, PaytoUri, stringifyPaytoUri } from "@gnu-taler/taler-util";
+import { useState } from "preact/hooks";
+import { useAsyncAsHook } from "../../hooks/useAsyncAsHook.js";
+import * as wxApi from "../../wxApi.js";
+import { Props, State } from "./index.js";
+
+export function useComponentState({ amount: amountStr, currency: currencyStr, onCancel, onSuccess }: Props, api: typeof wxApi): State {
+  const parsed = amountStr === undefined ? undefined : Amounts.parse(amountStr);
+  const currency = parsed !== undefined ? parsed.currency : currencyStr;
+
+  const hook = useAsyncAsHook(async () => {
+    const { balances } = await api.getBalance();
+    const { accounts } = await api.listKnownBankAccounts(currency);
+
+    return { accounts, balances };
+  });
+
+  const initialValue =
+    parsed !== undefined ? Amounts.stringifyValue(parsed) : "0";
+  // const [accountIdx, setAccountIdx] = useState<number>(0);
+  const [amount, setAmount] = useState(initialValue);
+
+  const [selectedAccount, setSelectedAccount] = useState<
+    PaytoUri | undefined
+  >();
+
+  const [fee, setFee] = useState<DepositGroupFees | undefined>(undefined);
+  const [addingAccount, setAddingAccount] = useState(false);
+
+  if (!currency) {
+    return {
+      status: "amount-or-currency-error",
+      error: undefined
+    }
+  }
+
+  if (!hook) {
+    return {
+      status: "loading",
+      error: undefined,
+    };
+  }
+  if (hook.hasError) {
+    return {
+      status: "loading-error",
+      error: hook,
+    }
+  }
+  const { accounts, balances } = hook.response;
+
+  const parsedAmount = Amounts.parse(`${currency}:${amount}`);
+
+  if (addingAccount) {
+    return {
+      status: "adding-account",
+      error: undefined,
+      currency,
+      onAccountAdded: (p: string) => {
+        updateAccountFromList(p);
+        setAddingAccount(false);
+        hook.retry()
+      },
+      onCancel: () => {
+        setAddingAccount(false);
+      }
+      ,
+    }
+  }
+
+  const bs = balances.filter((b) => b.available.startsWith(currency));
+  const balance =
+    bs.length > 0
+      ? Amounts.parseOrThrow(bs[0].available)
+      : Amounts.getZero(currency);
+
+  if (Amounts.isZero(balance)) {
+    return {
+      status: "no-enough-balance",
+      error: undefined,
+      currency,
+    };
+  }
+
+  if (accounts.length === 0) {
+    return {
+      status: "no-accounts",
+      error: undefined,
+      currency,
+      onAddAccount: {
+        onClick: async () => { setAddingAccount(true) }
+      },
+    }
+  }
+
+  const accountMap = createLabelsForBankAccount(accounts);
+  accountMap[""] = "Select one account..."
+
+  async function updateAccountFromList(accountStr: string): Promise<void> {
+    // const newSelected = !accountMap[accountStr] ? undefined : accountMap[accountStr];
+    // if (!newSelected) return;
+    const uri = !accountStr ? undefined : parsePaytoUri(accountStr);
+    setSelectedAccount(uri);
+    if (uri && parsedAmount) {
+      try {
+        const result = await getFeeForAmount(uri, parsedAmount, api);
+        setFee(result);
+      } catch (e) {
+        setFee(undefined);
+      }
+    }
+  }
+
+  async function updateAmount(numStr: string): Promise<void> {
+    setAmount(numStr);
+    const parsed = Amounts.parse(`${currency}:${numStr}`);
+    if (parsed && selectedAccount) {
+      try {
+        const result = await getFeeForAmount(selectedAccount, parsed, api);
+        setFee(result);
+      } catch (e) {
+        setFee(undefined);
+      }
+    }
+  }
+
+  const totalFee =
+    fee !== undefined
+      ? Amounts.sum([fee.wire, fee.coin, fee.refresh]).amount
+      : Amounts.getZero(currency);
+
+  const totalToDeposit = parsedAmount && fee !== undefined
+    ? Amounts.sub(parsedAmount, totalFee).amount
+    : Amounts.getZero(currency);
+
+  const isDirty = amount !== initialValue;
+  const amountError = !isDirty
+    ? undefined
+    : !parsedAmount
+      ? "Invalid amount"
+      : Amounts.cmp(balance, parsedAmount) === -1
+        ? `Too much, your current balance is ${Amounts.stringifyValue(balance)}`
+        : undefined;
+
+  const unableToDeposit =
+    !parsedAmount ||
+    selectedAccount === undefined ||
+    Amounts.isZero(totalToDeposit) ||
+    fee === undefined ||
+    amountError !== undefined;
+
+  async function doSend(): Promise<void> {
+    if (!selectedAccount || !parsedAmount || !currency) return;
+
+    const account = `payto://${selectedAccount.targetType}/${selectedAccount.targetPath}`;
+    const amount = Amounts.stringify(parsedAmount);
+    await api.createDepositGroup(account, amount);
+    onSuccess(currency);
+  }
+
+  return {
+    status: "ready",
+    error: undefined,
+    currency,
+    amount: {
+      value: String(amount),
+      onInput: updateAmount,
+      error: amountError,
+
+    },
+    onAddAccount: {
+      onClick: async () => { setAddingAccount(true) }
+    },
+    account: {
+      list: accountMap,
+      value: !selectedAccount ? "" : stringifyPaytoUri(selectedAccount),
+      onChange: updateAccountFromList,
+    },
+    selectedAccount,
+    cancelHandler: {
+      onClick: async () => {
+        onCancel(currency);
+      },
+    },
+    depositHandler: {
+      onClick: unableToDeposit ? undefined : doSend,
+    },
+    totalFee,
+    totalToDeposit,
+    // currentAccount,
+    // parsedAmount,
+  };
+}
+
+async function getFeeForAmount(
+  p: PaytoUri,
+  a: AmountJson,
+  api: typeof wxApi,
+): Promise<DepositGroupFees> {
+  const account = `payto://${p.targetType}/${p.targetPath}`;
+  const amount = Amounts.stringify(a);
+  return await api.getFeeForDeposit(account, amount);
+}
+
+export function labelForAccountType(id: string) {
+  switch (id) {
+    case "": return "Choose one";
+    case "x-taler-bank": return "Taler Bank";
+    case "bitcoin": return "Bitcoin";
+    case "iban": return "IBAN";
+    default: return id;
+  }
+}
+
+export function createLabelsForBankAccount(
+  knownBankAccounts: Array<KnownBankAccountsInfo>,
+): { [value: string]: string } {
+  const initialList: Record<string, string> = {
+  }
+  if (!knownBankAccounts.length) return initialList;
+  return knownBankAccounts.reduce((prev, cur, i) => {
+    prev[stringifyPaytoUri(cur.uri)] = cur.alias
+    return prev;
+  }, initialList);
+}

packages/taler-wallet-webextension/src/wallet/DepositPage/stories.tsx

@@ -0,0 +1,131 @@
+/*
+ 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/>
+ */
+
+/**
+ *
+ * @author Sebastian Javier Marchano (sebasjm)
+ */
+
+import { Amounts, DepositGroupFees } from "@gnu-taler/taler-util";
+import { createExample } from "../../test-utils.js";
+import { labelForAccountType } from "./state.js";
+import { ReadyView } from "./views.js";
+
+export default {
+  title: "wallet/deposit",
+};
+
+const accountsType = {
+  "": labelForAccountType(""),
+  iban: labelForAccountType("iban"),
+  bitcoin: labelForAccountType("bitcoin"),
+  "x-taler-bank": labelForAccountType("x-taler-bank"),
+};
+async function alwaysReturnFeeToOne(): Promise<DepositGroupFees> {
+  const fee = {
+    currency: "EUR",
+    value: 1,
+    fraction: 0,
+  };
+  return { coin: fee, refresh: fee, wire: fee };
+}
+
+// const ac = parsePaytoUri("payto://iban/ES8877998399652238")!;
+// const accountMap = createLabelsForBankAccount([ac]);
+
+export const WithNoAccountForIBAN = createExample(ReadyView, {
+  status: "ready",
+  account: {
+    list: {},
+    value: "",
+    onChange: async () => {
+      null;
+    },
+  },
+  currency: "USD",
+  amount: {
+    onInput: async () => {
+      null;
+    },
+    value: "10:USD",
+  },
+  onAddAccount: {},
+  cancelHandler: {},
+  depositHandler: {
+    onClick: async () => {
+      return;
+    },
+  },
+  totalFee: Amounts.getZero("USD"),
+  totalToDeposit: Amounts.parseOrThrow("USD:10"),
+  // onCalculateFee: alwaysReturnFeeToOne,
+});
+
+export const WithIBANAccountTypeSelected = createExample(ReadyView, {
+  status: "ready",
+  account: {
+    list: { asdlkajsdlk: "asdlkajsdlk", qwerqwer: "qwerqwer" },
+    value: "asdlkajsdlk",
+    onChange: async () => {
+      null;
+    },
+  },
+  currency: "USD",
+  amount: {
+    onInput: async () => {
+      null;
+    },
+    value: "10:USD",
+  },
+  onAddAccount: {},
+  cancelHandler: {},
+  depositHandler: {
+    onClick: async () => {
+      return;
+    },
+  },
+  totalFee: Amounts.getZero("USD"),
+  totalToDeposit: Amounts.parseOrThrow("USD:10"),
+  // onCalculateFee: alwaysReturnFeeToOne,
+});
+
+export const NewBitcoinAccountTypeSelected = createExample(ReadyView, {
+  status: "ready",
+  account: {
+    list: {},
+    value: "asdlkajsdlk",
+    onChange: async () => {
+      null;
+    },
+  },
+  onAddAccount: {},
+  currency: "USD",
+  amount: {
+    onInput: async () => {
+      null;
+    },
+    value: "10:USD",
+  },
+  cancelHandler: {},
+  depositHandler: {
+    onClick: async () => {
+      return;
+    },
+  },
+  totalFee: Amounts.getZero("USD"),
+  totalToDeposit: Amounts.parseOrThrow("USD:10"),
+  // onCalculateFee: alwaysReturnFeeToOne,
+});

packages/taler-wallet-webextension/src/wallet/DepositPage/test.ts

@@ -19,17 +19,12 @@
  * @author Sebastian Javier Marchano (sebasjm)
  */
 
-import {
+import { Amounts, Balance, BalancesResponse, DepositGroupFees, parsePaytoUri, stringifyPaytoUri } from "@gnu-taler/taler-util";
-  Amounts,
-  Balance,
-  BalancesResponse,
-  DepositGroupFees,
-  parsePaytoUri,
-} from "@gnu-taler/taler-util";
 import { expect } from "chai";
-import { mountHook } from "../test-utils.js";
+import { mountHook } from "../../test-utils.js";
-import { useComponentState } from "./DepositPage.js";
+
-import * as wxApi from "../wxApi.js";
+import * as wxApi from "../../wxApi.js";
+import { useComponentState } from "./state.js";
 
 const currency = "EUR";
 const withoutFee = async (): Promise<DepositGroupFees> => ({
@@ -45,7 +40,7 @@ const withSomeFee = async (): Promise<DepositGroupFees> => ({
 });
 
 const freeJustForIBAN = async (account: string): Promise<DepositGroupFees> =>
-  /IBAN/i.test(account) ? withoutFee() : withSomeFee();
+  /IBAN/i.test(account) ? withSomeFee() : withoutFee();
 
 const someBalance = [
   {
@@ -57,10 +52,11 @@ const nullFunction: any = () => null;
 type VoidFunction = () => void;
 
 describe("DepositPage states", () => {
-  it("should have status 'no-balance' when balance is empty", async () => {
+
+  it("should have status 'no-enough-balance' when balance is empty", async () => {
     const { getLastResultOrThrow, waitNextUpdate, assertNoPendingUpdate } =
       mountHook(() =>
-        useComponentState(currency, nullFunction, nullFunction, {
+        useComponentState({ currency, onCancel: nullFunction, onSuccess: nullFunction }, {
           getBalance: async () =>
           ({
             balances: [{ available: `${currency}:0` }],
@@ -78,55 +74,61 @@ describe("DepositPage states", () => {
 
     {
       const { status } = getLastResultOrThrow();
-      expect(status).equal("no-balance");
+      expect(status).equal("no-enough-balance");
     }
 
     await assertNoPendingUpdate();
   });
 
-  it("should have status 'no-accounts' when balance is not empty and accounts is empty", async () => {
+  // it("should have status 'no-accounts' when balance is not empty and accounts is empty", async () => {
-    const { getLastResultOrThrow, waitNextUpdate, assertNoPendingUpdate } =
+  //   const { getLastResultOrThrow, waitNextUpdate, assertNoPendingUpdate } =
-      mountHook(() =>
+  //     mountHook(() =>
-        useComponentState(currency, nullFunction, nullFunction, {
+  //       useComponentState({ currency, onCancel: nullFunction, onSuccess: nullFunction }, {
-          getBalance: async () =>
+  //         getBalance: async () =>
-            ({
+  //         ({
-              balances: [{ available: `${currency}:1` }],
+  //           balances: [{ available: `${currency}:1` }],
-            } as Partial<BalancesResponse>),
+  //         } as Partial<BalancesResponse>),
-          listKnownBankAccounts: async () => ({ accounts: {} }),
+  //         listKnownBankAccounts: async () => ({ accounts: {} }),
-        } as Partial<typeof wxApi> as any),
+  //       } as Partial<typeof wxApi> as any),
-      );
+  //     );
 
-    {
+  //   {
-      const { status } = getLastResultOrThrow();
+  //     const { status } = getLastResultOrThrow();
-      expect(status).equal("loading");
+  //     expect(status).equal("loading");
-    }
+  //   }
 
-    await waitNextUpdate();
+  //   await waitNextUpdate();
-    {
+  //   {
-      const r = getLastResultOrThrow();
+  //     const r = getLastResultOrThrow();
-      if (r.status !== "no-accounts") expect.fail();
+  //     if (r.status !== "no-accounts") expect.fail();
-      expect(r.cancelHandler.onClick).not.undefined;
+  //     expect(r.cancelHandler.onClick).not.undefined;
-    }
+  //   }
 
-    await assertNoPendingUpdate();
+  //   await assertNoPendingUpdate();
-  });
+  // });
 
-  const ibanPayto_str = "payto://iban/ES8877998399652238";
+  const ibanPayto = {
-  const ibanPayto = { ibanPayto_str: parsePaytoUri(ibanPayto_str)! };
+    uri: parsePaytoUri("payto://iban/ES8877998399652238")!,
-  const talerBankPayto_str = "payto://x-taler-bank/ES8877998399652238";
+    kyc_completed: false,
+    currency: "EUR",
+    alias: "my iban account"
+  };
   const talerBankPayto = {
-    talerBankPayto_str: parsePaytoUri(talerBankPayto_str)!,
+    uri: parsePaytoUri("payto://x-taler-bank/ES8877998399652238")!,
+    kyc_completed: false,
+    currency: "EUR",
+    alias: "my taler account"
   };
 
   it("should have status 'ready' but unable to deposit ", async () => {
     const { getLastResultOrThrow, waitNextUpdate, assertNoPendingUpdate } =
       mountHook(() =>
-        useComponentState(currency, nullFunction, nullFunction, {
+        useComponentState({ currency, onCancel: nullFunction, onSuccess: nullFunction }, {
           getBalance: async () =>
           ({
             balances: [{ available: `${currency}:1` }],
           } as Partial<BalancesResponse>),
-          listKnownBankAccounts: async () => ({ accounts: ibanPayto }),
+          listKnownBankAccounts: async () => ({ accounts: [ibanPayto] }),
         } as Partial<typeof wxApi> as any),
       );
 
@@ -142,7 +144,7 @@ describe("DepositPage states", () => {
       if (r.status !== "ready") expect.fail();
       expect(r.cancelHandler.onClick).not.undefined;
       expect(r.currency).eq(currency);
-      expect(r.account.value).eq("0");
+      expect(r.account.value).eq("");
       expect(r.amount.value).eq("0");
       expect(r.depositHandler.onClick).undefined;
     }
@@ -150,15 +152,15 @@ describe("DepositPage states", () => {
     await assertNoPendingUpdate();
   });
 
-  it("should not be able to deposit more than the balance ", async () => {
+  it.skip("should not be able to deposit more than the balance ", async () => {
     const { getLastResultOrThrow, waitNextUpdate, assertNoPendingUpdate } =
       mountHook(() =>
-        useComponentState(currency, nullFunction, nullFunction, {
+        useComponentState({ currency, onCancel: nullFunction, onSuccess: nullFunction }, {
           getBalance: async () =>
           ({
             balances: [{ available: `${currency}:1` }],
           } as Partial<BalancesResponse>),
-          listKnownBankAccounts: async () => ({ accounts: ibanPayto }),
+          listKnownBankAccounts: async () => ({ accounts: [ibanPayto] }),
           getFeeForDeposit: withoutFee,
         } as Partial<typeof wxApi> as any),
       );
@@ -175,7 +177,7 @@ describe("DepositPage states", () => {
       if (r.status !== "ready") expect.fail();
       expect(r.cancelHandler.onClick).not.undefined;
       expect(r.currency).eq(currency);
-      expect(r.account.value).eq("0");
+      expect(r.account.value).eq("");
       expect(r.amount.value).eq("0");
       expect(r.depositHandler.onClick).undefined;
       expect(r.totalFee).deep.eq(Amounts.parseOrThrow(`${currency}:0`));
@@ -190,7 +192,20 @@ describe("DepositPage states", () => {
       if (r.status !== "ready") expect.fail();
       expect(r.cancelHandler.onClick).not.undefined;
       expect(r.currency).eq(currency);
-      expect(r.account.value).eq("0");
+      expect(r.account.value).eq("");
+      expect(r.amount.value).eq("10");
+      expect(r.totalFee).deep.eq(Amounts.parseOrThrow(`${currency}:0`));
+      expect(r.depositHandler.onClick).undefined;
+    }
+
+    await waitNextUpdate();
+
+    {
+      const r = getLastResultOrThrow();
+      if (r.status !== "ready") expect.fail();
+      expect(r.cancelHandler.onClick).not.undefined;
+      expect(r.currency).eq(currency);
+      expect(r.account.value).eq("");
       expect(r.amount.value).eq("10");
       expect(r.totalFee).deep.eq(Amounts.parseOrThrow(`${currency}:0`));
       expect(r.depositHandler.onClick).undefined;
@@ -199,15 +214,15 @@ describe("DepositPage states", () => {
     await assertNoPendingUpdate();
   });
 
-  it("should calculate the fee upon entering amount ", async () => {
+  it.skip("should calculate the fee upon entering amount ", async () => {
     const { getLastResultOrThrow, waitNextUpdate, assertNoPendingUpdate } =
       mountHook(() =>
-        useComponentState(currency, nullFunction, nullFunction, {
+        useComponentState({ currency, onCancel: nullFunction, onSuccess: nullFunction }, {
           getBalance: async () =>
           ({
             balances: [{ available: `${currency}:1` }],
           } as Partial<BalancesResponse>),
-          listKnownBankAccounts: async () => ({ accounts: ibanPayto }),
+          listKnownBankAccounts: async () => ({ accounts: [ibanPayto] }),
           getFeeForDeposit: withSomeFee,
         } as Partial<typeof wxApi> as any),
       );
@@ -224,7 +239,7 @@ describe("DepositPage states", () => {
       if (r.status !== "ready") expect.fail();
       expect(r.cancelHandler.onClick).not.undefined;
       expect(r.currency).eq(currency);
-      expect(r.account.value).eq("0");
+      expect(r.account.value).eq("");
       expect(r.amount.value).eq("0");
       expect(r.depositHandler.onClick).undefined;
       expect(r.totalFee).deep.eq(Amounts.parseOrThrow(`${currency}:0`));
@@ -239,7 +254,21 @@ describe("DepositPage states", () => {
       if (r.status !== "ready") expect.fail();
       expect(r.cancelHandler.onClick).not.undefined;
       expect(r.currency).eq(currency);
-      expect(r.account.value).eq("0");
+      expect(r.account.value).eq("");
+      expect(r.amount.value).eq("10");
+      expect(r.totalFee).deep.eq(Amounts.parseOrThrow(`${currency}:0`));
+      expect(r.totalToDeposit).deep.eq(Amounts.parseOrThrow(`${currency}:10`));
+      expect(r.depositHandler.onClick).undefined;
+    }
+
+    await waitNextUpdate();
+
+    {
+      const r = getLastResultOrThrow();
+      if (r.status !== "ready") expect.fail();
+      expect(r.cancelHandler.onClick).not.undefined;
+      expect(r.currency).eq(currency);
+      expect(r.account.value).eq("");
       expect(r.amount.value).eq("10");
       expect(r.totalFee).deep.eq(Amounts.parseOrThrow(`${currency}:3`));
       expect(r.totalToDeposit).deep.eq(Amounts.parseOrThrow(`${currency}:7`));
@@ -252,13 +281,13 @@ describe("DepositPage states", () => {
   it("should calculate the fee upon selecting account ", async () => {
     const { getLastResultOrThrow, waitNextUpdate, assertNoPendingUpdate } =
       mountHook(() =>
-        useComponentState(currency, nullFunction, nullFunction, {
+        useComponentState({ currency, onCancel: nullFunction, onSuccess: nullFunction }, {
           getBalance: async () =>
           ({
             balances: [{ available: `${currency}:1` }],
           } as Partial<BalancesResponse>),
           listKnownBankAccounts: async () => ({
-            accounts: { ...ibanPayto, ...talerBankPayto },
+            accounts: [ibanPayto, talerBankPayto],
           }),
           getFeeForDeposit: freeJustForIBAN,
         } as Partial<typeof wxApi> as any),
@@ -276,23 +305,39 @@ describe("DepositPage states", () => {
       if (r.status !== "ready") expect.fail();
       expect(r.cancelHandler.onClick).not.undefined;
       expect(r.currency).eq(currency);
-      expect(r.account.value).eq("0");
+      expect(r.account.value).eq("");
       expect(r.amount.value).eq("0");
       expect(r.depositHandler.onClick).undefined;
       expect(r.totalFee).deep.eq(Amounts.parseOrThrow(`${currency}:0`));
+      expect(r.totalToDeposit).deep.eq(Amounts.parseOrThrow(`${currency}:0`));
 
       if (r.account.onChange === undefined) expect.fail();
-      r.account.onChange("1");
+      r.account.onChange(stringifyPaytoUri(ibanPayto.uri));
     }
 
-    await waitNextUpdate();
+    await waitNextUpdate("");
 
     {
       const r = getLastResultOrThrow();
       if (r.status !== "ready") expect.fail();
       expect(r.cancelHandler.onClick).not.undefined;
       expect(r.currency).eq(currency);
-      expect(r.account.value).eq("1");
+      expect(r.account.value).eq(stringifyPaytoUri(ibanPayto.uri));
+      expect(r.amount.value).eq("0");
+      expect(r.totalFee).deep.eq(Amounts.parseOrThrow(`${currency}:0`));
+      expect(r.totalToDeposit).deep.eq(Amounts.parseOrThrow(`${currency}:0`));
+      expect(r.depositHandler.onClick).undefined;
+
+    }
+
+    await waitNextUpdate("");
+
+    {
+      const r = getLastResultOrThrow();
+      if (r.status !== "ready") expect.fail();
+      expect(r.cancelHandler.onClick).not.undefined;
+      expect(r.currency).eq(currency);
+      expect(r.account.value).eq(stringifyPaytoUri(ibanPayto.uri));
       expect(r.amount.value).eq("0");
       expect(r.totalFee).deep.eq(Amounts.parseOrThrow(`${currency}:3`));
       expect(r.totalToDeposit).deep.eq(Amounts.parseOrThrow(`${currency}:0`));
@@ -301,31 +346,62 @@ describe("DepositPage states", () => {
       r.amount.onInput("10");
     }
 
-    await waitNextUpdate();
+    await waitNextUpdate("");
 
     {
       const r = getLastResultOrThrow();
       if (r.status !== "ready") expect.fail();
       expect(r.cancelHandler.onClick).not.undefined;
       expect(r.currency).eq(currency);
-      expect(r.account.value).eq("1");
+      expect(r.account.value).eq(stringifyPaytoUri(ibanPayto.uri));
       expect(r.amount.value).eq("10");
       expect(r.totalFee).deep.eq(Amounts.parseOrThrow(`${currency}:3`));
       expect(r.totalToDeposit).deep.eq(Amounts.parseOrThrow(`${currency}:7`));
       expect(r.depositHandler.onClick).undefined;
 
-      if (r.account.onChange === undefined) expect.fail();
-      r.account.onChange("0");
     }
 
-    await waitNextUpdate();
+    await waitNextUpdate("");
 
     {
       const r = getLastResultOrThrow();
       if (r.status !== "ready") expect.fail();
       expect(r.cancelHandler.onClick).not.undefined;
       expect(r.currency).eq(currency);
-      expect(r.account.value).eq("0");
+      expect(r.account.value).eq(stringifyPaytoUri(ibanPayto.uri));
+      expect(r.amount.value).eq("10");
+      expect(r.totalFee).deep.eq(Amounts.parseOrThrow(`${currency}:3`));
+      expect(r.totalToDeposit).deep.eq(Amounts.parseOrThrow(`${currency}:7`));
+      expect(r.depositHandler.onClick).undefined;
+
+
+      if (r.account.onChange === undefined) expect.fail();
+      r.account.onChange(stringifyPaytoUri(talerBankPayto.uri));
+    }
+
+    await waitNextUpdate("");
+
+    {
+      const r = getLastResultOrThrow();
+      if (r.status !== "ready") expect.fail();
+      expect(r.cancelHandler.onClick).not.undefined;
+      expect(r.currency).eq(currency);
+      expect(r.account.value).eq(stringifyPaytoUri(talerBankPayto.uri));
+      expect(r.amount.value).eq("10");
+      expect(r.totalFee).deep.eq(Amounts.parseOrThrow(`${currency}:3`));
+      expect(r.totalToDeposit).deep.eq(Amounts.parseOrThrow(`${currency}:7`));
+      expect(r.depositHandler.onClick).undefined;
+
+    }
+
+    await waitNextUpdate("");
+
+    {
+      const r = getLastResultOrThrow();
+      if (r.status !== "ready") expect.fail();
+      expect(r.cancelHandler.onClick).not.undefined;
+      expect(r.currency).eq(currency);
+      expect(r.account.value).eq(stringifyPaytoUri(talerBankPayto.uri));
       expect(r.amount.value).eq("10");
       expect(r.totalFee).deep.eq(Amounts.parseOrThrow(`${currency}:0`));
       expect(r.totalToDeposit).deep.eq(Amounts.parseOrThrow(`${currency}:10`));
@@ -335,15 +411,15 @@ describe("DepositPage states", () => {
     await assertNoPendingUpdate();
   });
 
-  it("should be able to deposit if has the enough balance ", async () => {
+  it.skip("should be able to deposit if has the enough balance ", async () => {
     const { getLastResultOrThrow, waitNextUpdate, assertNoPendingUpdate } =
       mountHook(() =>
-        useComponentState(currency, nullFunction, nullFunction, {
+        useComponentState({ currency, onCancel: nullFunction, onSuccess: nullFunction }, {
           getBalance: async () =>
           ({
             balances: [{ available: `${currency}:15` }],
           } as Partial<BalancesResponse>),
-          listKnownBankAccounts: async () => ({ accounts: ibanPayto }),
+          listKnownBankAccounts: async () => ({ accounts: [ibanPayto] }),
           getFeeForDeposit: withSomeFee,
         } as Partial<typeof wxApi> as any),
       );
@@ -360,7 +436,7 @@ describe("DepositPage states", () => {
       if (r.status !== "ready") expect.fail();
       expect(r.cancelHandler.onClick).not.undefined;
       expect(r.currency).eq(currency);
-      expect(r.account.value).eq("0");
+      expect(r.account.value).eq("");
       expect(r.amount.value).eq("0");
       expect(r.depositHandler.onClick).undefined;
       expect(r.totalFee).deep.eq(Amounts.parseOrThrow(`${currency}:0`));
@@ -375,7 +451,22 @@ describe("DepositPage states", () => {
       if (r.status !== "ready") expect.fail();
       expect(r.cancelHandler.onClick).not.undefined;
       expect(r.currency).eq(currency);
-      expect(r.account.value).eq("0");
+      expect(r.account.value).eq("");
+      expect(r.amount.value).eq("10");
+      expect(r.totalFee).deep.eq(Amounts.parseOrThrow(`${currency}:0`));
+      expect(r.totalToDeposit).deep.eq(Amounts.parseOrThrow(`${currency}:10`));
+      expect(r.depositHandler.onClick).undefined;
+
+    }
+
+    await waitNextUpdate();
+
+    {
+      const r = getLastResultOrThrow();
+      if (r.status !== "ready") expect.fail();
+      expect(r.cancelHandler.onClick).not.undefined;
+      expect(r.currency).eq(currency);
+      expect(r.account.value).eq("");
       expect(r.amount.value).eq("10");
       expect(r.totalFee).deep.eq(Amounts.parseOrThrow(`${currency}:3`));
       expect(r.totalToDeposit).deep.eq(Amounts.parseOrThrow(`${currency}:7`));
@@ -391,13 +482,11 @@ describe("DepositPage states", () => {
       if (r.status !== "ready") expect.fail();
       expect(r.cancelHandler.onClick).not.undefined;
       expect(r.currency).eq(currency);
-      expect(r.account.value).eq("0");
+      expect(r.account.value).eq("");
       expect(r.amount.value).eq("13");
       expect(r.totalFee).deep.eq(Amounts.parseOrThrow(`${currency}:3`));
       expect(r.totalToDeposit).deep.eq(Amounts.parseOrThrow(`${currency}:10`));
       expect(r.depositHandler.onClick).not.undefined;
-
-      r.amount.onInput("15");
     }
 
     await waitNextUpdate();
@@ -407,26 +496,13 @@ describe("DepositPage states", () => {
       if (r.status !== "ready") expect.fail();
       expect(r.cancelHandler.onClick).not.undefined;
       expect(r.currency).eq(currency);
-      expect(r.account.value).eq("0");
+      expect(r.account.value).eq("");
-      expect(r.amount.value).eq("15");
+      expect(r.amount.value).eq("13");
       expect(r.totalFee).deep.eq(Amounts.parseOrThrow(`${currency}:3`));
-      expect(r.totalToDeposit).deep.eq(Amounts.parseOrThrow(`${currency}:12`));
+      expect(r.totalToDeposit).deep.eq(Amounts.parseOrThrow(`${currency}:10`));
       expect(r.depositHandler.onClick).not.undefined;
-      r.amount.onInput("17");
     }
-    await waitNextUpdate();
 
-    {
-      const r = getLastResultOrThrow();
-      if (r.status !== "ready") expect.fail();
-      expect(r.cancelHandler.onClick).not.undefined;
-      expect(r.currency).eq(currency);
-      expect(r.account.value).eq("0");
-      expect(r.amount.value).eq("17");
-      expect(r.totalFee).deep.eq(Amounts.parseOrThrow(`${currency}:3`));
-      expect(r.totalToDeposit).deep.eq(Amounts.parseOrThrow(`${currency}:14`));
-      expect(r.depositHandler.onClick).undefined;
-    }
     await assertNoPendingUpdate();
   });
 });

packages/taler-wallet-webextension/src/wallet/DepositPage/views.tsx

@@ -0,0 +1,242 @@
+/*
+ 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 { Amounts, PaytoUri } from "@gnu-taler/taler-util";
+import { Fragment, h, VNode } from "preact";
+import { ErrorMessage } from "../../components/ErrorMessage.js";
+import { LoadingError } from "../../components/LoadingError.js";
+import { SelectList } from "../../components/SelectList.js";
+import {
+  ErrorText,
+  Input,
+  InputWithLabel,
+  SubTitle,
+  WarningBox,
+} from "../../components/styled/index.js";
+import { useTranslationContext } from "../../context/translation.js";
+import { Button } from "../../mui/Button.js";
+import { State } from "./index.js";
+
+export function LoadingErrorView({ error }: State.LoadingUriError): VNode {
+  const { i18n } = useTranslationContext();
+
+  return (
+    <LoadingError
+      title={<i18n.Translate>Could not load deposit balance</i18n.Translate>}
+      error={error}
+    />
+  );
+}
+
+export function AmountOrCurrencyErrorView(
+  p: State.AmountOrCurrencyError,
+): VNode {
+  const { i18n } = useTranslationContext();
+
+  return (
+    <ErrorMessage
+      title={
+        <i18n.Translate>
+          A currency or an amount should be indicated
+        </i18n.Translate>
+      }
+    />
+  );
+}
+
+export function NoEnoughBalanceView({
+  currency,
+}: State.NoEnoughBalance): VNode {
+  const { i18n } = useTranslationContext();
+
+  return (
+    <ErrorMessage
+      title={
+        <i18n.Translate>
+          There is no enough balance to make a deposit for currency {currency}
+        </i18n.Translate>
+      }
+    />
+  );
+}
+
+function AccountDetails({ account }: { account: PaytoUri }): VNode {
+  if (account.isKnown) {
+    if (account.targetType === "bitcoin") {
+      return (
+        <dl>
+          <dt>Bitcoin</dt>
+          <dd>{account.targetPath}</dd>
+        </dl>
+      );
+    }
+    if (account.targetType === "x-taler-bank") {
+      return (
+        <dl>
+          <dt>Bank host</dt>
+          <dd>{account.targetPath.split("/")[0]}</dd>
+          <dt>Account name</dt>
+          <dd>{account.targetPath.split("/")[1]}</dd>
+        </dl>
+      );
+    }
+    if (account.targetType === "iban") {
+      return (
+        <dl>
+          <dt>IBAN</dt>
+          <dd>{account.targetPath}</dd>
+        </dl>
+      );
+    }
+  }
+  return <Fragment />;
+}
+
+export function NoAccountToDepositView({
+  currency,
+  onAddAccount,
+}: State.NoAccounts): VNode {
+  const { i18n } = useTranslationContext();
+
+  return (
+    <Fragment>
+      <SubTitle>
+        <i18n.Translate>Send {currency} to your account</i18n.Translate>
+      </SubTitle>
+
+      <WarningBox>
+        <i18n.Translate>
+          There is no account to make a deposit for currency {currency}
+        </i18n.Translate>
+      </WarningBox>
+
+      <Button onClick={onAddAccount.onClick} variant="contained">
+        <i18n.Translate>Add account</i18n.Translate>
+      </Button>
+    </Fragment>
+  );
+}
+
+export function ReadyView(state: State.Ready): VNode {
+  const { i18n } = useTranslationContext();
+
+  return (
+    <Fragment>
+      <SubTitle>
+        <i18n.Translate>Send {state.currency} to your account</i18n.Translate>
+      </SubTitle>
+      <section>
+        <div
+          style={{
+            display: "flex",
+            justifyContent: "space-between",
+            marginBottom: 16,
+          }}
+        >
+          <Input>
+            <SelectList
+              label={<i18n.Translate>Select account</i18n.Translate>}
+              list={state.account.list}
+              name="account"
+              value={state.account.value}
+              onChange={state.account.onChange}
+            />
+          </Input>
+          <Button
+            onClick={state.onAddAccount.onClick}
+            variant="text"
+            style={{ marginLeft: "auto" }}
+          >
+            <i18n.Translate>Add another account</i18n.Translate>
+          </Button>
+        </div>
+
+        {state.selectedAccount && (
+          <Fragment>
+            <p>
+              <AccountDetails account={state.selectedAccount} />
+            </p>
+            <InputWithLabel invalid={!!state.amount.error}>
+              <label>
+                <i18n.Translate>Amount</i18n.Translate>
+              </label>
+              <div>
+                <span>{state.currency}</span>
+                <input
+                  type="number"
+                  value={state.amount.value}
+                  onInput={(e) => state.amount.onInput(e.currentTarget.value)}
+                />
+              </div>
+              {state.amount.error && (
+                <ErrorText>{state.amount.error}</ErrorText>
+              )}
+            </InputWithLabel>
+
+            <InputWithLabel>
+              <label>
+                <i18n.Translate>Deposit fee</i18n.Translate>
+              </label>
+              <div>
+                <span>{state.currency}</span>
+                <input
+                  type="number"
+                  disabled
+                  value={Amounts.stringifyValue(state.totalFee)}
+                />
+              </div>
+            </InputWithLabel>
+
+            <InputWithLabel>
+              <label>
+                <i18n.Translate>Total deposit</i18n.Translate>
+              </label>
+              <div>
+                <span>{state.currency}</span>
+                <input
+                  type="number"
+                  disabled
+                  value={Amounts.stringifyValue(state.totalToDeposit)}
+                />
+              </div>
+            </InputWithLabel>
+          </Fragment>
+        )}
+      </section>
+      <footer>
+        <Button
+          variant="contained"
+          color="secondary"
+          onClick={state.cancelHandler.onClick}
+        >
+          <i18n.Translate>Cancel</i18n.Translate>
+        </Button>
+        {!state.depositHandler.onClick ? (
+          <Button variant="contained" disabled>
+            <i18n.Translate>Deposit</i18n.Translate>
+          </Button>
+        ) : (
+          <Button variant="contained" onClick={state.depositHandler.onClick}>
+            <i18n.Translate>
+              Deposit&nbsp;{Amounts.stringifyValue(state.totalToDeposit)}{" "}
+              {state.currency}
+            </i18n.Translate>
+          </Button>
+        )}
+      </footer>
+    </Fragment>
+  );
+}

packages/taler-wallet-webextension/src/wallet/EmptyComponentExample/index.ts

@@ -34,7 +34,7 @@ export namespace State {
   }
 
   export interface LoadingUriError {
-    status: "loading-uri";
+    status: "loading-error";
     error: HookError;
   }
 
@@ -49,7 +49,7 @@ export namespace State {
 
 const viewMapping: StateViewMap<State> = {
   loading: Loading,
-  "loading-uri": LoadingUriView,
+  "loading-error": LoadingUriView,
   ready: ReadyView,
 };
 

packages/taler-wallet-webextension/src/wallet/index.stories.tsx

@@ -21,7 +21,7 @@
 
 import * as a1 from "./Backup.stories.js";
 import * as a3 from "./CreateManualWithdraw.stories.js";
-import * as a4 from "./DepositPage.stories.js";
+import * as a4 from "./DepositPage/stories.js";
 import * as a5 from "./ExchangeAddConfirm.stories.js";
 import * as a6 from "./ExchangeAddSetUrl.stories.js";
 import * as a7 from "./History.stories.js";

packages/taler-wallet-webextension/src/wxApi.ts

@@ -24,12 +24,8 @@
 import {
   AcceptExchangeTosRequest,
   AcceptManualWithdrawalResult,
-  AcceptPeerPullPaymentRequest,
+  AcceptPeerPullPaymentRequest, AcceptPeerPullPaymentResponse, AcceptPeerPushPaymentRequest, AcceptPeerPushPaymentResponse, AcceptTipRequest, AcceptTipResponse, AcceptWithdrawalResponse,
-  AcceptPeerPushPaymentRequest,
+  AddExchangeRequest, AddKnownBankAccountsRequest, AmountString,
-  AcceptTipRequest,
-  AcceptWithdrawalResponse,
-  AddExchangeRequest,
-  AmountString,
   ApplyRefundResponse,
   BalancesResponse,
   CheckPeerPullPaymentRequest,
@@ -41,9 +37,7 @@ import {
   CoreApiResponse,
   CreateDepositGroupRequest,
   CreateDepositGroupResponse,
-  DeleteTransactionRequest,
+  DeleteTransactionRequest, DepositGroupFees, ExchangeFullDetails, ExchangesListResponse, ForgetKnownBankAccountsRequest, GetExchangeTosResult,
-  ExchangesListResponse,
-  GetExchangeTosResult,
   GetExchangeWithdrawalInfo,
   GetFeeForDepositRequest,
   GetWithdrawalDetailsForUriRequest,
@@ -53,8 +47,7 @@ import {
   InitiatePeerPushPaymentResponse,
   KnownBankAccounts,
   Logger,
-  NotificationType,
+  NotificationType, PaytoUri, PrepareDepositRequest,
-  PrepareDepositRequest,
   PrepareDepositResponse,
   PreparePayResult,
   PrepareRefundRequest,
@@ -62,17 +55,9 @@ import {
   PrepareTipRequest,
   PrepareTipResult,
   RetryTransactionRequest,
-  SetWalletDeviceIdRequest,
+  SetWalletDeviceIdRequest, stringifyPaytoUri, Transaction,
-  TransactionsResponse,
+  TransactionsResponse, WalletCoreVersion,
-  WalletDiagnostics,
+  WalletDiagnostics, WithdrawUriInfoResponse
-  WalletCoreVersion,
-  WithdrawUriInfoResponse,
-  ExchangeFullDetails,
-  Transaction,
-  AcceptTipResponse,
-  AcceptPeerPullPaymentResponse,
-  AcceptPeerPushPaymentResponse,
-  DepositGroupFees,
 } from "@gnu-taler/taler-util";
 import {
   AddBackupProviderRequest,
@@ -81,9 +66,9 @@ import {
   PendingOperationsResponse,
   RemoveBackupProviderRequest,
   TalerError,
-  WalletContractData,
+  WalletContractData
 } from "@gnu-taler/taler-wallet-core";
-import { platform, MessageFromBackend } from "./platform/api.js";
+import { MessageFromBackend, platform } from "./platform/api.js";
 
 /**
  *
@@ -275,6 +260,23 @@ export function listKnownBankAccounts(
   return callBackend("listKnownBankAccounts", { currency });
 }
 
+export function addKnownBankAccounts(
+  payto: PaytoUri,
+  currency: string,
+  alias: string,
+): Promise<void> {
+  return callBackend("addKnownBankAccounts", {
+    payto: stringifyPaytoUri(payto),
+    currency,
+    alias
+  } as AddKnownBankAccountsRequest);
+}
+export function forgetKnownBankAccounts(
+  payto: string,
+): Promise<void> {
+  return callBackend("forgetKnownBankAccounts", { payto } as ForgetKnownBankAccountsRequest);
+}
+
 /**
  * Get information about the current state of wallet backups.
  */