@ledgerhq/live-common 34.45.0-nightly.1 → 34.45.0-nightly.2

package/src/bridge/generic-alpaca/alpaca/network/network-alpaca.ts

@@ -1,5 +1,4 @@
-import {
-  Account,
+import type {
   Balance,
   Block,
   BlockInfo,
@@ -7,10 +6,9 @@ import {
   FeeEstimation,
   Pagination,
   TransactionIntent,
-  Transaction,
   TransactionValidation,
-  AccountInfo,
   Api,
+  AssetInfo,
   Cursor,
   Page,
   Stake,
@@ -18,7 +16,7 @@ import {
 } from "@ledgerhq/coin-framework/api/index";
 import network from "@ledgerhq/live-network";
 
-function adaptOp(backendOp: any): Operation<any> {
+function adaptOp<T extends AssetInfo>(backendOp: Operation<T>): Operation<T> {
   const { date } = backendOp.tx;
   const newDate = new Date(date);
 
@@ -31,7 +29,7 @@ function adaptOp(backendOp: any): Operation<any> {
 
 const ALPACA_URL = "http://0.0.0.0:3000";
 
-const buildBroadcast = (networkFamily: string) =>
+const buildBroadcast = networkFamily =>
   async function broadcast(signedOperation: string): Promise<string> {
     const { data } = await network<
       {
@@ -50,7 +48,7 @@ const buildBroadcast = (networkFamily: string) =>
     return data.transactionIdentifier;
   };
 
-const buildCombine = (networkFamily: string) =>
+const buildCombine = networkFamily =>
   async function combine(tx: string, signature: string, pubKey?: string): Promise<string> {
     const { data } = await network<
       {
@@ -69,7 +67,7 @@ const buildCombine = (networkFamily: string) =>
     return data.signedTransaction;
   };
 
-const buildEstimateFees = (networkFamily: string) =>
+const buildEstimateFees = networkFamily =>
   async function estimateFees(intent: TransactionIntent<any>): Promise<FeeEstimation> {
     const { data } = await network<{ fee: string }, unknown>({
       method: "POST",
@@ -86,11 +84,8 @@ const buildEstimateFees = (networkFamily: string) =>
     };
   };
 
-const buildValidateIntent = (networkFamily: string) =>
-  async function validateIntent(
-    account: Account,
-    transaction: Transaction,
-  ): Promise<TransactionValidation> {
+const buildValidateIntent = networkFamily =>
+  async function validateIntent(transaction: TransactionIntent): Promise<TransactionValidation> {
     const { data } = await network<
       {
         errors: Record<string, Error>;
@@ -105,7 +100,6 @@ const buildValidateIntent = (networkFamily: string) =>
       url: `${ALPACA_URL}/${networkFamily}/transaction/validate`,
       data: {
         transaction,
-        account,
       },
     });
     return data;
@@ -122,13 +116,14 @@ const buildGetBalance = (networkFamily: string) =>
       {
         value: BigInt(data.value),
         asset: data.asset,
+        locked: BigInt(data?.locked ?? "0"),
       },
     ];
   };
 
-const buildGetAccountInfo = (networkFamily: string) =>
-  async function getBalance(address: string): Promise<AccountInfo> {
-    const { data } = await network<AccountInfo, unknown>({
+const buildGetSequence = (networkFamily: string) =>
+  async function getSequence(address: string): Promise<number> {
+    const { data } = await network<number, unknown>({
       method: "GET",
       url: `${ALPACA_URL}/${networkFamily}/account/${address}/info`,
     });
@@ -136,10 +131,10 @@ const buildGetAccountInfo = (networkFamily: string) =>
     return data;
   };
 
-const buildListOperations = (networkFamily: string) =>
+const buildListOperations = networkFamily =>
   async function listOperations(
     address: string,
-    pagination: Pagination,
+    pagination: Pagination = { minHeight: 0 },
   ): Promise<[Operation<any>[], string]> {
     const { data } = await network<{ operations: Operation<any>[] }, unknown>({
       method: "GET",
@@ -151,7 +146,7 @@ const buildListOperations = (networkFamily: string) =>
     return [data.operations.map(op => adaptOp(op)), ""];
   };
 
-const buildLastBlock = (networkFamily: string) =>
+const buildLastBlock = networkFamily =>
   async function lastBlock(): Promise<BlockInfo> {
     const { data } = await network<any, unknown>({
       method: "GET",
@@ -164,7 +159,7 @@ const buildLastBlock = (networkFamily: string) =>
     };
   };
 
-const buildCraftTransaction = (networkFamily: string) =>
+const buildCraftTransaction = networkFamily =>
   async function craftTransaction(intent: TransactionIntent<any>): Promise<string> {
     const { data } = await network<any, unknown>({
       method: "POST",
@@ -186,7 +181,7 @@ export const getNetworkAlpacaApi = (networkFamily: string) =>
     validateIntent: buildValidateIntent(networkFamily),
     estimateFees: buildEstimateFees(networkFamily),
     getBalance: buildGetBalance(networkFamily),
-    getAccountInfo: buildGetAccountInfo(networkFamily),
+    getSequence: buildGetSequence(networkFamily),
     listOperations: buildListOperations(networkFamily),
     lastBlock: buildLastBlock(networkFamily),
     craftTransaction: buildCraftTransaction(networkFamily),

package/src/bridge/generic-alpaca/broadcast.ts

@@ -2,10 +2,7 @@ import { AccountBridge, TransactionCommon } from "@ledgerhq/types-live";
 import { patchOperationWithHash } from "../../operation";
 import { getAlpacaApi } from "./alpaca";
 
-export const genericBroadcast: (
-  network: string,
-  kind: "local" | "remote",
-) => AccountBridge<TransactionCommon>["broadcast"] =
+export const genericBroadcast: (network, kind) => AccountBridge<TransactionCommon>["broadcast"] =
   (network, kind) =>
   async ({ signedOperation: { signature, operation } }) => {
     const hash = await getAlpacaApi(network, kind).broadcast(signature);

package/src/bridge/generic-alpaca/buildSubAccounts.ts

@@ -0,0 +1,110 @@
+import BigNumber from "bignumber.js";
+import { emptyHistoryCache } from "@ledgerhq/coin-framework/account/index";
+import type { CryptoCurrency, TokenCurrency } from "@ledgerhq/types-cryptoassets";
+import type { Operation, SyncConfig, TokenAccount } from "@ledgerhq/types-live";
+import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+import { listTokensForCryptoCurrency } from "@ledgerhq/cryptoassets";
+import { AssetInfo, Balance } from "@ledgerhq/coin-framework/api/types";
+import { findTokenById } from "@ledgerhq/cryptoassets/tokens";
+
+export interface OperationCommon extends Operation {
+  extra: Record<string, any>;
+}
+
+export const getAssetIdFromTokenId = (tokenId: string): string => tokenId.split("/")[2];
+
+export const getAssetIdFromAsset = (asset: AssetInfo) =>
+  asset.type !== "native" && "assetReference" in asset && "assetOwner" in asset
+    ? `${asset.assetReference}:${asset.assetOwner}`
+    : "";
+
+function buildTokenAccount({
+  parentAccountId,
+  assetBalance,
+  token,
+  operations,
+}: {
+  parentAccountId: string;
+  assetBalance: Balance;
+  token: TokenCurrency;
+  operations: OperationCommon[];
+}): TokenAccount {
+  const assetId = getAssetIdFromTokenId(token.id);
+  const id = `${parentAccountId}+${assetId}`;
+  const balance = new BigNumber(assetBalance.value.toString() || "0");
+
+  // TODO: recheck this logic
+  const spendableBalance = new BigNumber(assetBalance.value.toString()).minus(
+    new BigNumber(assetBalance.locked?.toString() || "0"),
+  );
+
+  const tokenOperations = operations.map(op => ({
+    ...op,
+    id: encodeOperationId(id, op.hash, op.extra?.ledgerOpType),
+    accountId: id,
+    type: op.extra?.ledgerOpType,
+    value: op.extra?.assetAmount ? new BigNumber(op.extra?.assetAmount) : op.value,
+  }));
+
+  return {
+    type: "TokenAccount",
+    id,
+    parentId: parentAccountId,
+    token,
+    operationsCount: operations.length,
+    operations: tokenOperations,
+    pendingOperations: [],
+    balance,
+    spendableBalance: spendableBalance,
+    swapHistory: [],
+    creationDate: operations.length > 0 ? operations[operations.length - 1].date : new Date(),
+    balanceHistoryCache: emptyHistoryCache, // calculated in the jsHelpers
+  };
+}
+
+export function buildSubAccounts({
+  currency,
+  accountId,
+  assetsBalance,
+  syncConfig,
+  operations,
+}: {
+  currency: CryptoCurrency;
+  accountId: string;
+  assetsBalance: Balance[];
+  syncConfig: SyncConfig;
+  operations: OperationCommon[];
+}): TokenAccount[] | undefined {
+  const { blacklistedTokenIds = [] } = syncConfig;
+  const allTokens = listTokensForCryptoCurrency(currency);
+
+  if (allTokens.length === 0 || assetsBalance.length === 0) {
+    return undefined;
+  }
+  const tokenAccounts: TokenAccount[] = [];
+  assetsBalance
+    .filter(b => b.asset.type !== "native") // NOTE: this could be removed, keeping here while fixing things up
+    .map(balance => {
+      const token = findToken(currency, balance);
+      // NOTE: for future tokens, will need to check over currencyName/standard(erc20,trc10,trc20, etc)/id
+      if (token && !blacklistedTokenIds.includes(token.id)) {
+        tokenAccounts.push(
+          buildTokenAccount({
+            parentAccountId: accountId,
+            assetBalance: balance,
+            token,
+            operations: operations.filter(
+              op =>
+                op.extra.assetReference === balance.asset?.["assetReference"] &&
+                op.extra.assetOwner === balance.asset?.["assetOwner"], // NOTE: we could narrow type
+            ),
+          }),
+        );
+      }
+    });
+  return tokenAccounts;
+}
+
+export function findToken(currency: CryptoCurrency, balance: Balance): TokenCurrency | undefined {
+  return findTokenById(`${currency.family}/asset/${getAssetIdFromAsset(balance.asset)}`);
+}

package/src/bridge/generic-alpaca/createTransaction.ts

@@ -1,27 +1,57 @@
-import { Account, TransactionCommon } from "@ledgerhq/types-live";
+import { Account, TokenAccount, TransactionCommon } from "@ledgerhq/types-live";
 import BigNumber from "bignumber.js";
 import type { Unit } from "@ledgerhq/types-cryptoassets";
 
+export enum NetworkCongestionLevel {
+  LOW = "LOW",
+  MEDIUM = "MEDIUM",
+  HIGH = "HIGH",
+}
+
 export type NetworkInfo = {
-  family: "xrp";
-  serverFee: BigNumber;
-  baseReserve: BigNumber;
+  fees: BigNumber;
 };
 
-export function createTransaction(account: Account): TransactionCommon & {
+export function createTransaction(account: Account | TokenAccount): TransactionCommon & {
   family: string;
-  fee: BigNumber | null | undefined;
-  networkInfo: NetworkInfo | null | undefined;
-  tag: number | null | undefined;
-  feeCustomUnit: Unit | null | undefined;
+  fees?: BigNumber | null;
+  tag?: number | null | undefined;
+  feeCustomUnit?: Unit | null | undefined;
+  memoType?: string | null;
+  memoValue?: string | null;
+  mode?: "send" | "changeTrust";
+  assetReference?: string;
+  assetOwner?: string;
+  networkInfo?: NetworkInfo | null;
 } {
-  return {
-    family: account.currency.family,
-    amount: BigNumber(0),
-    recipient: "",
-    fee: null,
-    tag: undefined,
-    networkInfo: null,
-    feeCustomUnit: null,
-  };
+  const currency =
+    account.type === "TokenAccount" ? account.token.parentCurrency : account.currency;
+  switch (currency.family) {
+    case "xrp":
+    case "ripple":
+      return {
+        family: currency.family,
+        amount: BigNumber(0),
+        recipient: "",
+        fees: null,
+        tag: undefined,
+        feeCustomUnit: null, // NOTE: XRP does not use custom units for fees anymore
+      };
+    case "stellar":
+      return {
+        family: currency.family,
+        amount: new BigNumber(0),
+        fees: null,
+        recipient: "",
+        memoValue: null,
+        memoType: null,
+        useAllAmount: false,
+        mode: "send",
+        assetReference: "",
+        assetOwner: "",
+        networkInfo: null,
+      };
+    default:
+      throw new Error(`Unsupported currency family: ${currency.family}`);
+  }
 }

package/src/bridge/generic-alpaca/currencyBridge.ts

@@ -3,7 +3,7 @@ import { CurrencyBridge } from "@ledgerhq/types-live";
 import { genericGetAccountShape } from "./getAccountShape";
 import { getSigner } from "./signer";
 
-export function getAlpacaCurrencyBridge(network: string, kind: "local" | "remote"): CurrencyBridge {
+export function getAlpacaCurrencyBridge(network: string, kind: string): CurrencyBridge {
   return {
     preload: () => Promise.resolve({}),
     hydrate: () => {

package/src/bridge/generic-alpaca/estimateMaxSpendable.ts

@@ -6,21 +6,30 @@ import { transactionToIntent } from "./utils";
 import BigNumber from "bignumber.js";
 
 export function genericEstimateMaxSpendable(
-  network: string,
-  kind: "local" | "remote",
+  network,
+  kind,
 ): AccountBridge<any>["estimateMaxSpendable"] {
   return async ({ account, parentAccount, transaction }) => {
+    if (account.type === "TokenAccount") {
+      return account.spendableBalance;
+    }
     const mainAccount = getMainAccount(account, parentAccount);
-
     const draftTransaction = {
       ...createTransaction(account as any),
       ...transaction,
       amount: mainAccount.spendableBalance,
+      useAllAmount: true,
+      fees: transaction?.fees ? BigInt(transaction.fees.toString()) : 0n,
     };
     const fees = await getAlpacaApi(network, kind).estimateFees(
       transactionToIntent(mainAccount, draftTransaction),
     );
-
+    const { amount } = await getAlpacaApi(network, kind).validateIntent(
+      transactionToIntent(account, { ...draftTransaction }),
+    );
+    if (network === "stellar") {
+      return amount > 0 ? new BigNumber(amount.toString()) : new BigNumber(0);
+    }
     const bnFee = BigNumber(fees.value.toString());
     return BigNumber.max(0, account.spendableBalance.minus(bnFee));
   };

package/src/bridge/generic-alpaca/getAccountShape.ts

@@ -3,59 +3,97 @@ import { GetAccountShape, mergeOps } from "@ledgerhq/coin-framework/bridge/jsHel
 import BigNumber from "bignumber.js";
 import { getAlpacaApi } from "./alpaca";
 import { adaptCoreOperationToLiveOperation, extractBalance } from "./utils";
+import { inferSubOperations } from "@ledgerhq/coin-framework/serialization";
+import { findToken } from "./buildSubAccounts";
+import { buildSubAccounts, OperationCommon } from "./buildSubAccounts";
 
-export function genericGetAccountShape(network: string, kind: "local" | "remote"): GetAccountShape {
-  return async info => {
-    try {
-      const { address, initialAccount, currency, derivationMode } = info;
-      const accountId = encodeAccountId({
-        type: "js",
-        version: "2",
-        currencyId: currency.id,
-        xpubOrAddress: address,
-        derivationMode,
-      });
-
-      const blockInfo = await getAlpacaApi(network, kind).lastBlock();
-
-      const balances = await getAlpacaApi(network, kind).getBalance(address);
-      const nativeBalance = extractBalance(balances, "native");
-      const balance = BigNumber(nativeBalance.value.toString());
-
-      let spendableBalance: BigNumber;
-      if (nativeBalance.locked) {
-        spendableBalance = BigNumber.max(
-          balance.minus(BigNumber(nativeBalance.locked.toString())),
-          BigNumber(0),
-        );
-      } else {
-        spendableBalance = initialAccount?.spendableBalance || balance;
+export function genericGetAccountShape(network: string, kind: string): GetAccountShape {
+  return async (info, syncConfig) => {
+    const { address, initialAccount, currency, derivationMode } = info;
+    const alpacaApi = getAlpacaApi(network, kind);
+
+    if (alpacaApi.getChainSpecificRules) {
+      const chainSpecificValidation = alpacaApi.getChainSpecificRules();
+      if (chainSpecificValidation.getAccountShape) {
+        chainSpecificValidation.getAccountShape(address);
       }
-      const oldOperations = initialAccount?.operations || [];
+    }
+
+    const accountId = encodeAccountId({
+      type: "js",
+      version: "2",
+      currencyId: currency.id,
+      xpubOrAddress: address,
+      derivationMode,
+    });
+
+    const blockInfo = await alpacaApi.lastBlock();
+    const balanceRes = await alpacaApi.getBalance(address);
+    const nativeAsset = extractBalance(balanceRes, "native");
+
+    const assetsBalance = balanceRes
+      .filter(b => b.asset.type !== "native")
+      .filter(b => findToken(currency, b));
+
+    const nativeBalance = BigInt(nativeAsset?.value ?? "0");
+
+    const spendableBalance = BigInt(nativeBalance - BigInt(nativeAsset?.locked ?? "0"));
 
-      const blockHeight = oldOperations.length ? (oldOperations[0].blockHeight ?? 0) + 1 : 0;
+    const oldOps = (initialAccount?.operations || []) as OperationCommon[];
+    const lastPagingToken = oldOps[0]?.extra?.pagingToken || "";
 
-      const [newOperations] = await getAlpacaApi(network, kind).listOperations(address, {
-        minHeight: blockHeight,
-      });
+    const blockHeight = oldOps.length ? (oldOps[0].blockHeight ?? 0) + 1 : 0;
+    const paginationParams: any = { minHeight: blockHeight };
+    if (lastPagingToken) {
+      paginationParams.lastPagingToken = lastPagingToken;
+    }
+
+    const [newCoreOps] = await alpacaApi.listOperations(address, paginationParams);
+    const newOps = newCoreOps.map(op =>
+      adaptCoreOperationToLiveOperation(accountId, op),
+    ) as OperationCommon[];
+    const mergedOps = mergeOps(oldOps, newOps) as OperationCommon[];
+
+    const assetOperations: OperationCommon[] = [];
+    mergedOps.forEach(operation => {
+      if (
+        operation?.extra?.assetReference &&
+        operation?.extra?.assetOwner &&
+        !["OPT_IN", "OPT_OUT"].includes(operation.type)
+      ) {
+        assetOperations.push(operation);
+      }
+    });
 
-      const operations = mergeOps(
-        oldOperations,
-        newOperations.map(op => adaptCoreOperationToLiveOperation(accountId, op)),
-      );
+    const subAccounts =
+      buildSubAccounts({
+        currency,
+        accountId,
+        assetsBalance,
+        syncConfig,
+        operations: assetOperations,
+      }) || [];
+
+    const operationsWithSubs = mergedOps.map(op => {
+      const subOperations = inferSubOperations(op.hash, subAccounts);
 
       return {
-        id: accountId,
-        xpub: address,
-        blockHeight: operations.length === 0 ? 0 : blockInfo.height || initialAccount?.blockHeight,
-        balance,
-        spendableBalance,
-        operations,
-        operationsCount: operations.length,
+        ...op,
+        subOperations,
       };
-    } catch (e) {
-      console.error("Error in getAccountShape", e);
-      throw e;
-    }
+    });
+
+    const res = {
+      id: accountId,
+      xpub: address,
+      blockHeight:
+        operationsWithSubs.length === 0 ? 0 : blockInfo.height || initialAccount?.blockHeight,
+      balance: new BigNumber(nativeBalance.toString()),
+      spendableBalance: new BigNumber(spendableBalance.toString()),
+      operations: operationsWithSubs,
+      subAccounts,
+      operationsCount: operationsWithSubs.length,
+    };
+    return res;
   };
 }

package/src/bridge/generic-alpaca/getTransactionStatus.ts

@@ -1,38 +1,62 @@
 import { AccountBridge, TransactionCommon } from "@ledgerhq/types-live";
+import { AccountAwaitingSendPendingOperations } from "@ledgerhq/errors";
 import BigNumber from "bignumber.js";
 import { getAlpacaApi } from "./alpaca";
+import { transactionToIntent } from "./utils";
 
 // => alpaca validateIntent
 export function genericGetTransactionStatus(
-  network: string,
-  kind: "local" | "remote",
+  network,
+  kind,
 ): AccountBridge<any>["getTransactionStatus"] {
-  return async (account, transaction: TransactionCommon & { fees: BigNumber }) => {
-    const { freshAddress, balance, currency } = account;
+  return async (
+    account,
+    transaction: TransactionCommon & {
+      fees: BigNumber | null | undefined;
+      assetReference?: string;
+      assetOwner?: string;
+      mode?: string;
+      subAccountId?: string;
+      memoType?: string;
+      memoValue?: string;
+    },
+  ) => {
     const alpacaApi = getAlpacaApi(network, kind);
-    const { errors, warnings } = await alpacaApi.validateIntent(
-      {
-        currencyName: currency.name,
-        address: freshAddress,
-        balance: BigInt(balance.toString()),
-        currencyUnit: currency.units[0],
-      },
-      {
-        type: "PAYMENT", // NOTE: assuming payment by default here
-        recipient: transaction.recipient,
-        amount: BigInt(transaction.amount?.toString() ?? "0"),
-        fee: BigInt(transaction.fees?.toString() ?? "0"),
-      },
-    );
+    const draftTransaction = {
+      mode: transaction?.mode,
+      recipient: transaction.recipient,
+      amount: transaction.amount ?? new BigNumber(0),
+      fees: transaction.fees ? BigInt(transaction.fees.toString()) : 0n,
+      useAllAmount: !!transaction.useAllAmount,
+      assetReference: transaction.assetReference || "",
+      assetOwner: transaction.assetOwner || "",
+      subAccountId: transaction.subAccountId || "",
+      memoType: transaction.memoType || "",
+      memoValue: transaction.memoValue || "",
+    };
+
+    if (alpacaApi.getChainSpecificRules) {
+      const chainSpecificValidation = alpacaApi.getChainSpecificRules();
+      if (chainSpecificValidation.getTransactionStatus.throwIfPendingOperation) {
+        if (account.pendingOperations.length > 0) {
+          throw new AccountAwaitingSendPendingOperations();
+        }
+      }
+    }
 
-    const estimatedFees = transaction.fees || new BigNumber(0);
+    const { errors, warnings, estimatedFees, amount, totalSpent } = await alpacaApi.validateIntent(
+      transactionToIntent(account, draftTransaction),
+    );
 
     return Promise.resolve({
       errors,
       warnings,
-      estimatedFees,
-      amount: transaction.amount,
-      totalSpent: transaction.amount.plus(transaction.fees),
+      estimatedFees:
+        !transaction.fees || transaction.fees.isZero()
+          ? new BigNumber(estimatedFees.toString())
+          : transaction.fees,
+      amount: transaction.amount.eq(0) ? new BigNumber(amount.toString()) : transaction.amount,
+      totalSpent: new BigNumber(totalSpent.toString()),
     });
   };
 }

package/src/bridge/generic-alpaca/prepareTransaction.ts

@@ -2,6 +2,7 @@ import { Account, AccountBridge, TransactionCommon } from "@ledgerhq/types-live"
 import { getAlpacaApi } from "./alpaca";
 import { transactionToIntent } from "./utils";
 import BigNumber from "bignumber.js";
+import { NetworkInfo } from "./createTransaction";
 
 function bnEq(a: BigNumber | null | undefined, b: BigNumber | null | undefined): boolean {
   return !a && !b ? true : !a || !b ? false : a.eq(b);
@@ -9,18 +10,51 @@ function bnEq(a: BigNumber | null | undefined, b: BigNumber | null | undefined):
 
 export function genericPrepareTransaction(
   network: string,
-  kind: "local" | "remote",
+  kind,
 ): AccountBridge<TransactionCommon, Account, any, any>["prepareTransaction"] {
-  return async (account, transaction: TransactionCommon & { fees: BigNumber }) => {
+  return async (
+    account,
+    transaction: TransactionCommon & {
+      fees: BigNumber | null | undefined;
+      assetReference?: string;
+      assetOwner?: string;
+      subAccountId?: string;
+      networkInfo?: NetworkInfo | null;
+    },
+  ) => {
+    const [assetReference, assetOwner] = getAssetInfos(transaction);
     const fees = await getAlpacaApi(network, kind).estimateFees(
-      transactionToIntent(account, transaction),
+      transactionToIntent(account, {
+        ...transaction,
+        fees: transaction.fees ? BigInt(transaction.fees.toString()) : 0n,
+      }),
     );
-    const bnFee = BigNumber(fees.value.toString());
-
-    if (!bnEq(transaction.fees, bnFee)) {
-      return { ...transaction, fees: bnFee };
+    // NOTE: this is problematic, we should maybe have a method / object that lists what field warrant an update per chain
+    // for reference, stellar checked this:
+    // transaction.networkInfo !== networkInfo ||
+    // transaction.baseReserve !== baseReserve
+    if (!bnEq(transaction.fees, new BigNumber(fees.value.toString()))) {
+      return {
+        ...transaction,
+        fees: new BigNumber(fees.value.toString()),
+        assetReference,
+        assetOwner,
+        networkInfo: {
+          fees: new BigNumber(fees.value.toString()),
+        },
+      };
     }
 
     return transaction;
   };
 }
+
+export function getAssetInfos(
+  tr: TransactionCommon & { assetReference?: string; assetOwner?: string },
+): string[] {
+  if (tr.subAccountId) {
+    const assetString = tr.subAccountId.split("+")[1];
+    return assetString.split(":");
+  }
+  return [tr.assetReference || "", tr.assetOwner || ""];
+}