@ledgerhq/live-common 34.39.0 → 34.40.0-nightly.1

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

@@ -0,0 +1,27 @@
+import { Account, TransactionCommon } from "@ledgerhq/types-live";
+import BigNumber from "bignumber.js";
+import type { Unit } from "@ledgerhq/types-cryptoassets";
+
+export type NetworkInfo = {
+  family: "xrp";
+  serverFee: BigNumber;
+  baseReserve: BigNumber;
+};
+
+export function createTransaction(account: Account): TransactionCommon & {
+  family: string;
+  fee: BigNumber | null | undefined;
+  networkInfo: NetworkInfo | null | undefined;
+  tag: number | null | undefined;
+  feeCustomUnit: Unit | null | undefined;
+} {
+  return {
+    family: account.currency.family,
+    amount: BigNumber(0),
+    recipient: "",
+    fee: null,
+    tag: undefined,
+    networkInfo: null,
+    feeCustomUnit: null,
+  };
+}

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

@@ -0,0 +1,17 @@
+import { makeScanAccounts } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { CurrencyBridge } from "@ledgerhq/types-live";
+import { genericGetAccountShape } from "./getAccountShape";
+import { getSigner } from "./signer";
+
+export function getAlpacaCurrencyBridge(network: string, kind: "local" | "remote"): CurrencyBridge {
+  return {
+    preload: () => Promise.resolve({}),
+    hydrate: () => {
+      return;
+    },
+    scanAccounts: makeScanAccounts({
+      getAccountShape: genericGetAccountShape(network, kind),
+      getAddressFn: getSigner(network).getAddress,
+    }),
+  };
+}

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

@@ -0,0 +1,27 @@
+import { AccountBridge } from "@ledgerhq/types-live";
+import { getMainAccount } from "../../account";
+import { getAlpacaApi } from "./alpaca";
+import { createTransaction } from "./createTransaction";
+import { transactionToIntent } from "./utils";
+import BigNumber from "bignumber.js";
+
+export function genericEstimateMaxSpendable(
+  network: string,
+  kind: "local" | "remote",
+): AccountBridge<any>["estimateMaxSpendable"] {
+  return async ({ account, parentAccount, transaction }) => {
+    const mainAccount = getMainAccount(account, parentAccount);
+
+    const draftTransaction = {
+      ...createTransaction(account as any),
+      ...transaction,
+      amount: mainAccount.spendableBalance,
+    };
+    const fees = await getAlpacaApi(network, kind).estimateFees(
+      transactionToIntent(mainAccount, draftTransaction),
+    );
+
+    const bnFee = BigNumber(fees.value.toString());
+    return BigNumber.max(0, account.spendableBalance.minus(bnFee));
+  };
+}

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

@@ -0,0 +1,62 @@
+import { encodeAccountId } from "@ledgerhq/coin-framework/account/index";
+import { GetAccountShape, mergeOps } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import BigNumber from "bignumber.js";
+import { getAlpacaApi } from "./alpaca";
+import { adaptCoreOperationToLiveOperation } from "./utils";
+
+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 balanceRes = await getAlpacaApi(network, kind).getBalance(address);
+      // FIXME: fix type Balance -> check "native" balance
+      // is balance[0] always the native ?
+      const balance = BigNumber(balanceRes[0].value.toString());
+
+      let spendableBalance: BigNumber;
+      if (balanceRes[0]?.locked) {
+        spendableBalance = BigNumber.max(
+          balance.minus(BigNumber(balanceRes[0].locked.toString())),
+          BigNumber(0),
+        );
+      } else {
+        spendableBalance = initialAccount?.spendableBalance || balance;
+      }
+      const oldOperations = initialAccount?.operations || [];
+
+      const blockHeight = oldOperations.length ? (oldOperations[0].blockHeight ?? 0) + 1 : 0;
+
+      const [newOperations] = await getAlpacaApi(network, kind).listOperations(address, {
+        minHeight: blockHeight,
+      });
+
+      const operations = mergeOps(
+        oldOperations,
+        newOperations.map(op => adaptCoreOperationToLiveOperation(accountId, op)),
+      );
+
+      return {
+        id: accountId,
+        xpub: address,
+        blockHeight: blockInfo.height || initialAccount?.blockHeight,
+        balance,
+        spendableBalance,
+        operations,
+        operationsCount: operations.length,
+      };
+    } catch (e) {
+      console.error("Error in getAccountShape", e);
+      throw e;
+    }
+  };
+}

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

@@ -0,0 +1,38 @@
+import { AccountBridge, TransactionCommon } from "@ledgerhq/types-live";
+import BigNumber from "bignumber.js";
+import { getAlpacaApi } from "./alpaca";
+
+// => alpaca validateIntent
+export function genericGetTransactionStatus(
+  network: string,
+  kind: "local" | "remote",
+): AccountBridge<any>["getTransactionStatus"] {
+  return async (account, transaction: TransactionCommon & { fees: BigNumber }) => {
+    const { freshAddress, balance, currency } = account;
+    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 estimatedFees = transaction.fees || new BigNumber(0);
+
+    return Promise.resolve({
+      errors,
+      warnings,
+      estimatedFees,
+      amount: transaction.amount,
+      totalSpent: transaction.amount.plus(transaction.fees),
+    });
+  };
+}

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

@@ -0,0 +1,26 @@
+import { Account, AccountBridge, TransactionCommon } from "@ledgerhq/types-live";
+import { getAlpacaApi } from "./alpaca";
+import { transactionToIntent } from "./utils";
+import BigNumber from "bignumber.js";
+
+function bnEq(a: BigNumber | null | undefined, b: BigNumber | null | undefined): boolean {
+  return !a && !b ? true : !a || !b ? false : a.eq(b);
+}
+
+export function genericPrepareTransaction(
+  network: string,
+  kind: "local" | "remote",
+): AccountBridge<TransactionCommon, Account, any, any>["prepareTransaction"] {
+  return async (account, transaction: TransactionCommon & { fees: BigNumber }) => {
+    const fees = await getAlpacaApi(network, kind).estimateFees(
+      transactionToIntent(account, transaction),
+    );
+    const bnFee = BigNumber(fees.value.toString());
+
+    if (!bnEq(transaction.fees, bnFee)) {
+      return { ...transaction, fees: bnFee };
+    }
+
+    return transaction;
+  };
+}

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

@@ -0,0 +1,98 @@
+import { Observable } from "rxjs";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import type {
+  Account,
+  DeviceId,
+  SignOperationEvent,
+  AccountBridge,
+  TransactionCommon,
+} from "@ledgerhq/types-live";
+import { getAlpacaApi } from "./alpaca";
+import { buildOptimisticOperation, transactionToIntent } from "./utils";
+import { FeeNotLoaded } from "@ledgerhq/errors";
+import { Result } from "@ledgerhq/coin-framework/derivation";
+import { MapMemo, TransactionIntent } from "@ledgerhq/coin-framework/api/types";
+
+/**
+ * Sign Transaction with Ledger hardware
+ */
+export const genericSignOperation =
+  (network: string, kind: "local" | "remote") =>
+  (signerContext: SignerContext<any>): AccountBridge<TransactionCommon>["signOperation"] =>
+  ({
+    account,
+    transaction,
+    deviceId,
+  }: {
+    account: Account;
+    transaction: TransactionCommon;
+    deviceId: DeviceId;
+  }): Observable<SignOperationEvent> =>
+    new Observable(o => {
+      async function main() {
+        if (!transaction["fees"]) throw new FeeNotLoaded();
+
+        const signedInfo = await signerContext(deviceId, async signer => {
+          const derivationPath = account.freshAddressPath;
+
+          const { publicKey } = (await signer.getAddress(derivationPath)) as Result;
+
+          const transactionIntent = transactionToIntent(account, transaction);
+          transactionIntent.senderPublicKey = publicKey;
+          // NOTE: is setting the memo here instead of transactionToIntent sensible?
+          const txWithMemo = transactionIntent as TransactionIntent<any, MapMemo<string, string>>;
+          if (transaction["tag"]) {
+            const txMemo = String(transaction["tag"]);
+            txWithMemo.memo = {
+              type: "map",
+              memos: new Map(),
+            };
+            txWithMemo.memo.memos.set("destinationTag", txMemo);
+          }
+
+          /* Craft unsigned blob via Alpaca */
+          const unsigned: string = await getAlpacaApi(network, kind).craftTransaction(
+            transactionIntent,
+          );
+
+          // TODO: should compute it and pass it down to craftTransaction (duplicate call right now)
+          const accountInfo = await getAlpacaApi(network, kind).getAccountInfo(
+            transactionIntent.sender,
+          );
+          const sequenceNumber = accountInfo.sequence;
+
+          /* Notify UI that the device is now showing the tx */
+          o.next({ type: "device-signature-requested" });
+          /* Sign on Ledger device */
+          const txnSig = await signer.signTransaction(derivationPath, unsigned);
+          return { unsigned, txnSig, publicKey, sequence: sequenceNumber };
+        });
+
+        /* If the user cancelled inside signerContext */
+        if (!signedInfo) return;
+        o.next({ type: "device-signature-granted" });
+
+        /* Combine payload + signature for broadcast */
+        const combined = await getAlpacaApi(network, kind).combine(
+          signedInfo.unsigned,
+          signedInfo.txnSig,
+          signedInfo.publicKey,
+        );
+
+        const operation = buildOptimisticOperation(account, transaction, signedInfo.sequence);
+        // NOTE: we set the transactionSequenceNumber before on the operation
+        // now that we create it in craftTransaction, we might need to return it back from craftTransaction also
+        o.next({
+          type: "signed",
+          signedOperation: {
+            operation,
+            signature: combined,
+          },
+        });
+      }
+
+      main().then(
+        () => o.complete(),
+        e => o.error(e),
+      );
+    });

package/src/bridge/generic-alpaca/signer/index.ts

@@ -0,0 +1,33 @@
+import { GetAddressFn } from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
+import xrpGetAddress from "@ledgerhq/coin-xrp/signer/getAddress";
+import { CreateSigner, executeWithSigner } from "../../setup";
+import Xrp from "@ledgerhq/hw-app-xrp";
+
+import Transport from "@ledgerhq/hw-transport";
+import { signTransaction } from "./signTransaction";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import { SignTransactionOptions } from "./types";
+
+export type AlpacaSigner = {
+  getAddress: GetAddressFn;
+  signTransaction?: (deviceId: string, opts: SignTransactionOptions) => Promise<string>;
+  signMessage?: (message: string) => Promise<string>;
+  context: SignerContext<any>;
+};
+
+export function getSigner(network: string): AlpacaSigner {
+  switch (network) {
+    case "ripple":
+    case "xrp": {
+      const createSigner: CreateSigner<Xrp> = (transport: Transport) => {
+        return new Xrp(transport);
+      };
+      return {
+        getAddress: xrpGetAddress(executeWithSigner(createSigner)),
+        signTransaction: signTransaction(executeWithSigner(createSigner)),
+        context: executeWithSigner(createSigner),
+      };
+    }
+  }
+  throw new Error(`signer for ${network} not implemented`);
+}

package/src/bridge/generic-alpaca/signer/signTransaction.ts

@@ -0,0 +1,13 @@
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import { XrpSigner } from "@ledgerhq/coin-xrp/index";
+import { SignTransactionOptions } from "./types";
+
+export const signTransaction = (signerContext: SignerContext<XrpSigner>) => {
+  return async (deviceId: string, { path, rawTxHex }: SignTransactionOptions) => {
+    const signedTx = await signerContext(deviceId, signer =>
+      signer.signTransaction(path, rawTxHex),
+    );
+
+    return signedTx;
+  };
+};

package/src/bridge/generic-alpaca/signer/types.ts

@@ -0,0 +1,4 @@
+export type SignTransactionOptions = {
+  rawTxHex: string;
+  path: string;
+};

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

@@ -0,0 +1,76 @@
+import BigNumber from "bignumber.js";
+import { genericEstimateMaxSpendable } from "../estimateMaxSpendable";
+import * as alpaca from "../alpaca";
+import { Account } from "@ledgerhq/types-live";
+
+// Mock the alpaca API
+jest.mock("../alpaca", () => ({
+  getAlpacaApi: jest.fn(),
+}));
+
+const mockedGetAlpacaApi = alpaca.getAlpacaApi as jest.Mock;
+
+// Dummy data
+const dummyAccount = {
+  id: "js:2:ripple:r123:",
+  type: "Account", // <-- this is mandatory for getMainAccount to work
+  spendableBalance: new BigNumber(50000000),
+  currency: { id: "ripple", name: "XRP", units: [{ name: "XRP", magnitude: 6 }] },
+  freshAddress: "r123",
+} as unknown as Account;
+
+describe("genericEstimateMaxSpendable", () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("subtracts estimated fee from spendable balance", async () => {
+    mockedGetAlpacaApi.mockReturnValue({
+      estimateFees: jest.fn().mockResolvedValue({ value: 10000n }), // 0.01 XRP
+    });
+
+    const estimate = genericEstimateMaxSpendable("xrp", "local");
+    const result = await estimate({
+      account: dummyAccount,
+      parentAccount: null,
+      transaction: {},
+    });
+
+    expect(result.toString()).toBe("49990000"); // 50_000_000 - 10_000
+  });
+
+  it("returns 0 if fee is higher than spendable", async () => {
+    const poorAccount = {
+      ...dummyAccount,
+      spendableBalance: new BigNumber(5000), // very low
+    };
+
+    mockedGetAlpacaApi.mockReturnValue({
+      estimateFees: jest.fn().mockResolvedValue({ value: 10000n }),
+    });
+
+    const estimate = genericEstimateMaxSpendable("xrp", "local");
+    const result = await estimate({
+      account: poorAccount,
+      parentAccount: null,
+      transaction: {},
+    });
+
+    expect(result.toString()).toBe("0");
+  });
+
+  it("returns full spendable balance if fee is 0", async () => {
+    mockedGetAlpacaApi.mockReturnValue({
+      estimateFees: jest.fn().mockResolvedValue({ value: 0n }),
+    });
+
+    const estimate = genericEstimateMaxSpendable("xrp", "local");
+    const result = await estimate({
+      account: dummyAccount,
+      parentAccount: null,
+      transaction: {},
+    });
+
+    expect(result.toString()).toBe("50000000");
+  });
+});

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

@@ -0,0 +1,92 @@
+import { genericPrepareTransaction } from "../prepareTransaction";
+import { getAlpacaApi } from "../alpaca";
+import { transactionToIntent } from "../utils";
+import BigNumber from "bignumber.js";
+import type { TransactionCommon } from "@ledgerhq/types-live";
+
+jest.mock("../alpaca", () => ({
+  getAlpacaApi: jest.fn(),
+}));
+
+jest.mock("../utils", () => ({
+  transactionToIntent: jest.fn(),
+}));
+
+describe("genericPrepareTransaction", () => {
+  const network = "testnet";
+  const kind = "local";
+
+  const account = {
+    id: "test-account",
+    address: "0xabc",
+  } as any;
+
+  const baseTransaction: TransactionCommon & { fees: BigNumber } = {
+    amount: new BigNumber(100_000),
+    fees: new BigNumber(500),
+    recipient: "0xrecipient",
+  };
+
+  const txIntent = { mock: "intent" };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    (transactionToIntent as jest.Mock).mockReturnValue(txIntent);
+  });
+
+  it("updates fees if they differ", async () => {
+    const newFee = new BigNumber(700);
+
+    (getAlpacaApi as jest.Mock).mockReturnValue({
+      estimateFees: jest.fn().mockResolvedValue({ value: newFee }),
+    });
+
+    const prepareTransaction = genericPrepareTransaction(network, kind);
+    const result = await prepareTransaction(account, { ...baseTransaction });
+
+    expect((result as any).fees.toString()).toBe(newFee.toString());
+    expect(transactionToIntent).toHaveBeenCalledWith(
+      account,
+      expect.objectContaining(baseTransaction),
+    );
+  });
+
+  it("returns original transaction if fees are the same", async () => {
+    const sameFee = baseTransaction.fees;
+
+    (getAlpacaApi as jest.Mock).mockReturnValue({
+      estimateFees: jest.fn().mockResolvedValue({ value: sameFee }),
+    });
+
+    const prepareTransaction = genericPrepareTransaction(network, kind);
+    const result = await prepareTransaction(account, baseTransaction);
+
+    expect(result).toBe(baseTransaction);
+  });
+
+  it("sets fee if original fees are undefined", async () => {
+    const newFee = new BigNumber(1234);
+    (getAlpacaApi as jest.Mock).mockReturnValue({
+      estimateFees: jest.fn().mockResolvedValue({ value: newFee }),
+    });
+
+    const txWithoutFees = { ...baseTransaction, fees: undefined as any };
+    const prepareTransaction = genericPrepareTransaction(network, kind);
+    const result = await prepareTransaction(account, txWithoutFees);
+
+    expect((result as any).fees.toString()).toBe(newFee.toString());
+    expect(result).not.toBe(txWithoutFees);
+  });
+
+  it("returns original if fees are BigNumber-equal but different instance", async () => {
+    const sameValue = new BigNumber(baseTransaction.fees.toString()); // different instance
+    (getAlpacaApi as jest.Mock).mockReturnValue({
+      estimateFees: jest.fn().mockResolvedValue({ value: sameValue }),
+    });
+
+    const prepareTransaction = genericPrepareTransaction(network, kind);
+    const result = await prepareTransaction(account, baseTransaction);
+
+    expect(result).toBe(baseTransaction); // still same reference
+  });
+});

package/src/bridge/generic-alpaca/tests/signOperation.test.ts

@@ -0,0 +1,97 @@
+import { lastValueFrom } from "rxjs";
+import { toArray } from "rxjs/operators";
+import { genericSignOperation } from "../signOperation";
+import { FeeNotLoaded } from "@ledgerhq/errors";
+import { getAlpacaApi } from "../alpaca";
+import { buildOptimisticOperation, transactionToIntent } from "../utils";
+
+jest.mock("../alpaca", () => ({
+  getAlpacaApi: jest.fn(),
+}));
+
+jest.mock("../utils", () => ({
+  buildOptimisticOperation: jest.fn(),
+  transactionToIntent: jest.fn(),
+}));
+
+describe("genericSignOperation", () => {
+  const network = "xrp";
+  const kind = "local";
+
+  const mockSignerContext = jest.fn();
+  const mockSigner = {
+    getAddress: jest.fn(),
+    signTransaction: jest.fn(),
+  };
+
+  const account = {
+    freshAddressPath: "44'/144'/0'/0/0",
+    address: "rTestAddress",
+  } as any;
+
+  const transaction = {
+    amount: 100_000n,
+    fees: 500n,
+    tag: 1234,
+  } as any;
+
+  const deviceId = "mockDevice";
+
+  const txIntent = {
+    memo: {
+      type: "map",
+      memos: new Map(),
+    },
+  };
+
+  const unsignedTx = "unsignedTx";
+  const signedTx = "signedTx";
+  const pubKey = "pubKey";
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    (getAlpacaApi as jest.Mock).mockReturnValue({
+      craftTransaction: jest.fn().mockResolvedValue(unsignedTx),
+      getAccountInfo: jest.fn().mockResolvedValue(pubKey),
+      combine: jest.fn().mockResolvedValue(signedTx),
+    });
+
+    (transactionToIntent as jest.Mock).mockReturnValue(txIntent);
+    (buildOptimisticOperation as jest.Mock).mockReturnValue({ id: "mock-op" });
+
+    mockSigner.getAddress.mockResolvedValue({ publicKey: pubKey });
+    mockSigner.signTransaction.mockResolvedValue("sig");
+    mockSignerContext.mockImplementation(async (_deviceId, cb) => cb(mockSigner));
+  });
+
+  it("emits full sign operation flow", async () => {
+    const signOperation = genericSignOperation(network, kind)(mockSignerContext);
+    const observable = signOperation({ account, transaction, deviceId });
+
+    const events = await lastValueFrom(observable.pipe(toArray()));
+
+    expect(events[0]).toEqual({ type: "device-signature-requested" });
+    expect(events[1]).toEqual({ type: "device-signature-granted" });
+    expect(events[2]).toEqual({
+      type: "signed",
+      signedOperation: {
+        operation: { id: "mock-op" },
+        signature: signedTx,
+      },
+    });
+
+    expect(transactionToIntent).toHaveBeenCalledWith(account, transaction);
+    expect(txIntent.memo.memos.get("destinationTag")).toBe("1234");
+  });
+
+  it("throws FeeNotLoaded if fees are missing", async () => {
+    const txWithoutFees = { ...transaction };
+    delete txWithoutFees.fees;
+
+    const signOperation = genericSignOperation(network, kind)(mockSignerContext);
+    const observable = signOperation({ account, transaction: txWithoutFees, deviceId });
+
+    await expect(observable.toPromise()).rejects.toThrow(FeeNotLoaded);
+  });
+});

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

@@ -0,0 +1,65 @@
+import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+import { Account, Operation, OperationType, TransactionCommon } from "@ledgerhq/types-live";
+import {
+  Operation as CoreOperation,
+  Asset,
+  TransactionIntent,
+} from "@ledgerhq/coin-framework/api/types";
+import BigNumber from "bignumber.js";
+import { fromBigNumberToBigInt } from "@ledgerhq/coin-framework/utils";
+
+export function adaptCoreOperationToLiveOperation(
+  accountId: string,
+  op: CoreOperation<Asset>,
+): Operation {
+  return {
+    id: encodeOperationId(accountId, op.tx.hash, op.type),
+    hash: op.tx.hash,
+    accountId,
+    type: op.type as OperationType,
+    value: new BigNumber(op.value.toString()),
+    fee: new BigNumber(op.tx.fees.toString()),
+    blockHash: op.tx.block.hash,
+    blockHeight: op.tx.block.height,
+    senders: op.senders,
+    recipients: op.recipients,
+    date: op.tx.date,
+    transactionSequenceNumber: op.details?.sequence as number,
+    extra: {},
+  };
+}
+
+export function transactionToIntent(
+  account: Account,
+  transaction: TransactionCommon,
+): TransactionIntent<any> {
+  return {
+    type: "Payment",
+    sender: account.freshAddress,
+    recipient: transaction.recipient,
+    amount: fromBigNumberToBigInt(transaction.amount, BigInt(0)),
+    asset: null,
+  };
+}
+
+export const buildOptimisticOperation = (
+  account: Account,
+  transaction: TransactionCommon,
+  sequenceNumber?: number,
+): Operation => {
+  return {
+    id: encodeOperationId(account.id, "", "OUT"),
+    hash: "",
+    type: "OUT",
+    value: transaction.amount,
+    fee: transaction["fees"] ?? BigNumber(0),
+    blockHash: null,
+    blockHeight: null,
+    senders: [account.freshAddress.toString()],
+    recipients: [transaction.recipient],
+    transactionSequenceNumber: sequenceNumber ?? 0,
+    accountId: account.id,
+    date: new Date(),
+    extra: {},
+  };
+};