From 948eb9ae8eae8d80087bfa4fe569e78eec8be61d Mon Sep 17 00:00:00 2001
From: Timur Sultanov <p3general@gmail.com>
Date: Tue, 7 Oct 2025 10:55:52 +0300
Subject: [PATCH 1/5] fix: correct amount calculation for self-transfer
 transactions in BTC, DASH, and DOGE

---
 src/lib/nodes/btc-indexer/utils.ts  | 4 +++-
 src/lib/nodes/dash/utils.ts         | 4 +++-
 src/lib/nodes/doge-indexer/utils.ts | 4 +++-
 3 files changed, 9 insertions(+), 3 deletions(-)

diff --git a/src/lib/nodes/btc-indexer/utils.ts b/src/lib/nodes/btc-indexer/utils.ts
index f05e79a71..686ce1467 100644
--- a/src/lib/nodes/btc-indexer/utils.ts
+++ b/src/lib/nodes/btc-indexer/utils.ts
@@ -12,6 +12,7 @@ export function normalizeTransaction(
   const recipients = tx.vout.map((vout) => vout.scriptpubkey_address)
 
   const direction = senders.includes(ownerAddress) ? 'from' : 'to'
+  const isSelfTransfer = senders.includes(ownerAddress) && recipients.includes(ownerAddress)
 
   if (direction === 'from') {
     // Disregard our address for an outgoing transaction unless it's the only address (i.e. we're sending to ourselves)
@@ -31,9 +32,10 @@ export function normalizeTransaction(
   // Calculate amount from outputs:
   // * for the outgoing transactions take outputs that DO NOT target us
   // * for the incoming transactions take outputs that DO target us
+  // * for self-transfers take outputs that DO target us
   const amount = tx.vout.reduce(
     (sum, t) =>
-      (direction === 'to') === (t.scriptpubkey_address === ownerAddress)
+      (isSelfTransfer || direction === 'to') === (t.scriptpubkey_address === ownerAddress)
         ? sum + Number(t.value)
         : sum,
     0
diff --git a/src/lib/nodes/dash/utils.ts b/src/lib/nodes/dash/utils.ts
index 3fbe6a28d..52e99f746 100644
--- a/src/lib/nodes/dash/utils.ts
+++ b/src/lib/nodes/dash/utils.ts
@@ -10,6 +10,7 @@ export function normalizeTransaction(tx: Transaction, ownerAddress: string): Das
   const recipients = tx.vout.flatMap((vout) => vout.scriptPubKey.addresses).filter(onlyUnique)
 
   const direction = senders.includes(ownerAddress) ? 'from' : 'to'
+  const isSelfTransfer = senders.includes(ownerAddress) && recipients.includes(ownerAddress)
 
   if (direction === 'from') {
     // Disregard our address for an outgoing transaction unless it's the only address (i.e. we're sending to ourselves)
@@ -29,9 +30,10 @@ export function normalizeTransaction(tx: Transaction, ownerAddress: string): Das
   // Calculate amount from outputs:
   // * for the outgoing transactions take outputs that DO NOT target us
   // * for the incoming transactions take outputs that DO target us
+  // * for self-transfers take outputs that DO target us
   const amount = tx.vout.reduce(
     (sum, t) =>
-      (direction === 'to') === t.scriptPubKey.addresses.includes(ownerAddress)
+      (isSelfTransfer || direction === 'to') === t.scriptPubKey.addresses.includes(ownerAddress)
         ? sum + Number(t.value)
         : sum,
     0
diff --git a/src/lib/nodes/doge-indexer/utils.ts b/src/lib/nodes/doge-indexer/utils.ts
index 458cf83af..337ff36f8 100644
--- a/src/lib/nodes/doge-indexer/utils.ts
+++ b/src/lib/nodes/doge-indexer/utils.ts
@@ -12,6 +12,7 @@ export function normalizeTransaction(tx: Transaction, ownerAddress: string): Dog
   const recipients = tx.vout.flatMap((vout) => vout.scriptPubKey.addresses).filter(onlyUnique)
 
   const direction = senders.includes(ownerAddress) ? 'from' : 'to'
+  const isSelfTransfer = senders.includes(ownerAddress) && recipients.includes(ownerAddress)
 
   if (direction === 'from') {
     // Disregard our address for an outgoing transaction unless it's the only address (i.e. we're sending to ourselves)
@@ -31,9 +32,10 @@ export function normalizeTransaction(tx: Transaction, ownerAddress: string): Dog
   // Calculate amount from outputs:
   // * for the outgoing transactions take outputs that DO NOT target us
   // * for the incoming transactions take outputs that DO target us
+  // * for self-transfers take outputs that DO target us
   const amount = tx.vout.reduce(
     (sum, t) =>
-      (direction === 'to') === t.scriptPubKey.addresses.includes(ownerAddress)
+      (isSelfTransfer || direction === 'to') === t.scriptPubKey.addresses.includes(ownerAddress)
         ? sum + Number(t.value)
         : sum,
     0

From b628ae2c926703e8b8e1c133350aeb95ff1b8a52 Mon Sep 17 00:00:00 2001
From: Timur Sultanov <p3general@gmail.com>
Date: Fri, 10 Oct 2025 19:46:20 +0300
Subject: [PATCH 2/5] feat: add color coding for transaction direction icons

---
 src/components/TransactionListItem.vue | 16 ++++++++++++----
 1 file changed, 12 insertions(+), 4 deletions(-)

diff --git a/src/components/TransactionListItem.vue b/src/components/TransactionListItem.vue
index 5f1e5aac3..25816b22f 100644
--- a/src/components/TransactionListItem.vue
+++ b/src/components/TransactionListItem.vue
@@ -3,7 +3,7 @@
     <v-list-item avatar :class="`${className}__tile`" @click="onClickTransaction">
       <template #prepend>
         <v-icon
-          :class="`${className}__prepend-icon`"
+          :class="`${className}__prepend-icon ${className}__prepend-icon ${directionClass}`"
           :icon="isStringEqualCI(senderId, userId) ? mdiAirplaneTakeoff : mdiAirplaneLanding"
           size="small"
         />
@@ -310,8 +310,15 @@ export default {
 /** Themes **/
 .v-theme--light.v-list {
   .transaction-item {
-    &__amount {
+    &__amount,
+    &__prependIcon {
       color: map.get(colors.$adm-colors, 'regular');
+      &--is-incoming {
+        color: map.get(colors.$adm-colors, 'good');
+      }
+      &--is-outgoing {
+        color: map.get(colors.$adm-colors, 'danger');
+      }
     }
     &__rates {
       color: map.get(colors.$adm-colors, 'muted');
@@ -329,8 +336,9 @@ export default {
 }
 .v-theme--dark.v-list {
   .transaction-item {
-    &__amount {
-      color: map.get(colors.$adm-colors, 'regular');
+    &__amount,
+    &__prependIcon {
+      color: map.get(colors.$adm-colors, 'grey-transparent');
       &--is-incoming {
         color: map.get(colors.$adm-colors, 'good');
       }

From 1a123ad6e351ef8b12040aa0ae64e28d2c0cfcc5 Mon Sep 17 00:00:00 2001
From: Timur Sultanov <p3general@gmail.com>
Date: Mon, 13 Oct 2025 19:47:03 +0300
Subject: [PATCH 3/5] fix: correct amount calculation for self-transfer
 transactions in BTC, DASH, and DOGE

---
 src/lib/nodes/btc-indexer/utils.ts  | 22 +++++++++++++---------
 src/lib/nodes/dash/utils.ts         | 22 +++++++++++++---------
 src/lib/nodes/doge-indexer/utils.ts | 22 +++++++++++++---------
 3 files changed, 39 insertions(+), 27 deletions(-)

diff --git a/src/lib/nodes/btc-indexer/utils.ts b/src/lib/nodes/btc-indexer/utils.ts
index 686ce1467..08e89788b 100644
--- a/src/lib/nodes/btc-indexer/utils.ts
+++ b/src/lib/nodes/btc-indexer/utils.ts
@@ -12,7 +12,9 @@ export function normalizeTransaction(
   const recipients = tx.vout.map((vout) => vout.scriptpubkey_address)
 
   const direction = senders.includes(ownerAddress) ? 'from' : 'to'
-  const isSelfTransfer = senders.includes(ownerAddress) && recipients.includes(ownerAddress)
+  const isSelfTransfer =
+    senders.every((addr) => addr === ownerAddress) &&
+    recipients.every((addr) => addr === ownerAddress)
 
   if (direction === 'from') {
     // Disregard our address for an outgoing transaction unless it's the only address (i.e. we're sending to ourselves)
@@ -32,14 +34,16 @@ export function normalizeTransaction(
   // Calculate amount from outputs:
   // * for the outgoing transactions take outputs that DO NOT target us
   // * for the incoming transactions take outputs that DO target us
-  // * for self-transfers take outputs that DO target us
-  const amount = tx.vout.reduce(
-    (sum, t) =>
-      (isSelfTransfer || direction === 'to') === (t.scriptpubkey_address === ownerAddress)
-        ? sum + Number(t.value)
-        : sum,
-    0
-  )
+  // * for self-transfers (all inputs and outputs are the same address) take the first output
+  const amount = isSelfTransfer
+    ? Number(tx.vout[0].value)
+    : tx.vout.reduce(
+        (sum, t) =>
+          (direction === 'to') === (t.scriptpubkey_address === ownerAddress)
+            ? sum + Number(t.value)
+            : sum,
+        0
+      )
 
   const confirmations = currentHeight
     ? currentHeight - tx.status.block_height + 1
diff --git a/src/lib/nodes/dash/utils.ts b/src/lib/nodes/dash/utils.ts
index 52e99f746..43cc88aee 100644
--- a/src/lib/nodes/dash/utils.ts
+++ b/src/lib/nodes/dash/utils.ts
@@ -10,7 +10,9 @@ export function normalizeTransaction(tx: Transaction, ownerAddress: string): Das
   const recipients = tx.vout.flatMap((vout) => vout.scriptPubKey.addresses).filter(onlyUnique)
 
   const direction = senders.includes(ownerAddress) ? 'from' : 'to'
-  const isSelfTransfer = senders.includes(ownerAddress) && recipients.includes(ownerAddress)
+  const isSelfTransfer =
+    senders.every((addr) => addr === ownerAddress) &&
+    recipients.every((addr) => addr === ownerAddress)
 
   if (direction === 'from') {
     // Disregard our address for an outgoing transaction unless it's the only address (i.e. we're sending to ourselves)
@@ -30,14 +32,16 @@ export function normalizeTransaction(tx: Transaction, ownerAddress: string): Das
   // Calculate amount from outputs:
   // * for the outgoing transactions take outputs that DO NOT target us
   // * for the incoming transactions take outputs that DO target us
-  // * for self-transfers take outputs that DO target us
-  const amount = tx.vout.reduce(
-    (sum, t) =>
-      (isSelfTransfer || direction === 'to') === t.scriptPubKey.addresses.includes(ownerAddress)
-        ? sum + Number(t.value)
-        : sum,
-    0
-  )
+  // * for self-transfers (all inputs and outputs are the same address) take the first output
+  const amount = isSelfTransfer
+    ? Number(tx.vout[0].value)
+    : tx.vout.reduce(
+        (sum, t) =>
+          (direction === 'to') === t.scriptPubKey.addresses.includes(ownerAddress)
+            ? sum + Number(t.value)
+            : sum,
+        0
+      )
 
   const confirmations = tx.confirmations
   const timestamp = tx.time * 1000
diff --git a/src/lib/nodes/doge-indexer/utils.ts b/src/lib/nodes/doge-indexer/utils.ts
index 337ff36f8..cbd948234 100644
--- a/src/lib/nodes/doge-indexer/utils.ts
+++ b/src/lib/nodes/doge-indexer/utils.ts
@@ -12,7 +12,9 @@ export function normalizeTransaction(tx: Transaction, ownerAddress: string): Dog
   const recipients = tx.vout.flatMap((vout) => vout.scriptPubKey.addresses).filter(onlyUnique)
 
   const direction = senders.includes(ownerAddress) ? 'from' : 'to'
-  const isSelfTransfer = senders.includes(ownerAddress) && recipients.includes(ownerAddress)
+  const isSelfTransfer =
+    senders.every((addr) => addr === ownerAddress) &&
+    recipients.every((addr) => addr === ownerAddress)
 
   if (direction === 'from') {
     // Disregard our address for an outgoing transaction unless it's the only address (i.e. we're sending to ourselves)
@@ -32,14 +34,16 @@ export function normalizeTransaction(tx: Transaction, ownerAddress: string): Dog
   // Calculate amount from outputs:
   // * for the outgoing transactions take outputs that DO NOT target us
   // * for the incoming transactions take outputs that DO target us
-  // * for self-transfers take outputs that DO target us
-  const amount = tx.vout.reduce(
-    (sum, t) =>
-      (isSelfTransfer || direction === 'to') === t.scriptPubKey.addresses.includes(ownerAddress)
-        ? sum + Number(t.value)
-        : sum,
-    0
-  )
+  // * for self-transfers (all inputs and outputs are the same address) take the first output
+  const amount = isSelfTransfer
+    ? Number(tx.vout[0].value)
+    : tx.vout.reduce(
+        (sum, t) =>
+          (direction === 'to') === t.scriptPubKey.addresses.includes(ownerAddress)
+            ? sum + Number(t.value)
+            : sum,
+        0
+      )
 
   const confirmations = tx.confirmations
   const timestamp = tx.time * 1000

From ed7f4bd61a3332b7ebce0926b763e1ba1fcf4b79 Mon Sep 17 00:00:00 2001
From: Timur Sultanov <p3general@gmail.com>
Date: Tue, 14 Oct 2025 10:51:24 +0300
Subject: [PATCH 4/5] fix: fix recepient address and transaction status for
 transactions with 2 inputs

---
 src/lib/nodes/btc-indexer/utils.ts  | 4 ++--
 src/lib/nodes/dash/utils.ts         | 2 +-
 src/lib/nodes/doge-indexer/utils.ts | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/lib/nodes/btc-indexer/utils.ts b/src/lib/nodes/btc-indexer/utils.ts
index 08e89788b..602988e94 100644
--- a/src/lib/nodes/btc-indexer/utils.ts
+++ b/src/lib/nodes/btc-indexer/utils.ts
@@ -8,8 +8,8 @@ export function normalizeTransaction(
   ownerAddress: string,
   currentHeight?: number
 ): BtcTransaction {
-  const senders = tx.vin.map((vin) => vin.prevout.scriptpubkey_address)
-  const recipients = tx.vout.map((vout) => vout.scriptpubkey_address)
+  const senders = [...new Set(tx.vin.map((vin) => vin.prevout.scriptpubkey_address))]
+  const recipients = [...new Set(tx.vout.map((vout) => vout.scriptpubkey_address))]
 
   const direction = senders.includes(ownerAddress) ? 'from' : 'to'
   const isSelfTransfer =
diff --git a/src/lib/nodes/dash/utils.ts b/src/lib/nodes/dash/utils.ts
index 43cc88aee..0a9b501fa 100644
--- a/src/lib/nodes/dash/utils.ts
+++ b/src/lib/nodes/dash/utils.ts
@@ -6,7 +6,7 @@ function onlyUnique<V>(value: V, index: number, array: V[]) {
 }
 
 export function normalizeTransaction(tx: Transaction, ownerAddress: string): DashTransaction {
-  const senders = tx.vin.map((vin) => vin.address)
+  const senders = [...new Set(tx.vin.map((vin) => vin.address))]
   const recipients = tx.vout.flatMap((vout) => vout.scriptPubKey.addresses).filter(onlyUnique)
 
   const direction = senders.includes(ownerAddress) ? 'from' : 'to'
diff --git a/src/lib/nodes/doge-indexer/utils.ts b/src/lib/nodes/doge-indexer/utils.ts
index cbd948234..0f9df1188 100644
--- a/src/lib/nodes/doge-indexer/utils.ts
+++ b/src/lib/nodes/doge-indexer/utils.ts
@@ -8,7 +8,7 @@ function onlyUnique<V>(value: V, index: number, array: V[]) {
 }
 
 export function normalizeTransaction(tx: Transaction, ownerAddress: string): DogeTransaction {
-  const senders = tx.vin.map((vin) => vin.addr)
+  const senders = [...new Set(tx.vin.map((vin) => vin.addr))]
   const recipients = tx.vout.flatMap((vout) => vout.scriptPubKey.addresses).filter(onlyUnique)
 
   const direction = senders.includes(ownerAddress) ? 'from' : 'to'

From c53ee3a206428d2b54cf020c97697e74b4a30c1d Mon Sep 17 00:00:00 2001
From: Timur Sultanov <p3general@gmail.com>
Date: Tue, 14 Oct 2025 11:14:29 +0300
Subject: [PATCH 5/5] test: add unit tests for BTC, DASH, and DOGE transaction
 normalization

---
 src/lib/nodes/btc-indexer/utils.spec.ts  | 182 ++++++++++++++++++++++
 src/lib/nodes/dash/utils.spec.ts         | 183 +++++++++++++++++++++++
 src/lib/nodes/doge-indexer/utils.spec.ts | 180 ++++++++++++++++++++++
 3 files changed, 545 insertions(+)
 create mode 100644 src/lib/nodes/btc-indexer/utils.spec.ts
 create mode 100644 src/lib/nodes/dash/utils.spec.ts
 create mode 100644 src/lib/nodes/doge-indexer/utils.spec.ts

diff --git a/src/lib/nodes/btc-indexer/utils.spec.ts b/src/lib/nodes/btc-indexer/utils.spec.ts
new file mode 100644
index 000000000..ed848d4df
--- /dev/null
+++ b/src/lib/nodes/btc-indexer/utils.spec.ts
@@ -0,0 +1,182 @@
+import { describe, it, expect } from 'vitest'
+import { normalizeTransaction } from './utils'
+import { Transaction } from './types/api/common/transaction'
+
+describe('normalizeTransaction', () => {
+  const OWNER_ADDRESS = '1EQuRM9nKdzUFUadUXKcaHQCeMR5eGsWwP'
+  const OTHER_ADDRESS = '18Yva8fgQyMxsSfYHpM2wqSnft814tPZxg'
+  const CURRENT_HEIGHT = 908000
+
+  // Transaction 795190ac... - Outgoing transaction with 2 inputs from same address
+  const txWithDuplicateSenders: Transaction = {
+    txid: '795190ac15ab1c402fd9dd117e41a2fee8c38b2b1c720fca1b73582d19595393',
+    version: 1,
+    locktime: 0,
+    vin: [
+      // Two inputs from the same address (owner used two UTXOs to cover amount + fee)
+      {
+        txid: 'd9dc71624543a28df63c2a10455f3b35fe78b4f4fb9a8ba271a07e750019b572',
+        vout: 0,
+        prevout: {
+          scriptpubkey: '76a914931ef5cbdad28723ba9596de5da1145ae969a71888ac',
+          scriptpubkey_asm:
+            'OP_DUP OP_HASH160 OP_PUSHBYTES_20 931ef5cbdad28723ba9596de5da1145ae969a718 OP_EQUALVERIFY OP_CHECKSIG',
+          scriptpubkey_type: 'p2pkh',
+          scriptpubkey_address: OWNER_ADDRESS,
+          value: 1000
+        },
+        scriptsig:
+          '473044022072f0797af905850aafed958e30d15fd3d9a3f76fd1db750b1b6059adf9355d1c0220383ebf2e39b66309e3342ce168386df6d9f020be4e7ec4de09c8ed98743525140121037ec9f6126013088b3d1e8f844f3e755144756a4e9a7da6b0094c189f55031934',
+        scriptsig_asm:
+          'OP_PUSHBYTES_71 3044022072f0797af905850aafed958e30d15fd3d9a3f76fd1db750b1b6059adf9355d1c0220383ebf2e39b66309e3342ce168386df6d9f020be4e7ec4de09c8ed987435251401 OP_PUSHBYTES_33 037ec9f6126013088b3d1e8f844f3e755144756a4e9a7da6b0094c189f55031934',
+        is_coinbase: false,
+        sequence: 4294967295
+      },
+      {
+        txid: '596b8c51880a09d352d1c30cae7f6948db23fafdd3cb264b95ec5c35e6202dc7',
+        vout: 1,
+        prevout: {
+          scriptpubkey: '76a914931ef5cbdad28723ba9596de5da1145ae969a71888ac',
+          scriptpubkey_asm:
+            'OP_DUP OP_HASH160 OP_PUSHBYTES_20 931ef5cbdad28723ba9596de5da1145ae969a718 OP_EQUALVERIFY OP_CHECKSIG',
+          scriptpubkey_type: 'p2pkh',
+          scriptpubkey_address: OWNER_ADDRESS,
+          value: 91629
+        },
+        scriptsig:
+          '483045022100d7e49c6656a8800d88664e0bf1611fadbe78add6bcb0a53fc2798775eead137d02206cd72545c51e4fdd141af5f823081a9f813f401fea88b78ac1b9020bbc86e03d0121037ec9f6126013088b3d1e8f844f3e755144756a4e9a7da6b0094c189f55031934',
+        scriptsig_asm:
+          'OP_PUSHBYTES_72 3045022100d7e49c6656a8800d88664e0bf1611fadbe78add6bcb0a53fc2798775eead137d02206cd72545c51e4fdd141af5f823081a9f813f401fea88b78ac1b9020bbc86e03d01 OP_PUSHBYTES_33 037ec9f6126013088b3d1e8f844f3e755144756a4e9a7da6b0094c189f55031934',
+        is_coinbase: false,
+        sequence: 4294967295
+      }
+    ],
+    vout: [
+      // First output: actual transfer to another address
+      {
+        scriptpubkey: '76a91452d27e8c1351dc928648968ba44c723fa402578788ac',
+        scriptpubkey_asm:
+          'OP_DUP OP_HASH160 OP_PUSHBYTES_20 52d27e8c1351dc928648968ba44c723fa4025787 OP_EQUALVERIFY OP_CHECKSIG',
+        scriptpubkey_type: 'p2pkh',
+        scriptpubkey_address: OTHER_ADDRESS,
+        value: 600
+      },
+      // Second output: change back to owner
+      {
+        scriptpubkey: '76a914931ef5cbdad28723ba9596de5da1145ae969a71888ac',
+        scriptpubkey_asm:
+          'OP_DUP OP_HASH160 OP_PUSHBYTES_20 931ef5cbdad28723ba9596de5da1145ae969a718 OP_EQUALVERIFY OP_CHECKSIG',
+        scriptpubkey_type: 'p2pkh',
+        scriptpubkey_address: OWNER_ADDRESS,
+        value: 91534
+      }
+    ],
+    size: 373,
+    weight: 1492,
+    fee: 495,
+    status: {
+      confirmed: true,
+      block_height: 907930,
+      block_hash: '0000000000000000000154792351118ab482e8b3880e9c30779ec444a9f3aa54',
+      block_time: 1753953340
+    }
+  }
+
+  // Transaction d9dc7162... - Self-transfer to the same address
+  const txSelfTransfer: Transaction = {
+    txid: 'd9dc71624543a28df63c2a10455f3b35fe78b4f4fb9a8ba271a07e750019b572',
+    version: 1,
+    locktime: 0,
+    vin: [
+      {
+        txid: 'cc24dacb04298f5381fd3ee0e742b8c1ce109d1e75f29079404fcf02b29556e7',
+        vout: 1,
+        prevout: {
+          scriptpubkey: '76a914931ef5cbdad28723ba9596de5da1145ae969a71888ac',
+          scriptpubkey_asm:
+            'OP_DUP OP_HASH160 OP_PUSHBYTES_20 931ef5cbdad28723ba9596de5da1145ae969a718 OP_EQUALVERIFY OP_CHECKSIG',
+          scriptpubkey_type: 'p2pkh',
+          scriptpubkey_address: OWNER_ADDRESS,
+          value: 96781
+        },
+        scriptsig: '47304402207c3b3...',
+        scriptsig_asm: 'OP_PUSHBYTES_71...',
+        is_coinbase: false,
+        sequence: 4294967295
+      }
+    ],
+    vout: [
+      // First output: actual transfer amount (what user entered in "Send" dialog)
+      {
+        scriptpubkey: '76a914931ef5cbdad28723ba9596de5da1145ae969a71888ac',
+        scriptpubkey_asm:
+          'OP_DUP OP_HASH160 OP_PUSHBYTES_20 931ef5cbdad28723ba9596de5da1145ae969a718 OP_EQUALVERIFY OP_CHECKSIG',
+        scriptpubkey_type: 'p2pkh',
+        scriptpubkey_address: OWNER_ADDRESS,
+        value: 1000
+      },
+      // Second output: change (remaining balance after transfer and fee)
+      {
+        scriptpubkey: '76a914931ef5cbdad28723ba9596de5da1145ae969a71888ac',
+        scriptpubkey_asm:
+          'OP_DUP OP_HASH160 OP_PUSHBYTES_20 931ef5cbdad28723ba9596de5da1145ae969a718 OP_EQUALVERIFY OP_CHECKSIG',
+        scriptpubkey_type: 'p2pkh',
+        scriptpubkey_address: OWNER_ADDRESS,
+        value: 94963
+      }
+    ],
+    size: 225,
+    weight: 900,
+    fee: 818,
+    status: {
+      confirmed: true,
+      block_height: 906955,
+      block_hash: '00000000000000000001547923511...',
+      block_time: 1753900000
+    }
+  }
+
+  it('should remove duplicate senders and display transaction correctly', () => {
+    const result = normalizeTransaction(txWithDuplicateSenders, OWNER_ADDRESS, CURRENT_HEIGHT)
+
+    // Assert: senders array should contain only unique addresses (no duplicates)
+    expect(result.senders).toEqual([OWNER_ADDRESS])
+    expect(result.senders).toHaveLength(1)
+
+    // Assert: direction should be 'from' (outgoing) since owner is the sender
+    expect(result.direction).toBe('from')
+
+    // Assert: senderId should be owner address (we are sending)
+    expect(result.senderId).toBe(OWNER_ADDRESS)
+
+    // Assert: recipientId should be OTHER_ADDRESS (recipient, not our change address)
+    // normalizeTransaction correctly filters out owner's change address from recipients
+    expect(result.recipientId).toBe(OTHER_ADDRESS)
+
+    // Assert: recipients array should only contain the actual recipient (change filtered out)
+    expect(result.recipients).toEqual([OTHER_ADDRESS])
+
+    // Assert: amount should be 0.000006 BTC (600 satoshi / 100,000,000)
+    // This is the actual transfer amount sent to OTHER_ADDRESS, not the change (91534)
+    expect(result.amount).toBe(0.000006)
+  })
+
+  it('should calculate correct amount for self-transfer', () => {
+    const result = normalizeTransaction(txSelfTransfer, OWNER_ADDRESS, CURRENT_HEIGHT)
+
+    // Assert: This is correctly identified as true self-transfer
+    // All senders = owner AND all recipients = owner
+    expect(result.senders).toEqual([OWNER_ADDRESS])
+    expect(result.recipients).toEqual([OWNER_ADDRESS])
+
+    // Assert: both sender and recipient are owner address (sending to self)
+    expect(result.senderId).toBe(OWNER_ADDRESS)
+    expect(result.recipientId).toBe(OWNER_ADDRESS)
+
+    // Assert: direction should be 'from' (outgoing, even though sending to self)
+    expect(result.direction).toBe('from')
+
+    // Assert: amount should be ONLY first output: 1000 satoshi = 0.00001 BTC
+    expect(result.amount).toBe(0.00001)
+  })
+})
diff --git a/src/lib/nodes/dash/utils.spec.ts b/src/lib/nodes/dash/utils.spec.ts
new file mode 100644
index 000000000..8196b29bd
--- /dev/null
+++ b/src/lib/nodes/dash/utils.spec.ts
@@ -0,0 +1,183 @@
+import { describe, it, expect } from 'vitest'
+import { normalizeTransaction } from './utils'
+import { Transaction } from './types/api/transaction'
+
+describe('normalizeTransaction', () => {
+  const OWNER_ADDRESS = 'XqPCbp7S5pVPdqVqH3L7D3vUqC8t9xYPZg'
+  const OTHER_ADDRESS = 'XmNwxKvKYqLkQzQvY8xJnBvZ6FwPzXqVaL'
+
+  // Transaction with duplicate senders (multiple inputs from same address)
+  const txWithDuplicateSenders: Transaction = {
+    txid: 'dash_tx_duplicate_senders',
+    version: 1,
+    type: 0,
+    size: 250,
+    locktime: 0,
+    vin: [
+      // Two inputs from the same address (owner used two UTXOs)
+      {
+        address: OWNER_ADDRESS,
+        value: 1000,
+        valueSat: 1000,
+        txid: 'prev1',
+        vout: 0,
+        scriptSig: { asm: '', hex: '' },
+        sequence: 0
+      },
+      {
+        address: OWNER_ADDRESS,
+        value: 91629,
+        valueSat: 91629,
+        txid: 'prev2',
+        vout: 1,
+        scriptSig: { asm: '', hex: '' },
+        sequence: 0
+      }
+    ],
+    vout: [
+      // First output: actual transfer to another address
+      {
+        value: 600,
+        valueSat: 600,
+        scriptPubKey: {
+          addresses: [OTHER_ADDRESS],
+          asm: 'OP_DUP...',
+          hex: '76a914...',
+          reqSigs: 1,
+          type: 'pubkeyhash'
+        },
+        n: 0,
+        spentTxId: '',
+        spentIndex: 0,
+        spentHeight: 0
+      },
+      // Second output: change back to owner
+      {
+        value: 91534,
+        valueSat: 91534,
+        scriptPubKey: {
+          addresses: [OWNER_ADDRESS],
+          asm: 'OP_DUP...',
+          hex: '76a914...',
+          reqSigs: 1,
+          type: 'pubkeyhash'
+        },
+        n: 1,
+        spentTxId: '',
+        spentIndex: 0,
+        spentHeight: 0
+      }
+    ],
+    hex: '0100000002...',
+    blockhash: '00000000000000000001...',
+    height: 2100000,
+    confirmations: 100,
+    time: 1753953340,
+    blocktime: 1753953340,
+    instantlock: false,
+    instantlock_internal: false,
+    chainlock: false
+  }
+
+  // Self-transfer transaction (sending to own address)
+  const txSelfTransfer: Transaction = {
+    txid: 'dash_tx_self_transfer',
+    version: 1,
+    type: 0,
+    size: 220,
+    locktime: 0,
+    vin: [
+      {
+        address: OWNER_ADDRESS,
+        value: 96781,
+        valueSat: 96781,
+        txid: 'prev3',
+        vout: 0,
+        scriptSig: { asm: '', hex: '' },
+        sequence: 0
+      }
+    ],
+    vout: [
+      // First output: actual transfer amount
+      {
+        value: 1000,
+        valueSat: 1000,
+        scriptPubKey: {
+          addresses: [OWNER_ADDRESS],
+          asm: 'OP_DUP...',
+          hex: '76a914...',
+          reqSigs: 1,
+          type: 'pubkeyhash'
+        },
+        n: 0,
+        spentTxId: '',
+        spentIndex: 0,
+        spentHeight: 0
+      },
+      // Second output: change
+      {
+        value: 94963,
+        valueSat: 94963,
+        scriptPubKey: {
+          addresses: [OWNER_ADDRESS],
+          asm: 'OP_DUP...',
+          hex: '76a914...',
+          reqSigs: 1,
+          type: 'pubkeyhash'
+        },
+        n: 1,
+        spentTxId: '',
+        spentIndex: 0,
+        spentHeight: 0
+      }
+    ],
+    hex: '0100000001...',
+    blockhash: '00000000000000000002...',
+    height: 2099000,
+    confirmations: 1100,
+    time: 1753900000,
+    blocktime: 1753900000,
+    instantlock: false,
+    instantlock_internal: false,
+    chainlock: false
+  }
+
+  it('should remove duplicate senders and display transaction correctly', () => {
+    const result = normalizeTransaction(txWithDuplicateSenders, OWNER_ADDRESS)
+
+    // Assert: senders array should contain only unique addresses
+    expect(result.senders).toEqual([OWNER_ADDRESS])
+    expect(result.senders).toHaveLength(1)
+
+    // Assert: direction should be 'from' (outgoing)
+    expect(result.direction).toBe('from')
+
+    // Assert: senderId should be owner, recipientId should be OTHER_ADDRESS
+    expect(result.senderId).toBe(OWNER_ADDRESS)
+    expect(result.recipientId).toBe(OTHER_ADDRESS)
+
+    // Assert: recipients should only contain actual recipient (change filtered out)
+    expect(result.recipients).toEqual([OTHER_ADDRESS])
+
+    // Assert: amount should be 600 (actual transfer)
+    expect(result.amount).toBe(600)
+  })
+
+  it('should calculate correct amount for self-transfer (fix for incorrect amount bug)', () => {
+    const result = normalizeTransaction(txSelfTransfer, OWNER_ADDRESS)
+
+    // Assert: correctly identified as self-transfer
+    expect(result.senders).toEqual([OWNER_ADDRESS])
+    expect(result.recipients).toEqual([OWNER_ADDRESS])
+
+    // Assert: both sender and recipient are owner
+    expect(result.senderId).toBe(OWNER_ADDRESS)
+    expect(result.recipientId).toBe(OWNER_ADDRESS)
+
+    // Assert: direction is outgoing (even though sending to self)
+    expect(result.direction).toBe('from')
+
+    // Assert: amount should be first output (1000)
+    expect(result.amount).toBe(1000)
+  })
+})
diff --git a/src/lib/nodes/doge-indexer/utils.spec.ts b/src/lib/nodes/doge-indexer/utils.spec.ts
new file mode 100644
index 000000000..b33cb5513
--- /dev/null
+++ b/src/lib/nodes/doge-indexer/utils.spec.ts
@@ -0,0 +1,180 @@
+import { describe, it, expect } from 'vitest'
+import { normalizeTransaction } from './utils'
+import { Transaction } from './types/api/transaction'
+
+describe('normalizeTransaction', () => {
+  const OWNER_ADDRESS = 'D7P2cNgXqTxHbFCzZhKdNZHRqWZvhRxYHB'
+  const OTHER_ADDRESS = 'DQz8fK9mXqTxHbFCzZhKdNZHRqWZvhRxYN'
+
+  // Transaction with duplicate senders (multiple inputs from same address)
+  const txWithDuplicateSenders: Transaction = {
+    txid: 'doge_tx_duplicate_senders',
+    hash: 'doge_tx_duplicate_senders',
+    size: 250,
+    vsize: 250,
+    version: 1,
+    locktime: 0,
+    vin: [
+      // Two inputs from the same address (owner used two UTXOs)
+      {
+        addr: OWNER_ADDRESS,
+        value: 1000,
+        valueSat: 1000,
+        txid: 'prev1',
+        vout: 0,
+        scriptSig: { asm: '', hex: '' },
+        sequence: 0,
+        n: 0,
+        doubleSpentTxID: null,
+        isConfirmed: true,
+        confirmations: 100,
+        unconfirmedInput: false
+      },
+      {
+        addr: OWNER_ADDRESS,
+        value: 91629,
+        valueSat: 91629,
+        txid: 'prev2',
+        vout: 1,
+        scriptSig: { asm: '', hex: '' },
+        sequence: 0,
+        n: 1,
+        doubleSpentTxID: null,
+        isConfirmed: true,
+        confirmations: 100,
+        unconfirmedInput: false
+      }
+    ],
+    vout: [
+      // First output: actual transfer to another address
+      {
+        value: '600',
+        scriptPubKey: {
+          addresses: [OTHER_ADDRESS],
+          asm: 'OP_DUP...',
+          hex: '76a914...',
+          reqSigs: 1,
+          type: 'pubkeyhash'
+        },
+        n: 0
+      },
+      // Second output: change back to owner
+      {
+        value: '91534',
+        scriptPubKey: {
+          addresses: [OWNER_ADDRESS],
+          asm: 'OP_DUP...',
+          hex: '76a914...',
+          reqSigs: 1,
+          type: 'pubkeyhash'
+        },
+        n: 1
+      }
+    ],
+    blockhash: '00000000000000000001...',
+    confirmations: 100,
+    time: 1753953340,
+    blocktime: 1753953340,
+    valueOut: 92134,
+    valueIn: 92629,
+    fees: 495
+  }
+
+  // Self-transfer transaction (sending to own address)
+  const txSelfTransfer: Transaction = {
+    txid: 'doge_tx_self_transfer',
+    hash: 'doge_tx_self_transfer',
+    size: 220,
+    vsize: 220,
+    version: 1,
+    locktime: 0,
+    vin: [
+      {
+        addr: OWNER_ADDRESS,
+        value: 96781,
+        valueSat: 96781,
+        txid: 'prev3',
+        vout: 0,
+        scriptSig: { asm: '', hex: '' },
+        sequence: 0,
+        n: 0,
+        doubleSpentTxID: null,
+        isConfirmed: true,
+        confirmations: 1100,
+        unconfirmedInput: false
+      }
+    ],
+    vout: [
+      // First output: actual transfer amount
+      {
+        value: '1000',
+        scriptPubKey: {
+          addresses: [OWNER_ADDRESS],
+          asm: 'OP_DUP...',
+          hex: '76a914...',
+          reqSigs: 1,
+          type: 'pubkeyhash'
+        },
+        n: 0
+      },
+      // Second output: change
+      {
+        value: '94963',
+        scriptPubKey: {
+          addresses: [OWNER_ADDRESS],
+          asm: 'OP_DUP...',
+          hex: '76a914...',
+          reqSigs: 1,
+          type: 'pubkeyhash'
+        },
+        n: 1
+      }
+    ],
+    blockhash: '00000000000000000002...',
+    confirmations: 1100,
+    time: 1753900000,
+    blocktime: 1753900000,
+    valueOut: 95963,
+    valueIn: 96781,
+    fees: 818
+  }
+
+  it('should remove duplicate senders and display transaction correctly', () => {
+    const result = normalizeTransaction(txWithDuplicateSenders, OWNER_ADDRESS)
+
+    // Assert: senders array should contain only unique addresses
+    expect(result.senders).toEqual([OWNER_ADDRESS])
+    expect(result.senders).toHaveLength(1)
+
+    // Assert: direction should be 'from' (outgoing)
+    expect(result.direction).toBe('from')
+
+    // Assert: senderId should be owner, recipientId should be OTHER_ADDRESS
+    expect(result.senderId).toBe(OWNER_ADDRESS)
+    expect(result.recipientId).toBe(OTHER_ADDRESS)
+
+    // Assert: recipients should only contain actual recipient (change filtered out)
+    expect(result.recipients).toEqual([OTHER_ADDRESS])
+
+    // Assert: amount should be 600 (actual transfer)
+    expect(result.amount).toBe(600)
+  })
+
+  it('should calculate correct amount for self-transfer (fix for incorrect amount bug)', () => {
+    const result = normalizeTransaction(txSelfTransfer, OWNER_ADDRESS)
+
+    // Assert: correctly identified as self-transfer
+    expect(result.senders).toEqual([OWNER_ADDRESS])
+    expect(result.recipients).toEqual([OWNER_ADDRESS])
+
+    // Assert: both sender and recipient are owner
+    expect(result.senderId).toBe(OWNER_ADDRESS)
+    expect(result.recipientId).toBe(OWNER_ADDRESS)
+
+    // Assert: direction is outgoing (even though sending to self)
+    expect(result.direction).toBe('from')
+
+    // Assert: amount should be first output (1000)
+    expect(result.amount).toBe(1000)
+  })
+})