@0xsequence/marketplace-sdk 0.10.0 → 1.1.0

package/public/mockServiceWorker.js

@@ -0,0 +1,344 @@
+/* eslint-disable */
+/* tslint:disable */
+
+/**
+ * Mock Service Worker.
+ * @see https://github.com/mswjs/msw
+ * - Please do NOT modify this file.
+ */
+
+const PACKAGE_VERSION = '2.10.2';
+const INTEGRITY_CHECKSUM = 'f5825c521429caf22a4dd13b66e243af';
+const IS_MOCKED_RESPONSE = Symbol('isMockedResponse');
+const activeClientIds = new Set();
+
+addEventListener('install', () => {
+	self.skipWaiting();
+});
+
+addEventListener('activate', (event) => {
+	event.waitUntil(self.clients.claim());
+});
+
+addEventListener('message', async (event) => {
+	const clientId = Reflect.get(event.source || {}, 'id');
+
+	if (!clientId || !self.clients) {
+		return;
+	}
+
+	const client = await self.clients.get(clientId);
+
+	if (!client) {
+		return;
+	}
+
+	const allClients = await self.clients.matchAll({
+		type: 'window',
+	});
+
+	switch (event.data) {
+		case 'KEEPALIVE_REQUEST': {
+			sendToClient(client, {
+				type: 'KEEPALIVE_RESPONSE',
+			});
+			break;
+		}
+
+		case 'INTEGRITY_CHECK_REQUEST': {
+			sendToClient(client, {
+				type: 'INTEGRITY_CHECK_RESPONSE',
+				payload: {
+					packageVersion: PACKAGE_VERSION,
+					checksum: INTEGRITY_CHECKSUM,
+				},
+			});
+			break;
+		}
+
+		case 'MOCK_ACTIVATE': {
+			activeClientIds.add(clientId);
+
+			sendToClient(client, {
+				type: 'MOCKING_ENABLED',
+				payload: {
+					client: {
+						id: client.id,
+						frameType: client.frameType,
+					},
+				},
+			});
+			break;
+		}
+
+		case 'MOCK_DEACTIVATE': {
+			activeClientIds.delete(clientId);
+			break;
+		}
+
+		case 'CLIENT_CLOSED': {
+			activeClientIds.delete(clientId);
+
+			const remainingClients = allClients.filter((client) => {
+				return client.id !== clientId;
+			});
+
+			// Unregister itself when there are no more clients
+			if (remainingClients.length === 0) {
+				self.registration.unregister();
+			}
+
+			break;
+		}
+	}
+});
+
+addEventListener('fetch', (event) => {
+	// Bypass navigation requests.
+	if (event.request.mode === 'navigate') {
+		return;
+	}
+
+	// Opening the DevTools triggers the "only-if-cached" request
+	// that cannot be handled by the worker. Bypass such requests.
+	if (
+		event.request.cache === 'only-if-cached' &&
+		event.request.mode !== 'same-origin'
+	) {
+		return;
+	}
+
+	// Bypass all requests when there are no active clients.
+	// Prevents the self-unregistered worked from handling requests
+	// after it's been deleted (still remains active until the next reload).
+	if (activeClientIds.size === 0) {
+		return;
+	}
+
+	const requestId = crypto.randomUUID();
+	event.respondWith(handleRequest(event, requestId));
+});
+
+/**
+ * @param {FetchEvent} event
+ * @param {string} requestId
+ */
+async function handleRequest(event, requestId) {
+	const client = await resolveMainClient(event);
+	const requestCloneForEvents = event.request.clone();
+	const response = await getResponse(event, client, requestId);
+
+	// Send back the response clone for the "response:*" life-cycle events.
+	// Ensure MSW is active and ready to handle the message, otherwise
+	// this message will pend indefinitely.
+	if (client && activeClientIds.has(client.id)) {
+		const serializedRequest = await serializeRequest(requestCloneForEvents);
+
+		// Clone the response so both the client and the library could consume it.
+		const responseClone = response.clone();
+
+		sendToClient(
+			client,
+			{
+				type: 'RESPONSE',
+				payload: {
+					isMockedResponse: IS_MOCKED_RESPONSE in response,
+					request: {
+						id: requestId,
+						...serializedRequest,
+					},
+					response: {
+						type: responseClone.type,
+						status: responseClone.status,
+						statusText: responseClone.statusText,
+						headers: Object.fromEntries(responseClone.headers.entries()),
+						body: responseClone.body,
+					},
+				},
+			},
+			responseClone.body ? [serializedRequest.body, responseClone.body] : [],
+		);
+	}
+
+	return response;
+}
+
+/**
+ * Resolve the main client for the given event.
+ * Client that issues a request doesn't necessarily equal the client
+ * that registered the worker. It's with the latter the worker should
+ * communicate with during the response resolving phase.
+ * @param {FetchEvent} event
+ * @returns {Promise<Client | undefined>}
+ */
+async function resolveMainClient(event) {
+	const client = await self.clients.get(event.clientId);
+
+	if (activeClientIds.has(event.clientId)) {
+		return client;
+	}
+
+	if (client?.frameType === 'top-level') {
+		return client;
+	}
+
+	const allClients = await self.clients.matchAll({
+		type: 'window',
+	});
+
+	return allClients
+		.filter((client) => {
+			// Get only those clients that are currently visible.
+			return client.visibilityState === 'visible';
+		})
+		.find((client) => {
+			// Find the client ID that's recorded in the
+			// set of clients that have registered the worker.
+			return activeClientIds.has(client.id);
+		});
+}
+
+/**
+ * @param {FetchEvent} event
+ * @param {Client | undefined} client
+ * @param {string} requestId
+ * @returns {Promise<Response>}
+ */
+async function getResponse(event, client, requestId) {
+	// Clone the request because it might've been already used
+	// (i.e. its body has been read and sent to the client).
+	const requestClone = event.request.clone();
+
+	function passthrough() {
+		// Cast the request headers to a new Headers instance
+		// so the headers can be manipulated with.
+		const headers = new Headers(requestClone.headers);
+
+		// Remove the "accept" header value that marked this request as passthrough.
+		// This prevents request alteration and also keeps it compliant with the
+		// user-defined CORS policies.
+		const acceptHeader = headers.get('accept');
+		if (acceptHeader) {
+			const values = acceptHeader.split(',').map((value) => value.trim());
+			const filteredValues = values.filter(
+				(value) => value !== 'msw/passthrough',
+			);
+
+			if (filteredValues.length > 0) {
+				headers.set('accept', filteredValues.join(', '));
+			} else {
+				headers.delete('accept');
+			}
+		}
+
+		return fetch(requestClone, { headers });
+	}
+
+	// Bypass mocking when the client is not active.
+	if (!client) {
+		return passthrough();
+	}
+
+	// Bypass initial page load requests (i.e. static assets).
+	// The absence of the immediate/parent client in the map of the active clients
+	// means that MSW hasn't dispatched the "MOCK_ACTIVATE" event yet
+	// and is not ready to handle requests.
+	if (!activeClientIds.has(client.id)) {
+		return passthrough();
+	}
+
+	// Notify the client that a request has been intercepted.
+	const serializedRequest = await serializeRequest(event.request);
+	const clientMessage = await sendToClient(
+		client,
+		{
+			type: 'REQUEST',
+			payload: {
+				id: requestId,
+				...serializedRequest,
+			},
+		},
+		[serializedRequest.body],
+	);
+
+	switch (clientMessage.type) {
+		case 'MOCK_RESPONSE': {
+			return respondWithMock(clientMessage.data);
+		}
+
+		case 'PASSTHROUGH': {
+			return passthrough();
+		}
+	}
+
+	return passthrough();
+}
+
+/**
+ * @param {Client} client
+ * @param {any} message
+ * @param {Array<Transferable>} transferrables
+ * @returns {Promise<any>}
+ */
+function sendToClient(client, message, transferrables = []) {
+	return new Promise((resolve, reject) => {
+		const channel = new MessageChannel();
+
+		channel.port1.onmessage = (event) => {
+			if (event.data && event.data.error) {
+				return reject(event.data.error);
+			}
+
+			resolve(event.data);
+		};
+
+		client.postMessage(message, [
+			channel.port2,
+			...transferrables.filter(Boolean),
+		]);
+	});
+}
+
+/**
+ * @param {Response} response
+ * @returns {Response}
+ */
+function respondWithMock(response) {
+	// Setting response status code to 0 is a no-op.
+	// However, when responding with a "Response.error()", the produced Response
+	// instance will have status code set to 0. Since it's not possible to create
+	// a Response instance with status code 0, handle that use-case separately.
+	if (response.status === 0) {
+		return Response.error();
+	}
+
+	const mockedResponse = new Response(response.body, response);
+
+	Reflect.defineProperty(mockedResponse, IS_MOCKED_RESPONSE, {
+		value: true,
+		enumerable: true,
+	});
+
+	return mockedResponse;
+}
+
+/**
+ * @param {Request} request
+ */
+async function serializeRequest(request) {
+	return {
+		url: request.url,
+		mode: request.mode,
+		method: request.method,
+		headers: Object.fromEntries(request.headers.entries()),
+		cache: request.cache,
+		credentials: request.credentials,
+		destination: request.destination,
+		integrity: request.integrity,
+		redirect: request.redirect,
+		referrer: request.referrer,
+		referrerPolicy: request.referrerPolicy,
+		body: await request.arrayBuffer(),
+		keepalive: request.keepalive,
+	};
+}

package/src/react/_internal/api/__mocks__/builder.msw.ts

@@ -72,6 +72,8 @@ export const mockShopCollections = [
 		bannerUrl: 'https://example.com/shop-banner.png',
 		saleBannerUrl: 'https://example.com/shop-sale-banner.png',
 		tokenIds: ['1', '2', '3'],
+		customTokenIds: [],
+		private: false,
 		createdAt: new Date('2025-03-16T13:04:16.098Z').toISOString(),
 		updatedAt: new Date('2025-03-16T13:04:16.098Z').toISOString(),
 	},
@@ -85,6 +87,8 @@ export const mockShopCollections = [
 		bannerUrl: 'https://example.com/polygon-shop-banner.png',
 		saleBannerUrl: 'https://example.com/polygon-shop-sale-banner.png',
 		tokenIds: ['4', '5', '6'],
+		customTokenIds: [],
+		private: false,
 		createdAt: new Date('2025-03-16T13:04:16.098Z').toISOString(),
 		updatedAt: new Date('2025-03-16T13:04:16.098Z').toISOString(),
 	},
@@ -152,6 +156,7 @@ export const mockConfig = {
 					},
 				],
 			},
+			private: false,
 			createdAt: new Date('2025-03-16T13:04:16.098Z').toISOString(),
 			updatedAt: new Date('2025-03-16T13:04:16.098Z').toISOString(),
 		},
@@ -179,6 +184,7 @@ export const mockConfig = {
 					},
 				],
 			},
+			private: false,
 			createdAt: new Date('2025-03-16T13:04:16.098Z').toISOString(),
 			updatedAt: new Date('2025-03-16T13:04:16.098Z').toISOString(),
 		},

package/src/react/_internal/api/__mocks__/metadata.msw.ts

@@ -132,7 +132,13 @@ export const mockFilters = [
 	},
 ];
 
-type Endpoint = Capitalize<keyof Metadata>;
+type Endpoint =
+	| 'GetContractInfo'
+	| 'GetContractInfoBatch'
+	| 'GetTokenMetadata'
+	| 'GetTokenMetadataPropertyFilters'
+	| 'SearchTokenMetadata';
+
 type EndpointReturn<E extends Endpoint> = Awaited<
 	ReturnType<Metadata[Uncapitalize<E>]>
 >;
@@ -164,6 +170,11 @@ export const handlers = [
 		filters: mockPropertyFilters,
 	}),
 
+	mockMetadataHandler('SearchTokenMetadata', {
+		tokenMetadata: [mockTokenMetadata],
+		page: { page: 1, pageSize: 10, more: false },
+	}),
+
 	http.post(mockMetadataEndpoint('GetContractInfoBatch'), async (request) => {
 		const body = (await request.request.json()) as GetContractInfoBatchArgs;
 		const chainId = Number(body.chainID);

package/src/react/_internal/api/builder.gen.ts

@@ -5,8 +5,6 @@
 //
 // webrpc-gen -schema=builder.main.ridl -target=typescript -client -out=../../webapp/src/rpc/proto/builder.gen.ts
 
-import type { OrderbookKind } from "./marketplace.gen";
-
 export const WebrpcHeader = "Webrpc";
 export const WebrpcHeaderValue =
   "webrpc@v0.26.0;gen-typescript@v0.17.0;sequence-builder@v0.1.0";
@@ -29,6 +27,7 @@ export enum FilterCondition {
 export interface LookupMarketplaceArgs {
   projectId?: number;
   domain?: string;
+  userAddress?: string;
 }
 
 export interface LookupMarketplaceReturn {
@@ -59,10 +58,10 @@ export interface MarketplaceSettings {
 }
 
 export interface MarketplacePage {
-  enabled: boolean
-  bannerUrl: string
-  ogImage: string
-  private: boolean
+  enabled: boolean;
+  bannerUrl: string;
+  ogImage: string;
+  private: boolean;
 }
 
 export interface MarketplaceSocials {
@@ -110,8 +109,10 @@ export interface MarketCollection {
   bannerUrl: string;
   feePercentage: number;
   currencyOptions: Array<string>;
-  destinationMarketplace: OrderbookKind;
+  destinationMarketplace: string;
   filterSettings?: CollectionFilterSettings;
+  sortOrder?: number;
+  private: boolean;
   createdAt?: string;
   updatedAt?: string;
 }
@@ -136,6 +137,9 @@ export interface ShopCollection {
   name: string;
   bannerUrl: string;
   tokenIds: Array<string>;
+  customTokenIds: Array<string>;
+  sortOrder?: number;
+  private: boolean;
   createdAt?: string;
   updatedAt?: string;
 }

package/src/react/_internal/api/marketplace.gen.ts

@@ -8,7 +8,7 @@
 export const WebrpcHeader = "Webrpc";
 
 export const WebrpcHeaderValue =
-  "webrpc@v0.25.4;gen-typescript@v0.17.0;marketplace-api@v0.0.0-cf3a5fae407a732cd5a90e4fd68184ac5591b2c1;marketplace-sdk@v0.10.0";
+  "webrpc@v0.25.4;gen-typescript@v0.17.0;marketplace-api@v0.0.0-cf3a5fae407a732cd5a90e4fd68184ac5591b2c1;marketplace-sdk@v1.1.0";
 
 // WebRPC description and code-gen version
 export const WebRPCVersion = "v1";

package/src/react/_internal/api/query-keys.ts

@@ -27,6 +27,7 @@ class CollectableKeys {
 	static offersCount = [...CollectableKeys.all, 'offersCount'] as const;
 	static listings = [...CollectableKeys.all, 'listings'] as const;
 	static listingsCount = [...CollectableKeys.all, 'listingsCount'] as const;
+	static listPrimarySaleItems = ['listPrimarySaleItems'] as const;
 	static filter = [...CollectableKeys.all, 'filter'] as const;
 	static counts = [...CollectableKeys.all, 'counts'] as const;
 	static collectibleActivities = [
@@ -54,6 +55,7 @@ class BalanceQueries {
 		...BalanceQueries.all,
 		'collectionBalanceDetails',
 	] as const;
+	static inventory = ['inventory'] as const;
 }
 
 // biome-ignore lint/complexity/noStaticOnlyClass: static class provides better organization and type safety for query keys

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

@@ -2,7 +2,7 @@ import type { Event as DatabeatEvent } from '@databeat/tracker';
 import { Databeat } from '@databeat/tracker';
 import { useContext } from 'react';
 
-import { MarketplaceSdkContext } from '../../provider';
+import { MarketplaceSdkContext } from '../../providers';
 import type {
 	EventType,
 	TrackBuyModalOpened,

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

@@ -50,6 +50,7 @@ type BuyModalOpenedProps = Omit<
 	| 'chainId'
 	| 'skipNativeBalanceCheck'
 	| 'nativeTokenAddress'
+	| 'successActionButtons'
 > & {
 	buyAnalyticsId: string;
 };

package/src/react/_internal/query-meta.ts

@@ -0,0 +1,3 @@
+export const persistentQueryMeta = {
+	persistent: true,
+};

package/src/react/_internal/utils.ts

@@ -16,6 +16,7 @@ export interface SignatureStep {
 
 export interface TransactionStep {
 	id:
+		| StepType.tokenApproval
 		| StepType.buy
 		| StepType.sell
 		| StepType.cancel
@@ -43,6 +44,7 @@ export function isSignatureStep(step: Step): step is SignatureStep {
 
 export function isTransactionStep(step: Step): step is TransactionStep {
 	return [
+		StepType.tokenApproval,
 		StepType.buy,
 		StepType.sell,
 		StepType.cancel,

package/src/react/_internal/wagmi/__tests__/create-config.test.ts

@@ -1,3 +1,4 @@
+import { allNetworks } from '@0xsequence/network';
 import { polygon } from 'viem/chains';
 import { beforeEach, describe, expect, it } from 'vitest';
 import { type Config, cookieStorage } from 'wagmi';
@@ -13,6 +14,7 @@ import { createWagmiConfig } from '../create-config';
 describe('createWagmiConfig', () => {
 	let baseMarketplace: MarketplaceConfig;
 	let baseSdkConfig: SdkConfig;
+	const expectedNetworkCount = Object.keys(allNetworks).length;
 
 	beforeEach(() => {
 		baseMarketplace = {
@@ -44,10 +46,11 @@ describe('createWagmiConfig', () => {
 				enabled: true,
 				bannerUrl: 'https://test.com/banner.jpg',
 				ogImage: '',
+				private: false,
 				collections: [
 					{
 						contractType: ContractType.ERC721,
-						marketplaceType: 'market',
+						cardType: 'market',
 						chainId: polygon.id,
 						bannerUrl: '',
 						itemsAddress: '0x1234567890123456789012345678901234567890',
@@ -58,6 +61,7 @@ describe('createWagmiConfig', () => {
 						feePercentage: 0,
 						destinationMarketplace: OrderbookKind.sequence_marketplace_v2,
 						currencyOptions: [],
+						private: false,
 					} as MarketCollection,
 				],
 			},
@@ -66,6 +70,7 @@ describe('createWagmiConfig', () => {
 				bannerUrl: '',
 				ogImage: '',
 				collections: [],
+				private: false,
 			},
 		};
 
@@ -87,9 +92,15 @@ describe('createWagmiConfig', () => {
 			);
 			expect(configWithEmptyCollections.chains).toBeDefined();
 			expect(Array.isArray(configWithEmptyCollections.chains)).toBe(true);
-			expect(configWithEmptyCollections.chains).toHaveLength(1);
-			// Default chain is polygon if no collections are specified
-			expect(configWithEmptyCollections.chains[0].id).toBe(polygon.id);
+			expect(configWithEmptyCollections.chains).toHaveLength(
+				expectedNetworkCount,
+			);
+			// All networks from allNetworks are now included
+			expect(
+				configWithEmptyCollections.chains.find(
+					(chain) => chain.id === polygon.id,
+				),
+			).toBeDefined();
 		});
 
 		it('should create config with universal wallet setup', () => {
@@ -113,7 +124,7 @@ describe('createWagmiConfig', () => {
 
 			const config = createWagmiConfig(marketplaceConfig, sdkConfig);
 			expect(config.connectors).toBeDefined();
-			expect(config.chains).toHaveLength(1);
+			expect(config.chains).toHaveLength(expectedNetworkCount);
 		});
 
 		it('should create config with embedded wallet setup', () => {
@@ -144,7 +155,7 @@ describe('createWagmiConfig', () => {
 
 			const config = createWagmiConfig(marketplaceConfig, sdkConfig);
 			expect(config.connectors).toBeDefined();
-			expect(config.chains).toHaveLength(1);
+			expect(config.chains).toHaveLength(expectedNetworkCount);
 		});
 
 		it('should respect EIP6963 wallet inclusion setting', () => {
@@ -163,7 +174,7 @@ describe('createWagmiConfig', () => {
 
 			const config = createWagmiConfig(marketplaceConfig, baseSdkConfig);
 			expect(config.connectors).toBeDefined();
-			expect(config.chains).toHaveLength(1);
+			expect(config.chains).toHaveLength(expectedNetworkCount);
 		});
 
 		it('should create SSR compatible config when ssr flag is true', async () => {
@@ -203,7 +214,7 @@ describe('createWagmiConfig', () => {
 
 			const config = createWagmiConfig(marketplaceConfig, baseSdkConfig);
 			expect(config.connectors).toBeDefined();
-			expect(config.chains).toHaveLength(1);
+			expect(config.chains).toHaveLength(expectedNetworkCount);
 		});
 	});
 });

package/src/react/_internal/wagmi/create-config.ts

@@ -1,10 +1,9 @@
-import { getDefaultChains } from '@0xsequence/connect';
 import { allNetworks, findNetworkConfig } from '@0xsequence/network';
 import type { Chain, Transport } from 'viem';
 import { cookieStorage, createConfig, createStorage, http } from 'wagmi';
-import type { Env, SdkConfig } from '../../../types';
+import type { Env, SdkConfig } from '../../../types/index';
 import type { MarketplaceConfig } from '../../../types/new-marketplace-types';
-import { DEFAULT_NETWORK } from '../consts';
+import { networkToWagmiChain } from '../../../utils/networkconfigToWagmiChain';
 import { getConnectors } from './get-connectors';
 
 export const createWagmiConfig = (
@@ -66,22 +65,12 @@ export function getWagmiChainsAndTransports({
 	return { chains, transports };
 }
 
-function getAllCollections(marketConfig: MarketplaceConfig) {
-	return [...marketConfig.market.collections, ...marketConfig.shop.collections];
-}
-
-function getChainConfigs(marketConfig: MarketplaceConfig): [Chain, ...Chain[]] {
-	const supportedChainIds = new Set(
-		getAllCollections(marketConfig).map((c) => c.chainId),
-	);
-
-	if (supportedChainIds.size === 0) {
-		supportedChainIds.add(DEFAULT_NETWORK);
-	}
-
-	const chains = getDefaultChains([...supportedChainIds]);
+function getChainConfigs(
+	_marketConfig: MarketplaceConfig,
+): [Chain, ...Chain[]] {
+	const chains = Object.values(allNetworks).map(networkToWagmiChain);
 
-	return chains;
+	return chains as [Chain, ...Chain[]];
 }
 
 function getTransportConfigs(

package/src/react/_internal/wagmi/get-connectors.ts

@@ -17,7 +17,7 @@ import {
 } from '@0xsequence/connect';
 import React, { type FunctionComponent } from 'react';
 import type { CreateConnectorFn } from 'wagmi';
-import type { Env, SdkConfig } from '../../../types';
+import type { Env, SdkConfig } from '../../../types/index';
 import type { MarketplaceConfig } from '../../../types/new-marketplace-types';
 import { MissingConfigError } from '../../../utils/_internal/error/transaction';
 import { MarketplaceWalletType } from '../api/builder.gen';