NNS1-3480: New util function mapIcpTransactionToReport

frontend/src/lib/utils/icp-transactions.utils.ts

@@ -125,6 +125,7 @@ const getTransactionInformation = (
   if (data === undefined) {
     throw new Error(`Unknown transaction type ${JSON.stringify(operation)}`);
   }
+
   return {
     from: "from" in data ? data.from : undefined,
     to: "to" in data ? data.to : undefined,
@@ -136,6 +137,67 @@ const getTransactionInformation = (
   };
 };
 
+export const mapIcpTransactionToReport = ({
+  transaction,
+  accountIdentifier,
+  neuronAccounts,
+  swapCanisterAccounts,
+}: {
+  transaction: TransactionWithId;
+  accountIdentifier: string;
+  neuronAccounts: Set<string>;
+  swapCanisterAccounts: Set<string>;
+}) => {
+  const txInfo = getTransactionInformation(transaction.transaction.operation);
+  if (txInfo === undefined) {
+    throw new Error(
+      `Unknown transaction type ${
+        Object.keys(transaction.transaction.operation)[0]
+      }`
+    );
+  }
+
+  const { to, from, amount, fee } = txInfo;
+  const isSelfTransaction = isToSelf(transaction.transaction);
+  const isReceive = isSelfTransaction || from !== accountIdentifier;
+  const useFee = !isReceive;
+  const feeApplied = useFee && fee ? fee : 0n;
+
+  const type = getTransactionType({
+    transaction: transaction.transaction,
+    neuronAccounts,
+    swapCanisterAccounts,
+    isReceive,
+  });
+
+  const blockTimestampNanos = fromNullable(
+    transaction.transaction.timestamp
+  )?.timestamp_nanos;
+  const createdTimestampNanos = fromNullable(
+    transaction.transaction.created_at_time
+  )?.timestamp_nanos;
+  const timestampNanos = blockTimestampNanos ?? createdTimestampNanos;
+  const timestampMilliseconds = nonNullish(timestampNanos)
+    ? Number(timestampNanos) / NANO_SECONDS_IN_MILLISECOND
+    : undefined;
+  const timestamp = nonNullish(timestampMilliseconds)
+    ? new Date(timestampMilliseconds)
+    : undefined;
+
+  const tokenAmount = TokenAmountV2.fromUlps({
+    amount: amount + feeApplied,
+    token: ICPToken,
+  });
+
+  return {
+    type,
+    to,
+    from,
+    tokenAmount,
+    timestamp,
+  };
+};
+
 export const mapIcpTransactionToUi = ({
   transaction,
   accountIdentifier,
@@ -181,6 +243,7 @@ export const mapIcpTransactionToUi = ({
     const blockTimestampNanos = fromNullable(
       transaction.transaction.timestamp
     )?.timestamp_nanos;
+
     const createdTimestampNanos = fromNullable(
       transaction.transaction.created_at_time
     )?.timestamp_nanos;

frontend/src/tests/lib/utils/icp-transactions.utils.spec.ts

@@ -5,6 +5,7 @@ import {
 import { NANO_SECONDS_IN_MILLISECOND } from "$lib/constants/constants";
 import type { UiTransaction } from "$lib/types/transaction";
 import {
+  mapIcpTransactionToReport,
   mapIcpTransactionToUi,
   mapToSelfTransactions,
   sortTransactionsByIdDescendingOrder,
@@ -30,6 +31,10 @@ describe("icp-transactions.utils", () => {
       spender: [],
     },
   };
+  const defaultTokenAmountWithOutFee = TokenAmountV2.fromUlps({
+    amount: amount,
+    token: ICPToken,
+  });
   const defaultUiTransaction: UiTransaction = {
     domKey: `${transactionId}-1`,
     isIncoming: false,
@@ -69,6 +74,219 @@ describe("icp-transactions.utils", () => {
       memo,
     });
 
+  describe("mapIcpTransactionToReport", () => {
+    const defaultReportTransaction = {
+      type: "send",
+      to,
+      from,
+      tokenAmount: TokenAmountV2.fromUlps({
+        amount: amount + fee,
+        token: ICPToken,
+      }),
+      timestamp: defaultTimestamp,
+    };
+    it("should throw an error if no transaction information is found", () => {
+      const transaction = createTransaction({
+        operation: {
+          // @ts-expect-error: Even though it is not possible our implementations handles it.
+          Unknown: {},
+        },
+      });
+
+      expect(() =>
+        mapIcpTransactionToReport({
+          transaction,
+          accountIdentifier: from,
+          neuronAccounts: new Set<string>(),
+          swapCanisterAccounts: new Set<string>(),
+        })
+      ).toThrowError('Unknown transaction type {"Unknown":{}}');
+    });
+
+    it("should return transaction information", () => {
+      const transaction = createTransaction({
+        operation: defaultTransferOperation,
+      });
+      const expectedIcpTransaction = {
+        ...defaultReportTransaction,
+      };
+
+      expect(
+        mapIcpTransactionToReport({
+          transaction,
+          accountIdentifier: from,
+          neuronAccounts: new Set<string>(),
+          swapCanisterAccounts: new Set<string>(),
+        })
+      ).toEqual(expectedIcpTransaction);
+    });
+
+    it("sould identify receive transactions", () => {
+      const transaction = createTransaction({
+        operation: {
+          Transfer: {
+            ...defaultTransferOperation.Transfer,
+            to: from,
+          },
+        },
+      });
+      const expectedIcpTransaction = {
+        ...defaultReportTransaction,
+        type: "receive",
+        to: from,
+        tokenAmount: defaultTokenAmountWithOutFee,
+      };
+
+      expect(
+        mapIcpTransactionToReport({
+          transaction,
+          accountIdentifier: from,
+          neuronAccounts: new Set<string>(),
+          swapCanisterAccounts: new Set<string>(),
+        })
+      ).toEqual(expectedIcpTransaction);
+    });
+
+    describe("should map to the correct transaction type", () => {
+      it("maps stake neuron transaction", () => {
+        const transaction = createTransaction({
+          operation: defaultTransferOperation,
+          memo: 12345n,
+        });
+        const expectedIcpTransaction = {
+          ...defaultReportTransaction,
+          type: "stakeNeuron",
+        };
+
+        expect(
+          mapIcpTransactionToReport({
+            transaction,
+            accountIdentifier: from,
+            neuronAccounts: new Set<string>([to]),
+            swapCanisterAccounts: new Set<string>(),
+          })
+        ).toEqual(expectedIcpTransaction);
+      });
+
+      it("maps top up neuron transaction", () => {
+        const transaction = createTransaction({
+          operation: defaultTransferOperation,
+          memo: 0n,
+        });
+        const expectedIcpTransaction = {
+          ...defaultReportTransaction,
+          type: "topUpNeuron",
+        };
+
+        expect(
+          mapIcpTransactionToReport({
+            transaction,
+            accountIdentifier: from,
+            neuronAccounts: new Set<string>([to]),
+            swapCanisterAccounts: new Set<string>(),
+          })
+        ).toEqual(expectedIcpTransaction);
+      });
+
+      it("maps create canister transaction", () => {
+        const transaction = createTransaction({
+          operation: defaultTransferOperation,
+          memo: CREATE_CANISTER_MEMO,
+        });
+        const expectedIcpTransaction = {
+          ...defaultReportTransaction,
+          type: "createCanister",
+        };
+
+        expect(
+          mapIcpTransactionToReport({
+            transaction,
+            accountIdentifier: from,
+            neuronAccounts: new Set<string>(),
+            swapCanisterAccounts: new Set<string>(),
+          })
+        ).toEqual(expectedIcpTransaction);
+      });
+
+      it("maps top up canister transaction", () => {
+        const transaction = createTransaction({
+          operation: defaultTransferOperation,
+          memo: TOP_UP_CANISTER_MEMO,
+        });
+        const expectedIcpTransaction = {
+          ...defaultReportTransaction,
+          type: "topUpCanister",
+        };
+
+        expect(
+          mapIcpTransactionToReport({
+            transaction,
+            accountIdentifier: from,
+            neuronAccounts: new Set<string>(),
+            swapCanisterAccounts: new Set<string>(),
+          })
+        ).toEqual(expectedIcpTransaction);
+      });
+    });
+
+    describe("maps timestamps", () => {
+      const createdDate = new Date("2023-01-01T00:12:00.000Z");
+      const blockDate = new Date("2023-01-01T00:34:00.000Z");
+      const createTimestamps = {
+        timestamp_nanos:
+          BigInt(createdDate.getTime()) * BigInt(NANO_SECONDS_IN_MILLISECOND),
+      };
+      const blockTimestamps = {
+        timestamp_nanos:
+          BigInt(blockDate.getTime()) * BigInt(NANO_SECONDS_IN_MILLISECOND),
+      };
+
+      it("prefers block timestamp", () => {
+        const transaction = createTransaction({
+          operation: defaultTransferOperation,
+        });
+        transaction.transaction.created_at_time = [createTimestamps];
+        transaction.transaction.timestamp = [blockTimestamps];
+
+        const expectedIcpTransaction = {
+          ...defaultReportTransaction,
+          timestamp: blockDate,
+        };
+
+        expect(
+          mapIcpTransactionToReport({
+            transaction,
+            accountIdentifier: from,
+            neuronAccounts: new Set<string>(),
+            swapCanisterAccounts: new Set<string>(),
+          })
+        ).toEqual(expectedIcpTransaction);
+      });
+
+      it("falls back on created timestamps", () => {
+        const transaction = createTransaction({
+          operation: defaultTransferOperation,
+        });
+        transaction.transaction.created_at_time = [createTimestamps];
+        transaction.transaction.timestamp = [];
+
+        const expectedIcpTransaction = {
+          ...defaultReportTransaction,
+          timestamp: createdDate,
+        };
+
+        expect(
+          mapIcpTransactionToReport({
+            transaction,
+            accountIdentifier: from,
+            neuronAccounts: new Set<string>(),
+            swapCanisterAccounts: new Set<string>(),
+          })
+        ).toEqual(expectedIcpTransaction);
+      });
+    });
+  });
+
   describe("mapIcpTransactionToUi", () => {
     it("maps stake neuron transaction", () => {
       const transaction = createTransaction({