Merge pull request #6793 from Zondax/fix/stacks-pending

[Fix/stacks] Optimistic operation disappears for long running transactions

.changeset/curly-donkeys-tickle.md

@@ -0,0 +1,5 @@
+---
+"@ledgerhq/live-common": patch
+---
+
+Add pending operations to stacks account object

libs/ledger-live-common/src/families/stacks/bridge/utils/misc.ts

@@ -10,7 +10,12 @@ import {
 
 import { decodeAccountId } from "../../../../account";
 import { fetchFullMempoolTxs, fetchNonce } from "../../bridge/utils/api";
-import { DecodedSendManyFunctionArgsCV, StacksNetwork, TransactionResponse } from "./api.types";
+import {
+  DecodedSendManyFunctionArgsCV,
+  MempoolTransaction,
+  StacksNetwork,
+  TransactionResponse,
+} from "./api.types";
 import { getCryptoCurrencyById } from "../../../../currencies";
 import { encodeOperationId, encodeSubOperationId } from "../../../../operation";
 import { StacksOperation } from "../../types";
@@ -59,14 +64,66 @@ export const getAddress = (
   derivationPath: string;
 } => ({ address: account.freshAddress, derivationPath: account.freshAddressPath });
 
-const getMemo = (memoHex: string): string => {
+const getMemo = (memoHex?: string): string => {
   if (memoHex?.substring(0, 2) === "0x") {
     return Buffer.from(memoHex.substring(2), "hex").toString().replaceAll("\x00", "");
   }
 
   return "";
 };
 
+export const mapPendingTxToOps =
+  (accountID: string, address: string) =>
+  (tx: MempoolTransaction): StacksOperation[] => {
+    const { sender_address, receipt_time, fee_rate, tx_id, token_transfer, tx_status, nonce } = tx;
+    if (tx.tx_type !== "token_transfer" || tx_status !== "pending") {
+      return [];
+    }
+
+    const memo = getMemo(token_transfer.memo);
+    const feeToUse = new BigNumber(fee_rate || "0");
+
+    const date = new Date(receipt_time * 1000);
+
+    const operationCommons = {
+      hash: tx_id,
+      fee: feeToUse,
+      accountId: accountID,
+      senders: [sender_address],
+      recipients: [token_transfer.recipient_address],
+      transactionSequenceNumber: nonce,
+      value: new BigNumber(token_transfer.amount).plus(feeToUse),
+      date,
+      extra: {
+        memo,
+      },
+      blockHeight: null,
+      blockHash: null,
+    };
+
+    const isSending = address === sender_address;
+    const isReceiving = token_transfer.recipient_address === address;
+
+    const ops: StacksOperation[] = [];
+    if (isSending) {
+      const type: OperationType = "OUT";
+      ops.push({
+        ...operationCommons,
+        id: encodeOperationId(accountID, tx_id, type),
+        type,
+      });
+    } else if (isReceiving) {
+      const type: OperationType = "IN";
+      ops.push({
+        ...operationCommons,
+        id: encodeOperationId(accountID, tx_id, type),
+        type,
+      });
+    }
+
+    return ops;
+  };
+
 export const mapTxToOps =
   (accountID: string, address: string) =>
   (tx: TransactionResponse): StacksOperation[] => {

libs/ledger-live-common/src/families/stacks/bridge/utils/misc.unit.test.ts

@@ -1,11 +1,31 @@
-import { mapTxToOps } from "./misc";
+import { mapPendingTxToOps, mapTxToOps } from "./misc";
 import { encodeAccountId } from "../../../../account";
 import { TransactionResponse } from "./api.types";
 import { fetchFullTxs } from "./api";
 import { Operation } from "@ledgerhq/types-live";
 
 const Address = "SP26AZ1JSFZQ82VH5W2NJSB2QW15EW5YKT6WMD69J";
 
+const mempoolTransfer = {
+  tx_id: "0x628369d2c9b49f0ec95531fe1e6a39141573117f3dd047fca65ff5e4058fbc55",
+  nonce: 32,
+  fee_rate: "487",
+  sender_address: "SPNX9YY3T4GR4XDSNRVWB2MDQVCTJMP3BGT7VCZA",
+  sponsored: false,
+  post_condition_mode: "deny",
+  post_conditions: [],
+  anchor_mode: "any",
+  tx_status: "pending",
+  receipt_time: 1714554733,
+  receipt_time_iso: "2024-05-01T09:12:13.000Z",
+  tx_type: "token_transfer",
+  token_transfer: {
+    recipient_address: "SP26AZ1JSFZQ82VH5W2NJSB2QW15EW5YKT6WMD69J",
+    amount: "9523",
+    memo: "0x00000000000000000000000000000000000000000000000000000000000000000000",
+  },
+};
+
 const sendManyTransfer = {
   tx: {
     tx_id: "0x68bdba90cdbd4e2e112fd008c8c396bd4ca365e482dc68fe25c7aeb5d8eb4c3f",
@@ -193,3 +213,26 @@ test("convert raw transactions to live operations", async () => {
   expect(operations).toBeDefined();
   expect(operations.length).toBeGreaterThan(0);
 });
+
+describe("operation building from mempool raw", () => {
+  test("map raw mempool transaction to op", async () => {
+    const accountId = encodeAccountId({
+      type: "js",
+      version: "2",
+      currencyId: "stacks",
+      xpubOrAddress: "",
+      derivationMode: "stacks_wallet",
+    });
+
+    const address = "SPNX9YY3T4GR4XDSNRVWB2MDQVCTJMP3BGT7VCZA";
+
+    // Contains operations for txn of type token_transfer
+    const operations = [mempoolTransfer].map(mapPendingTxToOps(accountId, address)).flat();
+
+    expect(operations.length).toBe(1);
+    expect(operations[0].type).toBe("OUT");
+    expect(operations[0].internalOperations).toBeUndefined();
+    expect(operations[0].senders).toHaveLength(1);
+    expect(operations[0].recipients).toHaveLength(1);
+  });
+});

libs/ledger-live-common/src/families/stacks/synchronization.ts

@@ -3,7 +3,7 @@ import BigNumber from "bignumber.js";
 import { Account } from "@ledgerhq/types-live";
 import { getAddressFromPublicKey } from "@stacks/transactions";
 import { encodeAccountId } from "@ledgerhq/coin-framework/account/index";
-import { mapTxToOps, reconciliatePublicKey } from "./bridge/utils/misc";
+import { mapTxToOps, mapPendingTxToOps, reconciliatePublicKey } from "./bridge/utils/misc";
 import { GetAccountShape, makeSync } from "../../bridge/jsHelpers";
 import {
   fetchBalances,
@@ -42,13 +42,15 @@ export const getAccountShape: GetAccountShape = async info => {
       .minus(new BigNumber(tx.token_transfer.amount));
   }
 
+  const pendingOperations = mempoolTxs.flatMap(mapPendingTxToOps(accountId, address));
+
   const result: Partial<Account> = {
     id: accountId,
     xpub: pubKey,
     freshAddress: address,
     balance,
     spendableBalance,
-    operations: rawTxs.flatMap(mapTxToOps(accountId, address)),
+    operations: pendingOperations.concat(rawTxs.flatMap(mapTxToOps(accountId, address))),
     blockHeight: blockHeight.chain_tip.block_height,
   };