@ledgerhq/live-common 25.0.0-next.2 → 25.0.0-next.5

package/src/currencies/react.ts

@@ -0,0 +1,16 @@
+import { useMemo } from "react";
+import { listAndFilterCurrencies } from "./helpers";
+import { Currency } from "../types";
+import { CurrencyFilters } from "../platform/filters";
+
+export function useFilteredCurrencies({
+  includeTokens,
+  currencies,
+}: CurrencyFilters): Currency[] {
+  return useMemo(() => {
+    return listAndFilterCurrencies({
+      includeTokens,
+      currencies,
+    });
+  }, [currencies, includeTokens]);
+}

package/src/families/cardano/__snapshots__/bridge.integration.test.ts.snap

@@ -820,7 +820,7 @@ Array [
     "operationsCount": 4,
     "pendingOperations": Array [],
     "seedIdentifier": "21a6a622d47969ef0b2b89ef7c2e8428f955bae3e52f211e651ccffd",
-    "spendableBalance": "1021211139",
+    "spendableBalance": "1019831859",
     "starred": false,
     "subAccounts": Array [],
     "swapHistory": Array [],
@@ -829,6 +829,20 @@ Array [
     "used": true,
     "xpub": "a902bc61a79256e1d5858d2ba49cab7011a26ad49580daace7412e255e818b1c1eba2defa321ff2937deba397f639f5bbabb0f0064516301fa4d08663c83f5b2",
   },
+  Object {
+    "approvals": undefined,
+    "balance": "5000000000",
+    "compoundBalance": undefined,
+    "id": "js:2:cardano_testnet:a902bc61a79256e1d5858d2ba49cab7011a26ad49580daace7412e255e818b1c1eba2defa321ff2937deba397f639f5bbabb0f0064516301fa4d08663c83f5b2:cardano+cardano_testnet%2Fnative%2F581684861359b6d4d00594073a9aa4223c6fc24d24da05e1b34fb865544553545f544f4b454e",
+    "operationsCount": 1,
+    "parentId": "js:2:cardano_testnet:a902bc61a79256e1d5858d2ba49cab7011a26ad49580daace7412e255e818b1c1eba2defa321ff2937deba397f639f5bbabb0f0064516301fa4d08663c83f5b2:cardano",
+    "pendingOperations": Array [],
+    "spendableBalance": "5000000000",
+    "starred": false,
+    "swapHistory": Array [],
+    "tokenId": "cardano_testnet/native/581684861359b6d4d00594073a9aa4223c6fc24d24da05e1b34fb865544553545f544f4b454e",
+    "type": "TokenAccountRaw",
+  },
   Object {
     "balance": "0",
     "cardanoResources": Object {
@@ -1662,6 +1676,32 @@ Array [
       "value": "1000000000",
     },
   ],
+  Array [
+    Object {
+      "accountId": "js:2:cardano_testnet:a902bc61a79256e1d5858d2ba49cab7011a26ad49580daace7412e255e818b1c1eba2defa321ff2937deba397f639f5bbabb0f0064516301fa4d08663c83f5b2:cardano+cardano_testnet%2Fnative%2F581684861359b6d4d00594073a9aa4223c6fc24d24da05e1b34fb865544553545f544f4b454e",
+      "blockHash": undefined,
+      "blockHeight": 3568569,
+      "contract": undefined,
+      "extra": Object {
+        "memo": undefined,
+      },
+      "fee": "215441",
+      "hash": "2c8106d296fe10a8e8bf37a0202df048265dc17f2aa6c184bd132960fbb18bae",
+      "id": "js:2:cardano_testnet:a902bc61a79256e1d5858d2ba49cab7011a26ad49580daace7412e255e818b1c1eba2defa321ff2937deba397f639f5bbabb0f0064516301fa4d08663c83f5b2:cardano+cardano_testnet%2Fnative%2F581684861359b6d4d00594073a9aa4223c6fc24d24da05e1b34fb865544553545f544f4b454e-2c8106d296fe10a8e8bf37a0202df048265dc17f2aa6c184bd132960fbb18bae-IN",
+      "operator": undefined,
+      "recipients": Array [
+        "addr_test1qqs6df3z63uknmct9wy77lpwss50j4d6u0jj7gg7v5wvll23krjmh2m86v92yu0my7rqydx3h5erqwty82kwgjuc4elsr6hdhy",
+        "addr_test1qzpdaf0vr0gdsjncllv7cejmpwmwu6m86c3epd8uadv99ktra2x9gp8eakdwsrv4k42ys4ajqy0r7f4k8hwrhcdt6sks7k7alz",
+      ],
+      "senders": Array [
+        "addr_test1qr4qq9s7cf28zse9t4c46l3utj6ajphx654l8ddcv6rhketra2x9gp8eakdwsrv4k42ys4ajqy0r7f4k8hwrhcdt6sksjh37nz",
+      ],
+      "standard": undefined,
+      "tokenId": undefined,
+      "type": "IN",
+      "value": "5000000000",
+    },
+  ],
   Array [],
 ]
 `;

package/src/families/cardano/bridge.integration.test.ts

@@ -1,3 +1,4 @@
+import { NotEnoughBalance } from "@ledgerhq/errors";
 import "../../__tests__/test-helpers/setup";
 import { testBridge } from "../../__tests__/test-helpers/bridge";
 import BigNumber from "bignumber.js";
@@ -33,6 +34,43 @@ const dataset: DatasetTest<Transaction> = {
                 },
               },
             },
+            {
+              name: "token amount more than balance",
+              transaction: fromTransactionRaw({
+                family: "cardano",
+                recipient:
+                  "addr_test1qpl90kc2jl5kr9tev0s7vays9yhwcdnq8nlylyk4dqsdq3g466elxnxwrzwq72pvp5akenj30t5s9et7frfvrxxx8xcsxrzs87",
+                amount: "5000000001",
+                subAccountId:
+                  "js:2:cardano_testnet:a902bc61a79256e1d5858d2ba49cab7011a26ad49580daace7412e255e818b1c1eba2defa321ff2937deba397f639f5bbabb0f0064516301fa4d08663c83f5b2:+cardano_testnet%2Fnative%2F581684861359b6d4d00594073a9aa4223c6fc24d24da05e1b34fb865544553545f544f4b454e",
+                mode: "send",
+              }),
+              expectedStatus: {
+                amount: new BigNumber("5000000001"),
+                errors: {
+                  amount: new NotEnoughBalance(),
+                },
+              },
+            },
+            {
+              name: "send max token",
+              transaction: fromTransactionRaw({
+                family: "cardano",
+                recipient:
+                  "addr_test1qpl90kc2jl5kr9tev0s7vays9yhwcdnq8nlylyk4dqsdq3g466elxnxwrzwq72pvp5akenj30t5s9et7frfvrxxx8xcsxrzs87",
+                amount: "0",
+                subAccountId:
+                  "js:2:cardano_testnet:a902bc61a79256e1d5858d2ba49cab7011a26ad49580daace7412e255e818b1c1eba2defa321ff2937deba397f639f5bbabb0f0064516301fa4d08663c83f5b2:+cardano_testnet%2Fnative%2F581684861359b6d4d00594073a9aa4223c6fc24d24da05e1b34fb865544553545f544f4b454e",
+                mode: "send",
+                useAllAmount: true,
+              }),
+              expectedStatus: {
+                amount: new BigNumber("5000000000"),
+                totalSpent: new BigNumber("5000000000"),
+                errors: {},
+                warnings: {},
+              },
+            },
           ],
         },
       ],

package/src/families/cardano/buildSubAccounts.ts

@@ -83,6 +83,10 @@ const mapTxToTokenAccountOperation = ({
 
       const tokenOperationType = token.amount.lt(0) ? "OUT" : "IN";
       const memo = getMemoFromTx(tx);
+      const extra = {};
+      if (memo) {
+        extra["memo"] = memo;
+      }
       const operation: Operation = {
         accountId: tokenAccountId,
         id: encodeOperationId(tokenAccountId, tx.hash, tokenOperationType),
@@ -102,9 +106,7 @@ const mapTxToTokenAccountOperation = ({
         ),
         blockHeight: tx.blockHeight,
         date: new Date(tx.timestamp),
-        extra: {
-          memo,
-        },
+        extra: extra,
         blockHash: undefined,
       };
       operations.push(operation);

package/src/families/cardano/deviceTransactionConfig.ts

@@ -0,0 +1,109 @@
+import BigNumber from "bignumber.js";
+import { getAccountUnit, getMainAccount } from "../../account";
+import { formatCurrencyUnit } from "../../currencies";
+import { DeviceTransactionField } from "../../transaction";
+import { Account, AccountLike, TransactionStatus } from "../../types";
+import { decodeTokenAssetId, decodeTokenCurrencyId } from "./buildSubAccounts";
+import { CardanoResources, Transaction } from "./types";
+import { utils as TyphonUtils } from "@stricahq/typhonjs";
+import { decodeTokenName } from "./logic";
+
+function getDeviceTransactionConfig({
+  account,
+  transaction,
+  parentAccount,
+}: {
+  account: AccountLike;
+  parentAccount: Account | null | undefined;
+  transaction: Transaction;
+  status: TransactionStatus;
+}): Array<DeviceTransactionField> {
+  const { mode } = transaction;
+  const fields: DeviceTransactionField[] = [];
+  const mainAccount = getMainAccount(account, parentAccount);
+
+  if (mode === "send") {
+    if (account.type === "TokenAccount") {
+      const cardanoResources = mainAccount.cardanoResources as CardanoResources;
+
+      const { assetId } = decodeTokenCurrencyId(account.token.id);
+      const { policyId, assetName } = decodeTokenAssetId(assetId);
+      const transactionAmount = transaction.useAllAmount
+        ? account.balance
+        : transaction.amount;
+      const { fees } = transaction;
+
+      const tokensToSend = [
+        {
+          policyId,
+          assetName,
+          amount: transactionAmount,
+        },
+      ];
+
+      const requiredMinAdaForTokens = TyphonUtils.calculateMinUtxoAmount(
+        tokensToSend,
+        new BigNumber(cardanoResources.protocolParams.lovelacePerUtxoWord)
+      );
+      fields.push({
+        type: "text",
+        label: "ADA",
+        value: formatCurrencyUnit(
+          getAccountUnit(mainAccount),
+          requiredMinAdaForTokens,
+          { showCode: true, disableRounding: true }
+        ),
+      });
+      fields.push({
+        type: "text",
+        label: "Token Name",
+        value: decodeTokenName(assetName),
+      });
+      fields.push({
+        type: "text",
+        label: "Amount",
+        value: formatCurrencyUnit(getAccountUnit(account), transactionAmount, {
+          showCode: true,
+          disableRounding: true,
+        }),
+      });
+      if (fees) {
+        fields.push({
+          type: "text",
+          label: "Fees",
+          value: formatCurrencyUnit(getAccountUnit(mainAccount), fees, {
+            showCode: true,
+            disableRounding: true,
+          }),
+        });
+      }
+    } else if (account.type === "Account") {
+      const { fees } = transaction;
+      const transactionAmount = transaction.useAllAmount
+        ? account.balance
+        : transaction.amount;
+      fields.push({
+        type: "text",
+        label: "Amount",
+        value: formatCurrencyUnit(getAccountUnit(account), transactionAmount, {
+          showCode: true,
+          disableRounding: true,
+        }),
+      });
+      if (fees) {
+        fields.push({
+          type: "text",
+          label: "Fees",
+          value: formatCurrencyUnit(getAccountUnit(account), fees, {
+            showCode: true,
+            disableRounding: true,
+          }),
+        });
+      }
+    }
+  }
+
+  return fields;
+}
+
+export default getDeviceTransactionConfig;

package/src/families/cardano/errors.ts

@@ -6,3 +6,10 @@ import { createCustomErrorClass } from "@ledgerhq/errors";
 export const CardanoMinAmountError = createCustomErrorClass(
   "CardanoMinAmountError"
 );
+
+/**
+ * Cardano error thrown when not enough funds to perform transaction
+ */
+export const CardanoNotEnoughFunds = createCustomErrorClass(
+  "CardanoNotEnoughFunds"
+);

package/src/families/cardano/js-estimateMaxSpendable.ts

@@ -30,10 +30,13 @@ const estimateMaxSpendable = async ({
     return account.balance;
   }
 
+  const dummyRecipient =
+    "addr_test1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq0uk53y";
   const a = getMainAccount(account, parentAccount);
-  const t = {
+  const t: Transaction = {
     ...createTransaction(),
     ...transaction,
+    recipient: dummyRecipient,
     // amount field will not be used to build a transaction when useAllAmount is true
     amount: new BigNumber(0),
     useAllAmount: true,

package/src/families/cardano/js-getTransactionStatus.ts

@@ -1,6 +1,5 @@
 import { BigNumber } from "bignumber.js";
 import {
-  NotEnoughBalance,
   RecipientRequired,
   FeeNotLoaded,
   InvalidAddress,
@@ -10,7 +9,7 @@ import type { Account, TransactionStatus } from "../../types";
 import type { CardanoResources, Token, Transaction } from "./types";
 import { isValidAddress } from "./logic";
 import { utils as TyphonUtils } from "@stricahq/typhonjs";
-import { CardanoMinAmountError } from "./errors";
+import { CardanoMinAmountError, CardanoNotEnoughFunds } from "./errors";
 import { AccountAwaitingSendPendingOperations } from "../../errors";
 import { getNetworkParameters } from "./networks";
 import { decodeTokenAssetId, decodeTokenCurrencyId } from "./buildSubAccounts";
@@ -86,17 +85,18 @@ const getTransactionStatus = async (
 
   if (!amount.gt(0)) {
     errors.amount = useAllAmount
-      ? new NotEnoughBalance()
+      ? new CardanoNotEnoughFunds()
       : new AmountRequired();
   } else if (!t.subAccountId && amount.lt(minTransactionAmount)) {
     errors.amount = new CardanoMinAmountError("", {
       amount: minTransactionAmount.div(1e6).toString(),
     });
   } else if (
-    (tokenAccount && totalSpent.gt(tokenAccount.balance)) ||
-    totalSpent.gt(a.balance)
+    tokenAccount
+      ? totalSpent.gt(tokenAccount.balance)
+      : totalSpent.gt(a.balance)
   ) {
-    errors.amount = new NotEnoughBalance();
+    errors.amount = new CardanoNotEnoughFunds();
   } else {
     try {
       await buildTransaction(a, t);
@@ -105,7 +105,7 @@ const getTransactionStatus = async (
         e.message.toLowerCase() === "not enough ada" ||
         e.message.toLowerCase() === "not enough tokens"
       ) {
-        errors.amount = new NotEnoughBalance();
+        errors.amount = new CardanoNotEnoughFunds();
       }
       throw e;
     }

package/src/families/cardano/js-signOperation.ts

@@ -83,11 +83,18 @@ const buildOptimisticOperation = (
     const memoMetadata = auxiliaryData.metadata.find(
       (m) => m.label === MEMO_LABEL
     );
-    if (memoMetadata && Array.isArray(memoMetadata.data)) {
-      memo = memoMetadata.data.join(", ");
+    if (memoMetadata && memoMetadata.data instanceof Map) {
+      const msg = memoMetadata.data.get("msg");
+      if (Array.isArray(msg) && msg.length) {
+        memo = msg.join(", ");
+      }
     }
   }
 
+  const extra = {};
+  if (memo) {
+    extra["memo"] = memo;
+  }
   const op: Operation = {
     id: encodeOperationId(account.id, transactionHash, opType),
     hash: transactionHash,
@@ -100,9 +107,7 @@ const buildOptimisticOperation = (
     recipients: transaction.getOutputs().map((o) => o.address.getBech32()),
     accountId: account.id,
     date: new Date(),
-    extra: {
-      memo,
-    },
+    extra: extra,
   };
 
   const tokenAccount = t.subAccountId

package/src/families/cardano/js-synchronisation.ts

@@ -21,6 +21,7 @@ import {
   getMemoFromTx,
   getOperationType,
   isHexString,
+  mergeTokens,
 } from "./logic";
 import { encodeOperationId } from "../../operation";
 import { getNetworkParameters } from "./networks";
@@ -28,6 +29,9 @@ import { getNetworkInfo } from "./api/getNetworkInfo";
 import uniqBy from "lodash/uniqBy";
 import postSyncPatch from "./postSyncPatch";
 import { getTransactions } from "./api/getTransactions";
+import { buildSubAccounts } from "./buildSubAccounts";
+import { calculateMinUtxoAmount } from "@stricahq/typhonjs/dist/utils/utils";
+import { listTokensForCryptoCurrency } from "../../currencies";
 
 function mapTxToAccountOperation(
   tx: APITransaction,
@@ -43,6 +47,10 @@ function mapTxToAccountOperation(
 
   const subOperations = inferSubOperations(tx.hash, subAccounts);
   const memo = getMemoFromTx(tx);
+  const extra = {};
+  if (memo) {
+    extra["memo"] = memo;
+  }
 
   return {
     accountId,
@@ -64,14 +72,12 @@ function mapTxToAccountOperation(
     subOperations,
     blockHeight: tx.blockHeight,
     date: new Date(tx.timestamp),
-    extra: {
-      memo,
-    },
+    extra: extra,
     blockHash: undefined,
   };
 }
 
-function syncUtxos(
+function prepareUtxos(
   newTransactions: Array<APITransaction>,
   stableUtxos: Array<CardanoOutput>,
   accountCredentialsMap: Record<string, PaymentCredential>
@@ -116,7 +122,10 @@ function syncUtxos(
   return utxos;
 }
 
-export const getAccountShape: GetAccountShape = async (info) => {
+export const getAccountShape: GetAccountShape = async (
+  info,
+  { blacklistedTokenIds }
+) => {
   const {
     transport,
     currency,
@@ -152,16 +161,27 @@ export const getAccountShape: GetAccountShape = async (info) => {
     derivationMode,
   });
 
+  // when new tokens are added / blacklist changes, we need to sync again because we need to go through all operations again
+  const syncHash =
+    JSON.stringify(blacklistedTokenIds || []) +
+    "_" +
+    listTokensForCryptoCurrency(currency, {
+      withDelisted: true,
+    }).length;
+  const outdatedSyncHash = initialAccount?.syncHash !== syncHash;
+
   const requiredConfirmations = 90;
 
   const oldOperations = initialAccount?.operations || [];
   const lastBlockHeight = oldOperations.length
     ? (oldOperations[0].blockHeight || 0) + 1
     : 0;
-  const syncFromBlockHeight =
-    lastBlockHeight > requiredConfirmations
-      ? lastBlockHeight - requiredConfirmations
-      : 0;
+
+  const syncFromBlockHeight = outdatedSyncHash
+    ? 0
+    : lastBlockHeight > requiredConfirmations
+    ? lastBlockHeight - requiredConfirmations
+    : 0;
 
   const {
     transactions: newTransactions,
@@ -195,21 +215,24 @@ export const getAccountShape: GetAccountShape = async (info) => {
     (u) => stableOperationsByIds[u.hash]
   );
 
-  const utxos = syncUtxos(newTransactions, stableUtxos, accountCredentialsMap);
+  const utxos = prepareUtxos(
+    newTransactions,
+    stableUtxos,
+    accountCredentialsMap
+  );
   const accountBalance = utxos.reduce(
     (total, u) => total.plus(u.amount),
     new BigNumber(0)
   );
-  // const tokenBalance = mergeTokens(utxos.map((u) => u.tokens).flat());
-  // const subAccounts = buildSubAccounts({
-  //   initialAccount,
-  //   parentAccountId: accountId,
-  //   parentCurrency: currency,
-  //   newTransactions,
-  //   tokens: tokenBalance,
-  //   accountCredentialsMap,
-  // });
-  const subAccounts = [];
+  const tokenBalance = mergeTokens(utxos.map((u) => u.tokens).flat());
+  const subAccounts = buildSubAccounts({
+    initialAccount,
+    parentAccountId: accountId,
+    parentCurrency: currency,
+    newTransactions,
+    tokens: tokenBalance,
+    accountCredentialsMap,
+  });
 
   const newOperations = newTransactions.map((t) =>
     mapTxToAccountOperation(t, accountId, accountCredentialsMap, subAccounts)
@@ -233,13 +256,21 @@ export const getAccountShape: GetAccountShape = async (info) => {
       }).getBech32(),
     }));
   const cardanoNetworkInfo = await getNetworkInfo(initialAccount, currency);
+  const minAdaBalanceForTokens = tokenBalance.length
+    ? calculateMinUtxoAmount(
+        tokenBalance,
+        new BigNumber(cardanoNetworkInfo.protocolParams.lovelacePerUtxoWord),
+        false
+      )
+    : new BigNumber(0);
 
   return {
     id: accountId,
     xpub,
     balance: accountBalance,
-    spendableBalance: accountBalance,
+    spendableBalance: accountBalance.minus(minAdaBalanceForTokens),
     operations: operations,
+    syncHash,
     subAccounts,
     freshAddresses,
     freshAddress: freshAddresses[0].address,

package/src/families/cardano/js-transaction.ts

@@ -47,7 +47,7 @@ export const prepareTransaction = async (
   try {
     transaction = await buildTransaction(a, t);
   } catch (error) {
-    return { ...t, fees: new BigNumber(0), amount: new BigNumber(0) };
+    return { ...t, fees: new BigNumber(0), amount: t.amount };
   }
 
   const transactionFees = transaction.getFee();

package/src/families/cardano/logic.ts

@@ -448,3 +448,13 @@ export function isHexString(value: string): boolean {
   const regExp = /^[0-9a-fA-F]+$/;
   return regExp.test(value);
 }
+
+export function decodeTokenName(assetName: string): string {
+  if (assetName.length > 0) {
+    const bytes = [...Buffer.from(assetName, "hex")];
+    if (bytes.filter((byte) => byte <= 32 || byte >= 127).length === 0) {
+      return String.fromCharCode(...bytes);
+    }
+  }
+  return assetName;
+}

package/src/families/cardano/specs.ts

@@ -9,10 +9,15 @@ import invariant from "invariant";
 import { utils as TyphonUtils } from "@stricahq/typhonjs";
 import { mergeTokens } from "./logic";
 import { parseCurrencyUnit } from "../../currencies";
+import { SubAccount } from "../../types";
 
 const currency = getCryptoCurrencyById("cardano");
 const minBalanceRequired = parseCurrencyUnit(currency.units[0], "2.2");
 const minBalanceRequiredForMaxSend = parseCurrencyUnit(currency.units[0], "1");
+const minSpendableRequiredForTokenTx = parseCurrencyUnit(
+  currency.units[0],
+  "3"
+);
 
 const cardano: AppSpec<Transaction> = {
   name: "cardano",
@@ -34,7 +39,12 @@ const cardano: AppSpec<Transaction> = {
 
         const updates = [
           { recipient },
-          { amount: new BigNumber(account.balance.dividedBy(2)).dp(0, 1) },
+          {
+            amount: new BigNumber(account.balance.dividedBy(2)).dp(
+              0,
+              BigNumber.ROUND_CEIL
+            ),
+          },
           { memo: "LedgerLiveBot" },
         ];
 
@@ -90,6 +100,48 @@ const cardano: AppSpec<Transaction> = {
         );
       },
     },
+    {
+      name: "move ~10% token",
+      maxRun: 1,
+      transaction: ({ account, siblings, bridge, maxSpendable }) => {
+        invariant(
+          maxSpendable.gte(minSpendableRequiredForTokenTx),
+          "balance is too low"
+        );
+        const sibling = pickSiblings(siblings, 3);
+        const recipient = sibling.freshAddress;
+        const transaction = bridge.createTransaction(account);
+
+        const subAccount = account.subAccounts?.find((subAccount) =>
+          subAccount.balance.gt(1)
+        ) as SubAccount;
+        invariant(subAccount, "No token account with balance");
+
+        const updates = [
+          { subAccountId: subAccount.id },
+          { recipient },
+          {
+            amount: new BigNumber(subAccount.balance.dividedBy(10)).dp(
+              0,
+              BigNumber.ROUND_CEIL
+            ),
+          },
+        ];
+
+        return {
+          transaction,
+          updates,
+        };
+      },
+      test: ({ operation, transaction }): void => {
+        expect(operation.subOperations).toBeTruthy();
+        expect(operation.subOperations?.length).toEqual(1);
+
+        const subOperation =
+          operation.subOperations && operation.subOperations[0];
+        expect(subOperation?.value).toEqual(transaction.amount);
+      },
+    },
   ],
 };
 

package/src/families/cardano/speculos-deviceActions.ts

@@ -39,6 +39,21 @@ const acceptTransaction: DeviceAction<Transaction, any> = deviceActionFlow({
       expectedValue: ({ account, status }) =>
         expectedValue(account.unit, status.amount),
     },
+    {
+      title: "Asset fingerprint",
+      button: "LRlr",
+    },
+    {
+      title: "Token amount",
+      button: "LRlr",
+    },
+    {
+      title: "Confirm",
+    },
+    {
+      title: "output?",
+      button: "Rr",
+    },
     {
       title: "Transaction fee",
       button: "LRlr",

package/src/families/hedera/api/mirror.ts

@@ -136,7 +136,7 @@ export async function getOperationsForAccount(
       // Set a value just so that it's considered confirmed according to isConfirmedOperation
       blockHeight: 5,
       blockHash: null,
-      extra: { consensus_timestamp },
+      extra: {},
       fee,
       hash,
       recipients,

package/src/families/hedera/api/network.ts

@@ -23,6 +23,7 @@ export async function buildUnsignedTransaction({
   return new hedera.TransferTransaction()
     .setNodeAccountIds([new AccountId(3)])
     .setTransactionId(hedera.TransactionId.generate(accountId))
+    .setTransactionMemo(transaction.memo ?? "")
     .addHbarTransfer(accountId, hbarAmount.negated())
     .addHbarTransfer(transaction.recipient, hbarAmount)
     .freeze();

package/src/families/hedera/deviceTransactionConfig.ts

@@ -39,6 +39,14 @@ function getDeviceTransactionConfig({
     });
   }
 
+  if (transaction.memo) {
+    fields.push({
+      type: "text",
+      label: "Memo",
+      value: transaction.memo,
+    });
+  }
+
   return fields;
 }