@0xsequence/marketplace-sdk 0.8.12 → 0.10.0

package/src/react/queries/__tests__/inventory.laos.test.ts

@@ -0,0 +1,496 @@
+import { server } from '@test';
+import { HttpResponse, http } from 'msw';
+import { afterEach, describe, expect, it } from 'vitest';
+import { ContractType } from '../../_internal';
+import { mockIndexerEndpoint } from '../../_internal/api/__mocks__/indexer.msw';
+import { laosHandlers } from '../../_internal/api/__mocks__/laos.msw';
+import { mockMarketplaceEndpoint } from '../../_internal/api/__mocks__/marketplace.msw';
+import { clearInventoryState, fetchInventory } from '../inventory';
+
+describe('fetchInventory with LAOS', () => {
+	const mockConfig = {
+		projectAccessKey: 'test-key',
+		projectId: '1',
+		chainId: 11155111,
+		apiUrl: 'https://marketplace-api.sequence.app',
+		isDev: false,
+	};
+
+	const defaultArgs = {
+		accountAddress:
+			'0xuser1234567890123456789012345678901234567890' as `0x${string}`,
+		collectionAddress:
+			'0x1234567890123456789012345678901234567890' as `0x${string}`,
+		chainId: 11155111,
+		isLaos721: true,
+	};
+
+	afterEach(() => {
+		server.resetHandlers();
+		clearInventoryState();
+	});
+
+	it('should fetch LAOS inventory using LAOS API', async () => {
+		server.use(
+			...laosHandlers,
+			// Mock marketplace config
+			http.post('*/rpc/MarketplaceService/LookupMarketplace', () => {
+				return HttpResponse.json({
+					marketplace: {
+						projectId: 1,
+						settings: {
+							style: {},
+							publisherId: 'test-publisher',
+							title: 'Test Marketplace',
+							socials: {
+								twitter: '',
+								discord: '',
+								website: '',
+								tiktok: '',
+								instagram: '',
+								youtube: '',
+							},
+							faviconUrl: '',
+							walletOptions: {
+								walletType: 'UNIVERSAL',
+								oidcIssuers: {},
+								connectors: [],
+								includeEIP6963Wallets: false,
+							},
+							logoUrl: '',
+							fontUrl: '',
+						},
+						market: {
+							enabled: true,
+							title: 'Test Market',
+							bannerUrl: '',
+							ogImage: '',
+						},
+						shop: {
+							enabled: false,
+							title: '',
+							bannerUrl: '',
+							ogImage: '',
+						},
+					},
+					marketCollections: [
+						{
+							id: 1,
+							projectId: 1,
+							chainId: 11155111,
+							itemsAddress: '0x1234567890123456789012345678901234567890',
+							contractType: ContractType.LAOS_ERC_721,
+							bannerUrl: '',
+							feePercentage: 0,
+							currencyOptions: [],
+							destinationMarketplace: 'sequence_marketplace_v2',
+						},
+					],
+					shopCollections: [],
+				});
+			}),
+			// Mock empty marketplace collectibles
+			http.post(mockMarketplaceEndpoint('ListCollectibles'), () => {
+				return HttpResponse.json({
+					collectibles: [],
+					page: { page: 1, pageSize: 10, more: false },
+				});
+			}),
+		);
+
+		const result = await fetchInventory(defaultArgs, mockConfig, {
+			page: 1,
+			pageSize: 10,
+		});
+
+		expect(result).toBeDefined();
+		expect(result.collectibles).toBeDefined();
+		// Should include balances from LAOS API
+		expect(result.collectibles.length).toBeGreaterThan(0);
+
+		// Verify LAOS-specific properties
+		const firstCollectible = result.collectibles[0];
+		expect(firstCollectible.balance).toBe('5'); // From mock LAOS response
+		expect(firstCollectible.contractInfo?.type).toBe('LAOS-ERC-721');
+	});
+
+	it('should handle LAOS API errors gracefully', async () => {
+		const errorArgs = {
+			...defaultArgs,
+			accountAddress:
+				'0x0000000000000000000000000000000000000001' as `0x${string}`, // Special address for 500 error
+		};
+
+		server.use(
+			...laosHandlers,
+			http.post('*/rpc/MarketplaceService/LookupMarketplace', () => {
+				return HttpResponse.json({
+					marketplace: {
+						projectId: 1,
+						settings: {
+							style: {},
+							publisherId: 'test-publisher',
+							title: 'Test Marketplace',
+							socials: {
+								twitter: '',
+								discord: '',
+								website: '',
+								tiktok: '',
+								instagram: '',
+								youtube: '',
+							},
+							faviconUrl: '',
+							walletOptions: {
+								walletType: 'UNIVERSAL',
+								oidcIssuers: {},
+								connectors: [],
+								includeEIP6963Wallets: false,
+							},
+							logoUrl: '',
+							fontUrl: '',
+						},
+						market: {
+							enabled: true,
+							title: 'Test Market',
+							bannerUrl: '',
+							ogImage: '',
+						},
+						shop: {
+							enabled: false,
+							title: '',
+							bannerUrl: '',
+							ogImage: '',
+						},
+					},
+					marketCollections: [
+						{
+							id: 1,
+							projectId: 1,
+							chainId: 11155111,
+							itemsAddress: '0x1234567890123456789012345678901234567890',
+							contractType: ContractType.LAOS_ERC_721,
+							bannerUrl: '',
+							feePercentage: 0,
+							currencyOptions: [],
+							destinationMarketplace: 'sequence_marketplace_v2',
+						},
+					],
+					shopCollections: [],
+				});
+			}),
+			http.post(mockMarketplaceEndpoint('ListCollectibles'), () => {
+				return HttpResponse.json({
+					collectibles: [],
+					page: { page: 1, pageSize: 10, more: false },
+				});
+			}),
+		);
+
+		await expect(
+			fetchInventory(errorArgs, mockConfig, { page: 1, pageSize: 10 }),
+		).rejects.toThrow('Failed to get token balances: Internal Server Error');
+	});
+
+	it('should handle empty LAOS balances', async () => {
+		const emptyArgs = {
+			...defaultArgs,
+			accountAddress:
+				'0x0000000000000000000000000000000000000003' as `0x${string}`, // Special address for empty response
+		};
+
+		server.use(
+			...laosHandlers,
+			http.post('*/rpc/MarketplaceService/LookupMarketplace', () => {
+				return HttpResponse.json({
+					marketplace: {
+						projectId: 1,
+						settings: {
+							style: {},
+							publisherId: 'test-publisher',
+							title: 'Test Marketplace',
+							socials: {
+								twitter: '',
+								discord: '',
+								website: '',
+								tiktok: '',
+								instagram: '',
+								youtube: '',
+							},
+							faviconUrl: '',
+							walletOptions: {
+								walletType: 'UNIVERSAL',
+								oidcIssuers: {},
+								connectors: [],
+								includeEIP6963Wallets: false,
+							},
+							logoUrl: '',
+							fontUrl: '',
+						},
+						market: {
+							enabled: true,
+							title: 'Test Market',
+							bannerUrl: '',
+							ogImage: '',
+						},
+						shop: {
+							enabled: false,
+							title: '',
+							bannerUrl: '',
+							ogImage: '',
+						},
+					},
+					marketCollections: [
+						{
+							id: 1,
+							projectId: 1,
+							chainId: 11155111,
+							itemsAddress: '0x1234567890123456789012345678901234567890',
+							contractType: ContractType.LAOS_ERC_721,
+							bannerUrl: '',
+							feePercentage: 0,
+							currencyOptions: [],
+							destinationMarketplace: 'sequence_marketplace_v2',
+						},
+					],
+					shopCollections: [],
+				});
+			}),
+			http.post(mockMarketplaceEndpoint('ListCollectibles'), () => {
+				return HttpResponse.json({
+					collectibles: [],
+					page: { page: 1, pageSize: 10, more: false },
+				});
+			}),
+		);
+
+		const result = await fetchInventory(emptyArgs, mockConfig, {
+			page: 1,
+			pageSize: 10,
+		});
+
+		expect(result).toBeDefined();
+		expect(result.collectibles).toEqual([]);
+		expect(result.page.more).toBe(false);
+	});
+
+	it('should include LAOS metadata in inventory items', async () => {
+		server.use(
+			...laosHandlers,
+			http.post('*/rpc/MarketplaceService/LookupMarketplace', () => {
+				return HttpResponse.json({
+					marketplace: {
+						projectId: 1,
+						settings: {
+							style: {},
+							publisherId: 'test-publisher',
+							title: 'Test Marketplace',
+							socials: {
+								twitter: '',
+								discord: '',
+								website: '',
+								tiktok: '',
+								instagram: '',
+								youtube: '',
+							},
+							faviconUrl: '',
+							walletOptions: {
+								walletType: 'UNIVERSAL',
+								oidcIssuers: {},
+								connectors: [],
+								includeEIP6963Wallets: false,
+							},
+							logoUrl: '',
+							fontUrl: '',
+						},
+						market: {
+							enabled: true,
+							title: 'Test Market',
+							bannerUrl: '',
+							ogImage: '',
+						},
+						shop: {
+							enabled: false,
+							title: '',
+							bannerUrl: '',
+							ogImage: '',
+						},
+					},
+					marketCollections: [
+						{
+							id: 1,
+							projectId: 1,
+							chainId: 11155111,
+							itemsAddress: '0x1234567890123456789012345678901234567890',
+							contractType: ContractType.LAOS_ERC_721,
+							bannerUrl: '',
+							feePercentage: 0,
+							currencyOptions: [],
+							destinationMarketplace: 'sequence_marketplace_v2',
+						},
+					],
+					shopCollections: [],
+				});
+			}),
+			http.post(mockMarketplaceEndpoint('ListCollectibles'), () => {
+				return HttpResponse.json({
+					collectibles: [],
+					page: { page: 1, pageSize: 10, more: false },
+				});
+			}),
+		);
+
+		const result = await fetchInventory(defaultArgs, mockConfig, {
+			page: 1,
+			pageSize: 10,
+		});
+
+		expect(result.collectibles.length).toBeGreaterThan(0);
+
+		const firstCollectible = result.collectibles[0];
+		expect(firstCollectible.metadata).toBeDefined();
+		expect(firstCollectible.metadata.name).toBe('Test Token 1');
+		expect(firstCollectible.metadata.description).toBe(
+			'A test token for LAOS testing',
+		);
+		expect(firstCollectible.metadata.image).toBe(
+			'https://example.com/token1.png',
+		);
+		expect(firstCollectible.metadata.attributes).toEqual([
+			{
+				trait_type: 'Rarity',
+				value: 'Common',
+			},
+		]);
+	});
+
+	it('should handle non-LAOS collections correctly', async () => {
+		const nonLaosArgs = {
+			...defaultArgs,
+			isLaos721: false,
+		};
+
+		server.use(
+			// Mock marketplace config without LAOS collections
+			http.post('*/rpc/MarketplaceService/LookupMarketplace', () => {
+				return HttpResponse.json({
+					marketplace: {
+						projectId: 1,
+						settings: {
+							style: {},
+							publisherId: 'test-publisher',
+							title: 'Test Marketplace',
+							socials: {
+								twitter: '',
+								discord: '',
+								website: '',
+								tiktok: '',
+								instagram: '',
+								youtube: '',
+							},
+							faviconUrl: '',
+							walletOptions: {
+								walletType: 'UNIVERSAL',
+								oidcIssuers: {},
+								connectors: [],
+								includeEIP6963Wallets: false,
+							},
+							logoUrl: '',
+							fontUrl: '',
+						},
+						market: {
+							enabled: true,
+							title: 'Test Market',
+							bannerUrl: '',
+							ogImage: '',
+						},
+						shop: {
+							enabled: false,
+							title: '',
+							bannerUrl: '',
+							ogImage: '',
+						},
+					},
+					marketCollections: [
+						{
+							id: 1,
+							projectId: 1,
+							chainId: 11155111,
+							itemsAddress: '0x1234567890123456789012345678901234567890',
+							contractType: ContractType.ERC721,
+							bannerUrl: '',
+							feePercentage: 0,
+							currencyOptions: [],
+							destinationMarketplace: 'sequence_marketplace_v2',
+						},
+					],
+					shopCollections: [],
+				});
+			}),
+			// Mock indexer token balances for non-LAOS collections
+			http.post(mockIndexerEndpoint('GetTokenBalances'), () => {
+				return HttpResponse.json({
+					page: { page: 1, pageSize: 10, more: false },
+					balances: [
+						{
+							accountAddress: '0xuser1234567890123456789012345678901234567890',
+							balance: '1',
+							blockHash: '0xblock123',
+							blockNumber: 12345,
+							chainId: 11155111,
+							contractAddress: '0x1234567890123456789012345678901234567890',
+							contractInfo: {
+								address: '0x1234567890123456789012345678901234567890',
+								chainId: 11155111,
+								decimals: 0,
+								deployed: true,
+								name: 'Regular Collection',
+								symbol: 'REG',
+								type: 'ERC721',
+							},
+							contractType: 'ERC721',
+							tokenID: '1',
+							tokenMetadata: {
+								contractAddress: '0x1234567890123456789012345678901234567890',
+								decimals: 0,
+								name: 'Regular NFT',
+								description: 'A regular NFT',
+								image: 'https://example.com/regular.png',
+								tokenId: '1',
+							},
+						},
+					],
+				});
+			}),
+			// Mock marketplace collectibles
+			http.post(mockMarketplaceEndpoint('ListCollectibles'), () => {
+				return HttpResponse.json({
+					collectibles: [
+						{
+							metadata: {
+								tokenId: '1',
+								name: 'Regular NFT',
+								description: 'A regular NFT',
+								image: 'https://example.com/regular.png',
+							},
+							order: null,
+						},
+					],
+					page: { page: 1, pageSize: 10, more: false },
+				});
+			}),
+		);
+
+		const result = await fetchInventory(nonLaosArgs, mockConfig, {
+			page: 1,
+			pageSize: 10,
+		});
+
+		expect(result).toBeDefined();
+		expect(result.collectibles).toBeDefined();
+		expect(result.collectibles.length).toBeGreaterThan(0);
+
+		// Should use marketplace data, not LAOS API
+		const firstCollectible = result.collectibles[0];
+		expect(firstCollectible.metadata.name).toBe('Regular NFT');
+	});
+});

package/src/react/queries/balanceOfCollectible.ts

@@ -1,13 +1,13 @@
 import { queryOptions, skipToken } from '@tanstack/react-query';
-import type { Hex } from 'viem';
+import type { Address } from 'viem';
 import type { UseQueryParameters } from 'wagmi/query';
 import type { SdkConfig } from '../../types';
-import { LaosAPI, collectableKeys, getIndexerClient } from '../_internal';
+import { collectableKeys, getIndexerClient, LaosAPI } from '../_internal';
 
 export type UseBalanceOfCollectibleArgs = {
-	collectionAddress: Hex;
+	collectionAddress: Address;
 	collectableId: string;
-	userAddress: Hex | undefined;
+	userAddress: Address | undefined;
 	chainId: number;
 	isLaos721?: boolean;
 	query?: UseQueryParameters;
@@ -21,13 +21,16 @@ export type UseBalanceOfCollectibleArgs = {
  * @returns The balance data
  */
 export async function fetchBalanceOfCollectible(
-	args: Omit<UseBalanceOfCollectibleArgs, 'userAddress'> & { userAddress: Hex },
+	args: Omit<UseBalanceOfCollectibleArgs, 'userAddress'> & {
+		userAddress: Address;
+	},
 	config: SdkConfig,
 ) {
 	if (args.isLaos721) {
 		const laosApi = new LaosAPI();
 		const response = await laosApi.getTokenBalances({
 			chainId: args.chainId.toString(),
+			contractAddress: args.collectionAddress,
 			accountAddress: args.userAddress,
 			includeMetadata: true,
 		});

package/src/react/queries/checkoutOptions.ts

@@ -0,0 +1,85 @@
+import { queryOptions } from '@tanstack/react-query';
+import type { Address } from 'viem';
+import type { SdkConfig } from '../../types';
+import type { MarketplaceKind } from '../_internal';
+import { getMarketplaceClient, type ValuesOptional } from '../_internal';
+import type {
+	CheckoutOptionsMarketplaceArgs,
+	CheckoutOptionsMarketplaceReturn,
+} from '../_internal/api/marketplace.gen';
+import type { StandardQueryOptions } from '../types/query';
+
+export interface FetchCheckoutOptionsParams
+	extends Omit<
+		CheckoutOptionsMarketplaceArgs,
+		'chainId' | 'wallet' | 'orders'
+	> {
+	chainId: number;
+	walletAddress: Address;
+	orders: Array<{
+		collectionAddress: string;
+		orderId: string;
+		marketplace: MarketplaceKind;
+	}>;
+	config: SdkConfig;
+}
+
+/**
+ * Fetches checkout options from the Marketplace API
+ */
+export async function fetchCheckoutOptions(
+	params: FetchCheckoutOptionsParams,
+): Promise<CheckoutOptionsMarketplaceReturn> {
+	const { chainId, walletAddress, orders, config, additionalFee } = params;
+
+	const client = getMarketplaceClient(config);
+
+	const apiArgs: CheckoutOptionsMarketplaceArgs = {
+		chainId: String(chainId),
+		wallet: walletAddress,
+		orders: orders.map((order) => ({
+			contractAddress: order.collectionAddress,
+			orderId: order.orderId,
+			marketplace: order.marketplace,
+		})),
+		additionalFee: additionalFee ?? 0,
+	};
+
+	const result = await client.checkoutOptionsMarketplace(apiArgs);
+	return result;
+}
+
+export type CheckoutOptionsQueryOptions =
+	ValuesOptional<FetchCheckoutOptionsParams> & {
+		query?: StandardQueryOptions;
+	};
+
+export function checkoutOptionsQueryOptions(
+	params: CheckoutOptionsQueryOptions,
+) {
+	const enabled = Boolean(
+		params.chainId &&
+			params.walletAddress &&
+			params.orders?.length &&
+			params.config &&
+			(params.query?.enabled ?? true),
+	);
+
+	return queryOptions({
+		queryKey: ['checkout', 'options', params],
+		queryFn: () =>
+			fetchCheckoutOptions({
+				// biome-ignore lint/style/noNonNullAssertion: The enabled check above ensures these are not undefined
+				chainId: params.chainId!,
+				// biome-ignore lint/style/noNonNullAssertion: The enabled check above ensures these are not undefined
+				walletAddress: params.walletAddress!,
+				// biome-ignore lint/style/noNonNullAssertion: The enabled check above ensures these are not undefined
+				orders: params.orders!,
+				// biome-ignore lint/style/noNonNullAssertion: The enabled check above ensures these are not undefined
+				config: params.config!,
+				additionalFee: params.additionalFee ?? 0,
+			}),
+		...params.query,
+		enabled,
+	});
+}

package/src/react/queries/checkoutOptionsSalesContract.ts

@@ -0,0 +1,89 @@
+import { queryOptions } from '@tanstack/react-query';
+import type { Address } from 'viem';
+import type { SdkConfig } from '../../types';
+import { getMarketplaceClient, type ValuesOptional } from '../_internal';
+import type {
+	CheckoutOptionsItem,
+	CheckoutOptionsSalesContractArgs,
+	CheckoutOptionsSalesContractReturn,
+} from '../_internal/api/marketplace.gen';
+import type { StandardQueryOptions } from '../types/query';
+
+export interface FetchCheckoutOptionsSalesContractParams
+	extends Omit<CheckoutOptionsSalesContractArgs, 'chainId' | 'wallet'> {
+	chainId: number;
+	walletAddress: Address;
+	contractAddress: string;
+	collectionAddress: string;
+	items: Array<CheckoutOptionsItem>;
+	config: SdkConfig;
+}
+
+/**
+ * Fetches checkout options for sales contract from the Marketplace API
+ */
+export async function fetchCheckoutOptionsSalesContract(
+	params: FetchCheckoutOptionsSalesContractParams,
+): Promise<CheckoutOptionsSalesContractReturn> {
+	const {
+		chainId,
+		walletAddress,
+		contractAddress,
+		collectionAddress,
+		items,
+		config,
+	} = params;
+
+	const client = getMarketplaceClient(config);
+
+	const apiArgs: CheckoutOptionsSalesContractArgs = {
+		chainId: String(chainId),
+		wallet: walletAddress,
+		contractAddress,
+		collectionAddress,
+		items,
+	};
+
+	const result = await client.checkoutOptionsSalesContract(apiArgs);
+	return result;
+}
+
+export type CheckoutOptionsSalesContractQueryOptions =
+	ValuesOptional<FetchCheckoutOptionsSalesContractParams> & {
+		query?: StandardQueryOptions;
+	};
+
+export function checkoutOptionsSalesContractQueryOptions(
+	params: CheckoutOptionsSalesContractQueryOptions,
+) {
+	const enabled = Boolean(
+		params.chainId &&
+			params.walletAddress &&
+			params.contractAddress &&
+			params.collectionAddress &&
+			params.items?.length &&
+			params.config &&
+			(params.query?.enabled ?? true),
+	);
+
+	return queryOptions({
+		queryKey: ['checkout', 'options', 'salesContract', params],
+		queryFn: () =>
+			fetchCheckoutOptionsSalesContract({
+				// biome-ignore lint/style/noNonNullAssertion: The enabled check above ensures these are not undefined
+				chainId: params.chainId!,
+				// biome-ignore lint/style/noNonNullAssertion: The enabled check above ensures these are not undefined
+				walletAddress: params.walletAddress!,
+				// biome-ignore lint/style/noNonNullAssertion: The enabled check above ensures these are not undefined
+				contractAddress: params.contractAddress!,
+				// biome-ignore lint/style/noNonNullAssertion: The enabled check above ensures these are not undefined
+				collectionAddress: params.collectionAddress!,
+				// biome-ignore lint/style/noNonNullAssertion: The enabled check above ensures these are not undefined
+				items: params.items!,
+				// biome-ignore lint/style/noNonNullAssertion: The enabled check above ensures these are not undefined
+				config: params.config!,
+			}),
+		...params.query,
+		enabled,
+	});
+}