fix: correct open issues with settlementDisplayAmount gql selection (#2393)

* test: expect correct decimal places for settlementDisplayAmount

* fix: change settlementDisplayAmount type to string

* test: add settlementDisplayAmount checks to onchain-send

* feat: add new SettlementAmounts calculator

* test: add unit tests for SettlementAmounts

* fix: switch to SettlementAmounts calculator in tx-history

* test: add settlementDisplayAmount check for pending incoming onchain txn

* fix: correct price for calculating pending incoming settlementDisplayAmount

Author: vindard

src/domain/fiat/display-currency.ts

@@ -14,11 +14,11 @@ export const minorToMajorUnit = ({
   displayMajorExponent: CurrencyMajorExponent
 }) => {
   const majorExponent = Number(displayMajorExponent)
-  return Number((Number(amount) / 10 ** majorExponent).toFixed(majorExponent))
+  return (Number(amount) / 10 ** majorExponent).toFixed(majorExponent)
 }
 
 export const usdMinorToMajorUnit = (amount: number | bigint) =>
-  minorToMajorUnit({ amount, displayMajorExponent: MajorExponent.STANDARD })
+  Number(minorToMajorUnit({ amount, displayMajorExponent: MajorExponent.STANDARD }))
 
 export const majorToMinorUnit = ({
   amount,

src/domain/wallets/index.types.d.ts

@@ -52,7 +52,7 @@ type BaseWalletTransaction = {
   readonly settlementAmount: Satoshis | UsdCents
   readonly settlementFee: Satoshis | UsdCents
   readonly settlementCurrency: WalletCurrency
-  readonly settlementDisplayAmount: number
+  readonly settlementDisplayAmount: DisplayCurrencyMajorAmount
   readonly settlementDisplayCurrency: DisplayCurrency | ""
   readonly displayCurrencyPerSettlementCurrencyUnit: number
   readonly status: TxStatus

src/domain/wallets/settlement-amounts.ts

@@ -0,0 +1,111 @@
+import { toSats } from "@domain/bitcoin"
+import { MajorExponent, minorToMajorUnit, toCents } from "@domain/fiat"
+import { WalletCurrency } from "@domain/shared"
+
+export const SettlementAmounts = () => {
+  const fromTxn = <S extends WalletCurrency>(
+    txn: LedgerTransaction<S>,
+  ): {
+    settlementAmount: Satoshis | UsdCents
+    settlementDisplayAmount: DisplayCurrencyMajorAmount
+  } => {
+    // ======
+    // Calculate: settlementAmount
+    // ======
+
+    const { debit, credit, currency } = txn
+    const settlementAmount =
+      currency === WalletCurrency.Btc ? toSats(credit - debit) : toCents(credit - debit)
+
+    // ======
+    // Calculate: settlementDisplayAmount
+    // ======
+
+    // Setup settlementDisplayAmount calc
+    const {
+      satsAmount: satsAmountRaw,
+      satsFee: satsFeeRaw,
+      centsAmount: centsAmountRaw,
+      centsFee: centsFeeRaw,
+      displayAmount: displayAmountRaw,
+      displayFee: displayFeeRaw,
+    } = txn
+
+    const satsAmount = satsAmountRaw || toSats(0)
+    const satsFee = satsFeeRaw || toSats(0)
+    const centsAmount = centsAmountRaw || toCents(0)
+    const centsFee = centsFeeRaw || toCents(0)
+    const displayAmount = displayAmountRaw || (0 as DisplayCurrencyBaseAmount)
+    const displayFee = displayFeeRaw || (0 as DisplayCurrencyBaseAmount)
+
+    const amount = {
+      sats: satsAmount,
+      cents: centsAmount,
+      display: displayAmount,
+    }
+    const negAmount = {
+      sats: toSats(-satsAmount),
+      cents: toCents(-centsAmount),
+      display: -displayAmount as DisplayCurrencyBaseAmount,
+    }
+    const fee = {
+      sats: satsFee,
+      cents: centsFee,
+      display: displayFee,
+    }
+    const negFee = {
+      sats: toSats(-satsFee),
+      cents: toCents(-centsFee),
+      display: -displayFee as DisplayCurrencyBaseAmount,
+    }
+    const zero = {
+      sats: 0 as Satoshis,
+      cents: 0 as UsdCents,
+      display: 0 as DisplayCurrencyBaseAmount,
+    }
+
+    const combinations: {
+      sats: Satoshis
+      cents: UsdCents
+      display: DisplayCurrencyBaseAmount
+    }[][] = [
+      [amount, zero],
+      [negAmount, zero],
+      [zero, fee],
+      [zero, negFee],
+      [amount, fee],
+      [negAmount, negFee],
+      [amount, negFee],
+      [negAmount, fee],
+    ]
+
+    // Match settlementDisplayAmount calc to settlementAmount
+    let matchIndex = -1
+    for (const [i, [amount, fee]] of combinations.entries()) {
+      const unit = currency === WalletCurrency.Btc ? "sats" : "cents"
+      if (amount[unit] + fee[unit] === settlementAmount) {
+        matchIndex = i
+        break
+      }
+    }
+
+    // Calculate settlementDisplayAmount with matched combination
+    let settlementDisplayAmountAsNumber = 0
+    if (matchIndex >= 0) {
+      const [amountToUse, feeToUse] = combinations[matchIndex]
+      settlementDisplayAmountAsNumber = amountToUse.display + feeToUse.display
+    }
+
+    return {
+      settlementAmount,
+      settlementDisplayAmount: minorToMajorUnit({
+        amount: settlementDisplayAmountAsNumber,
+        displayMajorExponent: MajorExponent.STANDARD,
+      }),
+    }
+  }
+
+  return {
+    fromTxn,
+  }
+}

src/domain/wallets/tx-history.ts

@@ -12,6 +12,7 @@ import { AdminLedgerTransactionType, LedgerTransactionType } from "@domain/ledge
 import { TxStatus } from "./tx-status"
 import { DepositFeeCalculator } from "./deposit-fee-calculator"
 import { PaymentInitiationMethod, SettlementMethod } from "./tx-methods"
+import { SettlementAmounts } from "./settlement-amounts"
 
 const filterPendingIncoming = ({
   pendingIncoming,
@@ -33,8 +34,11 @@ const filterPendingIncoming = ({
 
             const settlementAmount = toSats(sats - fee)
 
+            const priceForMinorUnit =
+              displayCurrencyPerSat.price * 10 ** Number(MajorExponent.STANDARD)
+
             const settlementDisplayAmount = minorToMajorUnit({
-              amount: Math.round(displayCurrencyPerSat.price * settlementAmount),
+              amount: Math.round(priceForMinorUnit * settlementAmount),
               displayMajorExponent: MajorExponent.STANDARD,
             })
 
@@ -77,7 +81,6 @@ const translateLedgerTxnToWalletTxn = <S extends WalletCurrency>({
   const {
     type,
     credit,
-    debit,
     currency,
     satsAmount: satsAmountRaw,
     satsFee: satsFeeRaw,
@@ -96,8 +99,7 @@ const translateLedgerTxnToWalletTxn = <S extends WalletCurrency>({
     type as AdminLedgerTransactionType,
   )
 
-  const settlementAmount =
-    currency === WalletCurrency.Btc ? toSats(credit - debit) : toCents(credit - debit)
+  const { settlementAmount, settlementDisplayAmount } = SettlementAmounts().fromTxn(txn)
 
   let satsAmount = satsAmountRaw || 0
   let centsAmount = centsAmountRaw || 0
@@ -127,11 +129,6 @@ const translateLedgerTxnToWalletTxn = <S extends WalletCurrency>({
 
   const status = txn.pendingConfirmation ? TxStatus.Pending : TxStatus.Success
 
-  const settlementDisplayAmount = minorToMajorUnit({
-    amount: displayAmount,
-    displayMajorExponent: MajorExponent.STANDARD,
-  })
-
   const baseTransaction: BaseWalletTransaction = {
     id: txn.id,
     walletId: txn.walletId,

test/e2e/servers/graphql-main-server/with-auth-requests.spec.ts

@@ -259,7 +259,7 @@ describe("graphql", () => {
             node: expect.objectContaining({
               settlementAmount: 4_000,
               settlementCurrency: WalletCurrency.Usd,
-              settlementDisplayAmount: "40",
+              settlementDisplayAmount: "40.00",
               settlementDisplayCurrency: DisplayCurrency.Usd,
             }),
           }),

test/integration/02-user-wallet/02-receive-onchain.spec.ts

@@ -409,6 +409,12 @@ describe("UserWallet - On chain", () => {
     expect(pendingTx.initiationVia.address).toBe(address)
     expect(pendingTx.createdAt).toBeInstanceOf(Date)
 
+    expect(pendingTx.settlementDisplayAmount).toBe(
+      (
+        pendingTx.settlementAmount * pendingTx.displayCurrencyPerSettlementCurrencyUnit
+      ).toFixed(2),
+    )
+
     // Check pendingTx from cache
     const { result: txsFromCache, error: errorFromCache } =
       await getTransactionsForWalletId(walletIdA)

test/integration/02-user-wallet/02-send-onchain.spec.ts

@@ -49,6 +49,8 @@ import {
   UnknownOnChainServiceError,
 } from "@domain/bitcoin/onchain/errors"
 import { TxDecoder } from "@domain/bitcoin/onchain"
+import { SettlementAmounts } from "@domain/wallets/settlement-amounts"
+
 import * as OnChainServiceImpl from "@services/lnd/onchain-service"
 import { DealerPriceService } from "@services/dealer-price"
 
@@ -236,6 +238,13 @@ const testExternalSend = async ({
     const pendingTx = pendingTxs[0]
     const interimBalance = await getBalanceHelper(senderWalletId)
 
+    const pendingLedgerTx = await LedgerService().getTransactionById(
+      pendingTx.id as LedgerTransactionId,
+    )
+    if (pendingLedgerTx instanceof Error) throw pendingLedgerTx
+    const { settlementDisplayAmount } = SettlementAmounts().fromTxn(pendingLedgerTx)
+    expect(pendingTx.settlementDisplayAmount).toBe(settlementDisplayAmount)
+
     if (sendAll) {
       expect(pendingTx.settlementAmount).toBe(-initialWalletBalance)
       expect(interimBalance).toBe(0)
@@ -291,6 +300,13 @@ const testExternalSend = async ({
     expect(settledTx.settlementFee).toBe(fee)
     expect(settledTx.displayCurrencyPerSettlementCurrencyUnit).toBeGreaterThan(0)
 
+    const settledLedgerTx = await LedgerService().getTransactionById(
+      settledTx.id as LedgerTransactionId,
+    )
+    if (settledLedgerTx instanceof Error) throw settledLedgerTx
+    const { settlementDisplayAmount } = SettlementAmounts().fromTxn(settledLedgerTx)
+    expect(settledTx.settlementDisplayAmount).toBe(settlementDisplayAmount)
+
     const finalBalance = await getBalanceHelper(senderWalletId)
 
     if (sendAll) {
@@ -540,6 +556,13 @@ const testInternalSend = async ({
   expect(senderSettledTx.settlementAmount).toBe(-senderAmount)
   expect(senderSettledTx.displayCurrencyPerSettlementCurrencyUnit).toBeGreaterThan(0)
 
+  const senderSettledLedgerTx = await LedgerService().getTransactionById(
+    senderSettledTx.id as LedgerTransactionId,
+  )
+  if (senderSettledLedgerTx instanceof Error) throw senderSettledLedgerTx
+  const { settlementDisplayAmount } = SettlementAmounts().fromTxn(senderSettledLedgerTx)
+  expect(senderSettledTx.settlementDisplayAmount).toBe(settlementDisplayAmount)
+
   // Check txn details for received wallet
   // ===
   const { result: txsRecipient, error: errorUserA } = await getTransactionsForWalletId(
@@ -565,6 +588,13 @@ const testInternalSend = async ({
   expect(recipientSettledTx.settlementAmount).toBe(recipientAmount)
   expect(recipientSettledTx.displayCurrencyPerSettlementCurrencyUnit).toBeGreaterThan(0)
 
+  expect(recipientSettledTx.settlementDisplayAmount).toBe(
+    (
+      recipientSettledTx.settlementAmount *
+      recipientSettledTx.displayCurrencyPerSettlementCurrencyUnit
+    ).toFixed(2),
+  )
+
   // Check memos
   // ===
   const matchTx = (tx: WalletTransaction) =>