feat: increase test coverage

bunfig.toml

@@ -1,4 +1,4 @@
 [test]
 coverageSkipTestFiles = true
-coverageThreshold = 0
+coverageThreshold = 0.8
 root = "./src"

package.json

@@ -8,7 +8,7 @@
   "scripts": {
     "anvil-fork": "make anvil-fork",
     "test-fork": "make test-fork",
-    "test": "bun test src",
+    "test": "bun test",
     "build": "bun tsc",
     "format": "prettier --write .",
     "watch": "bun test --watch src"
@@ -21,6 +21,6 @@
   },
   "dependencies": {
     "@noble/secp256k1": "^2.0.0",
-    "viem": "^2.7.19"
+    "viem": "^2.9.16"
   }
 }

src/lib/actions/getAnnouncements/getAnnouncements.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from 'bun:test';
+import { describe, test, expect, beforeAll } from 'bun:test';
 import ERC556AnnouncerAbi from '../../abi/ERC5564Announcer';
 import {
   VALID_SCHEME_ID,
@@ -7,39 +7,51 @@ import {
 } from '../../..';
 import setupTestEnv from '../../helpers/test/setupTestEnv';
 import setupTestWallet from '../../helpers/test/setupTestWallet';
+import type { StealthActions } from '../../stealthClient/types';
+import type { SuperWalletClient } from '../../helpers/types';
+import type { Address } from 'viem';
 
-describe('getAnnouncements', async () => {
-  const { stealthClient, ERC5564DeployBlock, ERC5564Address } =
-    await setupTestEnv();
-  const walletClient = await setupTestWallet();
+describe('getAnnouncements', () => {
+  let stealthClient: StealthActions;
+  let walletClient: SuperWalletClient;
+  let fromBlock: bigint;
+  let ERC5564Address: Address;
 
+  // Set up stealth address details
   const schemeId = VALID_SCHEME_ID.SCHEME_ID_1;
   const { stealthMetaAddressURI } = generateRandomStealthMetaAddress();
-  const fromBlock = ERC5564DeployBlock;
-
-  // Set up stealth address details
   const { stealthAddress, viewTag, ephemeralPublicKey } =
     generateStealthAddress({
       stealthMetaAddressURI,
       schemeId,
     });
 
-  // Announce the stealth address, ephemeral public key, and view tag
-  const hash = await walletClient.writeContract({
-    address: ERC5564Address,
-    functionName: 'announce',
-    args: [BigInt(schemeId), stealthAddress, ephemeralPublicKey, viewTag],
-    abi: ERC556AnnouncerAbi,
-    chain: walletClient.chain,
-    account: walletClient.account!,
-  });
+  // Set up the test environment and announce the stealth address
+  beforeAll(async () => {
+    const {
+      stealthClient: client,
+      ERC5564Address,
+      ERC5564DeployBlock,
+    } = await setupTestEnv();
+    walletClient = await setupTestWallet();
+    stealthClient = client;
+    fromBlock = ERC5564DeployBlock;
+
+    // Announce the stealth address, ephemeral public key, and view tag
+    const hash = await walletClient.writeContract({
+      address: ERC5564Address,
+      functionName: 'announce',
+      args: [BigInt(schemeId), stealthAddress, ephemeralPublicKey, viewTag],
+      abi: ERC556AnnouncerAbi,
+      chain: walletClient.chain,
+      account: walletClient.account!,
+    });
 
-  console.log('Waiting for announcement transaction to be mined...');
-  // Wait for the transaction to be mined
-  const res = await walletClient.waitForTransactionReceipt({
-    hash,
+    // Wait for the transaction to be mined
+    await walletClient.waitForTransactionReceipt({
+      hash,
+    });
   });
-  console.log('Announcement transaction mined:', res.transactionHash);
 
   test('fetches announcements successfully', async () => {
     const announcements = await stealthClient.getAnnouncements({

src/lib/actions/getAnnouncements/getAnnouncements.ts

@@ -1,12 +1,12 @@
 import type { BlockType } from '../types';
 
 import { type PublicClient, parseAbiItem } from 'viem';
-import { getBlock, getLogs } from 'viem/actions';
+import { getBlock, getBlockNumber, getLogs } from 'viem/actions';
 import { handleViemPublicClient } from '../../stealthClient/createStealthClient';
-import type {
-  AnnouncementLog,
-  GetAnnouncementsParams,
-  GetAnnouncementsReturnType,
+import {
+  type AnnouncementLog,
+  type GetAnnouncementsParams,
+  type GetAnnouncementsReturnType,
 } from './types';
 
 /**
@@ -98,10 +98,6 @@ const fetchLogsInChunks = async ({
     block: toBlock ?? 'latest',
   });
 
-  if (!resolvedToBlock) {
-    throw new Error('Failed to resolve toBlock');
-  }
-
   let currentBlock = resolvedFromBlock;
   const allLogs = [];
 
@@ -134,25 +130,25 @@ const fetchLogsInChunks = async ({
  * @param {Object} params - Parameters for resolving the block number.
  *   - `publicClient`: An instance of the viem `PublicClient`.
  *   - `block`: The block number or tag to resolve.
- * @returns {Promise<bigint | null>} The resolved block number as a bigint or null.
+ * @returns {Promise<bigint>} The resolved block number as a bigint or null.
  */
-async function resolveBlockNumber({
+export async function resolveBlockNumber({
   publicClient,
   block,
 }: {
   publicClient: PublicClient;
   block?: BlockType;
-}): Promise<bigint | null> {
+}): Promise<bigint> {
   if (typeof block === 'bigint') {
     return block;
   }
 
-  try {
-    const res = await getBlock(publicClient, { blockTag: block });
-    return res.number;
-  } catch (error) {
-    throw new Error(`Failed to resolve block number: ${error}.`);
+  const { number } = await getBlock(publicClient, { blockTag: block });
+  // Get the latest block number if null, since it is the pending block
+  if (!number) {
+    return getBlockNumber(publicClient);
   }
+  return number;
 }
 
 export default getAnnouncements;

src/lib/actions/getAnnouncementsForUser/getAnnouncementsForUser.test.ts

@@ -1,55 +1,85 @@
-import { expect, test, describe } from 'bun:test';
+import { expect, test, describe, beforeAll } from 'bun:test';
 import setupTestEnv from '../../helpers/test/setupTestEnv';
 import setupTestWallet from '../../helpers/test/setupTestWallet';
 import setupTestStealthKeys from '../../helpers/test/setupTestStealthKeys';
 import { VALID_SCHEME_ID, generateStealthAddress } from '../../../utils/crypto';
 import { ERC5564AnnouncerAbi } from '../../abi';
-
-describe('getAnnouncementsForUser', async () => {
-  const { stealthClient, ERC5564Address, ERC5564DeployBlock } =
-    await setupTestEnv();
-  const walletClient = await setupTestWallet();
-  const schemeId = VALID_SCHEME_ID.SCHEME_ID_1;
-  const { stealthMetaAddressURI, spendingPublicKey, viewingPrivateKey } =
-    setupTestStealthKeys(schemeId);
-  const fromBlock = ERC5564DeployBlock;
-
-  // Set up stealth address details
-  const { stealthAddress, ephemeralPublicKey, viewTag } =
-    generateStealthAddress({
+import type { AnnouncementLog } from '..';
+import { FromValueNotFoundError, TransactionHashRequiredError } from './types';
+import {
+  getTransactionFrom,
+  processAnnouncement,
+} from './getAnnouncementsForUser';
+import { type PublicClient } from 'viem';
+import { getViewTagFromMetadata } from '../../..';
+import type { HexString } from '../../../utils/crypto/types';
+import type { StealthActions } from '../../stealthClient/types';
+import type { SuperWalletClient } from '../../helpers/types';
+
+describe('getAnnouncementsForUser', () => {
+  let stealthClient: StealthActions;
+  let walletClient: SuperWalletClient;
+
+  let stealthAddress: HexString,
+    ephemeralPublicKey: HexString,
+    viewTag: HexString;
+  let spendingPublicKey: HexString,
+    viewingPrivateKey: HexString,
+    stealthMetaAddressURI: string;
+
+  let announcements: AnnouncementLog[] = [];
+
+  beforeAll(async () => {
+    // Set up the test environment
+    const {
+      stealthClient: client,
+      ERC5564Address,
+      ERC5564DeployBlock,
+    } = await setupTestEnv();
+    walletClient = await setupTestWallet();
+    stealthClient = client;
+
+    // Set up the stealth keys and generate a stealth address
+    const schemeId = VALID_SCHEME_ID.SCHEME_ID_1;
+    ({ stealthMetaAddressURI, spendingPublicKey, viewingPrivateKey } =
+      setupTestStealthKeys(schemeId));
+
+    ({ stealthAddress, ephemeralPublicKey, viewTag } = generateStealthAddress({
       stealthMetaAddressURI,
-      schemeId,
+      schemeId: VALID_SCHEME_ID.SCHEME_ID_1,
+    }));
+
+    // Announce the stealth address, ephemeral public key, and view tag
+    const hash = await walletClient.writeContract({
+      address: ERC5564Address,
+      functionName: 'announce',
+      args: [BigInt(schemeId), stealthAddress, ephemeralPublicKey, viewTag],
+      abi: ERC5564AnnouncerAbi,
+      chain: walletClient.chain,
+      account: walletClient.account!,
     });
 
-  // Announce the stealth address, ephemeral public key, and view tag
-  const hash = await walletClient.writeContract({
-    address: ERC5564Address,
-    functionName: 'announce',
-    args: [BigInt(schemeId), stealthAddress, ephemeralPublicKey, viewTag],
-    abi: ERC5564AnnouncerAbi,
-    chain: walletClient.chain,
-    account: walletClient.account!,
-  });
-
-  console.log('Waiting for announcement transaction to be mined...');
-  // Wait for the transaction to be mined
-  const res = await walletClient.waitForTransactionReceipt({
-    hash,
-  });
-  console.log('Announcement transaction mined:', res.transactionHash);
-
-  // Fetch relevant announcements to check against
-  console.log('fetching announcements...');
-  const announcements = await stealthClient.getAnnouncements({
-    ERC5564Address,
-    args: {
-      schemeId: BigInt(schemeId),
-      stealthAddress,
-      caller: walletClient.account?.address, // Just an example; the caller is the address of the wallet since it called announce
-    },
-    fromBlock,
+    console.log('Waiting for announcement transaction to be mined...');
+    // Wait for the transaction to be mined
+    const res = await walletClient.waitForTransactionReceipt({
+      hash,
+    });
+    console.log('Announcement transaction mined:', res.transactionHash);
+
+    // Fetch relevant announcements to check against
+    console.log('fetching announcements...');
+    announcements = await stealthClient.getAnnouncements({
+      ERC5564Address,
+      args: {
+        schemeId: BigInt(schemeId),
+        stealthAddress,
+        caller: walletClient.account?.address, // Just an example; the caller is the address of the wallet since it called announce
+      },
+      fromBlock: ERC5564DeployBlock,
+      toBlock: 'latest',
+    });
+    console.log('relevant announcements fetched for testing');
   });
-  console.log('relevant announcements fetched for testing');
 
   test('filters announcements correctly for the user', async () => {
     // Fetch announcements for the specific user
@@ -162,4 +192,61 @@ describe('getAnnouncementsForUser', async () => {
       `Processed ${largeNumberOfAnnouncements} announcements in ${endTime - startTime} milliseconds.`
     );
   });
+
+  test('throws TransactionHashRequiredError when transactionHash is null', async () => {
+    const announcementWithoutHash: AnnouncementLog = {
+      ...announcements[0],
+      transactionHash: null,
+    };
+
+    expect(
+      processAnnouncement(
+        announcementWithoutHash,
+        walletClient as PublicClient,
+        {
+          spendingPublicKey,
+          viewingPrivateKey,
+          excludeList: new Set([]),
+          includeList: new Set([]),
+        }
+      )
+    ).rejects.toBeInstanceOf(TransactionHashRequiredError);
+  });
+
+  test('throws FromValueNotFoundError when the "from" value is not found', async () => {
+    const invalidHash = '0xinvalidhash';
+
+    expect(
+      getTransactionFrom({
+        publicClient: walletClient as PublicClient,
+        hash: invalidHash,
+      })
+    ).rejects.toBeInstanceOf(FromValueNotFoundError);
+  });
+
+  test('throws error if view tag does not start with 0x', () => {
+    const metadata = 'invalidmetadata';
+    expect(() => getViewTagFromMetadata(metadata as HexString)).toThrow(
+      'Invalid metadata format'
+    );
+  });
+});
+
+describe('getAnnouncementsForUser error class tests', () => {
+  test('TransactionHashRequiredError should have the correct message', () => {
+    const errorMessage = 'The transaction hash is required.';
+    const error = new TransactionHashRequiredError();
+
+    expect(error.message).toBe(errorMessage);
+    expect(error.name).toBe('TransactionHashRequiredError');
+  });
+
+  test('FromValueNotFoundError should have the correct message', () => {
+    const errorMessage =
+      'The "from" value could not be retrieved for a transaction.';
+    const error = new FromValueNotFoundError();
+
+    expect(error.message).toBe(errorMessage);
+    expect(error.name).toBe('FromValueNotFoundError');
+  });
 });

src/lib/actions/getAnnouncementsForUser/getAnnouncementsForUser.ts

@@ -84,7 +84,7 @@ async function getAnnouncementsForUser({
  * - `includeList`: Addresses to specifically include in the results.
  * @returns {Promise<ProcessAnnouncementReturnType>} A promise that resolves to the processed announcement if it is relevant, or null otherwise.
  */
-async function processAnnouncement(
+export async function processAnnouncement(
   announcement: AnnouncementLog,
   publicClient: PublicClient,
   {
@@ -173,7 +173,7 @@ async function shouldIncludeAnnouncement({
  * @returns {Promise<`0x${string}`>} A promise that resolves to the transaction sender address.
  * @throws {FromValueNotFoundError} If the transaction or sender address cannot be fetched, indicating a potential issue with the transaction lookup.
  */
-async function getTransactionFrom({
+export async function getTransactionFrom({
   publicClient,
   hash,
 }: {

src/lib/actions/getStealthMetaAddress/getStealthMetaAddress.test.ts

@@ -6,6 +6,7 @@ import {
   VALID_SCHEME_ID,
   generateRandomStealthMetaAddress,
 } from '../../..';
+import { GetStealthMetaAddressError } from './types';
 
 describe('getStealthMetaAddress', async () => {
   const { stealthClient, ERC6538Address } = await setupTestEnv();
@@ -41,4 +42,16 @@ describe('getStealthMetaAddress', async () => {
 
     expect(result).toEqual(stealthMetaAddress);
   });
+
+  test('should throw an error if the stealth meta address cannot be fetched', async () => {
+    const invalidRegistrant = '0xInvalidRegistrant';
+
+    expect(
+      stealthClient.getStealthMetaAddress({
+        ERC6538Address,
+        registrant: invalidRegistrant,
+        schemeId: VALID_SCHEME_ID.SCHEME_ID_1,
+      })
+    ).rejects.toBeInstanceOf(GetStealthMetaAddressError);
+  });
 });