@0xsequence/marketplace-sdk 0.8.10 → 0.8.12

package/src/types/buyModalErrors.ts

@@ -0,0 +1,438 @@
+// Enhanced error types with price context and better debugging information
+export type BuyModalError =
+	| PriceOverflowError
+	| PriceCalculationError
+	| InvalidPriceFormatError
+	| InvalidQuantityError
+	| NetworkError
+	| ContractError
+	| CheckoutError
+	| ValidationError
+	| StateError;
+
+export interface PriceOverflowError {
+	type: 'PRICE_OVERFLOW';
+	maxSafeValue: string;
+	attemptedValue: string;
+	operation: string;
+	timestamp: number;
+}
+
+export interface PriceCalculationError {
+	type: 'PRICE_CALCULATION_ERROR';
+	operation: string;
+	inputs: string[];
+	originalError?: string;
+	timestamp: number;
+}
+
+// export interface InsufficientFundsError {
+//   type: "INSUFFICIENT_FUNDS";
+//   required: Price;
+//   available: Price;
+//   currency: string;
+//   shortfall: Price;
+//   timestamp: number;
+// }
+
+export interface InvalidPriceFormatError {
+	type: 'INVALID_PRICE_FORMAT';
+	providedPrice: string;
+	expectedFormat: string;
+	suggestions?: string[];
+	timestamp: number;
+}
+
+export interface InvalidQuantityError {
+	type: 'INVALID_QUANTITY';
+	provided: number;
+	min: number;
+	max: number;
+	available?: number;
+	timestamp: number;
+}
+
+export interface NetworkError {
+	type: 'NETWORK_ERROR';
+	message: string;
+	retryable: boolean;
+	chainId?: number;
+	endpoint?: string;
+	timestamp: number;
+}
+
+export interface ContractError {
+	type: 'CONTRACT_ERROR';
+	contractAddress: string;
+	message: string;
+	method?: string;
+	chainId?: number;
+	blockNumber?: number;
+	timestamp: number;
+}
+
+export interface CheckoutError {
+	type: 'CHECKOUT_ERROR';
+	provider: string;
+	message: string;
+	code?: string;
+	retryable: boolean;
+	timestamp: number;
+}
+
+export interface ValidationError {
+	type: 'VALIDATION_ERROR';
+	field: string;
+	message: string;
+	value?: unknown;
+	constraints?: Record<string, unknown>;
+	timestamp: number;
+}
+
+export interface StateError {
+	type: 'STATE_ERROR';
+	currentState: string;
+	attemptedAction: string;
+	message: string;
+	timestamp: number;
+}
+
+// biome-ignore lint/complexity/noStaticOnlyClass:
+export class BuyModalErrorFactory {
+	static priceOverflow(
+		maxSafeValue: string,
+		attemptedValue: string,
+		operation: string,
+	): PriceOverflowError {
+		return {
+			type: 'PRICE_OVERFLOW',
+			maxSafeValue,
+			attemptedValue,
+			operation,
+			timestamp: Date.now(),
+		};
+	}
+
+	static priceCalculation(
+		operation: string,
+		inputs: string[],
+		originalError?: string,
+	): PriceCalculationError {
+		return {
+			type: 'PRICE_CALCULATION_ERROR',
+			operation,
+			inputs,
+			originalError,
+			timestamp: Date.now(),
+		};
+	}
+
+	//   static insufficientFunds(
+	//     required: Price,
+	//     available: Price,
+	//     currency: string,
+	//     shortfall: Price
+	//   ): InsufficientFundsError {
+	//     return {
+	//       type: "INSUFFICIENT_FUNDS",
+	//       required,
+	//       available,
+	//       currency,
+	//       shortfall,
+	//       timestamp: Date.now(),
+	//     };
+	//   }
+
+	static invalidPriceFormat(
+		providedPrice: string,
+		expectedFormat: string,
+		suggestions?: string[],
+	): InvalidPriceFormatError {
+		return {
+			type: 'INVALID_PRICE_FORMAT',
+			providedPrice,
+			expectedFormat,
+			suggestions,
+			timestamp: Date.now(),
+		};
+	}
+
+	static invalidQuantity(
+		provided: number,
+		min: number,
+		max: number,
+		available?: number,
+	): InvalidQuantityError {
+		return {
+			type: 'INVALID_QUANTITY',
+			provided,
+			min,
+			max,
+			available,
+			timestamp: Date.now(),
+		};
+	}
+
+	static networkError(
+		message: string,
+		retryable: boolean,
+		chainId?: number,
+		endpoint?: string,
+	): NetworkError {
+		return {
+			type: 'NETWORK_ERROR',
+			message,
+			retryable,
+			chainId,
+			endpoint,
+			timestamp: Date.now(),
+		};
+	}
+
+	static contractError(
+		contractAddress: string,
+		message: string,
+		method?: string,
+		chainId?: number,
+		blockNumber?: number,
+	): ContractError {
+		return {
+			type: 'CONTRACT_ERROR',
+			contractAddress,
+			message,
+			method,
+			chainId,
+			blockNumber,
+			timestamp: Date.now(),
+		};
+	}
+
+	static checkoutError(
+		provider: string,
+		message: string,
+		code?: string,
+		retryable = false,
+	): CheckoutError {
+		return {
+			type: 'CHECKOUT_ERROR',
+			provider,
+			message,
+			code,
+			retryable,
+			timestamp: Date.now(),
+		};
+	}
+
+	static validationError(
+		field: string,
+		message: string,
+		value?: unknown,
+		constraints?: Record<string, unknown>,
+	): ValidationError {
+		return {
+			type: 'VALIDATION_ERROR',
+			field,
+			message,
+			value,
+			constraints,
+			timestamp: Date.now(),
+		};
+	}
+
+	static stateError(
+		currentState: string,
+		attemptedAction: string,
+		message: string,
+	): StateError {
+		return {
+			type: 'STATE_ERROR',
+			currentState,
+			attemptedAction,
+			message,
+			timestamp: Date.now(),
+		};
+	}
+}
+
+// Error message formatters for user-friendly display
+// biome-ignore lint/complexity/noStaticOnlyClass: Formatter provides good namespacing for error formatting
+export class BuyModalErrorFormatter {
+	static format(error: BuyModalError): string {
+		switch (error.type) {
+			case 'PRICE_OVERFLOW':
+				return 'Price calculation exceeded safe limits. Please reduce quantity or contact support.';
+
+			case 'PRICE_CALCULATION_ERROR':
+				return 'Price calculation failed. Please refresh and try again.';
+
+			//   case "INSUFFICIENT_FUNDS":
+			//     return `Insufficient funds. You need ${error.currency} but only have available.`;
+
+			case 'INVALID_PRICE_FORMAT':
+				return `Invalid price format. Expected: ${error.expectedFormat}`;
+
+			case 'INVALID_QUANTITY':
+				return `Invalid quantity. Must be between ${error.min} and ${error.max}.`;
+
+			case 'NETWORK_ERROR':
+				return error.retryable
+					? `Network error. ${error.message} Please try again.`
+					: `Network unavailable. ${error.message}`;
+
+			case 'CONTRACT_ERROR':
+				return `Blockchain error at ${error.contractAddress}. Please refresh and try again.`;
+
+			case 'CHECKOUT_ERROR':
+				return error.retryable
+					? `Checkout failed with ${error.provider}. Please try again.`
+					: `Checkout unavailable with ${error.provider}.`;
+
+			case 'VALIDATION_ERROR':
+				return `${error.field}: ${error.message}`;
+
+			case 'STATE_ERROR':
+				return `Invalid operation: ${error.message}`;
+
+			default:
+				return 'An unexpected error occurred. Please try again.';
+		}
+	}
+
+	static isRetryable(error: BuyModalError): boolean {
+		switch (error.type) {
+			case 'NETWORK_ERROR':
+			case 'CHECKOUT_ERROR':
+				return error.retryable;
+
+			case 'PRICE_CALCULATION_ERROR':
+			case 'CONTRACT_ERROR':
+				return true;
+
+			default:
+				return false;
+		}
+	}
+
+	static getRecoveryAction(error: BuyModalError): string {
+		switch (error.type) {
+			//   case "INSUFFICIENT_FUNDS":
+			//     return "Add funds to your wallet";
+
+			case 'INVALID_QUANTITY':
+				return 'Adjust quantity';
+
+			case 'INVALID_PRICE_FORMAT':
+				return 'Enter valid price';
+
+			case 'NETWORK_ERROR':
+			case 'CONTRACT_ERROR':
+				return 'Retry transaction';
+
+			case 'CHECKOUT_ERROR':
+				return 'Try different payment method';
+
+			default:
+				return 'Refresh and try again';
+		}
+	}
+
+	/**
+	 * Transform class-based errors (BaseError/TransactionError) to user-friendly BuyModalError
+	 * This bridges the internal error system with the modal error system
+	 */
+	static fromTransactionError(error: Error): BuyModalError {
+		// Import transaction errors
+		const errorName = error.name || error.constructor.name;
+
+		switch (errorName) {
+			case 'PriceCalculationError':
+				return BuyModalErrorFactory.priceCalculation(
+					'price calculation',
+					[],
+					error.message,
+				);
+
+			case 'SalesContractError': {
+				// Extract contract address from error message if available
+				const addressMatch = error.message.match(/0x[a-fA-F0-9]{40}/);
+				return BuyModalErrorFactory.contractError(
+					addressMatch?.[0] || 'unknown',
+					error.message,
+				);
+			}
+
+			case 'QuantityValidationError': {
+				// Parse quantity from error message
+				const quantityMatch = error.message.match(/Invalid quantity: (\d+)/);
+				const availableMatch = error.message.match(
+					/available supply \((\d+)\)/,
+				);
+				return BuyModalErrorFactory.invalidQuantity(
+					Number(quantityMatch?.[1] || 0),
+					0,
+					Number(availableMatch?.[1] || 0),
+				);
+			}
+
+			case 'UserRejectedRequestError':
+				return BuyModalErrorFactory.checkoutError(
+					'user',
+					'User cancelled the transaction',
+					'USER_REJECTED',
+					false,
+				);
+
+			case 'NoWalletConnectedError':
+				return BuyModalErrorFactory.stateError(
+					'disconnected',
+					'purchase',
+					'Please connect your wallet to continue',
+				);
+
+			case 'ChainSwitchError':
+			case 'NetworkError':
+				return BuyModalErrorFactory.networkError(
+					error.message,
+					true, // retryable
+				);
+
+			case 'ShopDataValidationError':
+				return BuyModalErrorFactory.validationError(
+					'shop-config',
+					error.message,
+				);
+
+			default:
+				// Generic error for unknown types
+				return BuyModalErrorFactory.stateError(
+					'unknown',
+					'operation',
+					error.message || 'An unexpected error occurred',
+				);
+		}
+	}
+
+	/**
+	 * Enhanced error wrapper that catches and transforms errors consistently
+	 */
+	static async withErrorHandling<T>(
+		operation: () => Promise<T>,
+		_context: string, // Prefixed with underscore to indicate intentionally unused
+	): Promise<T> {
+		try {
+			return await operation();
+		} catch (error) {
+			// Transform the error to user-friendly format
+			const buyModalError = BuyModalErrorFormatter.fromTransactionError(
+				error as Error,
+			);
+
+			// Re-throw as the original error for error boundaries to catch
+			// but attach the transformed error for UI consumption
+			const enhancedError = error as Error & { buyModalError?: BuyModalError };
+			enhancedError.buyModalError = buyModalError;
+
+			throw enhancedError;
+		}
+	}
+}

package/src/types/index.ts

@@ -1,10 +1,8 @@
 export * from './api-types';
 export * from './sdk-config';
 export * from './types';
-export type * from '../react/_internal/api/builder.gen';
 export type * from './../react/queries/marketplaceConfig';
 export {
-	MarketplaceWallet,
+	type MarketplaceWallet,
 	FilterCondition,
-	MarketplaceType,
 } from '../react/_internal/api/builder.gen';

package/src/types/new-marketplace-types.ts

@@ -0,0 +1,104 @@
+import type {
+	FilterCondition,
+	MarketplaceSettings,
+	MarketplaceWalletType,
+	OpenIdProvider,
+} from '../react/_internal/api/builder.gen';
+import type { ContractType, OrderbookKind } from './api-types';
+import type { MarketplaceType } from './types';
+
+export interface MarketplaceConfig {
+	projectId: number;
+	settings: MarketplaceSettings;
+	market: MarketPage;
+	shop: ShopPage;
+}
+
+interface MarketplacePage {
+	enabled: boolean;
+	bannerUrl: string;
+	ogImage?: string;
+}
+
+export interface MarketPage extends MarketplacePage {
+	collections: MarketCollection[];
+}
+
+export interface ShopPage extends MarketplacePage {
+	collections: ShopCollection[];
+}
+
+export interface MarketplaceSocials {
+	twitter: string;
+	discord: string;
+	website: string;
+	tiktok: string;
+	instagram: string;
+	youtube: string;
+}
+
+export interface MarketplaceWalletEcosystem {
+	walletUrl: string;
+	walletAppName: string;
+	logoLightUrl?: string;
+	logoDarkUrl?: string;
+}
+
+export interface MarketplaceWalletEmbedded {
+	tenantKey: string;
+	emailEnabled: boolean;
+	providers: Array<OpenIdProvider>;
+}
+
+interface MarketplaceCollection {
+	chainId: number;
+	bannerUrl: string;
+	itemsAddress: string;
+	filterSettings?: CollectionFilterSettings;
+}
+
+export interface MarketCollection extends MarketplaceCollection {
+	marketplaceType: MarketplaceType;
+	contractType: ContractType; //TODO: This should be added to the shop collection too
+	feePercentage: number;
+	destinationMarketplace: OrderbookKind;
+	currencyOptions: Array<string>;
+}
+
+export interface ShopCollection extends MarketplaceCollection {
+	marketplaceType: MarketplaceType;
+	saleAddress: string;
+}
+
+export interface EcosystemWalletSettings {
+	walletUrl: string;
+	walletAppName: string;
+	logoLightUrl?: string;
+	logoDarkUrl?: string;
+}
+
+export interface MarketplaceWalletOptions {
+	walletType: MarketplaceWalletType;
+	oidcIssuers: { [key: string]: string };
+	connectors: Array<string>;
+	includeEIP6963Wallets: boolean;
+	ecosystem?: EcosystemWalletSettings;
+	waas?: MarketplaceWalletWaasSettings;
+}
+
+export interface MarketplaceWalletWaasSettings {
+	tenantKey: string;
+	emailEnabled: boolean;
+	providers: Array<OpenIdProvider>;
+}
+
+export interface MetadataFilterRule {
+	key: string;
+	condition: FilterCondition;
+	value?: string;
+}
+
+export interface CollectionFilterSettings {
+	filterOrder: Array<string>;
+	exclusions: Array<MetadataFilterRule>;
+}

package/src/types/sdk-config.ts

@@ -1,21 +1,31 @@
-import type { MarketplaceSettings } from '../react/_internal/api/builder.gen';
+import type { LookupMarketplaceReturn } from '../react/_internal/api/builder.gen';
+import type { MarketplaceConfig } from './types';
 
-export type Env = 'development' | 'next' | 'production';
+export type Env = 'development' | 'production' | 'next';
+
+export type ApiConfig = {
+	env: Env;
+	accessKey?: string;
+};
 
 export type SdkConfig = {
 	projectAccessKey: string;
 	projectId: string;
 	walletConnectProjectId?: string;
 	_internal?: {
-		prefetchedMarketplaceSettings?: MarketplaceSettings;
-		devAccessKey?: string;
-		nextAccessKey?: string;
-		builderEnv?: Env;
-		marketplaceEnv?: Env;
-		nodeGatewayEnv?: Env;
-		metadataEnv?: Env;
-		indexerEnv?: Env;
-		sequenceApiEnv?: Env;
-		sequenceWalletEnv?: Env;
+		prefetchedMarketplaceSettings?: LookupMarketplaceReturn;
+		overrides?: {
+			marketplaceConfig?: Partial<MarketplaceConfig>;
+
+			api?: {
+				builder?: ApiConfig;
+				marketplace?: ApiConfig;
+				nodeGateway?: ApiConfig;
+				metadata?: ApiConfig;
+				indexer?: ApiConfig;
+				sequenceApi?: ApiConfig;
+				sequenceWallet?: ApiConfig;
+			};
+		};
 	};
 };

package/src/types/types.ts

@@ -1,10 +1,27 @@
 import type { Currency } from './api-types';
+import type { MarketplaceConfig } from './new-marketplace-types';
+export * from './new-marketplace-types';
 
 export type Price = {
 	amountRaw: string;
 	currency: Currency;
 };
 
+export type MarketplaceType = 'market' | 'shop';
+
+export enum CollectibleCardAction {
+	BUY = 'Buy',
+	SELL = 'Sell',
+	LIST = 'Create listing',
+	OFFER = 'Make an offer',
+	TRANSFER = 'Transfer',
+}
+
+export type MarketCollection =
+	MarketplaceConfig['market']['collections'][number];
+
+export type ShopCollection = MarketplaceConfig['shop']['collections'][number];
+
 // export type Order = Omit<APIOrder, 'priceAmount' | 'priceAmountNet'> & {
 // 	priceAmount: bigint;
 // 	priceAmountNet: bigint;

package/src/utils/_internal/error/transaction.ts

@@ -371,6 +371,38 @@ export class WalletInstanceNotFoundError extends TransactionError {
 	}
 }
 
+export class SalesContractError extends TransactionError {
+	override name = 'SalesContractError';
+	constructor(contractAddress: string, method?: string, cause?: Error) {
+		super(`Sales contract operation failed: ${contractAddress}`, {
+			details: `Failed to interact with sales contract${
+				method ? ` on method: ${method}` : ''
+			}. ${cause?.message || 'Contract may be paused or misconfigured.'}`,
+			cause,
+		});
+	}
+}
+
+export class QuantityValidationError extends TransactionError {
+	override name = 'QuantityValidationError';
+	constructor(provided: number, available: number, tokenId?: string) {
+		super(`Invalid quantity: ${provided}`, {
+			details: `Requested quantity (${provided}) exceeds available supply (${available})${
+				tokenId ? ` for token ${tokenId}` : ''
+			}.`,
+		});
+	}
+}
+
+export class ShopDataValidationError extends TransactionError {
+	override name = 'ShopDataValidationError';
+	constructor(missingField: string) {
+		super(`Invalid shop configuration: missing ${missingField}`, {
+			details: `The shop is missing required field: ${missingField}. Check your marketplace configuration.`,
+		});
+	}
+}
+
 export type TransactionErrorTypes =
 	| ChainIdUnavailableError
 	| TransactionReceiptError
@@ -408,4 +440,7 @@ export type TransactionErrorTypes =
 	| TransactionExecutionError
 	| NoWalletConnectedError
 	| TransactionError
-	| WalletInstanceNotFoundError;
+	| WalletInstanceNotFoundError
+	| SalesContractError
+	| QuantityValidationError
+	| ShopDataValidationError;

package/tsconfig.json

@@ -6,5 +6,5 @@
 			"@test": ["./test/test-utils.tsx"]
 		}
 	},
-	"include": ["src", "tsup.config.ts", "test", "eslint.config.mjs", "eslint"]
+	"include": ["src", "tsdown.config.ts", "test", "eslint.config.mjs", "eslint"]
 }