feat: address monitor and btc tx notifications

scripts/generate-manifest.js

@@ -69,7 +69,7 @@ const manifest = {
   manifest_version: 3,
   author: 'Leather Wallet, LLC',
   description: 'Leather Bitcoin Wallet - Your Bitcoin Wallet for DeFi, NFTs, Ordinals, and dApps',
-  permissions: ['contextMenus', 'storage', 'unlimitedStorage'],
+  permissions: ['contextMenus', 'storage', 'unlimitedStorage', 'notifications'],
   commands: {
     _execute_browser_action: {
       suggested_key: {

src/app/features/address-monitor/use-monitorable-addresses.ts

@@ -0,0 +1,79 @@
+import { useMemo } from 'react';
+
+import type { HDKey } from '@scure/bip32';
+import type { P2Ret } from '@scure/btc-signer/payment';
+
+import {
+  type SupportedPaymentType,
+  deriveAddressIndexZeroFromAccount,
+  getNativeSegwitPaymentFromAddressIndex,
+  getTaprootPaymentFromAddressIndex,
+} from '@leather.io/bitcoin';
+import type { BitcoinNetworkModes } from '@leather.io/models';
+import { createNullArrayOfLength, isDefined } from '@leather.io/utils';
+
+import { useCurrentAccountIndex } from '@app/store/accounts/account';
+import { useGenerateNativeSegwitAccount } from '@app/store/accounts/blockchain/bitcoin/native-segwit-account.hooks';
+import { useGenerateTaprootAccount } from '@app/store/accounts/blockchain/bitcoin/taproot-account.hooks';
+import { useStacksAccounts } from '@app/store/accounts/blockchain/stacks/stacks-account.hooks';
+import { useCurrentNetworkId } from '@app/store/networks/networks.selectors';
+import type { MonitoredAddress } from '@background/monitors/address-monitor';
+
+const paymentFnMap: Record<
+  SupportedPaymentType,
+  (keychain: HDKey, network: BitcoinNetworkModes) => P2Ret
+> = {
+  p2tr: getTaprootPaymentFromAddressIndex,
+  p2wpkh: getNativeSegwitPaymentFromAddressIndex,
+};
+
+export function useMonitorableAddresses() {
+  const currentAccountIndex = useCurrentAccountIndex();
+  const currentNetworkId = useCurrentNetworkId();
+  const createNativeSegwitAccount = useGenerateNativeSegwitAccount();
+  const createTaprootAccount = useGenerateTaprootAccount();
+
+  const stacksAccounts = useStacksAccounts();
+
+  return useMemo(() => {
+    if (!stacksAccounts || !currentNetworkId) return;
+
+    const stacksAddresses = stacksAccounts.map(
+      account =>
+        ({
+          accountIndex: account.index,
+          address: account.address,
+          chain: 'stacks',
+          isCurrent: account.index === currentAccountIndex,
+        }) satisfies MonitoredAddress
+    );
+    const btcAddresses = createNullArrayOfLength(stacksAccounts.length).flatMap((_, index) =>
+      [createNativeSegwitAccount(index), createTaprootAccount(index)]
+        .filter(isDefined)
+        .map(account => {
+          const addressIndexKeychain = deriveAddressIndexZeroFromAccount(account.keychain);
+          if (account.type !== 'p2tr' && account.type !== 'p2wpkh') return undefined;
+          const payment = paymentFnMap[account.type](addressIndexKeychain, 'mainnet');
+          if (!payment.address) return undefined;
+          return {
+            accountIndex: index,
+            address: payment.address,
+            chain: 'bitcoin',
+            isCurrent: index === currentAccountIndex,
+          } satisfies MonitoredAddress;
+        })
+        .filter(isDefined)
+    );
+    // if one address array is empty and the other not, we're in an intermediate state
+    return (stacksAddresses.length === 0 && btcAddresses.length > 0) ||
+      (btcAddresses.length === 0 && stacksAddresses.length > 0)
+      ? undefined
+      : [...stacksAddresses, ...btcAddresses];
+  }, [
+    createNativeSegwitAccount,
+    createTaprootAccount,
+    stacksAccounts,
+    currentNetworkId,
+    currentAccountIndex,
+  ]);
+}

src/app/features/address-monitor/use-sync-address-monitor.ts

@@ -0,0 +1,29 @@
+import { useEffect, useRef } from 'react';
+
+import isEqual from 'lodash.isequal';
+
+import { logger } from '@shared/logger';
+import { InternalMethods } from '@shared/message-types';
+import { sendMessage } from '@shared/messages';
+
+import { useMonitorableAddresses } from '@app/features/address-monitor/use-monitorable-addresses';
+import type { MonitoredAddress } from '@background/monitors/address-monitor';
+
+export function useSyncAddressMonitor() {
+  const addresses = useMonitorableAddresses();
+  const prevAddresses = useRef<MonitoredAddress[]>([]);
+
+  useEffect(() => {
+    if (addresses && !isEqual(addresses, prevAddresses.current)) {
+      prevAddresses.current = addresses;
+
+      logger.debug('Syncing Monitored Addresses: ', addresses);
+      sendMessage({
+        method: InternalMethods.AddressMonitorUpdated,
+        payload: {
+          addresses,
+        },
+      });
+    }
+  }, [addresses]);
+}

src/app/features/container/container.tsx

@@ -19,6 +19,7 @@ import { useOnWalletLock } from '@app/routes/hooks/use-on-wallet-lock';
 import { useAppDispatch, useHasStateRehydrated } from '@app/store';
 import { stxChainSlice } from '@app/store/chains/stx-chain.slice';
 
+import { useSyncAddressMonitor } from '../address-monitor/use-sync-address-monitor';
 import { useRestoreFormState } from '../popup-send-form-restoration/use-restore-form-state';
 
 export function Container() {
@@ -28,7 +29,7 @@ export function Container() {
   const dispatch = useAppDispatch();
 
   const hasStateRehydrated = useHasStateRehydrated();
-
+  useSyncAddressMonitor();
   useOnWalletLock(() => closeWindow());
   useOnSignOut(() => closeWindow());
   useRestoreFormState();

src/app/store/accounts/blockchain/bitcoin/native-segwit-account.hooks.ts

@@ -45,7 +45,7 @@ const selectCurrentNetworkNativeSegwitAccountBuilder = createSelector(
     nativeSegwitKeychains[bitcoinNetworkToNetworkMode(network.chain.bitcoin.bitcoinNetwork)]
 );
 
-function useNativeSegwitAccountBuilder() {
+export function useGenerateNativeSegwitAccount() {
   return useSelector(selectCurrentNetworkNativeSegwitAccountBuilder);
 }
 
@@ -72,7 +72,7 @@ export function useNativeSegwitNetworkSigners() {
 }
 
 export function useNativeSegwitSigner(accountIndex: number) {
-  const account = useNativeSegwitAccountBuilder()(accountIndex);
+  const account = useGenerateNativeSegwitAccount()(accountIndex);
   const extendedPublicKeyVersions = useBitcoinExtendedPublicKeyVersions();
 
   return useMemo(() => {

src/app/store/accounts/blockchain/bitcoin/taproot-account.hooks.ts

@@ -45,6 +45,10 @@ const selectCurrentTaprootAccount = createSelector(
   (taprootKeychain, accountIndex) => taprootKeychain(accountIndex)
 );
 
+export function useGenerateTaprootAccount() {
+  return useSelector(selectCurrentNetworkTaprootAccountBuilder);
+}
+
 export function useTaprootAccount(accountIndex: number) {
   const generateTaprootAccount = useSelector(selectCurrentNetworkTaprootAccountBuilder);
   return useMemo(

src/background/background.ts

@@ -13,6 +13,7 @@ import {
   isLegacyMessage,
 } from './messaging/legacy/legacy-external-message-handler';
 import { rpcMessageHandler } from './messaging/rpc-message-handler';
+import { initAddressMonitor } from './monitors/address-monitor';
 
 initContextMenuActions();
 warnUsersAboutDevToolsDangers();
@@ -59,3 +60,7 @@ chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
   // Listener fn must return `true` to indicate the response will be async
   return true;
 });
+
+initAddressMonitor().catch(e => {
+  logger.error('Unable to Initialise Address Monitor: ', e);
+});

src/background/messaging/internal-methods/message-handler.ts

@@ -1,6 +1,9 @@
 import { logger } from '@shared/logger';
+import { InternalMethods } from '@shared/message-types';
 import { BackgroundMessages } from '@shared/messages';
 
+import { syncAddressMonitor } from '@background/monitors/address-monitor';
+
 function validateMessagesAreFromExtension(sender: chrome.runtime.MessageSender) {
   // Only respond to internal messages from our UI, not content scripts in other applications
   return sender.url?.startsWith(chrome.runtime.getURL(''));
@@ -28,5 +31,16 @@ export async function internalBackgroundMessageHandler(
     return;
   }
   logger.debug('Internal message', message);
+
+  switch (message.method) {
+    case InternalMethods.AddressMonitorUpdated:
+      await syncAddressMonitor(message.payload.addresses);
+      break;
+  }
+
+  if (message.method.includes('bitcoinKeys/signOut')) {
+    await syncAddressMonitor([]);
+  }
+
   sendResponse();
 }

src/background/monitors/address-monitor.ts

@@ -0,0 +1,43 @@
+/* eslint-disable no-console */
+import { z } from 'zod';
+
+import { createBitcoinTransactionMonitor } from './address-monitors/bitcoin-transaction-monitor';
+
+const monitoredAddressSchema = z.object({
+  chain: z.enum(['bitcoin', 'stacks']),
+  accountIndex: z.number(),
+  isCurrent: z.boolean(),
+  address: z.string(),
+});
+
+export type MonitoredAddress = z.infer<typeof monitoredAddressSchema>;
+
+export interface AddressMonitor {
+  syncAddresses(addresses: MonitoredAddress[]): void;
+}
+
+const monitors: AddressMonitor[] = [];
+
+export async function initAddressMonitor() {
+  const addresses = await readMonitoredAddressStore();
+  monitors.push(createBitcoinTransactionMonitor(addresses));
+}
+
+export async function syncAddressMonitor(addresses: MonitoredAddress[]) {
+  await writeMonitoredAddressStore(addresses);
+  monitors.forEach(monitor => monitor.syncAddresses(addresses));
+}
+
+const ADDRESS_MONITOR_STORE = 'addressMonitorStore';
+
+async function readMonitoredAddressStore() {
+  const result = await chrome.storage.local.get(ADDRESS_MONITOR_STORE);
+  const addresses = result[ADDRESS_MONITOR_STORE] || [];
+  return addresses;
+}
+
+async function writeMonitoredAddressStore(addresses: MonitoredAddress[]) {
+  await chrome.storage.local.set({
+    [ADDRESS_MONITOR_STORE]: addresses,
+  });
+}