@0xsequence/marketplace-sdk 0.0.0-20250513233135

package/src/utils/getMarketplaceDetails.ts

@@ -0,0 +1,111 @@
+import type { Image } from '@0xsequence/design-system';
+import type { ComponentType } from 'react';
+import {
+	AlienSwapLogo,
+	BlurLogo,
+	LooksRareLogo,
+	MagicEdenLogo,
+	MintifyLogo,
+	OpenSeaLogo,
+	SequenceLogo,
+	X2y2Logo,
+} from '../react/ui/components/marketplace-logos';
+import { MarketplaceKind } from '../types';
+
+interface Marketplace {
+	logo: ComponentType<React.ComponentProps<typeof Image>>;
+	displayName: string;
+}
+
+const MARKETPLACES: Record<string, Marketplace> = {
+	sequence: {
+		logo: SequenceLogo,
+		displayName: 'Sequence',
+	},
+	opensea: {
+		logo: OpenSeaLogo,
+		displayName: 'OpenSea',
+	},
+	magiceden: {
+		logo: MagicEdenLogo,
+		displayName: 'Magic Eden',
+	},
+	mintify: {
+		logo: MintifyLogo,
+		displayName: 'Mintify',
+	},
+	looksrare: {
+		logo: LooksRareLogo,
+		displayName: 'Looks Rare',
+	},
+	x2y2: {
+		logo: X2y2Logo,
+		displayName: 'X2Y2',
+	},
+	blur: {
+		logo: BlurLogo,
+		displayName: 'Blur',
+	},
+	alienswap: {
+		logo: AlienSwapLogo,
+		displayName: 'AlienSwap',
+	},
+} as const;
+
+const KIND_TO_MARKETPLACE: Partial<
+	Record<MarketplaceKind, keyof typeof MARKETPLACES>
+> = {
+	[MarketplaceKind.sequence_marketplace_v1]: 'sequence',
+	[MarketplaceKind.sequence_marketplace_v2]: 'sequence',
+	[MarketplaceKind.opensea]: 'opensea',
+	[MarketplaceKind.mintify]: 'mintify',
+	[MarketplaceKind.looks_rare]: 'looksrare',
+	[MarketplaceKind.x2y2]: 'x2y2',
+	[MarketplaceKind.blur]: 'blur',
+	[MarketplaceKind.magic_eden]: 'magiceden',
+};
+
+type MarketplaceDetailsProp = {
+	originName: string;
+	kind: MarketplaceKind;
+};
+
+// TODO: add support for more marketplaces and improve detection of marketplace
+export function getMarketplaceDetails({
+	originName,
+	kind,
+}: MarketplaceDetailsProp) {
+	if (
+		kind === MarketplaceKind.sequence_marketplace_v1 ||
+		kind === MarketplaceKind.sequence_marketplace_v2
+	) {
+		return MARKETPLACES.sequence;
+	}
+
+	let name = originName.toLowerCase();
+
+	try {
+		//Check if the name can be parsed as a url
+		new URL(name);
+		// if it can we are naively trying to extract the root domain
+		name = getRootDomain(name) || name;
+	} catch {}
+
+	name = name.replace(/ /g, '');
+
+	const details = MARKETPLACES[name];
+
+	if (details) {
+		return details;
+	}
+
+	if (KIND_TO_MARKETPLACE[kind]) {
+		return MARKETPLACES[KIND_TO_MARKETPLACE[kind]];
+	}
+}
+
+function getRootDomain(url: string) {
+	const domain = url.replace(/^(https?:\/\/)?(www\.)?/, '');
+	const parts = domain.split('.');
+	return parts[parts.length - 2] || parts[0];
+}

package/src/utils/getSequenceMarketRequestId.ts

@@ -0,0 +1,32 @@
+import {
+	type Address,
+	type Hex,
+	type PublicClient,
+	parseEventLogs,
+} from 'viem';
+import { SequenceMarketplaceV1_ABI } from '..';
+
+export const getSequenceMarketplaceRequestId = async (
+	hash: Hex,
+	publicClient: PublicClient,
+	walletAddress: Address,
+) => {
+	try {
+		const receipt = await publicClient.getTransactionReceipt({
+			hash: hash,
+		});
+
+		const logs = parseEventLogs({
+			abi: SequenceMarketplaceV1_ABI,
+			eventName: 'RequestCreated',
+			args: {
+				creator: walletAddress,
+			},
+			logs: receipt.logs,
+		});
+
+		return logs[0].args.requestId.toString();
+	} catch (error) {
+		console.error(error);
+	}
+};

package/src/utils/index.ts

@@ -0,0 +1,7 @@
+export * from './abi';
+export * from './address';
+export * from './network';
+export * from './price';
+export * from './getMarketplaceDetails';
+export * from './networkconfigToWagmiChain';
+export * from './cn';

package/src/utils/network.ts

@@ -0,0 +1,5 @@
+import { networks } from '@0xsequence/network';
+
+export const getPresentableChainName = (chainId: number) => {
+	return networks[chainId as keyof typeof networks]?.title ?? 'Unknown Network';
+};

package/src/utils/networkconfigToWagmiChain.ts

@@ -0,0 +1,17 @@
+import type { NetworkConfig } from '@0xsequence/network';
+import type { Chain } from 'viem';
+
+export const networkToWagmiChain = (network: NetworkConfig): Chain => ({
+	...network,
+	id: Number(network.chainId),
+	name: network.name,
+	nativeCurrency: { ...network.nativeToken },
+	rpcUrls: {
+		default: {
+			http: [network.rpcUrl],
+		},
+		public: {
+			http: [network.rpcUrl],
+		},
+	},
+});

package/src/utils/price.ts

@@ -0,0 +1,131 @@
+import * as dn from 'dnum';
+import { formatUnits } from 'viem';
+
+type CalculatePriceDifferencePercentageArgs = {
+	inputPriceRaw: bigint;
+	basePriceRaw: bigint;
+	decimals: number;
+};
+
+/**
+ * Calculates the percentage difference between two prices
+ * @param args - Object containing input price, base price, and decimals
+ * @returns The percentage difference as a string with 2 decimal places
+ * @example
+ * ```ts
+ * const diff = calculatePriceDifferencePercentage({
+ *   inputPriceRaw: 1000000n,
+ *   basePriceRaw: 900000n,
+ *   decimals: 6
+ * }); // Returns "11.11"
+ * ```
+ */
+export const calculatePriceDifferencePercentage = ({
+	inputPriceRaw,
+	basePriceRaw,
+	decimals,
+}: CalculatePriceDifferencePercentageArgs) => {
+	const inputPrice = Number(formatUnits(inputPriceRaw, decimals));
+	const basePrice = Number(formatUnits(basePriceRaw, decimals));
+	const difference = inputPrice - basePrice;
+	const percentageDifference = (difference / basePrice) * 100;
+
+	return percentageDifference.toFixed(2);
+};
+
+/**
+ * Formats a raw price amount with the specified number of decimal places
+ * @param amount - The raw price amount as a bigint
+ * @param decimals - Number of decimal places to format to
+ * @returns Formatted price string with proper decimal and thousands separators
+ * @example
+ * ```ts
+ * const formatted = formatPrice(1000000n, 6); // Returns "1.000000"
+ * ```
+ */
+export const formatPrice = (amount: bigint, decimals: number): string => {
+	const formattedUnits = Number(formatUnits(amount, decimals));
+	return formattedUnits.toLocaleString('en-US', {
+		minimumFractionDigits: 0,
+		maximumFractionDigits: decimals,
+	});
+};
+
+/**
+ * Calculates the final earnings amount after applying multiple fee percentages
+ * @param amount - The raw amount as a bigint (e.g., from a blockchain transaction)
+ * @param decimals - The number of decimal places for the currency (e.g., 18 for ETH, 6 for USDC)
+ * @param fees - Array of fee percentages to apply (e.g., [2.5, 1.0] for 2.5% and 1% fees)
+ * @returns Formatted string representing the final earnings after all fees are applied
+ * @throws Will return '0' if there's an error in calculation
+ * @example
+ * ```ts
+ * const earnings = calculateEarningsAfterFees(
+ *   1000000000000000000n, // 1 ETH
+ *   18,                   // ETH decimals
+ *   [2.5, 1.0]           // 2.5% and 1% fees
+ * ); // Returns "0.96525" (1 ETH after 2.5% and 1% fees)
+ * ```
+ */
+export const calculateEarningsAfterFees = (
+	amount: bigint,
+	decimals: number,
+	fees: number[],
+): string => {
+	try {
+		const decimalAmount = Number(formatUnits(amount, decimals));
+		let earnings = dn.from(decimalAmount.toString(), decimals);
+
+		for (const fee of fees) {
+			if (fee > 0) {
+				const feeMultiplier = dn.from((1 - fee / 100).toString(), decimals);
+				earnings = dn.multiply(earnings, feeMultiplier);
+			}
+		}
+
+		return dn.format(earnings, {
+			digits: decimals,
+			trailingZeros: false,
+			locale: 'en-US',
+		});
+	} catch (error) {
+		console.error('Error calculating earnings after fees:', error);
+		return '0';
+	}
+};
+
+/**
+ * Formats a price amount with fee applied
+ * @param amount - The raw price amount as a bigint
+ * @param decimals - Number of decimal places for the currency
+ * @param feePercentage - Fee percentage to apply (e.g., 3.5 for 3.5%)
+ * @returns Formatted price string with fee applied and proper decimal/thousands separators
+ * @example
+ * ```ts
+ * const priceWithFee = formatPriceWithFee(1000000n, 6, 3.5); // Returns "1.035"
+ * ```
+ */
+export const formatPriceWithFee = (
+	amount: bigint,
+	decimals: number,
+	feePercentage: number,
+): string => {
+	try {
+		const decimalAmount = Number(formatUnits(amount, decimals));
+		const price = dn.from(decimalAmount.toString(), decimals);
+		const feeMultiplier = dn.from(
+			(1 + feePercentage / 100).toString(),
+			decimals,
+		);
+		const totalPrice = dn.multiply(price, feeMultiplier);
+
+		return dn.format(totalPrice, {
+			digits: decimals,
+			trailingZeros: false,
+			locale: 'en-US',
+		});
+	} catch (error) {
+		console.error('Error formatting price with fee:', error);
+		return '0';
+	}
+};

package/test/const.ts

@@ -0,0 +1,69 @@
+import { anvil } from 'viem/chains';
+import type { Currency } from '../src';
+import { CurrencyStatus } from '../src/react/_internal';
+
+export const TEST_CHAIN = {
+	...anvil,
+	rpcUrls: {
+		default: { http: [`http://127.0.0.1:8545/${process.env.VITEST_POOL_ID}`] },
+	},
+};
+
+export const USDC_ADDRESS = '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48';
+
+export const USDC_HOLDER = '0x5414d89a8bf7e99d732bc52f3e6a3ef461c0c078';
+
+// Deafault accounts for Anvil
+export const TEST_ACCOUNTS = [
+	'0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266',
+	'0x70997970C51812dc3A010C7d01b50e0d17dc79C8',
+	'0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
+	'0x90F79bf6EB2c4f870365E785982E1f101E93b906',
+	'0x15d34AAf54267DB7D7c367839AAf71A00a2C6A65',
+	'0x9965507D1a55bcC2695C58ba16FB37d819B0A4dc',
+	'0x976EA74026E726554dB657fA54763abd0C3a0aa9',
+	'0x14dC79964da2C08b23698B3D3cc7Ca32193d9955',
+	'0x23618e81E3f5cdF7f54C3d65f7FBc0aBf5B21E8f',
+	'0xa0Ee7A142d267C1f36714E4a8F75612F20a79720',
+] as const;
+
+export const TEST_PRIVATE_KEYS = [
+	'0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80',
+	'0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d',
+	'0x5de4111afa1a4b94908f83103eb1f1706367c2e68ca870fc3fb9a804cdab365a',
+	'0x7c852118294e51e653712a81e05800f419141751be58f605c371e15141b007a6',
+	'0x47e179ec197488593b187f80a00eb0da91f1b9d0b13f8733639f19c30a34926a',
+	'0x8b3a350cf5c34c9194ca85829a2df0ec3153be0318b5e2d3348e872092edffba',
+	'0x92db14e403b83dfe3df233f83dfa3a0d7096f21ca9b0d6d6b8d88b2b4ec1564e',
+	'0x4bbbf85ce3377467afe5d46f804f221813b2bb87f24d81f60f1fcdbf7cbf4356',
+	'0xdbda1821b80551c9d65939329250298aa3472ba22feea921c0cf5d620ea67b97',
+	'0x2a871d0798f97d79848a013d4936a73bf4cc922c825d33c1cf7073dff6d409c6',
+] as const;
+
+export const TEST_COLLECTIBLE = {
+	collectionAddress: '0xbabafdd8045740449a42b788a26e9b3a32f88ac1',
+	chainId: 1,
+	collectibleId: '7602',
+} as const;
+
+export const TEST_CURRENCY: Currency = {
+	chainId: 1,
+	contractAddress: USDC_ADDRESS,
+	status: CurrencyStatus.active,
+	name: 'Test Token',
+	symbol: 'TEST',
+	decimals: 18,
+	imageUrl: 'https://example.com/test.png',
+	exchangeRate: 1,
+	defaultChainCurrency: false,
+	nativeCurrency: false,
+	createdAt: '2021-01-01T00:00:00.000Z',
+	updatedAt: '2021-01-01T00:00:00.000Z',
+};
+
+export const TEST_CURRENCY_2: Currency = {
+	...TEST_CURRENCY,
+	symbol: 'TEST2',
+};
+
+export const TEST_CURRENCIES = [TEST_CURRENCY, TEST_CURRENCY_2];

package/test/globalSetup.ts

@@ -0,0 +1,16 @@
+import { createServer } from 'prool';
+import { anvil } from 'prool/instances';
+
+export default async function setup() {
+	const server = createServer({
+		host: '127.0.0.1',
+		port: 8545,
+		instance: anvil({
+			chainId: 1,
+			forkUrl: 'https://nodes.sequence.app/mainnet',
+			forkBlockNumber: 19868020n,
+			noMining: true,
+		}),
+	});
+	await server.start();
+}

package/test/index.ts

@@ -0,0 +1 @@
+export * from './test-utils';

package/test/mocks/wallet.ts

@@ -0,0 +1,63 @@
+import type { TransactionReceipt } from '@0xsequence/indexer';
+import { type Hex, type PublicClient, custom } from 'viem';
+import { vi } from 'vitest';
+import { WalletKind } from '../../src';
+import type { WalletInstance } from '../../src/react/_internal/wallet/wallet';
+import { ChainSwitchUserRejectedError } from '../../src/utils/_internal/error/transaction';
+
+export type MockWallet = WalletInstance;
+
+/**
+ * Creates a mock wallet with pre-configured mock functions for testing
+ * @param overrides - Optional overrides for the default mock implementations
+ * @returns A mock wallet instance with vitest mock functions
+ */
+export function createMockWallet(overrides?: Partial<MockWallet>): MockWallet {
+	const defaultMockWallet: MockWallet = {
+		getChainId: vi.fn().mockResolvedValue(1),
+		switchChain: vi.fn().mockResolvedValue(undefined),
+		address: vi
+			.fn()
+			.mockResolvedValue('0x0000000000000000000000000000000000000000' as Hex),
+		handleSendTransactionStep: vi.fn().mockResolvedValue('0x123' as Hex),
+		handleSignMessageStep: vi.fn().mockResolvedValue('0xsignature' as Hex),
+		handleConfirmTransactionStep: vi
+			.fn()
+			.mockResolvedValue({} as TransactionReceipt),
+		isWaaS: false,
+		transport: custom({
+			request: vi.fn(),
+		}),
+		walletKind: WalletKind.unknown,
+		hasTokenApproval: vi.fn().mockResolvedValue(true),
+		// @ts-expect-error
+		publicClient: vi.fn().mockResolvedValue({} as PublicClient),
+	};
+
+	return {
+		...defaultMockWallet,
+		...overrides,
+	};
+}
+
+/**
+ * Common mock implementations for wallet functions
+ * These are the actual mock functions that can be used directly or as overrides
+ */
+export const commonWalletMocks = {
+	successfulChainId: vi.fn().mockResolvedValue(1),
+	successfulAddress: vi
+		.fn()
+		.mockResolvedValue('0x0000000000000000000000000000000000000000' as Hex),
+	successfulTransaction: vi.fn().mockResolvedValue('0x123' as Hex),
+	successfulSignature: vi.fn().mockResolvedValue('0xsignature' as Hex),
+	successfulConfirmation: vi.fn().mockResolvedValue({} as TransactionReceipt),
+	successfulTokenApproval: vi.fn().mockResolvedValue(true),
+	chainSwitchRejection: vi
+		.fn()
+		.mockRejectedValue(new ChainSwitchUserRejectedError()),
+	transactionFailure: vi
+		.fn()
+		.mockRejectedValue(new Error('Transaction failed')),
+	signatureFailure: vi.fn().mockRejectedValue(new Error('Signature failed')),
+};

package/test/setup.ts

@@ -0,0 +1,38 @@
+import { cleanup } from '@testing-library/react';
+import { afterAll, afterEach, beforeAll } from 'vitest';
+import '@testing-library/jest-dom/vitest';
+import { server } from './test-utils';
+
+// https://github.com/jsdom/jsdom/issues/1695
+window.HTMLElement.prototype.scrollIntoView = () => {};
+
+// jsdom does not support replaceSync yet, so we need to polyfill it for web-sdk
+if (!('replaceSync' in CSSStyleSheet.prototype)) {
+	Object.defineProperty(CSSStyleSheet.prototype, 'replaceSync', {
+		value(cssText: string) {
+			this.cssText = cssText;
+			return cssText;
+		},
+	});
+}
+
+beforeAll(async () => {
+	server.listen({
+		onUnhandledRequest(request, print) {
+			// Ignore requests to the local anvil node
+			if (request.url.includes('127.0.0.1:8545')) {
+				return;
+			}
+			print.warning();
+		},
+	});
+});
+
+afterEach(() => {
+	cleanup();
+	server.resetHandlers();
+});
+
+afterAll(() => {
+	server.close();
+});

package/test/test-utils.tsx

@@ -0,0 +1,203 @@
+import {
+	SequenceConnectProvider,
+	createConfig as createSequenceConnectConfig,
+} from '@0xsequence/connect';
+import { ThemeProvider } from '@0xsequence/design-system';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { renderHook, render as rtlRender } from '@testing-library/react';
+import type { RenderOptions } from '@testing-library/react';
+import { HttpResponse, http as mswHttp } from 'msw';
+import { setupServer } from 'msw/node';
+import type { ReactElement } from 'react';
+import {
+	type Client,
+	createTestClient,
+	publicActions,
+	walletActions,
+} from 'viem';
+import { mainnet as wagmiMainet, polygon as wagmiPolygon } from 'viem/chains';
+import { http, type Config, WagmiProvider, createConfig } from 'wagmi';
+import { mock } from 'wagmi/connectors';
+import { handlers as marketplaceConfigHandlers } from '../src/react/_internal/api/__mocks__/builder.msw';
+import { handlers as indexerHandlers } from '../src/react/_internal/api/__mocks__/indexer.msw';
+import { handlers as marketplaceHandlers } from '../src/react/_internal/api/__mocks__/marketplace.msw';
+import { handlers as metadataHandlers } from '../src/react/_internal/api/__mocks__/metadata.msw';
+import { TEST_ACCOUNTS, TEST_CHAIN, TEST_PRIVATE_KEYS } from './const';
+
+const tickHandler = mswHttp.post(
+	'https://nodes.sequence.app/rpc/Databeat/Tick',
+	() => {
+		return HttpResponse.json({});
+	},
+);
+
+export const server = setupServer(
+	...marketplaceHandlers,
+	...metadataHandlers,
+	...indexerHandlers,
+	...marketplaceConfigHandlers,
+	tickHandler,
+);
+
+const createTestQueryClient = () =>
+	new QueryClient({
+		defaultOptions: {
+			queries: {
+				retry: false,
+				staleTime: 0,
+			},
+		},
+	});
+
+export const testClient = createTestClient({
+	transport: http(),
+	chain: TEST_CHAIN,
+	mode: 'anvil',
+	account: TEST_ACCOUNTS[0],
+	key: TEST_PRIVATE_KEYS[0],
+	pollingInterval: 100,
+})
+	.extend(publicActions)
+	.extend(walletActions) satisfies Client;
+
+const mainnet = {
+	...wagmiMainet,
+	rpcUrls: { default: { http: ['http://127.0.0.1:8545/1'] } },
+};
+
+const polygon = {
+	...wagmiPolygon,
+	rpcUrls: { default: { http: ['http://127.0.0.1:8545/1'] } },
+};
+
+const mockConnector = mock({
+	accounts: [TEST_ACCOUNTS[0]],
+	features: {
+		defaultConnected: true,
+		reconnect: true,
+	},
+});
+
+const wagmiConfigObj = {
+	chains: [mainnet, polygon],
+	connectors: [mockConnector],
+	transports: {
+		[mainnet.id]: http(),
+		[polygon.id]: http(),
+	},
+	multiInjectedProviderDiscovery: false,
+} as const;
+
+export const wagmiConfig = createConfig(wagmiConfigObj);
+
+function mockWaas() {
+	return new Proxy(mockConnector, {
+		apply(target, thisArg, args) {
+			const connector = Reflect.apply(target, thisArg, args);
+			connector.id = 'waas';
+			return connector;
+		},
+	});
+}
+
+function mockSequenceConnector() {
+	return new Proxy(mockConnector, {
+		apply(target, thisArg, args) {
+			const connector = Reflect.apply(target, thisArg, args);
+			connector.id = 'sequence';
+		},
+	});
+}
+
+const wagmiConfigEmbedded = createConfig({
+	...wagmiConfigObj,
+	connectors: [mockWaas()],
+});
+
+const wagmiConfigSequence = createConfig({
+	...wagmiConfigObj,
+	connectors: [mockSequenceConnector()],
+});
+
+type Options = Omit<RenderOptions, 'wrapper'> & {
+	wagmiConfig?: Config;
+	useEmbeddedWallet?: boolean;
+	useSequenceConnector?: boolean;
+};
+
+function renderWithClient(ui: ReactElement, options?: Options) {
+	const testQueryClient = createTestQueryClient();
+	let config = options?.wagmiConfig;
+	if (!config) {
+		// if testing waas, use the embedded wallet config
+		config = options?.useEmbeddedWallet
+			? wagmiConfigEmbedded
+			: // if testing sequence universal connector, use the sequence connector config
+				options?.useSequenceConnector
+				? wagmiConfigSequence
+				: // if testing non-sequence connector, use the default config
+					wagmiConfig;
+	}
+
+	// TODO: move make this more configurable, maybe use our own hook to create the config
+	const sequenceConnectConfig = createSequenceConnectConfig('universal', {
+		projectAccessKey: 'test',
+		chainIds: [1, 137],
+		defaultChainId: 1,
+		appName: 'Demo Dapp',
+	});
+
+	const Wrapper = ({ children }: { children: React.ReactNode }) => (
+		<WagmiProvider config={config}>
+			<QueryClientProvider client={testQueryClient}>
+				<SequenceConnectProvider config={sequenceConnectConfig.connectConfig}>
+					<ThemeProvider>{children}</ThemeProvider>
+				</SequenceConnectProvider>
+			</QueryClientProvider>
+		</WagmiProvider>
+	);
+
+	const { rerender, ...result } = rtlRender(ui, {
+		wrapper: Wrapper,
+		...options,
+	});
+
+	return {
+		...result,
+		rerender: (rerenderUi: ReactElement) =>
+			rerender(<Wrapper>{rerenderUi}</Wrapper>),
+	};
+}
+
+function renderHookWithClient<P, R>(
+	callback: (props: P) => R,
+	options?: Omit<RenderOptions, 'queries'> & {
+		wagmiConfig?: Config;
+		useEmbeddedWallet?: boolean;
+	},
+) {
+	const testQueryClient = createTestQueryClient();
+
+	let config = options?.wagmiConfig;
+	if (!config) {
+		config = options?.useEmbeddedWallet ? wagmiConfigEmbedded : wagmiConfig;
+	}
+
+	return renderHook(callback, {
+		wrapper: ({ children }) => {
+			return (
+				<WagmiProvider config={config}>
+					<QueryClientProvider client={testQueryClient}>
+						<ThemeProvider>{children}</ThemeProvider>
+					</QueryClientProvider>
+				</WagmiProvider>
+			);
+		},
+		...options,
+	});
+}
+
+export * from '@testing-library/react';
+
+export { renderWithClient as render };
+export { renderHookWithClient as renderHook };