[ENG-3617] Update the rbf logic

hooks/index.ts

@@ -1,2 +1,3 @@
 export * from './brc20';
 export * from './inscriptions';
+export * from './useRbfTransactionData';

hooks/useRbfTransactionData/helpers.test.ts

@@ -0,0 +1,176 @@
+import BigNumber from 'bignumber.js';
+import { calculateStxData } from './helpers';
+import { StxTransactionData, SettingsNetwork, AppInfo } from '../../types';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { StacksMocknet } from '@stacks/network';
+import axios from 'axios';
+import { microstacksToStx } from '../../currency';
+
+vi.mock('axios');
+vi.mock('@stacks/transactions', async () => {
+  const actual = await vi.importActual<any>('@stacks/transactions');
+  return {
+    ...actual,
+    estimateTransaction: vi.fn().mockResolvedValue([
+      { fee: 1000, fee_rate: 1000 },
+      { fee: 2000, fee_rate: 2000 },
+      { fee: 3000, fee_rate: 3000 },
+    ]),
+  };
+});
+
+const lowFee = 1000;
+const mediumFee = 2000;
+const highFee = 3000;
+
+const mockTransaction: StxTransactionData = {
+  txid: 'mock-txid',
+  amount: BigNumber(100),
+  seenTime: new Date(),
+  incoming: false,
+  txType: 'token_transfer',
+  txStatus: 'success',
+  blockHash: 'mock-blockhash',
+  blockHeight: 1,
+  burnBlockTime: 1,
+  burnBlockTimeIso: new Date(),
+  canonical: true,
+  fee: BigNumber(lowFee),
+  nonce: 1,
+  postConditionMode: 'mock-mode',
+  senderAddress: 'mock-senderaddress',
+  sponsored: false,
+  txIndex: 1,
+  txResults: 'mock-results',
+};
+
+const mockBtcNetwork: SettingsNetwork = {
+  type: 'Mainnet',
+  address: 'mock-address',
+  btcApiUrl: 'mock-btcApiUrl',
+  fallbackBtcApiUrl: 'mock-fallbackBtcApiUrl',
+};
+
+const mockStacksNetwork = new StacksMocknet();
+
+const mockAppInfo: AppInfo = {
+  stxSendTxMultiplier: 1,
+  poolStackingTxMultiplier: 1,
+  otherTxMultiplier: 1,
+  thresholdHighSatsFee: 1,
+  thresholdHighSatsPerByteRatio: 1,
+  thresholdHighStacksFee: 5000,
+};
+
+const mockStxAvailableBalance = '5000';
+
+const mockResult = {
+  rbfTransaction: undefined,
+  rbfTxSummary: {
+    currentFee: microstacksToStx(BigNumber(lowFee)).toNumber(),
+    currentFeeRate: microstacksToStx(BigNumber(lowFee)).toNumber(),
+    minimumRbfFee: microstacksToStx(BigNumber(lowFee).multipliedBy(1.25)).toNumber(),
+    minimumRbfFeeRate: microstacksToStx(BigNumber(lowFee).multipliedBy(1.25)).toNumber(),
+  },
+  rbfRecommendedFees: {
+    high: {
+      enoughFunds: true,
+      fee: microstacksToStx(BigNumber(highFee)).toNumber(),
+      feeRate: microstacksToStx(BigNumber(highFee)).toNumber(),
+    },
+    medium: {
+      enoughFunds: true,
+      fee: microstacksToStx(BigNumber(mediumFee)).toNumber(),
+      feeRate: microstacksToStx(BigNumber(mediumFee)).toNumber(),
+    },
+  },
+  mempoolFees: {
+    fastestFee: microstacksToStx(BigNumber(highFee)).toNumber(),
+    halfHourFee: microstacksToStx(BigNumber(mediumFee)).toNumber(),
+    hourFee: microstacksToStx(BigNumber(lowFee)).toNumber(),
+    economyFee: microstacksToStx(BigNumber(lowFee)).toNumber(),
+    minimumFee: microstacksToStx(BigNumber(lowFee)).toNumber(),
+  },
+};
+
+const mockRawTx =
+  // eslint-disable-next-line max-len
+  '0x80800000000400483cd5c1c96119e132aa12b76df34f003c85f9af00000000000000240000000000021cd200006c47412a98c710eaaa276f93d9a77097616afe9ac8f48068bae96f8084c23ad26b4d6e77fce26b20be0faa86493e2fd8567e48283157973399ab5e283965b20e03020000000000051a5953622a9370e859e5a8e290ed38b1a885bf09df00000000000186a000000000000000000000000000000000000000000000000000000000000000000000';
+
+describe('calculateStxData method', async () => {
+  beforeEach(() => {
+    vi.mocked(axios.get).mockResolvedValue({
+      data: {
+        raw_tx: mockRawTx,
+      },
+    });
+  });
+
+  it('should return the fee estimation fetched from the Stacks function', async () => {
+    const result = await calculateStxData(
+      mockTransaction,
+      mockBtcNetwork,
+      mockStacksNetwork,
+      mockAppInfo,
+      mockStxAvailableBalance,
+    );
+
+    expect(result).toBeDefined();
+    expect(result).toEqual(mockResult);
+  });
+
+  it('should return the fee estimation based on the current fee', async () => {
+    const fee = BigNumber(2000);
+    const tx = { ...mockTransaction, fee };
+    const result = await calculateStxData(tx, mockBtcNetwork, mockStacksNetwork, mockAppInfo, mockStxAvailableBalance);
+
+    expect(result).toBeDefined();
+    expect(result).toEqual({
+      ...mockResult,
+      rbfRecommendedFees: {
+        highest: {
+          enoughFunds: true,
+          fee: microstacksToStx(fee.multipliedBy(1.5)).toNumber(),
+          feeRate: microstacksToStx(fee.multipliedBy(1.5)).toNumber(),
+        },
+        higher: {
+          enoughFunds: true,
+          fee: microstacksToStx(fee.multipliedBy(1.25)).toNumber(),
+          feeRate: microstacksToStx(fee.multipliedBy(1.25)).toNumber(),
+        },
+      },
+      rbfTxSummary: {
+        currentFee: microstacksToStx(fee).toNumber(),
+        currentFeeRate: microstacksToStx(fee).toNumber(),
+        minimumRbfFee: microstacksToStx(fee.multipliedBy(1.25)).toNumber(),
+        minimumRbfFeeRate: microstacksToStx(fee.multipliedBy(1.25)).toNumber(),
+      },
+    });
+  });
+
+  it('should return falsy value for the enoughFunds when the balance is not enough', async () => {
+    const availableBalance = '1';
+    const result = await calculateStxData(
+      mockTransaction,
+      mockBtcNetwork,
+      mockStacksNetwork,
+      mockAppInfo,
+      availableBalance,
+    );
+
+    expect(result).toBeDefined();
+    expect(result).toEqual({
+      ...mockResult,
+      rbfRecommendedFees: {
+        high: {
+          ...mockResult.rbfRecommendedFees.high,
+          enoughFunds: false,
+        },
+        medium: {
+          ...mockResult.rbfRecommendedFees.medium,
+          enoughFunds: false,
+        },
+      },
+    });
+  });
+});

hooks/useRbfTransactionData/helpers.ts

@@ -0,0 +1,121 @@
+import { deserializeTransaction, estimateTransaction } from '@stacks/transactions';
+import BigNumber from 'bignumber.js';
+import { RbfRecommendedFees, getRawTransaction, rbf } from '../../transactions';
+import {
+  AppInfo,
+  RecommendedFeeResponse,
+  SettingsNetwork,
+  BtcTransactionData,
+  StacksNetwork,
+  StacksTransaction,
+  StxTransactionData,
+} from '../../types';
+import { microstacksToStx } from '../../currency';
+
+export type RbfData = {
+  rbfTransaction?: InstanceType<typeof rbf.RbfTransaction>;
+  rbfTxSummary?: {
+    currentFee: number;
+    currentFeeRate: number;
+    minimumRbfFee: number;
+    minimumRbfFeeRate: number;
+  };
+  rbfRecommendedFees?: RbfRecommendedFees;
+  mempoolFees?: RecommendedFeeResponse;
+  isLoading?: boolean;
+  errorCode?: 'SOMETHING_WENT_WRONG';
+};
+
+export const isBtcTransaction = (
+  transaction: BtcTransactionData | StxTransactionData,
+): transaction is BtcTransactionData => transaction?.txType === 'bitcoin';
+
+export const constructRecommendedFees = (
+  lowerName: keyof RbfRecommendedFees,
+  lowerFeeRate: number,
+  higherName: keyof RbfRecommendedFees,
+  higherFeeRate: number,
+  stxAvailableBalance: string,
+): RbfRecommendedFees => {
+  const bigNumLowerFee = BigNumber(lowerFeeRate);
+  const bigNumHigherFee = BigNumber(higherFeeRate);
+
+  return {
+    [lowerName]: {
+      enoughFunds: bigNumLowerFee.lte(BigNumber(stxAvailableBalance)),
+      feeRate: microstacksToStx(bigNumLowerFee).toNumber(),
+      fee: microstacksToStx(bigNumLowerFee).toNumber(),
+    },
+    [higherName]: {
+      enoughFunds: bigNumHigherFee.lte(BigNumber(stxAvailableBalance)),
+      feeRate: microstacksToStx(bigNumHigherFee).toNumber(),
+      fee: microstacksToStx(bigNumHigherFee).toNumber(),
+    },
+  };
+};
+
+export const sortFees = (fees: RbfRecommendedFees) =>
+  Object.fromEntries(
+    Object.entries(fees).sort((a, b) => {
+      const priorityOrder = ['highest', 'higher', 'high', 'medium'];
+      return priorityOrder.indexOf(a[0]) - priorityOrder.indexOf(b[0]);
+    }),
+  );
+
+export const calculateStxData = async (
+  transaction: StxTransactionData,
+  btcNetwork: SettingsNetwork,
+  stacksNetwork: StacksNetwork,
+  appInfo: AppInfo | null,
+  stxAvailableBalance: string,
+): Promise<RbfData> => {
+  const { fee } = transaction;
+  const txRaw: string = await getRawTransaction(transaction.txid, btcNetwork);
+  const unsignedTx: StacksTransaction = deserializeTransaction(txRaw);
+
+  const [slow, medium, high] = await estimateTransaction(unsignedTx.payload, undefined, stacksNetwork);
+
+  let feePresets: RbfRecommendedFees = {};
+  let mediumFee = medium.fee;
+  let highFee = high.fee;
+  const higherFee = fee.multipliedBy(1.25).toNumber();
+  const highestFee = fee.multipliedBy(1.5).toNumber();
+
+  if (appInfo?.thresholdHighStacksFee) {
+    if (high.fee > appInfo.thresholdHighStacksFee) {
+      // adding a fee cap
+      highFee = appInfo.thresholdHighStacksFee * 1.5;
+      mediumFee = appInfo.thresholdHighStacksFee;
+    }
+  }
+
+  let minimumFee = fee.multipliedBy(1.25).toNumber();
+  if (!Number.isSafeInteger(minimumFee)) {
+    // round up the fee to the nearest integer
+    minimumFee = Math.ceil(minimumFee);
+  }
+
+  if (fee.lt(BigNumber(mediumFee))) {
+    feePresets = constructRecommendedFees('medium', mediumFee, 'high', highFee, stxAvailableBalance);
+  } else {
+    feePresets = constructRecommendedFees('higher', higherFee, 'highest', highestFee, stxAvailableBalance);
+  }
+
+  return {
+    rbfTransaction: undefined,
+    rbfTxSummary: {
+      currentFee: microstacksToStx(fee).toNumber(),
+      currentFeeRate: microstacksToStx(fee).toNumber(),
+      minimumRbfFee: microstacksToStx(BigNumber(minimumFee)).toNumber(),
+      minimumRbfFeeRate: microstacksToStx(BigNumber(minimumFee)).toNumber(),
+    },
+    rbfRecommendedFees: sortFees(feePresets),
+    mempoolFees: {
+      fastestFee: microstacksToStx(BigNumber(high.fee)).toNumber(),
+      halfHourFee: microstacksToStx(BigNumber(medium.fee)).toNumber(),
+      hourFee: microstacksToStx(BigNumber(slow.fee)).toNumber(),
+      economyFee: microstacksToStx(BigNumber(slow.fee)).toNumber(),
+      minimumFee: microstacksToStx(BigNumber(slow.fee)).toNumber(),
+    },
+  };
+};

hooks/useRbfTransactionData/index.ts

@@ -0,0 +1,96 @@
+import { useCallback, useEffect, useState } from 'react';
+import { rbf } from '../../transactions';
+import { Account, AppInfo, BtcTransactionData, SettingsNetwork, StacksNetwork, StxTransactionData } from '../../types';
+import { RbfData, calculateStxData, isBtcTransaction, sortFees } from './helpers';
+import { BitcoinEsploraApiProvider, mempoolApi } from '../../api';
+
+const useRbfTransactionData = ({
+  account,
+  transaction,
+  stacksNetwork,
+  btcNetwork,
+  esploraProvider,
+  stxAvailableBalance,
+  appInfo,
+  isLedgerAccount,
+}: {
+  account: Account | null;
+  transaction?: BtcTransactionData | StxTransactionData;
+  stacksNetwork: StacksNetwork;
+  btcNetwork: SettingsNetwork;
+  esploraProvider: BitcoinEsploraApiProvider;
+  stxAvailableBalance: string;
+  appInfo: AppInfo | null;
+  isLedgerAccount: boolean;
+}): RbfData => {
+  const [isLoading, setIsLoading] = useState(true);
+  const [rbfData, setRbfData] = useState<RbfData>({});
+  const [errorCode, setErrorCode] = useState<'SOMETHING_WENT_WRONG' | undefined>();
+
+  const fetchStxData = useCallback(async () => {
+    if (!transaction || isBtcTransaction(transaction)) {
+      return;
+    }
+    try {
+      setIsLoading(true);
+      const calculatedData = await calculateStxData(
+        transaction,
+        btcNetwork,
+        stacksNetwork,
+        appInfo,
+        stxAvailableBalance,
+      );
+      setRbfData(calculatedData);
+    } catch (err: any) {
+      setErrorCode('SOMETHING_WENT_WRONG');
+    } finally {
+      setIsLoading(false);
+    }
+  }, [transaction, btcNetwork, stacksNetwork, appInfo, stxAvailableBalance]);
+
+  const fetchRbfData = useCallback(async () => {
+    if (!account || !transaction) {
+      return;
+    }
+
+    if (!isBtcTransaction(transaction)) {
+      return fetchStxData();
+    }
+
+    try {
+      setIsLoading(true);
+
+      const rbfTx = new rbf.RbfTransaction(transaction, {
+        ...account,
+        accountType: account.accountType || 'software',
+        accountId: isLedgerAccount && account.deviceAccountIndex ? account.deviceAccountIndex : account.id,
+        network: btcNetwork.type,
+        esploraProvider,
+      });
+
+      const mempoolFees = await mempoolApi.getRecommendedFees(btcNetwork.type);
+      const rbfRecommendedFeesResponse = await rbfTx.getRbfRecommendedFees(mempoolFees);
+
+      const rbfTransactionSummary = await rbf.getRbfTransactionSummary(esploraProvider, transaction.txid);
+
+      setRbfData({
+        rbfTransaction: rbfTx,
+        rbfTxSummary: rbfTransactionSummary,
+        rbfRecommendedFees: sortFees(rbfRecommendedFeesResponse),
+        mempoolFees,
+      });
+    } catch (err: any) {
+      setErrorCode('SOMETHING_WENT_WRONG');
+    } finally {
+      setIsLoading(false);
+    }
+  }, [account, transaction, btcNetwork.type]);
+
+  useEffect(() => {
+    fetchRbfData();
+  }, [fetchRbfData]);
+
+  return { ...rbfData, isLoading, errorCode };
+};
+
+export default useRbfTransactionData;