@0xsequence/marketplace-sdk 0.0.1 → 0.1.0

package/src/react/_internal/types.ts

@@ -1,13 +1,37 @@
-import type { ChainId as NetworkChainId } from '@0xsequence/network';
+import { ChainId as NetworkChainId } from '@0xsequence/network';
 import type { ContractType } from '@types';
+import type { Address } from 'viem';
+import { z } from 'zod';
 
-export type QueryArg = {
-	query?: {
-		enabled?: boolean;
-		//TODO: Add more fields
-	};
-};
+export const QueryArgSchema = z
+	.object({
+		enabled: z.boolean().optional(),
+	})
+	.optional();
 
-export type ChainId = string | number | NetworkChainId;
+export type QueryArg = z.infer<typeof QueryArgSchema>;
+
+export const CollectableIdSchema = z.string().or(z.number());
+
+export const ChainIdSchema = z.union([
+	z.string(),
+	z.number(),
+	z.nativeEnum(NetworkChainId),
+]);
+
+export const AddressSchema = z.string().transform((val, ctx) => {
+	const regex = /^0x[a-fA-F0-9]{40}$/;
+
+	if (!regex.test(val)) {
+		ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			message: `Invalid Address ${val}`,
+		});
+	}
+
+	return val as Address;
+});
+
+export type ChainId = z.infer<typeof ChainIdSchema>;
 
 export type CollectionType = ContractType.ERC1155 | ContractType.ERC721;

package/src/react/hooks/index.ts

@@ -1,4 +1,5 @@
 export * from './useBalanceOfCollectible';
+export * from './useCountOfCollectables';
 export * from './useCollectible';
 export * from './useCollection';
 export * from './useConfig';

package/src/react/hooks/useBalanceOfCollectible.tsx

@@ -1,51 +1,76 @@
 import {
-	type ChainId,
-	type QueryArg,
+	AddressSchema,
+	ChainIdSchema,
+	CollectableIdSchema,
+	type QueryArgSchema,
 	collectableKeys,
 	getIndexerClient,
 } from '@internal';
-import { queryOptions, useQuery } from '@tanstack/react-query';
+import { queryOptions, skipToken, useQuery } from '@tanstack/react-query';
 import type { SdkConfig } from '@types';
+import type { Hex } from 'viem';
+import { z } from 'zod';
 import { useConfig } from './useConfig';
 
-export type UseBalanceOfCollectibleArgs = {
-	collectionAddress: string;
-	userAddress: string;
-	tokenId: string;
-	chainId: ChainId;
-} & QueryArg;
+const fetchBalanceOfCollectibleSchema = z.object({
+	collectionAddress: AddressSchema,
+	collectableId: CollectableIdSchema.pipe(z.coerce.string()),
+	userAddress: AddressSchema,
+	chainId: ChainIdSchema.pipe(z.coerce.number()),
+});
+
+type FetchBalanceOfCollectibleArgs = z.input<
+	typeof fetchBalanceOfCollectibleSchema
+>;
 
 const fetchBalanceOfCollectible = async (
-	args: UseBalanceOfCollectibleArgs,
+	args: FetchBalanceOfCollectibleArgs,
 	config: SdkConfig,
 ) => {
-	const indexerClient = getIndexerClient(args.chainId, config);
+	const parsedArgs = fetchBalanceOfCollectibleSchema.parse(args);
+	const indexerClient = getIndexerClient(parsedArgs.chainId, config);
 	return indexerClient
 		.getTokenBalances({
-			accountAddress: args.userAddress,
-			contractAddress: args.collectionAddress,
-			tokenID: args.tokenId,
+			accountAddress: parsedArgs.userAddress,
+			contractAddress: parsedArgs.collectionAddress,
+			tokenID: parsedArgs.collectableId,
 			includeMetadata: false,
 			metadataOptions: {
 				verifiedOnly: true,
-				includeContracts: [args.collectionAddress],
+				includeContracts: [parsedArgs.collectionAddress],
 			},
 		})
 		.then((res) => res.balances[0] || null);
 };
 
+interface BalanceOfCollectibleOptions
+	extends Omit<FetchBalanceOfCollectibleArgs, 'userAddress'> {
+	userAddress?: Hex;
+	query?: z.infer<typeof QueryArgSchema>;
+}
 export const balanceOfCollectibleOptions = (
-	args: UseBalanceOfCollectibleArgs,
+	args: BalanceOfCollectibleOptions,
 	config: SdkConfig,
 ) => {
 	return queryOptions({
 		...args.query,
 		queryKey: [...collectableKeys.userBalances, args, config],
-		queryFn: () => fetchBalanceOfCollectible(args, config),
+		queryFn: args.userAddress
+			? () =>
+					fetchBalanceOfCollectible(
+						{
+							...args,
+							// biome-ignore lint/style/noNonNullAssertion: this is guaranteed by the userAddress check above
+							userAddress: args.userAddress!,
+						},
+						config,
+					)
+			: skipToken,
+		enabled: !!args.userAddress || args.query?.enabled,
 	});
 };
 
-export const useBalanceOfCollectible = (args: UseBalanceOfCollectibleArgs) => {
+export const useBalanceOfCollectible = (args: BalanceOfCollectibleOptions) => {
 	const config = useConfig();
 	return useQuery(balanceOfCollectibleOptions(args, config));
 };

package/src/react/hooks/useCollectible.tsx

@@ -1,31 +1,37 @@
 import {
-	type ChainId,
-	type QueryArg,
+	AddressSchema,
+	ChainIdSchema,
+	QueryArgSchema,
 	collectableKeys,
 	getMetadataClient,
 } from '@internal';
 import { queryOptions, useQuery } from '@tanstack/react-query';
 import type { SdkConfig } from '@types';
+import { z } from 'zod';
 import { useConfig } from './useConfig';
 
-export type UseCollectibleArgs = {
-	chainId: ChainId;
-	collectionAddress: string;
-	collectibleId: string;
-} & QueryArg;
+const UseCollectibleSchema = z.object({
+	chainId: ChainIdSchema.pipe(z.coerce.string()),
+	collectionAddress: AddressSchema,
+	collectibleId: z.string(),
+	query: QueryArgSchema,
+});
 
-export type UseCollectibleReturn = ReturnType<typeof fetchCollectible>;
+export type UseCollectibleArgs = z.infer<typeof UseCollectibleSchema>;
+
+export type UseCollectibleReturn = Awaited<ReturnType<typeof fetchCollectible>>;
 
 const fetchCollectible = async (
 	args: UseCollectibleArgs,
 	config: SdkConfig,
 ) => {
+	const parsedArgs = UseCollectibleSchema.parse(args);
 	const metadataClient = getMetadataClient(config);
 	return metadataClient
 		.getTokenMetadata({
-			chainID: String(args.chainId),
-			contractAddress: args.collectionAddress,
-			tokenIDs: [args.collectibleId],
+			chainID: parsedArgs.chainId,
+			contractAddress: parsedArgs.collectionAddress,
+			tokenIDs: [parsedArgs.collectibleId],
 		})
 		.then((resp) => resp.tokenMetadata[0]);
 };

package/src/react/hooks/useCollection.tsx

@@ -1,42 +1,48 @@
 import {
-	type ChainId,
-	type QueryArg,
-	collectionKeys,
-	getMetadataClient,
-} from '@internal';
-import { queryOptions, useQuery } from '@tanstack/react-query';
-import type { SdkConfig } from '@types';
-import { useConfig } from './useConfig';
+  AddressSchema,
+  ChainIdSchema,
+  QueryArgSchema,
+  collectionKeys,
+  getMetadataClient,
+} from "@internal";
+import { queryOptions, useQuery } from "@tanstack/react-query";
+import type { SdkConfig } from "@types";
+import { z } from "zod";
+import { useConfig } from "./useConfig";
 
-export type UseCollectionArgs = {
-	chainId: ChainId;
-	collectionAddress: string;
-} & QueryArg;
+const UseCollectionSchema = z.object({
+  chainId: ChainIdSchema.pipe(z.coerce.string()),
+  collectionAddress: AddressSchema,
+  query: QueryArgSchema,
+});
 
-export type UseCollectionReturn = ReturnType<typeof fetchCollection>;
+export type UseCollectionArgs = z.input<typeof UseCollectionSchema>;
+
+export type UseCollectionReturn = Awaited<ReturnType<typeof fetchCollection>>;
 
 const fetchCollection = async (args: UseCollectionArgs, config: SdkConfig) => {
-	const metadataClient = getMetadataClient(config);
-	return metadataClient
-		.getContractInfo({
-			chainID: String(args.chainId),
-			contractAddress: args.collectionAddress,
-		})
-		.then((resp) => resp.contractInfo);
+  const parsedArgs = UseCollectionSchema.parse(args);
+  const metadataClient = getMetadataClient(config);
+  return metadataClient
+    .getContractInfo({
+      chainID: parsedArgs.chainId,
+      contractAddress: parsedArgs.collectionAddress,
+    })
+    .then((resp) => resp.contractInfo);
 };
 
 export const collectionOptions = (
-	args: UseCollectionArgs,
-	config: SdkConfig,
+  args: UseCollectionArgs,
+  config: SdkConfig
 ) => {
-	return queryOptions({
-		...args.query,
-		queryKey: [...collectionKeys.detail, args, config],
-		queryFn: () => fetchCollection(args, config),
-	});
+  return queryOptions({
+    ...args.query,
+    queryKey: [...collectionKeys.detail, args, config],
+    queryFn: () => fetchCollection(args, config),
+  });
 };
 
 export const useCollection = (args: UseCollectionArgs) => {
-	const config = useConfig();
-	return useQuery(collectionOptions(args, config));
+  const config = useConfig();
+  return useQuery(collectionOptions(args, config));
 };

package/src/react/hooks/useCountOfCollectables.tsx

@@ -0,0 +1,77 @@
+import {
+	AddressSchema,
+	ChainIdSchema,
+	OrderSide,
+	QueryArgSchema,
+	collectableKeys,
+	getMarketplaceClient,
+} from '@internal';
+import { queryOptions, useQuery } from '@tanstack/react-query';
+import type { SdkConfig } from '@types';
+import { z } from 'zod';
+import { collectiblesFilterSchema } from '../_internal/api/zod-schema';
+import { useConfig } from './useConfig';
+
+const BaseSchema = z.object({
+	chainId: ChainIdSchema.pipe(z.coerce.string()),
+	collectionAddress: AddressSchema,
+	query: QueryArgSchema,
+});
+
+const UseCountOfCollectableSchema = BaseSchema.extend({
+	filter: collectiblesFilterSchema,
+	side: z.nativeEnum(OrderSide),
+}).or(
+	BaseSchema.extend({
+		filter: z.undefined(),
+		side: z.undefined(),
+	}),
+);
+
+export type UseCountOfCollectablesArgs = z.infer<
+	typeof UseCountOfCollectableSchema
+>;
+
+export type UseContOfCollectableReturn = Awaited<
+	ReturnType<typeof fetchCountOfCollectables>
+>;
+
+const fetchCountOfCollectables = async (
+	args: UseCountOfCollectablesArgs,
+	config: SdkConfig,
+) => {
+	const parsedArgs = UseCountOfCollectableSchema.parse(args);
+	const marketplaceClient = getMarketplaceClient(parsedArgs.chainId, config);
+	if (parsedArgs.filter) {
+		return marketplaceClient
+			.getCountOfFilteredCollectibles({
+				...parsedArgs,
+				contractAddress: parsedArgs.collectionAddress,
+				// biome-ignore lint/style/noNonNullAssertion: safe to assert here, as it's validated
+				side: parsedArgs.side!,
+			})
+			.then((resp) => resp.count);
+	}
+	return marketplaceClient
+		.getCountOfAllCollectibles({
+			...parsedArgs,
+			contractAddress: parsedArgs.collectionAddress,
+		})
+		.then((resp) => resp.count);
+};
+
+export const countOfCollectablesOptions = (
+	args: UseCountOfCollectablesArgs,
+	config: SdkConfig,
+) => {
+	return queryOptions({
+		...args.query,
+		queryKey: [...collectableKeys.counts, args],
+		queryFn: () => fetchCountOfCollectables(args, config),
+	});
+};
+
+export const useCountOfCollectables = (args: UseCountOfCollectablesArgs) => {
+	const config = useConfig();
+	return useQuery(countOfCollectablesOptions(args, config));
+};

package/src/react/hooks/useCurrencies.tsx

@@ -1,7 +1,9 @@
 import {
+	AddressSchema,
 	type ChainId,
+	ChainIdSchema,
 	type Currency,
-	type QueryArg,
+	QueryArgSchema,
 	configKeys,
 	currencyKeys,
 	getMarketplaceClient,
@@ -9,31 +11,40 @@ import {
 } from '@internal';
 import { queryOptions, useQuery } from '@tanstack/react-query';
 import type { MarketplaceConfig, SdkConfig } from '@types';
+import { z } from 'zod';
 import { useConfig } from './useConfig';
 
-export type UseCurrenciesArgs = {
-	chainId: ChainId;
-	collectionAddress?: string;
-	includeNativeCurrency?: boolean;
-} & QueryArg;
+const ChainIdCoerce = ChainIdSchema.transform((val) => val.toString());
 
-export type UseCurrenciesReturn = ReturnType<typeof fetchCurrencies>;
+const UseCurrenciesArgsSchema = z.object({
+	chainId: ChainIdCoerce,
+	collectionAddress: AddressSchema.optional(),
+	includeNativeCurrency: z.boolean().optional(),
+	query: QueryArgSchema,
+});
+
+type UseCurrenciesArgs = z.input<typeof UseCurrenciesArgsSchema>;
+
+export type UseCurrenciesReturn = Awaited<ReturnType<typeof fetchCurrencies>>;
 
 const fetchCurrencies = async (chainId: ChainId, config: SdkConfig) => {
-	const marketplaceClient = getMarketplaceClient(chainId, config);
+	const parsedChainId = ChainIdCoerce.parse(chainId);
+	const marketplaceClient = getMarketplaceClient(parsedChainId, config);
 	return marketplaceClient.listCurrencies().then((resp) => resp.currencies);
 };
 
 const selectCurrencies = (data: Currency[], args: UseCurrenciesArgs) => {
+	const argsParsed = UseCurrenciesArgsSchema.parse(args);
 	// if collectionAddress is passed, filter currencies based on collection currency options
-	if (args.collectionAddress) {
+	if (argsParsed.collectionAddress) {
 		const queryClient = getQueryClient();
 		const marketplaceConfigCache = queryClient.getQueriesData({
 			queryKey: configKeys.marketplace,
 		})[0][1] as MarketplaceConfig;
 
 		const collection = marketplaceConfigCache?.collections.find(
-			(collection) => collection.collectionAddress === args.collectionAddress,
+			(collection) =>
+				collection.collectionAddress === argsParsed.collectionAddress,
 		);
 
 		if (!collection) {
@@ -44,12 +55,12 @@ const selectCurrencies = (data: Currency[], args: UseCurrenciesArgs) => {
 			(currency) =>
 				collection.currencyOptions?.includes(currency.contractAddress) ||
 				// biome-ignore lint/suspicious/noDoubleEquals: <explanation>
-				currency.nativeCurrency == args.includeNativeCurrency ||
+				currency.nativeCurrency == argsParsed.includeNativeCurrency ||
 				currency.defaultChainCurrency,
 		);
 	}
 	// if includeNativeCurrency is true, return all currencies
-	if (args.includeNativeCurrency) {
+	if (argsParsed.includeNativeCurrency) {
 		return data;
 	}
 

package/src/react/hooks/useFilters.tsx

@@ -1,26 +1,32 @@
 import {
-	type ChainId,
-	type QueryArg,
+	AddressSchema,
+	ChainIdSchema,
+	QueryArgSchema,
 	collectableKeys,
 	getMetadataClient,
 } from '@internal';
 import { queryOptions, useQuery } from '@tanstack/react-query';
 import type { SdkConfig } from '@types';
+import { z } from 'zod';
 import { useConfig } from './useConfig';
 
-export type UseFiltersArgs = {
-	chainId: ChainId;
-	collectionAddress: string;
-} & QueryArg;
+const UseFiltersSchema = z.object({
+	chainId: ChainIdSchema.pipe(z.coerce.string()),
+	collectionAddress: AddressSchema,
+	query: QueryArgSchema,
+});
 
-export type UseFilterReturn = ReturnType<typeof fetchFilters>;
+export type UseFiltersArgs = z.infer<typeof UseFiltersSchema>;
+
+export type UseFilterReturn = Awaited<ReturnType<typeof fetchFilters>>;
 
 export const fetchFilters = async (args: UseFiltersArgs, config: SdkConfig) => {
+	const parsedArgs = UseFiltersSchema.parse(args);
 	const metadataClient = getMetadataClient(config);
 	return metadataClient
 		.tokenCollectionFilters({
-			chainID: String(args.chainId),
-			contractAddress: args.collectionAddress,
+			chainID: parsedArgs.chainId,
+			contractAddress: parsedArgs.collectionAddress,
 		})
 		.then((resp) => resp.filters);
 };

package/src/react/hooks/useFloorOrder.tsx

@@ -1,28 +1,43 @@
-import { collectableKeys, getMarketplaceClient } from '@internal';
+import {
+	AddressSchema,
+	ChainIdSchema,
+	QueryArgSchema,
+	collectableKeys,
+	getMarketplaceClient,
+} from '@internal';
 import { queryOptions, useQuery } from '@tanstack/react-query';
 import type { SdkConfig } from '@types';
+import { z } from 'zod';
 import { useConfig } from './useConfig';
 
-export type UseFloorOrder = {
-	chainId: string;
-	collectionAddress: string;
-};
+const UseFloorOrderSchema = z.object({
+	chainId: ChainIdSchema.pipe(z.coerce.string()),
+	collectionAddress: AddressSchema,
+	query: QueryArgSchema,
+});
+
+export type UseFloorOrderArgs = z.infer<typeof UseFloorOrderSchema>;
+
+export type UseFloorOrderReturn = Awaited<ReturnType<typeof fetchFloorOrder>>;
 
-const fetchFloorOrder = async (args: UseFloorOrder, config: SdkConfig) => {
+const fetchFloorOrder = async (args: UseFloorOrderArgs, config: SdkConfig) => {
 	const marketplaceClient = getMarketplaceClient(args.chainId, config);
 	return marketplaceClient
 		.getFloorOrder({ contractAddress: args.collectionAddress })
 		.then((data) => data.collectible);
 };
 
-export const floorOrderOptions = (args: UseFloorOrder, config: SdkConfig) => {
+export const floorOrderOptions = (
+	args: UseFloorOrderArgs,
+	config: SdkConfig,
+) => {
 	return queryOptions({
 		queryKey: [...collectableKeys.floorOrders, args, config],
 		queryFn: () => fetchFloorOrder(args, config),
 	});
 };
 
-export const useFloorOrder = (args: UseFloorOrder) => {
+export const useFloorOrder = (args: UseFloorOrderArgs) => {
 	const config = useConfig();
 	return useQuery(floorOrderOptions(args, config));
 };

package/src/react/hooks/useGenerateSellTransaction.tsx

@@ -1,27 +1,34 @@
 import {
 	type ChainId,
+	ChainIdSchema,
 	type GenerateSellTransactionArgs,
 	getMarketplaceClient,
 } from '@internal';
 import { useMutation } from '@tanstack/react-query';
 import type { SdkConfig } from '@types';
+import { z } from 'zod';
+import { stepSchema } from '../_internal/api/zod-schema';
 import { useConfig } from './useConfig';
 
-export type UseGenerateSellTransactionArgs = {
-	chainId: ChainId;
-	onSuccess?: () => void | Promise<void>;
-};
+const UserGeneratSellTransactionArgsSchema = z.object({
+	chainId: ChainIdSchema.pipe(z.coerce.string()),
+	onSuccess: z.function().args(stepSchema.array().optional()).optional(),
+});
+
+type UseGenerateSellTransactionArgs = z.infer<
+	typeof UserGeneratSellTransactionArgsSchema
+>;
 
 export const generateSellTransaction = async (
 	args: GenerateSellTransactionArgs,
 	config: SdkConfig,
 	chainId: ChainId,
 ) => {
-	console.log('generateSellTransaction');
-	console.log(args);
-	console.log(chainId);
-	const marketplaceClient = getMarketplaceClient(chainId, config);
-	return marketplaceClient.generateSellTransaction(args);
+	const parsedChainId = ChainIdSchema.pipe(z.coerce.string()).parse(chainId);
+	const marketplaceClient = getMarketplaceClient(parsedChainId, config);
+	return marketplaceClient
+		.generateSellTransaction(args)
+		.then((data) => data.steps);
 };
 
 export const useGenerateSellTransaction = (

package/src/react/hooks/useHighestOffer.tsx

@@ -1,31 +1,41 @@
 import {
-	type GetCollectibleHighestOfferArgs,
-	type QueryArg,
+	AddressSchema,
+	ChainIdSchema,
+	QueryArgSchema,
 	collectableKeys,
 	getMarketplaceClient,
 } from '@internal';
 import { queryOptions, useQuery } from '@tanstack/react-query';
 import type { SdkConfig } from '@types';
+import { z } from 'zod';
+import { getCollectibleHighestOfferArgsSchema } from '../_internal/api/zod-schema';
 import { useConfig } from './useConfig';
 
-export type UseHighestOfferArgs = Omit<
-	GetCollectibleHighestOfferArgs,
-	'contractAddress'
-> & {
-	collectionAddress: string;
-	chainId: string;
-} & QueryArg;
+const UseHighestOfferArgsSchema = getCollectibleHighestOfferArgsSchema
+	.omit({
+		contractAddress: true,
+	})
+	.extend({
+		collectionAddress: AddressSchema,
+		chainId: ChainIdSchema.pipe(z.coerce.string()),
+		query: QueryArgSchema,
+	});
+
+export type UseHighestOfferArgs = z.infer<typeof UseHighestOfferArgsSchema>;
 
-export type UseHighestOfferReturn = ReturnType<typeof fetchHighestOffer>;
+export type UseHighestOfferReturn = Awaited<
+	ReturnType<typeof fetchHighestOffer>
+>;
 
 const fetchHighestOffer = async (
 	args: UseHighestOfferArgs,
 	config: SdkConfig,
 ) => {
-	const marketplaceClient = getMarketplaceClient(args.chainId, config);
+	const parsedArgs = UseHighestOfferArgsSchema.parse(args);
+	const marketplaceClient = getMarketplaceClient(parsedArgs.chainId, config);
 	return marketplaceClient.getCollectibleHighestOffer({
-		...args,
-		contractAddress: args.collectionAddress,
+		...parsedArgs,
+		contractAddress: parsedArgs.collectionAddress,
 	});
 };