@coin-voyage/swapkit 0.3.0 → 0.4.0

package/dist/hooks/use-token-data.js

@@ -1,13 +1,25 @@
 import { useAccount } from "@coin-voyage/crypto/hooks";
-import { fetchTokenList, tokenToCurrency } from "@coin-voyage/shared/currency";
-import { currencyID } from "@coin-voyage/shared/types";
-import { useEffect, useReducer, useState } from "react";
+import { fetchTokenList, formatCurrencyAmount, tokenToCurrency } from "@coin-voyage/shared/currency";
+import { getChainTypeByChainId } from "@coin-voyage/shared/chain";
+import { ChainType, currencyID } from "@coin-voyage/shared/types";
+import { useCallback, useEffect, useMemo, useReducer, useRef, useState } from "react";
 import { useSwapKit } from "../providers/swapkit-context";
+const BALANCE_REFRESH_DELAYS_MS = [4000, 12000];
+// The token list and the portfolio can report the same address in different casing.
+function currencyKey(currency) {
+    const chainType = getChainTypeByChainId(currency.chain_id);
+    const caseInsensitive = chainType === ChainType.EVM || chainType === ChainType.SUI;
+    return currencyID(caseInsensitive ? { ...currency, address: currency.address?.toLowerCase() } : currency);
+}
 function mergeTokens(tokenList, portfolio) {
-    const portfolioById = new Map(portfolio.map((token) => [currencyID(token.currency), token]));
-    const tokenListIds = new Set(tokenList.map(currencyID));
-    const listed = tokenList.map((currency) => portfolioById.get(currencyID(currency)) ?? { currency });
-    const unlisted = portfolio.filter((token) => !tokenListIds.has(currencyID(token.currency)));
+    const portfolioByKey = new Map(portfolio.map((token) => [currencyKey(token.currency), token]));
+    const tokenListKeys = new Set(tokenList.map(currencyKey));
+    const listed = tokenList.map((currency) => {
+        const held = portfolioByKey.get(currencyKey(currency));
+        // Keep the listed address so the token's id stays stable once balances load.
+        return held ? { ...held, currency: { ...held.currency, address: currency.address } } : { currency };
+    });
+    const unlisted = portfolio.filter((token) => !tokenListKeys.has(currencyKey(token.currency)));
     return [...listed, ...unlisted].sort((left, right) => (right.balanceUsd ?? 0) - (left.balanceUsd ?? 0));
 }
 export function useTokenData() {
@@ -17,11 +29,24 @@ export function useTokenData() {
     const [portfolioState, setPortfolioState] = useState({
         walletKey: "[]",
         tokens: [],
+        complete: false,
     });
     const [isLoading, setIsLoading] = useState(true);
     const [tokenError, setTokenError] = useState(null);
     const [portfolioError, setPortfolioError] = useState(null);
-    const [portfolioRevision, refreshBalances] = useReducer((revision) => revision + 1, 0);
+    const [portfolioRevision, bumpPortfolioRevision] = useReducer((revision) => revision + 1, 0);
+    const refreshTimers = useRef([]);
+    const clearRefreshTimers = useCallback(() => {
+        refreshTimers.current.forEach(clearTimeout);
+        refreshTimers.current = [];
+    }, []);
+    // Balances can lag behind a settled swap, so refetch now and again once the chain data has caught up.
+    const refreshBalances = useCallback(() => {
+        clearRefreshTimers();
+        bumpPortfolioRevision();
+        refreshTimers.current = BALANCE_REFRESH_DELAYS_MS.map((delay) => setTimeout(bumpPortfolioRevision, delay));
+    }, [clearRefreshTimers]);
+    useEffect(() => clearRefreshTimers, [clearRefreshTimers]);
     useEffect(() => {
         let active = true;
         fetchTokenList()
@@ -61,9 +86,10 @@ export function useTokenData() {
             setPortfolioError(null);
             setPortfolioState({
                 walletKey,
+                complete: !data.errors?.length,
                 tokens: data.portfolio.flatMap((result) => result.currencies.map(({ balance, currency }) => ({
                     currency,
-                    balance: Number(balance.ui),
+                    balance: formatCurrencyAmount(balance.raw, currency.decimals),
                     balanceUsd: balance.value_usd ?? undefined,
                 }))),
             });
@@ -75,7 +101,10 @@ export function useTokenData() {
         });
         return () => controller.abort();
     }, [api, portfolioRevision, walletKey]);
-    const activePortfolioTokens = portfolioState.walletKey === walletKey ? portfolioState.tokens : [];
-    const tokens = mergeTokens(listedCurrencies, activePortfolioTokens);
-    return { tokens, accounts, isLoading, error: tokenError ?? portfolioError, refreshBalances };
+    const portfolioActive = portfolioState.walletKey === walletKey;
+    // True once every connected wallet's balances are known, so a token without a balance is a zero balance.
+    const balancesLoaded = portfolioActive && portfolioState.complete;
+    // Token identities must stay stable across renders: the quote request is memoized on them.
+    const tokens = useMemo(() => mergeTokens(listedCurrencies, portfolioActive ? portfolioState.tokens : []), [listedCurrencies, portfolioActive, portfolioState.tokens]);
+    return { tokens, accounts, isLoading, error: tokenError ?? portfolioError, balancesLoaded, refreshBalances };
 }

package/dist/hooks/use-token-data.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/hooks/use-token-data.test.js

@@ -0,0 +1,81 @@
+// @vitest-environment jsdom
+import { fetchTokenList } from "@coin-voyage/shared/currency";
+import { ChainId, ChainType } from "@coin-voyage/shared/types";
+import { act, cleanup, renderHook, waitFor } from "@testing-library/react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { useTokenData } from "./use-token-data";
+const { api } = vi.hoisted(() => ({ api: { portfolio: vi.fn() } }));
+vi.mock("@coin-voyage/crypto/hooks", () => ({
+    useAccount: () => ({ accounts: [{ address: "0x123", chainType: ChainType.EVM }] }),
+}));
+vi.mock("@coin-voyage/shared/currency", async (importOriginal) => ({
+    ...(await importOriginal()),
+    fetchTokenList: vi.fn().mockResolvedValue({ chains: [] }),
+}));
+vi.mock("../providers/swapkit-context", () => ({
+    useSwapKit: () => ({ api }),
+}));
+afterEach(() => {
+    cleanup();
+    vi.clearAllMocks();
+});
+describe("useTokenData", () => {
+    it.each([
+        { decimals: 6, raw: "1234567", ui: "1.23", expected: "1.234567" },
+        { decimals: 9, raw: "1239999999", ui: "1.24", expected: "1.239999999" },
+        { decimals: 18, raw: "1123456789012345678", ui: "1.12", expected: "1.123456789012345678" },
+        { decimals: 18, raw: "1", ui: "0.00", expected: "0.000000000000000001" },
+    ])("preserves the raw balance at $decimals decimals ($raw)", async ({ decimals, raw, ui, expected }) => {
+        const currency = { id: "eth", chain_id: ChainId.ETH, name: "Ether", symbol: "ETH", decimals };
+        api.portfolio.mockResolvedValue({
+            data: { portfolio: [{ currencies: [{ currency, balance: { raw, ui, value_usd: 12.34 } }] }] },
+        });
+        const { result } = renderHook(() => useTokenData());
+        await waitFor(() => expect(result.current.tokens).toHaveLength(1));
+        expect(result.current.tokens[0]).toEqual({ currency, balance: expected, balanceUsd: 12.34 });
+    });
+    it("attaches balances to listed tokens when the portfolio address casing differs", async () => {
+        const address = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48";
+        const listed = { name: "USD Coin", ticker: "USDC", decimals: 6, chainId: ChainId.ETH, address };
+        vi.mocked(fetchTokenList).mockResolvedValueOnce({ chains: [{ tokens: [listed] }] });
+        const held = {
+            id: "usdc",
+            chain_id: ChainId.ETH,
+            address: address.toLowerCase(),
+            name: "USD Coin",
+            symbol: "USDC",
+            decimals: 6,
+        };
+        api.portfolio.mockResolvedValue({
+            data: { portfolio: [{ currencies: [{ currency: held, balance: { raw: "1500000", ui: "1.5", value_usd: 1.5 } }] }] },
+        });
+        const { result, rerender } = renderHook(() => useTokenData());
+        await waitFor(() => expect(result.current.tokens[0]?.balance).toBe("1.5"));
+        expect(result.current.tokens).toHaveLength(1);
+        expect(result.current.tokens[0].currency.address).toBe(address);
+        const { currency } = result.current.tokens[0];
+        rerender();
+        expect(result.current.tokens[0].currency).toBe(currency);
+    });
+    it("refetches the portfolio immediately and again after a refresh", async () => {
+        vi.useFakeTimers();
+        try {
+            api.portfolio.mockResolvedValue({ data: { portfolio: [] } });
+            const { result, unmount } = renderHook(() => useTokenData());
+            expect(api.portfolio).toHaveBeenCalledTimes(1);
+            act(() => result.current.refreshBalances());
+            expect(api.portfolio).toHaveBeenCalledTimes(2);
+            await act(() => vi.advanceTimersByTimeAsync(4000));
+            expect(api.portfolio).toHaveBeenCalledTimes(3);
+            await act(() => vi.advanceTimersByTimeAsync(8000));
+            expect(api.portfolio).toHaveBeenCalledTimes(4);
+            act(() => result.current.refreshBalances());
+            unmount();
+            await vi.advanceTimersByTimeAsync(20000);
+            expect(api.portfolio).toHaveBeenCalledTimes(5);
+        }
+        finally {
+            vi.useRealTimers();
+        }
+    });
+});

package/dist/lib/amount-input.d.ts

@@ -1,3 +1,4 @@
+export declare function balanceFraction(balance: string, fraction: number, decimals: number): string;
 export declare function isValidSwapAmountInput(value: string): boolean;
 export declare function toSwapAmountInputValue(amount?: string | null): string;
 export declare function shouldValidateSwapBalance(amount: string): boolean;

package/dist/lib/amount-input.js

@@ -1,4 +1,11 @@
+import { formatCurrencyAmount, parseCurrencyAmount } from "@coin-voyage/shared/currency";
 const DECIMAL_INPUT = /^(?:\d+(?:\.\d*)?|\.\d+)?$/;
+export function balanceFraction(balance, fraction, decimals) {
+    if (fraction === 1)
+        return balance;
+    const raw = BigInt(parseCurrencyAmount(balance, decimals));
+    return formatCurrencyAmount((raw * BigInt(fraction * 100)) / 100n, decimals);
+}
 export function isValidSwapAmountInput(value) {
     return DECIMAL_INPUT.test(value);
 }

package/dist/lib/amount-input.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/amount-input.test.js

@@ -0,0 +1,17 @@
+import { describe, expect, it } from "vitest";
+import { balanceFraction } from "./amount-input";
+describe("balanceFraction", () => {
+    it.each(["1.239999999999999999", "0.000000000000000001", "9007199254740993.123456789012345678", "0"])("preserves the full MAX balance %s", (balance) => {
+        expect(balanceFraction(balance, 1, 18)).toBe(balance);
+    });
+    it.each([
+        [0.25, "0.309999999999999999"],
+        [0.5, "0.619999999999999999"],
+        [0.75, "0.929999999999999999"],
+    ])("floors a %s fraction to spendable base units", (fraction, expected) => {
+        expect(balanceFraction("1.239999999999999999", fraction, 18)).toBe(expected);
+    });
+    it("does not round a fraction up for indivisible tokens", () => {
+        expect(balanceFraction("3", 0.5, 0)).toBe("1");
+    });
+});

package/dist/lib/execution.d.ts

@@ -41,5 +41,7 @@ export type SwapStage = {
     swapData: SwapExecuteResponse | null;
     message: string;
 };
+/** Whether the user's own swap transaction delivers the output, leaving no separate receive leg to track. */
+export declare function deliversInSwapTransaction(swapData: SwapExecuteResponse): boolean;
 export declare function buildSwapExecuteTransactions(swapData: SwapExecuteResponse, fromAddress: string): ExecuteTransaction[];
 export {};

package/dist/lib/execution.js

@@ -1,4 +1,10 @@
 import { isChainPaymentData, isDepositStepData } from "@coin-voyage/shared/payment";
+/** Whether the user's own swap transaction delivers the output, leaving no separate receive leg to track. */
+export function deliversInSwapTransaction(swapData) {
+    const { input, output, steps } = swapData.data;
+    const lastStep = steps[steps.length - 1];
+    return (input.currency.chain_id === output.currency.chain_id && lastStep !== undefined && !isDepositStepData(lastStep.data));
+}
 export function buildSwapExecuteTransactions(swapData, fromAddress) {
     const steps = swapData.data.steps;
     if (steps.length === 0)

package/dist/lib/execution.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/execution.test.js

@@ -0,0 +1,24 @@
+import { ChainId } from "@coin-voyage/shared/types";
+import { describe, expect, it } from "vitest";
+import { deliversInSwapTransaction } from "./execution";
+const swapStep = { data: { type: "EVM" } };
+const depositStep = { data: { amount: "1", currency: {}, deposit_address: "0x1" } };
+function swapData(inputChain, outputChain, steps) {
+    return {
+        data: { input: { currency: { chain_id: inputChain } }, output: { currency: { chain_id: outputChain } }, steps },
+    };
+}
+describe("deliversInSwapTransaction", () => {
+    it("is true for a same-chain swap executed by the user's transaction", () => {
+        expect(deliversInSwapTransaction(swapData(ChainId.ETH, ChainId.ETH, [swapStep]))).toBe(true);
+    });
+    it("is false for a cross-chain swap", () => {
+        expect(deliversInSwapTransaction(swapData(ChainId.ETH, ChainId.BASE, [swapStep]))).toBe(false);
+    });
+    it("is false when the user deposits and the output is delivered later", () => {
+        expect(deliversInSwapTransaction(swapData(ChainId.ETH, ChainId.ETH, [swapStep, depositStep]))).toBe(false);
+    });
+    it("is false without steps", () => {
+        expect(deliversInSwapTransaction(swapData(ChainId.ETH, ChainId.ETH, []))).toBe(false);
+    });
+});

package/dist/lib/output-wallet.d.ts

@@ -15,10 +15,9 @@ interface GetSwapWalletRequirementProps {
 }
 export declare function shouldUseSeparateOutputWallet(sourceChainType: ChainType | undefined, destinationChainType: ChainType | undefined): boolean;
 interface ShouldShowOutputWalletSelectorProps {
-    requiresSeparateOutputWallet: boolean;
     outputChainType?: ChainType;
     connectionRequirement: SwapWalletRequirement;
 }
-export declare function shouldShowOutputWalletSelector({ requiresSeparateOutputWallet, outputChainType, connectionRequirement, }: ShouldShowOutputWalletSelectorProps): boolean;
+export declare function shouldShowOutputWalletSelector({ outputChainType, connectionRequirement, }: ShouldShowOutputWalletSelectorProps): boolean;
 export declare function getSwapWalletRequirement({ inputWalletAddress, inputChainType, shouldRestrictInputChainType, outputWalletAddress, outputChainType, }: GetSwapWalletRequirementProps): SwapWalletRequirement;
 export {};

package/dist/lib/output-wallet.js

@@ -2,8 +2,8 @@ import { getChainTypeName } from "@coin-voyage/shared/chain";
 export function shouldUseSeparateOutputWallet(sourceChainType, destinationChainType) {
     return Boolean(sourceChainType && destinationChainType && sourceChainType !== destinationChainType);
 }
-export function shouldShowOutputWalletSelector({ requiresSeparateOutputWallet, outputChainType, connectionRequirement, }) {
-    return Boolean(outputChainType && requiresSeparateOutputWallet && connectionRequirement.target !== "input");
+export function shouldShowOutputWalletSelector({ outputChainType, connectionRequirement, }) {
+    return Boolean(outputChainType && connectionRequirement.target !== "input");
 }
 export function getSwapWalletRequirement({ inputWalletAddress, inputChainType, shouldRestrictInputChainType = true, outputWalletAddress, outputChainType, }) {
     if (!inputWalletAddress) {

package/dist/lib/output-wallet.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/output-wallet.test.js

@@ -0,0 +1,26 @@
+import { ChainType } from "@coin-voyage/shared/types";
+import { describe, expect, it } from "vitest";
+import { shouldShowOutputWalletSelector } from "./output-wallet";
+describe("shouldShowOutputWalletSelector", () => {
+    it("allows changing the recipient when the input wallet is connected", () => {
+        expect(shouldShowOutputWalletSelector({
+            outputChainType: ChainType.EVM,
+            connectionRequirement: { target: "none" },
+        })).toBe(true);
+    });
+    it("allows choosing an address when an output wallet is required", () => {
+        expect(shouldShowOutputWalletSelector({
+            outputChainType: ChainType.SOL,
+            connectionRequirement: { target: "output", label: "Connect Wallet" },
+        })).toBe(true);
+    });
+    it("hides the selector until the input wallet is connected", () => {
+        expect(shouldShowOutputWalletSelector({
+            outputChainType: ChainType.EVM,
+            connectionRequirement: { target: "input", label: "Connect Wallet" },
+        })).toBe(false);
+    });
+    it("hides the selector without a destination chain", () => {
+        expect(shouldShowOutputWalletSelector({ connectionRequirement: { target: "none" } })).toBe(false);
+    });
+});

package/dist/providers/swapkit-context.d.ts

@@ -1,4 +1,4 @@
-import type { ApiClient, APIEnvironment } from "@coin-voyage/shared/api";
+import type { ApiClient, APIEnvironment } from "@coin-voyage/shared/api/browser";
 import type { SwapKitMode, SwapKitTheme } from "../types";
 export interface SwapKitContextValue {
     api: ApiClient;

package/dist/providers/swapkit-provider.js

@@ -1,7 +1,7 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { useInWagmiContext } from "@coin-voyage/crypto/evm";
 import { useConnectCallback } from "@coin-voyage/crypto/hooks";
-import { ApiClient } from "@coin-voyage/shared/api";
+import { ApiClient } from "@coin-voyage/shared/api/browser";
 import { generateSessionId } from "@coin-voyage/shared/utils";
 import { useMemo, useState } from "react";
 import { SwapKitContext } from "./swapkit-context";

package/dist/styles/root.js

@@ -2,23 +2,23 @@ import { css } from "styled-components";
 import styled from "./styled";
 import { darkTheme, lightTheme } from "./theme";
 function variables(theme) {
-    return css `
-    --sk-font-family: ${theme.fontFamily};
-    --sk-background: ${theme.background};
-    --sk-surface: ${theme.surface};
-    --sk-surface-elevated: ${theme.surfaceElevated};
-    --sk-border: ${theme.border};
-    --sk-text: ${theme.text};
-    --sk-text-muted: ${theme.textMuted};
-    --sk-accent: ${theme.accent};
-    --sk-accent-hover: ${theme.accentHover};
-    --sk-accent-text: ${theme.accentText};
-    --sk-danger: ${theme.danger};
-    --sk-warning: ${theme.warning};
-    --sk-success: ${theme.success};
-    --sk-overlay: ${theme.overlay};
-    --sk-shadow: ${theme.shadow};
-    --sk-radius: ${theme.radius};
+    return css `
+    --sk-font-family: ${theme.fontFamily};
+    --sk-background: ${theme.background};
+    --sk-surface: ${theme.surface};
+    --sk-surface-elevated: ${theme.surfaceElevated};
+    --sk-border: ${theme.border};
+    --sk-text: ${theme.text};
+    --sk-text-muted: ${theme.textMuted};
+    --sk-accent: ${theme.accent};
+    --sk-accent-hover: ${theme.accentHover};
+    --sk-accent-text: ${theme.accentText};
+    --sk-danger: ${theme.danger};
+    --sk-warning: ${theme.warning};
+    --sk-success: ${theme.success};
+    --sk-overlay: ${theme.overlay};
+    --sk-shadow: ${theme.shadow};
+    --sk-radius: ${theme.radius};
   `;
 }
 function modeVariables(mode, customTheme) {
@@ -28,48 +28,48 @@ function modeVariables(mode, customTheme) {
         return variables(light);
     if (mode === "dark")
         return variables(dark);
-    return css `
-    ${variables(light)}
-    @media (prefers-color-scheme: dark) {
-      ${variables(dark)}
-    }
+    return css `
+    ${variables(light)}
+    @media (prefers-color-scheme: dark) {
+      ${variables(dark)}
+    }
   `;
 }
-export const SwapKitRoot = styled.div `
-  ${({ $mode, $customTheme }) => modeVariables($mode, $customTheme)}
-
-  all: initial;
-  display: block;
-  width: 100%;
-  color: var(--sk-text);
-  background: var(--sk-background);
-  font-family: var(--sk-font-family);
-  font-size: 16px;
-  text-align: left;
-  text-rendering: optimizeLegibility;
-  -webkit-font-smoothing: antialiased;
-
-  &,
-  * {
-    box-sizing: border-box;
-    font-family: var(--sk-font-family);
-  }
-
-  button,
-  input {
-    font-family: var(--sk-font-family);
-  }
-
-  button:focus-visible,
-  input:focus-visible,
-  a:focus-visible {
-    outline: 2px solid var(--sk-accent);
-    outline-offset: 2px;
-  }
-
-  img,
-  svg {
-    display: block;
-    max-width: 100%;
-  }
+export const SwapKitRoot = styled.div `
+  ${({ $mode, $customTheme }) => modeVariables($mode, $customTheme)}
+
+  all: initial;
+  display: block;
+  width: 100%;
+  color: var(--sk-text);
+  background: ${({ $customTheme }) => $customTheme.background ?? "transparent"};
+  font-family: var(--sk-font-family);
+  font-size: 16px;
+  text-align: left;
+  text-rendering: optimizeLegibility;
+  -webkit-font-smoothing: antialiased;
+
+  &,
+  * {
+    box-sizing: border-box;
+    font-family: var(--sk-font-family);
+  }
+
+  button,
+  input {
+    font-family: var(--sk-font-family);
+  }
+
+  button:focus-visible,
+  input:focus-visible,
+  a:focus-visible {
+    outline: 2px solid var(--sk-accent);
+    outline-offset: 2px;
+  }
+
+  img,
+  svg {
+    display: block;
+    max-width: 100%;
+  }
 `;

package/dist/styles/theme.js

@@ -1,7 +1,7 @@
 export const lightTheme = {
     fontFamily: `Roboto, Arial, Helvetica, sans-serif`,
     background: "#f4f5f7",
-    surface: "#ffffff",
+    surface: "#f4f5f7",
     surfaceElevated: "#f7f8fa",
     border: "#e4e7ec",
     text: "#15181e",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@coin-voyage/swapkit",
   "description": "A reusable cross-chain swap component for CoinVoyage.",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "private": false,
   "sideEffects": false,
   "author": "Lars <lars@coinvoyage.io>",
@@ -22,8 +22,8 @@
     "LICENSE"
   ],
   "dependencies": {
-    "@coin-voyage/crypto": "3.5.0",
-    "@coin-voyage/shared": "3.5.0"
+    "@coin-voyage/crypto": "3.6.0",
+    "@coin-voyage/shared": "3.6.0"
   },
   "devDependencies": {
     "@testing-library/react": "^16.3.0",
@@ -36,7 +36,7 @@
     "typescript-plugin-styled-components": "^3.0.0"
   },
   "peerDependencies": {
-    "@bigmi/react": "^0.9.1",
+    "@bigmi/react": "^0.9.4",
     "@mysten/dapp-kit-react": "^2.1.4",
     "@solana/wallet-adapter-react": "^0.15.39",
     "@tanstack/react-query": "^5.90.6",
@@ -56,14 +56,14 @@
   "scripts": {
     "watch": "tsc -w -p ./tsconfig.json",
     "build": "tsc --build --force",
-    "test": "vitest run --config ./vitest.config.ts",
-    "test:coverage": "vitest run --coverage --maxWorkers=1 --no-file-parallelism --config ./vitest.config.ts",
     "clean": "rm -rf dist tsconfig.tsbuildinfo coverage",
+    "release:build": "pnpm clean && pnpm build",
     "pre:release": "pnpm version prerelease --preid=beta",
     "pre:publish": "pnpm publish --access public --tag beta --no-git-checks",
     "pre:steps": "pnpm pre:release && pnpm pre:publish",
-    "release:build": "pnpm clean && pnpm build",
     "release": "pnpm publish --access public --no-git-checks",
-    "type-check": "tsc --noEmit"
+    "type-check": "tsc --noEmit",
+    "test": "vitest run --config ./vitest.config.ts",
+    "test:coverage": "vitest run --coverage --maxWorkers=1 --no-file-parallelism --config ./vitest.config.ts"
   }
 }