@0xsequence/marketplace-sdk 0.2.0 → 0.3.1

package/src/react/hooks/useCancelOrder.tsx

@@ -0,0 +1,38 @@
+import {
+	type CancelInput,
+	TransactionType,
+} from '../_internal/transaction-machine/execute-transaction';
+import {
+	useTransactionMachine,
+	type UseTransactionMachineConfig,
+} from '../_internal/transaction-machine/useTransactionMachine';
+
+interface UseCancelOrderArgs extends Omit<UseTransactionMachineConfig, 'type'> {
+	onSuccess?: (hash: string) => void;
+	onError?: (error: Error) => void;
+	onTransactionSent?: (hash: string) => void;
+}
+
+export const useCancelOrder = ({
+	onSuccess,
+	onError,
+	onTransactionSent,
+	...config
+}: UseCancelOrderArgs) => {
+	const machine = useTransactionMachine(
+		{
+			...config,
+			type: TransactionType.CANCEL,
+		},
+		onSuccess,
+		onError,
+		onTransactionSent,
+	);
+
+	return {
+		cancel: (props: CancelInput) => machine?.start({ props }),
+		onError,
+		onSuccess,
+		onTransactionSent,
+	};
+};

package/src/react/hooks/useCheckoutOptions.tsx

@@ -1,63 +1,66 @@
-import { queryOptions, useQuery } from "@tanstack/react-query";
-import { z } from "zod";
-import type { SdkConfig } from "../../types";
+import { queryOptions, useQuery } from '@tanstack/react-query';
+import { z } from 'zod';
+import type { SdkConfig } from '../../types';
 import {
-  AddressSchema,
-  ChainIdSchema,
-  MarketplaceKind,
-  QueryArgSchema,
-  getMarketplaceClient,
-} from "../_internal";
-import { useConfig } from "./useConfig";
+	AddressSchema,
+	ChainIdSchema,
+	MarketplaceKind,
+	QueryArgSchema,
+	getMarketplaceClient,
+} from '../_internal';
+import { useConfig } from './useConfig';
+import { useAccount } from 'wagmi';
+import type { Hex } from 'viem';
 
 const UseCheckoutOptionsSchema = z.object({
-  chainId: ChainIdSchema.pipe(z.coerce.string()),
-  walletAddress: AddressSchema,
-  orders: z.array(
-    z.object({
-      collectionAddress: AddressSchema,
-      orderId: z.string(),
-      quantity: z.number(),
-      marketplace: z.nativeEnum(MarketplaceKind),
-    })
-  ),
-  query: QueryArgSchema,
+	chainId: ChainIdSchema.pipe(z.coerce.string()),
+	orders: z.array(
+		z.object({
+			collectionAddress: AddressSchema,
+			orderId: z.string(),
+			marketplace: z.nativeEnum(MarketplaceKind),
+		}),
+	),
+	query: QueryArgSchema,
 });
 
 export type UseCheckoutOptionsArgs = z.infer<typeof UseCheckoutOptionsSchema>;
 
 export type UseCheckoutOptionsReturn = Awaited<
-  ReturnType<typeof fetchCheckoutOptions>
+	ReturnType<typeof fetchCheckoutOptions>
 >;
 
 const fetchCheckoutOptions = async (
-  args: UseCheckoutOptionsArgs,
-  config: SdkConfig
+	args: UseCheckoutOptionsArgs & { walletAddress: Hex },
+	config: SdkConfig,
 ) => {
-  const marketplaceClient = getMarketplaceClient(args.chainId, config);
-  return marketplaceClient.checkoutOptionsMarketplace({
-    wallet: args.walletAddress,
-    orders: args.orders.map((order) => ({
-      contractAddress: order.collectionAddress,
-      orderId: order.orderId,
-      marketplace: order.marketplace,
-      quantity: order.quantity,
-    })),
-    additionalFee: 0, //TODO: add additional fee
-  });
+	const marketplaceClient = getMarketplaceClient(args.chainId, config);
+	return marketplaceClient.checkoutOptionsMarketplace({
+		wallet: args.walletAddress,
+		orders: args.orders.map((order) => ({
+			contractAddress: order.collectionAddress,
+			orderId: order.orderId,
+			marketplace: order.marketplace,
+		})),
+		additionalFee: 0, //TODO: add additional fee
+	});
 };
 
 export const checkoutOptionsOptions = (
-  args: UseCheckoutOptionsArgs,
-  config: SdkConfig
+	args: UseCheckoutOptionsArgs & { walletAddress: Hex },
+	config: SdkConfig,
 ) => {
-  return queryOptions({
-    queryKey: ["checkoutOptions", args],
-    queryFn: () => fetchCheckoutOptions(args, config),
-  });
+	return queryOptions({
+		queryKey: ['checkoutOptions', args],
+		queryFn: () => fetchCheckoutOptions(args, config),
+	});
 };
 
 export const useCheckoutOptions = (args: UseCheckoutOptionsArgs) => {
-  const config = useConfig();
-  return useQuery(checkoutOptionsOptions(args, config));
+	const { address } = useAccount();
+	const config = useConfig();
+	return useQuery(
+		// biome-ignore lint/style/noNonNullAssertion: <explanation>
+		checkoutOptionsOptions({ walletAddress: address!, ...args }, config),
+	);
 };

package/src/react/hooks/useCountOfCollectables.tsx

@@ -1,77 +1,77 @@
-import { queryOptions, useQuery } from "@tanstack/react-query";
-import { z } from "zod";
-import type { SdkConfig } from "../../types";
+import { queryOptions, useQuery } from '@tanstack/react-query';
+import { z } from 'zod';
+import type { SdkConfig } from '../../types';
 import {
-  AddressSchema,
-  ChainIdSchema,
-  OrderSide,
-  QueryArgSchema,
-  collectableKeys,
-  getMarketplaceClient,
-} from "../_internal";
-import { collectiblesFilterSchema } from "../_internal/api/zod-schema";
-import { useConfig } from "./useConfig";
+	AddressSchema,
+	ChainIdSchema,
+	OrderSide,
+	QueryArgSchema,
+	collectableKeys,
+	getMarketplaceClient,
+} from '../_internal';
+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,
+	chainId: ChainIdSchema.pipe(z.coerce.string()),
+	collectionAddress: AddressSchema,
+	query: QueryArgSchema,
 });
 
 const UseCountOfCollectableSchema = BaseSchema.extend({
-  filter: collectiblesFilterSchema,
-  side: z.nativeEnum(OrderSide),
+	filter: collectiblesFilterSchema,
+	side: z.nativeEnum(OrderSide),
 }).or(
-  BaseSchema.extend({
-    filter: z.undefined(),
-    side: z.undefined(),
-  })
+	BaseSchema.extend({
+		filter: z.undefined(),
+		side: z.undefined(),
+	}),
 );
 
 export type UseCountOfCollectablesArgs = z.infer<
-  typeof UseCountOfCollectableSchema
+	typeof UseCountOfCollectableSchema
 >;
 
 export type UseContOfCollectableReturn = Awaited<
-  ReturnType<typeof fetchCountOfCollectables>
+	ReturnType<typeof fetchCountOfCollectables>
 >;
 
 const fetchCountOfCollectables = async (
-  args: UseCountOfCollectablesArgs,
-  config: SdkConfig
+	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);
+	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
+	args: UseCountOfCollectablesArgs,
+	config: SdkConfig,
 ) => {
-  return queryOptions({
-    ...args.query,
-    queryKey: [...collectableKeys.counts, args],
-    queryFn: () => fetchCountOfCollectables(args, config),
-  });
+	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));
+	const config = useConfig();
+	return useQuery(countOfCollectablesOptions(args, config));
 };

package/src/react/hooks/useCreateListing.tsx

@@ -0,0 +1,65 @@
+import { useState, useCallback } from 'react';
+import type { Hash } from 'viem';
+import {
+	type ListingInput,
+	TransactionType,
+	type TransactionSteps,
+} from '../_internal/transaction-machine/execute-transaction';
+import {
+	useTransactionMachine,
+	type UseTransactionMachineConfig,
+} from '../_internal/transaction-machine/useTransactionMachine';
+
+interface UseCreateListingArgs
+	extends Omit<UseTransactionMachineConfig, 'type'> {
+	onSuccess?: (hash: Hash) => void;
+	onError?: (error: Error) => void;
+	onTransactionSent?: (hash: Hash) => void;
+}
+
+export const useCreateListing = ({
+	onSuccess,
+	onError,
+	onTransactionSent,
+	...config
+}: UseCreateListingArgs) => {
+	const [isLoading, setIsLoading] = useState(false);
+	const [steps, setSteps] = useState<TransactionSteps | null>(null);
+
+	const machine = useTransactionMachine(
+		{
+			...config,
+			type: TransactionType.LISTING,
+		},
+		onSuccess,
+		onError,
+		onTransactionSent,
+	);
+
+	const loadSteps = useCallback(
+		async (props: ListingInput) => {
+			if (!machine) return;
+			setIsLoading(true);
+			try {
+				const generatedSteps = await machine.getTransactionSteps(props);
+				setSteps(generatedSteps);
+			} catch (error) {
+				onError?.(error as Error);
+			} finally {
+				setIsLoading(false);
+			}
+		},
+		[machine, onError],
+	);
+
+	return {
+		createListing: (props: ListingInput) => machine?.start({ props }),
+		getListingSteps: (props: ListingInput) => ({
+			isLoading,
+			steps,
+			refreshSteps: () => loadSteps(props),
+		}),
+		onError,
+		onSuccess,
+	};
+};

package/src/react/hooks/useCurrencies.tsx

@@ -1,26 +1,26 @@
-import { queryOptions, useQuery } from "@tanstack/react-query";
-import { z } from "zod";
-import { useConfig } from "./useConfig";
+import { queryOptions, useQuery } from '@tanstack/react-query';
+import { z } from 'zod';
+import { useConfig } from './useConfig';
 import {
-  ChainIdSchema,
-  AddressSchema,
-  QueryArgSchema,
-  getMarketplaceClient,
-  type Currency,
-  getQueryClient,
-  configKeys,
-  currencyKeys,
-  ChainId,
-} from "../_internal";
-import { SdkConfig, MarketplaceConfig } from "../../types";
+	ChainIdSchema,
+	AddressSchema,
+	QueryArgSchema,
+	getMarketplaceClient,
+	type Currency,
+	getQueryClient,
+	configKeys,
+	currencyKeys,
+	type ChainId,
+} from '../_internal';
+import type { SdkConfig, MarketplaceConfig } from '../../types';
 
 const ChainIdCoerce = ChainIdSchema.transform((val) => val.toString());
 
 const UseCurrenciesArgsSchema = z.object({
-  chainId: ChainIdCoerce,
-  collectionAddress: AddressSchema.optional(),
-  includeNativeCurrency: z.boolean().optional(),
-  query: QueryArgSchema,
+	chainId: ChainIdCoerce,
+	collectionAddress: AddressSchema.optional(),
+	includeNativeCurrency: z.boolean().optional(),
+	query: QueryArgSchema,
 });
 
 type UseCurrenciesArgs = z.input<typeof UseCurrenciesArgsSchema>;
@@ -28,60 +28,60 @@ type UseCurrenciesArgs = z.input<typeof UseCurrenciesArgsSchema>;
 export type UseCurrenciesReturn = Awaited<ReturnType<typeof fetchCurrencies>>;
 
 const fetchCurrencies = async (chainId: ChainId, config: SdkConfig) => {
-  const parsedChainId = ChainIdCoerce.parse(chainId);
-  const marketplaceClient = getMarketplaceClient(parsedChainId, config);
-  return marketplaceClient.listCurrencies().then((resp) => resp.currencies);
+	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 (argsParsed.collectionAddress) {
-    const queryClient = getQueryClient();
-    const marketplaceConfigCache = queryClient.getQueriesData({
-      queryKey: configKeys.marketplace,
-    })[0][1] as MarketplaceConfig;
+	const argsParsed = UseCurrenciesArgsSchema.parse(args);
+	// if collectionAddress is passed, filter currencies based on collection currency options
+	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 === argsParsed.collectionAddress
-    );
+		const collection = marketplaceConfigCache?.collections.find(
+			(collection) =>
+				collection.collectionAddress === argsParsed.collectionAddress,
+		);
 
-    if (!collection) {
-      throw new Error("Collection doesn't exist");
-    }
+		if (!collection) {
+			throw new Error("Collection doesn't exist");
+		}
 
-    return data.filter(
-      (currency) =>
-        collection.currencyOptions?.includes(currency.contractAddress) ||
-        // biome-ignore lint/suspicious/noDoubleEquals: <explanation>
-        currency.nativeCurrency == argsParsed.includeNativeCurrency ||
-        currency.defaultChainCurrency
-    );
-  }
-  // if includeNativeCurrency is true, return all currencies
-  if (argsParsed.includeNativeCurrency) {
-    return data;
-  }
+		return data.filter(
+			(currency) =>
+				collection.currencyOptions?.includes(currency.contractAddress) ||
+				// biome-ignore lint/suspicious/noDoubleEquals: <explanation>
+				currency.nativeCurrency == argsParsed.includeNativeCurrency ||
+				currency.defaultChainCurrency,
+		);
+	}
+	// if includeNativeCurrency is true, return all currencies
+	if (argsParsed.includeNativeCurrency) {
+		return data;
+	}
 
-  // if includeNativeCurrency is false or undefined, filter out native currencies
-  return data.filter((currency) => !currency.nativeCurrency);
+	// if includeNativeCurrency is false or undefined, filter out native currencies
+	return data.filter((currency) => !currency.nativeCurrency);
 };
 
 export const currenciesOptions = (
-  args: UseCurrenciesArgs,
-  config: SdkConfig
+	args: UseCurrenciesArgs,
+	config: SdkConfig,
 ) => {
-  return queryOptions({
-    ...args.query,
-    queryKey: [...currencyKeys.lists, args.chainId],
-    queryFn: () => fetchCurrencies(args.chainId, config),
-    select: (data) => selectCurrencies(data, args),
-    enabled: args.query?.enabled,
-  });
+	return queryOptions({
+		...args.query,
+		queryKey: [...currencyKeys.lists, args.chainId],
+		queryFn: () => fetchCurrencies(args.chainId, config),
+		select: (data) => selectCurrencies(data, args),
+		enabled: args.query?.enabled,
+	});
 };
 
 export const useCurrencies = (args: UseCurrenciesArgs) => {
-  const config = useConfig();
-  return useQuery(currenciesOptions(args, config));
+	const config = useConfig();
+	return useQuery(currenciesOptions(args, config));
 };

package/src/react/hooks/useCurrency.tsx

@@ -0,0 +1,64 @@
+import { queryOptions, useQuery } from '@tanstack/react-query';
+import { z } from 'zod';
+import { useConfig } from './useConfig';
+import {
+	ChainIdSchema,
+	AddressSchema,
+	QueryArgSchema,
+	getMarketplaceClient,
+	type Currency,
+	currencyKeys,
+	type ChainId,
+	getQueryClient,
+} from '../_internal';
+import type { SdkConfig } from '../../types';
+
+const ChainIdCoerce = ChainIdSchema.transform((val) => val.toString());
+
+const UseCurrencyArgsSchema = z.object({
+	chainId: ChainIdCoerce,
+	currencyAddress: AddressSchema,
+	query: QueryArgSchema,
+});
+
+type UseCurrencyArgs = z.input<typeof UseCurrencyArgsSchema>;
+
+export type UseCurrencyReturn = Currency | undefined;
+
+const fetchCurrency = async (
+	chainId: ChainId,
+	currencyAddress: string,
+	config: SdkConfig,
+): Promise<Currency | undefined> => {
+	const parsedChainId = ChainIdCoerce.parse(chainId);
+
+	const queryClient = getQueryClient();
+	let currencies = queryClient.getQueryData([...currencyKeys.lists, chainId]) as
+		| Currency[]
+		| undefined;
+
+	if (!currencies) {
+		const marketplaceClient = getMarketplaceClient(parsedChainId, config);
+		currencies = await marketplaceClient
+			.listCurrencies()
+			.then((resp) => resp.currencies);
+	}
+
+	return currencies?.find(
+		(currency) =>
+			currency.contractAddress.toLowerCase() === currencyAddress.toLowerCase(),
+	);
+};
+
+export const currencyOptions = (args: UseCurrencyArgs, config: SdkConfig) => {
+	return queryOptions({
+		...args.query,
+		queryKey: [...currencyKeys.details, args.chainId, args.currencyAddress],
+		queryFn: () => fetchCurrency(args.chainId, args.currencyAddress, config),
+	});
+};
+
+export const useCurrency = (args: UseCurrencyArgs) => {
+	const config = useConfig();
+	return useQuery(currencyOptions(args, config));
+};

package/src/react/hooks/useGenerateBuyTransaction.tsx

@@ -0,0 +1,71 @@
+import { queryOptions, useQuery } from '@tanstack/react-query';
+import { z } from 'zod';
+import type { SdkConfig } from '../../types';
+import {
+	AddressSchema,
+	ChainIdSchema,
+	getMarketplaceClient,
+	MarketplaceKind,
+	QueryArgSchema,
+	WalletKind,
+} from '../_internal';
+import { useConfig } from './useConfig';
+import { useAccount } from 'wagmi';
+import type { Hex } from 'viem';
+
+export const UseGenerateBuyTransactionArgsSchema = z.object({
+	chainId: ChainIdSchema.pipe(z.coerce.string()),
+	collectionAddress: AddressSchema,
+	marketplace: z.nativeEnum(MarketplaceKind),
+	ordersData: z.array(
+		z.object({
+			orderId: z.string(),
+			quantity: z.string(),
+			marketplace: z.string(),
+		}),
+	),
+	walletType: z.nativeEnum(WalletKind).optional(),
+	query: QueryArgSchema,
+});
+
+type UseGenerateBuyTransactionArgs = z.infer<
+	typeof UseGenerateBuyTransactionArgsSchema
+>;
+
+export const fetchGenerateBuyTransaction = async (
+	args: UseGenerateBuyTransactionArgs & { buyer: Hex },
+	config: SdkConfig,
+) => {
+	const parsedArgs = UseGenerateBuyTransactionArgsSchema.parse(args);
+	const marketplaceClient = getMarketplaceClient(parsedArgs.chainId, config);
+
+	return marketplaceClient
+		.generateBuyTransaction({
+			...parsedArgs,
+			buyer: args.buyer,
+			additionalFees: [], // TODO: Add additional fees
+		})
+		.then((data) => data.steps);
+};
+
+export const generateBuyTransactionOptions = (
+	args: UseGenerateBuyTransactionArgs & { buyer: Hex },
+	config: SdkConfig,
+) => {
+	return queryOptions({
+		queryKey: ['generateBuyTransaction', args],
+		queryFn: () => fetchGenerateBuyTransaction(args, config),
+		...args.query,
+	});
+};
+
+export const useGenerateBuyTransaction = (
+	args: UseGenerateBuyTransactionArgs,
+) => {
+	const { address } = useAccount();
+	const config = useConfig();
+	return useQuery(
+		// biome-ignore lint/style/noNonNullAssertion: <explanation>
+		generateBuyTransactionOptions({ buyer: address!, ...args }, config),
+	);
+};

package/src/react/hooks/useGenerateCancelTransaction.tsx

@@ -0,0 +1,50 @@
+import { useMutation } from '@tanstack/react-query';
+import { z } from 'zod';
+import type { SdkConfig } from '../../types';
+import {
+	type ChainId,
+	ChainIdSchema,
+	type GenerateCancelTransactionArgs,
+	getMarketplaceClient,
+} from '../_internal';
+import { stepSchema } from '../_internal/api/zod-schema';
+import { useConfig } from './useConfig';
+
+const UserGenerateCancelTransactionArgsSchema = z.object({
+	chainId: ChainIdSchema.pipe(z.coerce.string()),
+	onSuccess: z.function().args(stepSchema.array().optional()).optional(),
+});
+
+type UseGenerateCancelTransactionArgs = z.infer<
+	typeof UserGenerateCancelTransactionArgsSchema
+>;
+
+export const generateCancelTransaction = async (
+	args: GenerateCancelTransactionArgs,
+	config: SdkConfig,
+	chainId: ChainId,
+) => {
+	const parsedChainId = ChainIdSchema.pipe(z.coerce.string()).parse(chainId);
+	const marketplaceClient = getMarketplaceClient(parsedChainId, config);
+	return marketplaceClient
+		.generateCancelTransaction(args)
+		.then((data) => data.steps);
+};
+
+export const useGenerateCancelTransaction = (
+	params: UseGenerateCancelTransactionArgs,
+) => {
+	const config = useConfig();
+
+	const { mutate, mutateAsync, ...result } = useMutation({
+		onSuccess: params.onSuccess,
+		mutationFn: (args: GenerateCancelTransactionArgs) =>
+			generateCancelTransaction(args, config, params.chainId),
+	});
+
+	return {
+		...result,
+		generateCancelTransaction: mutate,
+		generateCancelTransactionAsync: mutateAsync,
+	};
+};