@0xsequence/marketplace-sdk 0.5.3 → 0.5.4

package/dist/{services-BRBVE0mm.d.ts → services-Dd2MoBTM.d.ts}

@@ -1,6 +1,7 @@
 import { SequenceIndexer } from '@0xsequence/indexer';
 import { SequenceMetadata } from '@0xsequence/metadata';
-import { ap as Marketplace, N as Env, Q as SdkConfig } from './sdk-config-B32_2bG3.js';
+import { E as Env, S as SdkConfig } from './sdk-config-xWkdBdrL.js';
+import { an as Marketplace } from './marketplace.gen-D0ADxbfH.js';
 
 declare class SequenceMarketplace extends Marketplace {
     projectAccessKey: string;

package/dist/types/index.d.ts

@@ -1,6 +1,7 @@
-import { w as Currency } from '../sdk-config-B32_2bG3.js';
-export { q as Activity, y as AdditionalFee, A as Asset, L as CheckoutOptions, K as CheckoutOptionsItem, J as CheckoutOptionsMarketplaceOrder, v as Collectible, o as CollectibleOrder, f as CollectibleStatus, l as CollectiblesFilter, r as Collection, s as CollectionConfig, t as CollectionLastSynced, d as CollectionStatus, C as ContractType, D as CreateReq, I as Domain, N as Env, E as ExecuteType, n as FeeBreakdown, F as Filter, G as GetOrdersInput, M as MarketplaceKind, m as Order, x as OrderData, p as OrderFilter, b as OrderSide, c as OrderStatus, O as OrderbookKind, i as Page, B as PostRequest, u as Project, e as ProjectStatus, k as PropertyFilter, P as PropertyType, Q as SdkConfig, H as Signature, j as SortBy, S as SortOrder, a as SourceKind, z as Step, g as StepType, h as TokenMetadata, T as TransactionCrypto, W as WalletKind } from '../sdk-config-B32_2bG3.js';
-export { C as CollectionFilterSettings, F as FilterCondition, d as MarketplaceCollection, g as MarketplaceConfig, f as MarketplaceSettings, e as MarketplaceSocials, a as MarketplaceType, M as MarketplaceWallet, b as MarketplaceWalletOptions, c as MetadataFilterRule } from '../builder-types-wOwfTJpd.js';
+export { E as Env, S as SdkConfig } from '../sdk-config-xWkdBdrL.js';
+import { w as Currency } from '../marketplace.gen-D0ADxbfH.js';
+export { q as Activity, y as AdditionalFee, A as Asset, L as CheckoutOptions, K as CheckoutOptionsItem, J as CheckoutOptionsMarketplaceOrder, v as Collectible, o as CollectibleOrder, f as CollectibleStatus, l as CollectiblesFilter, r as Collection, s as CollectionConfig, t as CollectionLastSynced, d as CollectionStatus, C as ContractType, D as CreateReq, I as Domain, E as ExecuteType, n as FeeBreakdown, F as Filter, G as GetOrdersInput, M as MarketplaceKind, m as Order, x as OrderData, p as OrderFilter, b as OrderSide, c as OrderStatus, O as OrderbookKind, i as Page, B as PostRequest, u as Project, e as ProjectStatus, k as PropertyFilter, P as PropertyType, H as Signature, j as SortBy, S as SortOrder, a as SourceKind, z as Step, g as StepType, h as TokenMetadata, T as TransactionCrypto, W as WalletKind } from '../marketplace.gen-D0ADxbfH.js';
+export { C as CollectionFilterSettings, F as FilterCondition, d as MarketplaceCollection, g as MarketplaceConfig, f as MarketplaceSettings, e as MarketplaceSocials, a as MarketplaceType, M as MarketplaceWallet, b as MarketplaceWalletOptions, c as MetadataFilterRule } from '../builder-types-Jl3Ymws8.js';
 
 type Price = {
     amountRaw: string;

package/dist/{types-BY3husBh.d.ts → types-vOfhbBkR.d.ts}

@@ -1,8 +1,9 @@
 import { ChainId as ChainId$1 } from '@0xsequence/network';
 import { z } from 'zod';
 import { Chain } from 'viem';
-import { C as ContractType, Q as SdkConfig, O as OrderbookKind, M as MarketplaceKind, D as CreateReq } from './sdk-config-B32_2bG3.js';
-import { g as MarketplaceConfig } from './builder-types-wOwfTJpd.js';
+import { C as ContractType, O as OrderbookKind, M as MarketplaceKind, D as CreateReq } from './marketplace.gen-D0ADxbfH.js';
+import { S as SdkConfig } from './sdk-config-xWkdBdrL.js';
+import { g as MarketplaceConfig } from './builder-types-Jl3Ymws8.js';
 
 declare const QueryArgSchema: z.ZodOptional<z.ZodObject<{
     enabled: z.ZodOptional<z.ZodBoolean>;

package/dist/utils/index.d.ts

@@ -1,13 +1,14 @@
 export { EIP2981_ABI, SequenceMarketplaceV1_ABI, SequenceMarketplaceV2_ABI } from './abi/marketplace/index.js';
 export { ERC1155_ABI, ERC20_ABI, ERC721_ABI } from './abi/token/index.js';
 import { PublicClient } from 'viem';
-import { c as ChainId } from '../types-BY3husBh.js';
-import { M as MarketplaceKind } from '../sdk-config-B32_2bG3.js';
+import { c as ChainId } from '../types-vOfhbBkR.js';
+import { M as MarketplaceKind } from '../marketplace.gen-D0ADxbfH.js';
 import { ComponentType } from 'react';
 import { Image } from '@0xsequence/design-system';
 import '@0xsequence/network';
 import 'zod';
-import '../builder-types-wOwfTJpd.js';
+import '../sdk-config-xWkdBdrL.js';
+import '../builder-types-Jl3Ymws8.js';
 
 declare const truncateMiddle: (address: string, minPrefix?: number, minSuffix?: number) => string;
 declare const truncateEnd: (text: string | undefined, truncateAt: number) => string;

package/dist/utils/index.js

@@ -7,8 +7,8 @@ import {
   getPublicRpcClient,
   truncateEnd,
   truncateMiddle
-} from "../chunk-BZD2LDJJ.js";
-import "../chunk-MWDG7UTB.js";
+} from "../chunk-7C7ADZ2H.js";
+import "../chunk-ZBLU3Q22.js";
 import "../chunk-MCI3KOSQ.js";
 import {
   EIP2981_ABI,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@0xsequence/marketplace-sdk",
   "private": false,
-  "version": "0.5.3",
+  "version": "0.5.4",
   "type": "module",
   "sideEffects": [
     "**/*.css"
@@ -33,6 +33,7 @@
     }
   },
   "dependencies": {
+    "@databeat/tracker": "^0.9.3",
     "@legendapp/state": "^3.0.0-beta.26",
     "@radix-ui/react-dialog": "^1.1.6",
     "@radix-ui/react-popover": "^1.1.6",

package/src/react/_internal/databeat/index.ts

@@ -0,0 +1,63 @@
+import type { Event as DatabeatEvent } from '@databeat/tracker';
+import { Databeat } from '@databeat/tracker';
+
+import { useConfig } from '../../hooks';
+import type {
+	EventType,
+	TrackCreateListing,
+	TrackCreateOffer,
+	TrackSellItems,
+	TrackTransactionFailed,
+} from './types';
+
+export type EventTypes = keyof typeof EventType;
+export type Event = DatabeatEvent<EventTypes>;
+
+export class DatabeatAnalytics extends Databeat<Extract<EventTypes, string>> {
+	// Currently handled by kit-checkout
+	// trackBuyItems(args: TrackBuyItems) {
+	//   this.track({
+	//     event: 'BUY_ITEMS',
+	//     props: args.props,
+	//     nums: args.nums
+	//   })
+	// }
+
+	trackSellItems(args: TrackSellItems) {
+		this.track({
+			event: 'SELL_ITEMS',
+			props: args.props,
+			nums: args.nums,
+		});
+	}
+
+	trackCreateListing(args: TrackCreateListing) {
+		this.track({
+			event: 'CREATE_LISTING',
+			props: args.props,
+			nums: args.nums,
+		});
+	}
+
+	trackCreateOffer(args: TrackCreateOffer) {
+		this.track({
+			event: 'CREATE_OFFER',
+			props: args.props,
+			nums: args.nums,
+		});
+	}
+
+	trackTransactionFailed(args: TrackTransactionFailed) {
+		this.track({
+			event: 'TRANSACTION_FAILED',
+			props: args,
+		});
+	}
+}
+
+export const useAnalytics = () => {
+	const config = useConfig();
+	return new DatabeatAnalytics('https://databeat.sequence.app', {
+		jwt: config.projectAccessKey,
+	});
+};

package/src/react/_internal/databeat/types.ts

@@ -0,0 +1,70 @@
+import type { MarketplaceKind, OrderbookKind } from '../api';
+
+export enum EventType {
+	BUY_ITEMS = 0,
+	SELL_ITEMS = 1,
+	CREATE_LISTING = 2,
+	CREATE_OFFER = 3,
+	CANCEL_LISTING = 4,
+	CANCEL_OFFER = 5,
+	TRANSACTION_FAILED = 6,
+}
+
+interface PropsEvent {
+	[key: string]: string;
+}
+
+interface NumsEvent {
+	[key: string]: number;
+}
+
+interface Transaction extends PropsEvent {
+	chainId: string;
+	txnHash: string;
+}
+
+interface TradeItemsInfo extends PropsEvent {
+	marketplaceKind: MarketplaceKind;
+	collectionAddress: string;
+	currencyAddress: string;
+	currencySymbol: string;
+}
+
+interface TradeItemsValues extends NumsEvent {
+	currencyValueDecimal: number;
+	currencyValueRaw: number;
+}
+
+export interface TrackBuyItems {
+	props: TradeItemsInfo & Transaction;
+	nums: TradeItemsValues;
+}
+
+export interface TrackSellItems {
+	props: TradeItemsInfo & Transaction;
+	nums: TradeItemsValues;
+}
+
+interface ListOfferItemsInfo extends PropsEvent {
+	orderbookKind: OrderbookKind;
+	collectionAddress: string;
+	currencyAddress: string;
+	currencySymbol: string;
+}
+
+interface ListOfferItemsValues extends NumsEvent {
+	currencyValueDecimal: number;
+	currencyValueRaw: number;
+}
+
+export interface TrackCreateListing {
+	props: ListOfferItemsInfo & Transaction;
+	nums: ListOfferItemsValues;
+}
+
+export interface TrackCreateOffer {
+	props: ListOfferItemsInfo & Transaction;
+	nums: ListOfferItemsValues;
+}
+
+export interface TrackTransactionFailed extends Transaction, PropsEvent {}

package/src/react/hooks/__tests__/useListCollectiblesPaginated.test.tsx

@@ -0,0 +1,217 @@
+import { waitFor } from '@testing-library/react';
+import { http, HttpResponse } from 'msw';
+import { zeroAddress } from 'viem';
+import { describe, expect, it } from 'vitest';
+import {
+	mockCollectibleOrder,
+	mockMarketplaceEndpoint,
+} from '../../_internal/api/__mocks__/marketplace.msw';
+import { OrderSide } from '../../_internal/api/marketplace.gen';
+import { renderHook } from '../../_internal/test-utils';
+import { server } from '../../_internal/test/setup';
+import { useListCollectiblesPaginated } from '../useListCollectiblesPaginated';
+import type { UseListCollectiblesPaginatedArgs } from '../useListCollectiblesPaginated';
+
+describe('useListCollectiblesPaginated', () => {
+	const defaultArgs: UseListCollectiblesPaginatedArgs = {
+		chainId: '1',
+		collectionAddress: zeroAddress,
+		side: OrderSide.listing,
+		query: {
+			enabled: true,
+			page: 1,
+			pageSize: 30,
+		},
+	};
+
+	it('should fetch collectibles successfully', async () => {
+		// Set up mock response
+		server.use(
+			http.post(mockMarketplaceEndpoint('ListCollectibles'), () => {
+				return HttpResponse.json({
+					collectibles: [mockCollectibleOrder],
+					page: { page: 1, pageSize: 30, more: false },
+				});
+			}),
+		);
+
+		const { result } = renderHook(() =>
+			useListCollectiblesPaginated(defaultArgs),
+		);
+
+		// Wait for the query to complete
+		await waitFor(() => {
+			expect(result.current.isSuccess).toBe(true);
+		});
+
+		// Verify the data
+		expect(result.current.data?.collectibles).toEqual([mockCollectibleOrder]);
+		expect(result.current.data?.page).toEqual({
+			page: 1,
+			pageSize: 30,
+			more: false,
+		});
+	});
+
+	it('should handle error states', async () => {
+		// Override the handler to return an error
+		server.use(
+			http.post(mockMarketplaceEndpoint('ListCollectibles'), () => {
+				return HttpResponse.json(
+					{ error: { message: 'Failed to fetch collectibles' } },
+					{ status: 500 },
+				);
+			}),
+		);
+
+		const { result } = renderHook(() =>
+			useListCollectiblesPaginated(defaultArgs),
+		);
+
+		// Wait for the error state
+		await waitFor(() => {
+			expect(result.current.isError).toBe(true);
+		});
+
+		expect(result.current.error).toBeDefined();
+		expect(result.current.data).toBeUndefined();
+	});
+
+	it('should handle pagination correctly', async () => {
+		// Set up mock response for page 2
+		const modifiedCollectibleOrder = {
+			...mockCollectibleOrder,
+			metadata: {
+				...mockCollectibleOrder.metadata,
+				tokenId: '2',
+			},
+		};
+
+		server.use(
+			http.post(mockMarketplaceEndpoint('ListCollectibles'), () => {
+				return HttpResponse.json({
+					collectibles: [modifiedCollectibleOrder],
+					page: { page: 2, pageSize: 20, more: false },
+				});
+			}),
+		);
+
+		const paginatedArgs: UseListCollectiblesPaginatedArgs = {
+			...defaultArgs,
+			query: {
+				enabled: true,
+				page: 2,
+				pageSize: 20,
+			},
+		};
+
+		const { result } = renderHook(() =>
+			useListCollectiblesPaginated(paginatedArgs),
+		);
+
+		// Wait for the query to complete
+		await waitFor(() => {
+			expect(result.current.isSuccess).toBe(true);
+		});
+
+		// Verify the data for page 2
+		expect(result.current.data?.collectibles[0].metadata.tokenId).toBe('2');
+		expect(result.current.data?.page).toEqual({
+			page: 2,
+			pageSize: 20,
+			more: false,
+		});
+	});
+
+	it('should refetch when args change', async () => {
+		// Set up initial mock response
+		server.use(
+			http.post(mockMarketplaceEndpoint('ListCollectibles'), () => {
+				return HttpResponse.json({
+					collectibles: [mockCollectibleOrder],
+					page: { page: 1, pageSize: 30, more: true },
+				});
+			}),
+		);
+
+		let currentArgs = defaultArgs;
+		const { result, rerender } = renderHook(() =>
+			useListCollectiblesPaginated(currentArgs),
+		);
+
+		// Wait for initial data
+		await waitFor(() => {
+			expect(result.current.isSuccess).toBe(true);
+		});
+
+		// Change args and rerender
+		currentArgs = {
+			...defaultArgs,
+			query: {
+				...defaultArgs.query,
+				page: 2,
+			},
+		};
+
+		// Set up mock response for page 2
+		const modifiedCollectibleOrder = {
+			...mockCollectibleOrder,
+			metadata: {
+				...mockCollectibleOrder.metadata,
+				tokenId: '2',
+			},
+		};
+
+		server.use(
+			http.post(mockMarketplaceEndpoint('ListCollectibles'), () => {
+				return HttpResponse.json({
+					collectibles: [modifiedCollectibleOrder],
+					page: { page: 2, pageSize: 30, more: false },
+				});
+			}),
+		);
+
+		rerender();
+
+		// Wait for new data
+		await waitFor(() => {
+			expect(result.current.data?.page?.page).toBe(2);
+		});
+
+		// Verify new data
+		expect(result.current.data?.collectibles[0].metadata.tokenId).toBe('2');
+	});
+
+	it('should not fetch when enabled is false', async () => {
+		// Set up a mock handler to ensure no requests are made
+		let requestMade = false;
+		server.use(
+			http.post(mockMarketplaceEndpoint('ListCollectibles'), () => {
+				requestMade = true;
+				return HttpResponse.json({
+					collectibles: [mockCollectibleOrder],
+					page: { page: 1, pageSize: 30, more: false },
+				});
+			}),
+		);
+
+		const disabledArgs: UseListCollectiblesPaginatedArgs = {
+			...defaultArgs,
+			query: {
+				enabled: false,
+				page: 1,
+				pageSize: 30,
+			},
+		};
+
+		const { result } = renderHook(() =>
+			useListCollectiblesPaginated(disabledArgs),
+		);
+
+		// For disabled queries, we expect no loading state and no data
+		expect(result.current.isLoading).toBe(false);
+		expect(result.current.data).toBeUndefined();
+		expect(result.current.error).toBeNull();
+		expect(requestMade).toBe(false);
+	});
+});

package/src/react/hooks/index.ts

@@ -13,6 +13,7 @@ export * from './useHighestOffer';
 export * from './useListBalances';
 export * from './useListCollectibleActivities';
 export * from './useListCollectibles';
+export * from './useListCollectiblesPaginated';
 export * from './useListCollectionActivities';
 export * from './useListOffersForCollectible';
 export * from './useCountOffersForCollectible';

package/src/react/hooks/useFilters.tsx

@@ -1,6 +1,8 @@
+import type { PropertyFilter } from '@0xsequence/metadata';
 import { queryOptions, useQuery } from '@tanstack/react-query';
 import { z } from 'zod';
 import { FilterCondition, type SdkConfig } from '../../types';
+import { compareAddress } from '../../utils';
 import {
 	AddressSchema,
 	ChainIdSchema,
@@ -11,8 +13,6 @@ import {
 } from '../_internal';
 import { useConfig } from './useConfig';
 import { marketplaceConfigOptions } from './useMarketplaceConfig';
-import { compareAddress } from '../../utils';
-import type { PropertyFilter } from '@0xsequence/metadata';
 
 const UseFiltersSchema = z.object({
 	chainId: ChainIdSchema.pipe(z.coerce.string()),
@@ -45,7 +45,13 @@ export const fetchFilters = async (args: UseFiltersArgs, config: SdkConfig) => {
 		compareAddress(c.address, parsedArgs.collectionAddress),
 	)?.filterSettings;
 
-	if (!collectionFilters) return filters;
+	if (
+		!collectionFilters?.exclusions ||
+		collectionFilters.exclusions.length === 0 ||
+		!collectionFilters.filterOrder ||
+		collectionFilters.filterOrder.length === 0
+	)
+		return filters;
 
 	const { filterOrder, exclusions } = collectionFilters;
 

package/src/react/hooks/useListCollectiblesPaginated.tsx

@@ -0,0 +1,78 @@
+import { queryOptions, useQuery } from '@tanstack/react-query';
+import { z } from 'zod';
+import type { Page, SdkConfig } from '../../types';
+import {
+	AddressSchema,
+	ChainIdSchema,
+	type ListCollectiblesArgs,
+	collectableKeys,
+	getMarketplaceClient,
+} from '../_internal';
+import { listCollectiblesArgsSchema } from '../_internal/api/zod-schema';
+import { useConfig } from './useConfig';
+
+const UseListCollectiblesPaginatedArgsSchema = listCollectiblesArgsSchema
+	.omit({
+		contractAddress: true,
+	})
+	.extend({
+		collectionAddress: AddressSchema,
+		chainId: ChainIdSchema.pipe(z.coerce.string()),
+		query: z
+			.object({
+				enabled: z.boolean().optional(),
+				page: z.number().optional().default(1),
+				pageSize: z.number().optional().default(30),
+			})
+			.optional()
+			.default({}),
+	});
+
+export type UseListCollectiblesPaginatedArgs = z.infer<
+	typeof UseListCollectiblesPaginatedArgsSchema
+>;
+
+export type UseListCollectiblesPaginatedReturn = Awaited<
+	ReturnType<typeof fetchCollectiblesPaginated>
+>;
+
+const fetchCollectiblesPaginated = async (
+	args: UseListCollectiblesPaginatedArgs,
+	marketplaceClient: Awaited<ReturnType<typeof getMarketplaceClient>>,
+) => {
+	const parsedArgs = UseListCollectiblesPaginatedArgsSchema.parse(args);
+	const page: Page = {
+		page: parsedArgs.query?.page ?? 1,
+		pageSize: parsedArgs.query?.pageSize ?? 30,
+	};
+
+	const arg = {
+		...parsedArgs,
+		contractAddress: parsedArgs.collectionAddress,
+		page,
+	} as ListCollectiblesArgs;
+
+	return marketplaceClient.listCollectibles(arg);
+};
+
+export const listCollectiblesPaginatedOptions = (
+	args: UseListCollectiblesPaginatedArgs,
+	config: SdkConfig,
+) => {
+	const marketplaceClient = getMarketplaceClient(
+		args.chainId as string,
+		config,
+	);
+	return queryOptions({
+		queryKey: [...collectableKeys.lists, 'paginated', args],
+		queryFn: () => fetchCollectiblesPaginated(args, marketplaceClient),
+		enabled: args.query?.enabled ?? true,
+	});
+};
+
+export const useListCollectiblesPaginated = (
+	args: UseListCollectiblesPaginatedArgs,
+) => {
+	const config = useConfig();
+	return useQuery(listCollectiblesPaginatedOptions(args, config));
+};

package/src/react/ui/modals/CreateListingModal/hooks/useTransactionSteps.tsx

@@ -1,5 +1,5 @@
 import type { Observable } from '@legendapp/state';
-import type { Address, Hex } from 'viem';
+import { type Address, type Hex, formatUnits } from 'viem';
 import type { OrderbookKind } from '../../../../../types';
 import {
 	ExecuteType,
@@ -10,17 +10,21 @@ import {
 	collectableKeys,
 	getMarketplaceClient,
 } from '../../../../_internal';
+import { useAnalytics } from '../../../../_internal/databeat';
 import { TransactionType } from '../../../../_internal/types';
 import type { ListingInput } from '../../../../_internal/types';
-import { useWallet } from '../../../../_internal/wallet/useWallet';
 import type {
 	SignatureStep,
 	TransactionStep as WalletTransactionStep,
 } from '../../../../_internal/utils';
-import { useConfig, useGenerateListingTransaction } from '../../../../hooks';
+import { useWallet } from '../../../../_internal/wallet/useWallet';
+import {
+	useConfig,
+	useCurrencies,
+	useGenerateListingTransaction,
+} from '../../../../hooks';
 import { useTransactionStatusModal } from '../../_internal/components/transactionStatusModal';
 import type { ModalCallbacks } from '../../_internal/types';
-
 interface UseTransactionStepsArgs {
 	listingInput: ListingInput;
 	chainId: string;
@@ -44,7 +48,11 @@ export const useTransactionSteps = ({
 	const expiry = new Date(Number(listingInput.listing.expiry) * 1000);
 	const { show: showTransactionStatusModal } = useTransactionStatusModal();
 	const sdkConfig = useConfig();
+	const { data: currencies } = useCurrencies({
+		chainId: Number(chainId),
+	});
 	const marketplaceClient = getMarketplaceClient(chainId, sdkConfig);
+	const analytics = useAnalytics();
 	const { generateListingTransactionAsync, isPending: generatingSteps } =
 		useGenerateListingTransaction({
 			chainId,
@@ -164,6 +172,34 @@ export const useTransactionSteps = ({
 				steps$.transaction.isExecuting.set(false);
 				steps$.transaction.exist.set(false);
 			}
+
+			if (hash || orderId) {
+				const currencyDecimal =
+					currencies?.find(
+						(currency) =>
+							currency.contractAddress === listingInput.listing.currencyAddress,
+					)?.decimals || 0;
+
+				const currencyValueRaw = Number(listingInput.listing.pricePerToken);
+				const currencyValueDecimal = Number(
+					formatUnits(BigInt(currencyValueRaw), currencyDecimal),
+				);
+
+				analytics.trackCreateListing({
+					props: {
+						orderbookKind,
+						collectionAddress,
+						currencyAddress: listingInput.listing.currencyAddress,
+						currencySymbol: '',
+						chainId,
+						txnHash: hash || '',
+					},
+					nums: {
+						currencyValueDecimal,
+						currencyValueRaw,
+					},
+				});
+			}
 		} catch (error) {
 			steps$.transaction.isExecuting.set(false);
 			steps$.transaction.exist.set(false);