@0xsequence/marketplace-sdk 0.10.0 → 1.0.0

package/src/react/hooks/useTokenSaleDetailsBatch.tsx

@@ -1,130 +0,0 @@
-import { useQuery } from '@tanstack/react-query';
-import { getUnixTime } from 'date-fns';
-import type { Address } from 'viem';
-import { useReadContracts } from 'wagmi';
-import { ERC1155_SALES_CONTRACT_ABI } from '../..';
-import { getIndexerClient } from '../_internal';
-import { useConfig } from './useConfig';
-
-interface useTokenSaleDetailsBatch {
-	tokenIds: string[];
-	salesContractAddress: Address;
-	collectionAddress: Address;
-	chainId: number;
-	query?: {
-		enabled?: boolean;
-	};
-}
-
-export function useTokenSaleDetailsBatch({
-	tokenIds,
-	salesContractAddress,
-	chainId,
-	collectionAddress,
-	query,
-}: useTokenSaleDetailsBatch) {
-	const config = useConfig();
-	const indexerClient = getIndexerClient(chainId, config);
-
-	const getReadContractsArgs = (tokenIds: string[]) =>
-		tokenIds.map((tokenId) => ({
-			address: salesContractAddress,
-			abi: ERC1155_SALES_CONTRACT_ABI,
-			functionName: 'tokenSaleDetails',
-			args: [tokenId],
-			chainId,
-		}));
-
-	const {
-		data: tokenSaleDetails,
-		isLoading: tokenSaleDetailsLoading,
-		error: tokenSaleDetailsError,
-	} = useReadContracts({
-		batchSize: 500_000, // Node gateway limit has a limit of 512kB, setting it to 500kB to be safe
-		contracts: getReadContractsArgs(tokenIds),
-		query: {
-			enabled: query?.enabled,
-		},
-	});
-
-	// Query token supplies individually using the indexer client:
-	/*
-	This way, if token 4 isn't minted, we can still get the supply information for tokens 0-3, and just treat token 4's supply as 0 (unminted). 
-	The problem is essentially that one unminted token was poisoning the entire response when querying all tokens at once.
-	*/
-	const {
-		data: tokenSupplies,
-		isLoading: tokenSuppliesLoading,
-		error: tokenSuppliesError,
-	} = useQuery({
-		queryKey: ['token-supplies-batch', chainId, collectionAddress, tokenIds],
-		queryFn: async () => {
-			const supplies = await Promise.all(
-				tokenIds.map(async (tokenId) => {
-					try {
-						const result = await indexerClient.getTokenSupplies({
-							contractAddress: collectionAddress,
-							includeMetadata: false,
-						});
-						const supply = result.tokenIDs?.find((s) => s.tokenID === tokenId);
-						return {
-							tokenId,
-							supply: supply ? Number(supply.supply) : 0,
-							error: null,
-						};
-					} catch (error) {
-						return {
-							tokenId,
-							supply: 0,
-							error,
-						};
-					}
-				}),
-			);
-			return supplies;
-		},
-		enabled: query?.enabled,
-	});
-
-	const extendedSupplyData = (tokenSaleDetails || [])
-		.map((data, index) => ({
-			...data,
-			tokenId: tokenIds[index],
-		}))
-		.filter((data) => data.status === 'success')
-		.filter((data) => {
-			if (typeof data.result !== 'object') return false;
-			const now = BigInt(getUnixTime(new Date()));
-			return data.result.endTime > now && data.result.startTime < now;
-		});
-
-	const getInitialSupply = (tokenId: string): number | undefined => {
-		const found = extendedSupplyData.find((data) => data.tokenId === tokenId);
-		if (!found || typeof found.result !== 'object' || found.result === null)
-			return undefined;
-		const supply = found.result.supplyCap;
-		if (supply === undefined) return undefined;
-		// https://github.com/0xsequence/contracts-library/blob/ead1baf34270c76260d01cfc130bb7cc9d57518e/src/tokens/ERC1155/utility/sale/IERC1155Sale.sol#L8
-		// 0 means infinite
-		if (supply === 0n) return Number.POSITIVE_INFINITY;
-		return Number(supply);
-	};
-
-	const getRemainingSupply = (tokenId: string): number | undefined => {
-		const initialSupply = getInitialSupply(tokenId);
-		if (!initialSupply) return undefined;
-
-		const supplyData = tokenSupplies?.find((s) => s.tokenId === tokenId);
-		if (!supplyData || supplyData.error) return initialSupply; // If no supply data or error, assume nothing is minted
-
-		return initialSupply - supplyData.supply;
-	};
-
-	return {
-		extendedSupplyData,
-		getInitialSupply,
-		getRemainingSupply,
-		loading: tokenSuppliesLoading || tokenSaleDetailsLoading,
-		error: tokenSuppliesError || tokenSaleDetailsError,
-	};
-}

package/src/react/ui/modals/_internal/components/actionModal/store.ts

@@ -1,57 +0,0 @@
-import { createStore } from '@xstate/store';
-import { useSelector } from '@xstate/store/react';
-import type { Address } from 'viem';
-
-export interface ActionModalState {
-	isOpen: boolean;
-	chainId: number | null;
-	collectionAddress: Address | null;
-}
-
-const initialContext: ActionModalState = {
-	isOpen: false,
-	chainId: null,
-	collectionAddress: null,
-};
-
-export const actionModalStore = createStore({
-	context: initialContext,
-	on: {
-		open: (
-			context,
-			event: { chainId: number; collectionAddress: Address },
-		) => ({
-			...context,
-			isOpen: true,
-			chainId: event.chainId,
-			collectionAddress: event.collectionAddress,
-		}),
-		close: (context) => ({
-			...context,
-			isOpen: false,
-			chainId: null,
-			collectionAddress: null,
-		}),
-	},
-});
-
-// Selector hooks
-export const useActionModalState = () =>
-	useSelector(actionModalStore, (state) => state.context);
-
-export const useIsActionModalOpen = () =>
-	useSelector(actionModalStore, (state) => state.context.isOpen);
-
-export const useActionModalChainId = () =>
-	useSelector(actionModalStore, (state) => state.context.chainId);
-
-export const useActionModalCollectionAddress = () =>
-	useSelector(actionModalStore, (state) => state.context.collectionAddress);
-
-export function openModal(chainId: number, collectionAddress: Address) {
-	actionModalStore.send({ type: 'open', chainId, collectionAddress });
-}
-
-export function closeModal() {
-	actionModalStore.send({ type: 'close' });
-}

package/src/react/ui/modals/modal-provider.tsx

@@ -1,25 +0,0 @@
-import { observer } from '@legendapp/state/react';
-import SwitchChainModal from './_internal/components/switchChainModal';
-import TransactionStatusModal from './_internal/components/transactionStatusModal';
-import { BuyModal } from './BuyModal/components/Modal';
-import { CreateListingModal } from './CreateListingModal/Modal';
-import { MakeOfferModal } from './MakeOfferModal/Modal';
-import { SellModal } from './SellModal/Modal';
-import SuccessfulPurchaseModal from './SuccessfulPurchaseModal';
-import { TransferModal } from './TransferModal';
-
-export const ModalProvider = observer(() => {
-	return (
-		<>
-			<CreateListingModal />
-			<MakeOfferModal />
-			<TransferModal />
-			<SellModal />
-			<BuyModal />
-			<SuccessfulPurchaseModal />
-			{/* Helper modals */}
-			<SwitchChainModal />
-			<TransactionStatusModal />
-		</>
-	);
-});

package/test/mocks/wallet.ts

@@ -1,63 +0,0 @@
-import type { TransactionReceipt } from '@0xsequence/indexer';
-import { custom, type Hex, type PublicClient } 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')),
-};