@manifoldxyz/marketplace-sdk 4.0.2 → 4.1.0

package/README.md

@@ -1,7 +1,171 @@
-# marketplace-sdk
+# @manifoldxyz/marketplace-sdk
 
-This package contains the core library for interacting with the Manifold marketplace.
+TypeScript SDK for interacting with Manifold's on-chain marketplace contracts. Provides typed classes for managing listings (auctions, fixed-price, dynamic-price, offers-only), bids, offers, purchases, and real-time event subscriptions — used by Manifold's marketplace widgets and studio apps.
 
-The marketplace-sdk relies on the Manifold's EthereumProvider (node connection management library)
+## Prerequisites
 
-Please see code-comments for a full description of methods.
+- **Node.js** >= 14
+- **Yarn** (package manager)
+- **ManifoldEthereumProvider** — must be available on `window.ManifoldEthereumProvider` at runtime (provided by Manifold's frontend infrastructure)
+
+## Setup
+
+```bash
+# Clone
+git clone git@github.com:manifoldxyz/marketplace-sdk.git
+cd marketplace-sdk
+
+# Install dependencies
+yarn install
+
+# Build
+yarn build
+
+# Run tests
+yarn test
+
+# Lint
+yarn lint
+yarn lint:fix
+
+# Format
+yarn format
+```
+
+## Installation (as dependency)
+
+```bash
+yarn add @manifoldxyz/marketplace-sdk
+# or
+npm install @manifoldxyz/marketplace-sdk
+```
+
+## Usage
+
+```typescript
+import { MarketplaceListing, MarketplaceTopic, ListingType } from '@manifoldxyz/marketplace-sdk';
+
+// Create a listing instance
+const listing = new MarketplaceListing(
+  marketplaceContractAddress,
+  networkId,
+  listingId,
+  2 // version (default: 2)
+);
+
+// Wait for listing data to resolve
+await listing.listingPromise;
+
+// Subscribe to events
+listing.subscribe(MarketplaceTopic.PURCHASE_EVENT_V2, (event) => {
+  console.log('Purchase event:', event);
+});
+
+// Clean up
+listing.unsubscribeAll();
+```
+
+## Available Scripts
+
+| Script | Command | Description |
+|--------|---------|-------------|
+| `build` | `yarn build` | Compiles TypeScript to `dist/` (cleans first) |
+| `test` | `yarn test` | Runs TypeScript compiler + Jest test suite |
+| `lint` | `yarn lint` | ESLint check |
+| `lint:fix` | `yarn lint:fix` | ESLint with auto-fix |
+| `format` | `yarn format` | Prettier + ESLint fix |
+
+## Architecture
+
+```
+src/
+├── index.ts                    # Package entry — re-exports all public types
+├── lib/
+│   ├── MarketplaceListing.ts   # Core class — listing lifecycle, event subscriptions,
+│   │                           #   bidding, purchasing, offers, identity verification
+│   └── Web3Protocol.ts         # Web3 call/write helpers with ManifoldBridgeProvider fallback
+├── classes/
+│   ├── Listing.ts              # Listing type hierarchy (Auction, FixedPrice, LazyFixed,
+│   │                           #   DynamicPrice, OffersOnly + base abstract classes)
+│   ├── ListingType.ts          # Enum: AUCTION, FIXED_PRICE, DYNAMIC_PRICE, OFFERS_ONLY
+│   ├── Bid.ts                  # Bid and BidHistory data classes
+│   ├── Offer.ts                # Offer and OfferHistory data classes
+│   ├── Purchase.ts             # Purchase data class
+│   └── Token.ts                # Token metadata class (address, media, attributes)
+├── abi/                        # Contract ABIs
+│   ├── MarketplaceContractABIv1.json
+│   ├── MarketplaceContractABIv2.json
+│   ├── IdentityVerifierABIv1.json
+│   ├── IdentityVerifierABIv2.json
+│   ├── IdentityVerifierViewABIv2.json
+│   └── LazyDeliveryABI.json
+└── ts-shims/
+    └── shims-manifold-window.d.ts  # Window type augmentation for ManifoldEthereumProvider
+```
+
+### Key Concepts
+
+- **MarketplaceListing** — Main entry point. Wraps a marketplace contract listing with methods for bidding, purchasing, making offers, fetching history, and subscribing to on-chain events. Supports contract versions 1 and 2.
+- **Web3Protocol** — Provides `callWeb3()` and `writeWeb3()` with automatic fallback to Manifold's bridge provider when the browser provider is unavailable or times out.
+- **Listing hierarchy** — Abstract `Listing` → `TokenListing` (concrete token) / `LazyTokenListing` (lazy-minted) → specific types (Auction, FixedPrice, etc.)
+- **MarketplaceTopic** — Event topic hashes for on-chain event subscriptions (purchases, bids, offers).
+
+### API Endpoints (hardcoded)
+
+| Network | Endpoint |
+|---------|----------|
+| Mainnet | `https://marketplace.api.manifoldxyz.dev` |
+| Optimism | `https://optimism.marketplace.api.manifoldxyz.dev` |
+| Base | `https://base.marketplace.api.manifoldxyz.dev` |
+| Sepolia | `https://sepolia.marketplace.api.manifoldxyz.dev` |
+| Shape | `https://shape.marketplace.api.manifoldxyz.dev` |
+| Apechain | `https://apechain.marketplace.api.manifoldxyz.dev` |
+| Campaign (Redeem) | `https://redeem.api.manifoldxyz.dev` |
+
+## Exported API
+
+| Export | Type | Description |
+|--------|------|-------------|
+| `MarketplaceListing` | Class | Core listing manager — lifecycle, events, transactions |
+| `MarketplaceTopic` | Enum | On-chain event topic hashes |
+| `Listing` | Abstract Class | Base listing type |
+| `ListingType` | Enum | `AUCTION`, `FIXED_PRICE`, `DYNAMIC_PRICE`, `OFFERS_ONLY` |
+| `Token` | Class | Token metadata container |
+| `Bid` / `BidHistory` | Class | Bid data types |
+| `Offer` / `OfferHistory` | Class | Offer data types |
+
+## External Dependencies
+
+### Internal Packages
+
+| Package | Version | Purpose |
+|---------|---------|---------|
+| `@manifoldxyz/js-ts-utils` | `^7.5.0` | Shared utilities (Media, Network types) |
+| `@manifoldxyz/contract-abis` | `^1.0.0` | ERC20, ERC721, ERC1155 ABIs |
+| `@manifoldxyz/ens-batch-lookup-ethers` | `^0.0.2` | Batch ENS name resolution |
+| `@manifoldxyz/frontend-provider-types` | `^2.1.0` | Provider event types (CHAIN_CHANGED) |
+| `@manifoldxyz/manifold-provider-client` | `^0.2.0` | ManifoldBridgeProvider for fallback web3 calls |
+| `@manifoldxyz/lint-configs` | `^0.1.0` | Shared ESLint/Prettier configs (dev) |
+
+### Internal Services
+
+| Service | Endpoint | Repo |
+|---------|----------|------|
+| Marketplace API | `marketplace.api.manifoldxyz.dev` | [marketplace-server](https://github.com/manifoldxyz/marketplace-server) |
+| Redeem API | `redeem.api.manifoldxyz.dev` | — |
+
+### Third-Party Libraries
+
+| Library | Purpose | Config |
+|---------|---------|--------|
+| `@ethersproject/*` | Ethereum contract interaction (BigNumber, units, ABI encoding) | — |
+| `merkletreejs` + `keccak256` | Merkle tree construction for allowlist verification | — |
+
+## Publishing
+
+This package is published as `@manifoldxyz/marketplace-sdk` to npm. The `files` field in `package.json` includes only `dist/` and `README.md`.
+
+```bash
+yarn build
+npm publish
+```

package/dist/classes/Token.d.ts

@@ -29,4 +29,18 @@ declare class Token implements IToken {
     burnt?: boolean | undefined;
     constructor(address: string, id: string, lazy: boolean, image_url: string, original_image_url: string | undefined, animation_url: string | undefined, original_animation_url: string | undefined, name: string, description: string, attributes: Array<object> | undefined, tokenData: JSON | undefined, originalURI: string, burnt?: boolean);
 }
+/**
+ * The marketplace API's cached, CDN-optimized media for a token
+ * (`GET /token/<address>/<id>/media`). A URL is usable only when its matching
+ * `*_status` is `'ok'`.
+ */
+interface TokenMedia {
+    image_status?: string;
+    image_url?: string;
+    original_image_url?: string;
+    animation_status?: string;
+    animation_url?: string;
+    original_animation_url?: string;
+}
+export type { TokenMedia };
 export default Token;

package/dist/index.d.ts

@@ -2,6 +2,6 @@ import { Bid, BidHistory } from './classes/Bid';
 import { Listing } from './classes/Listing';
 import ListingType from './classes/ListingType';
 import { Offer, OfferHistory } from './classes/Offer';
-import Token from './classes/Token';
+import Token, { TokenMedia } from './classes/Token';
 import { MarketplaceListing, MarketplaceTopic } from './lib/MarketplaceListing';
-export { MarketplaceTopic, MarketplaceListing, Listing, ListingType, Token, Bid, BidHistory, Offer, OfferHistory, };
+export { MarketplaceTopic, MarketplaceListing, Listing, ListingType, Token, TokenMedia, Bid, BidHistory, Offer, OfferHistory, };

package/dist/lib/MarketplaceListing.d.ts

@@ -7,7 +7,7 @@ import { Bid, BidHistory } from '../classes/Bid';
 import { Listing } from '../classes/Listing';
 import { OfferHistory } from '../classes/Offer';
 import { Purchase } from '../classes/Purchase';
-import Token from '../classes/Token';
+import Token, { TokenMedia } from '../classes/Token';
 declare enum MarketplaceTopic {
     PURCHASE_EVENT_V1 = "0xdc84c3c75a393011959e6391215e5b01982de6ad00f83b8b26ac7c52a5844b22",
     BID_EVENT_V1 = "0x68debf84f0c6c4d7f73019f874d0f4f4b4c6d895ebce90dc010abac51d74d60a",
@@ -174,9 +174,79 @@ declare class MarketplaceListing {
      */
     private _checkReferrer;
     /**
-     * Get token details for this listing
+     * Get token details for this listing: on-chain metadata with the cached,
+     * CDN-optimized media applied on top.
+     *
+     * Composed of the independent reads below, fetched in parallel. A caller
+     * that renders text and media separately should use those directly:
+     * `getCachedTokenMetadata()` (fast, from the marketplace API's index) then
+     * `getTokenMetadata()` (authoritative, from the chain) for text, and
+     * `getTokenMedia()` for the artwork. None of them waits for another.
      */
     getTokenDetails(): Promise<Token>;
+    /**
+     * The token's own metadata: name, description, attributes and the media URLs
+     * the metadata declares, read via tokenURI (`uri` for ERC1155, `assetURI` for
+     * lazy delivery). Does NOT wait for, or apply, the cached media -- see
+     * `getTokenMedia()` and `applyTokenMedia()`.
+     *
+     * Burnt tokens (tokenURI reverts) fall back to the marketplace API's cached
+     * copy, which already carries cached media URLs.
+     */
+    getTokenMetadata(): Promise<Token>;
+    /**
+     * The marketplace API's cached, CDN-optimized media for this listing's token
+     * (`/token/<address>/<id>/media`). Needs only the token address and id, so it
+     * does not wait for tokenURI or the metadata.
+     *
+     * Never rejects: resolves to `null` when the lookup fails or has no entry.
+     * Shares one request with `getCachedTokenMetadata()` (see
+     * `_fetchSharedCachedToken`).
+     */
+    getTokenMedia(): Promise<TokenMedia | null>;
+    /**
+     * The token's name, description and attributes as last indexed by the
+     * marketplace API (NFT proxy), WITHOUT reading the chain. Answers in ~0.1s;
+     * `getTokenMetadata()` needs a tokenURI RPC plus the metadata fetch, and on
+     * contracts that build metadata on-chain the RPC can take seconds or fail.
+     *
+     * For showing the token's text immediately. It is an index, not the source of
+     * truth: callers must replace it with `getTokenMetadata()` when that lands.
+     * Measured on 60 live mainnet listings: indexed for 39, and for all 39 the
+     * name and description equalled the chain's.
+     *
+     * Media URLs are the metadata's own, as in `getTokenMetadata()`; cached media
+     * comes from `getTokenMedia()`. Never rejects: `null` when the token is not
+     * indexed or the lookup fails.
+     */
+    getCachedTokenMetadata(): Promise<Token | null>;
+    /**
+     * The cached-token lookup WITH token details, shared by `getTokenMedia()`,
+     * `getCachedTokenMetadata()` and the burnt-token fallback in
+     * `getTokenMetadata()`: one `/media?withTokenDetails=true` request per load
+     * instead of up to three. The answer is reused for
+     * `CACHED_TOKEN_REUSE_MS` -- long enough to cover a slow or reverting tokenURI
+     * call on the same load (seconds), short enough that a later load re-reads
+     * the API. Never rejects; a failed lookup (`null`) is not reused.
+     *
+     * Costs ~17 KB more than the plain lookup on an average listing (8.8 KB ->
+     * 26.2 KB measured on 25 live mainnet listings), in exchange for the token's
+     * text ~3x sooner than the chain read (p50 0.08s vs 0.21s; seconds on
+     * contracts whose tokenURI RPC is slow).
+     */
+    private _fetchSharedCachedToken;
+    private static readonly CACHED_TOKEN_REUSE_MS;
+    private _cachedTokenRequest;
+    /** The token id the marketplace API indexes this listing's token under. */
+    private _tokenRef;
+    private static _isBurnAddress;
+    /**
+     * Apply cached media (`getTokenMedia()`) on top of a token's metadata
+     * (`getTokenMetadata()`). A cached URL wins only when its status is `ok`;
+     * otherwise the metadata's own URL is kept. Pure: returns a new Token and
+     * leaves both inputs untouched. `media === null` returns the token as is.
+     */
+    static applyTokenMedia(token: Token, media: TokenMedia | null): Token;
     /**
      * Fetch metadata with server fallback
      */

package/dist/lib/MarketplaceListing.js

@@ -1218,15 +1218,36 @@ class MarketplaceListing {
         });
     }
     /**
-     * Get token details for this listing
+     * Get token details for this listing: on-chain metadata with the cached,
+     * CDN-optimized media applied on top.
+     *
+     * Composed of the independent reads below, fetched in parallel. A caller
+     * that renders text and media separately should use those directly:
+     * `getCachedTokenMetadata()` (fast, from the marketplace API's index) then
+     * `getTokenMetadata()` (authoritative, from the chain) for text, and
+     * `getTokenMedia()` for the artwork. None of them waits for another.
      */
     getTokenDetails() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [token, media] = yield Promise.all([this.getTokenMetadata(), this.getTokenMedia()]);
+            return MarketplaceListing.applyTokenMedia(token, media);
+        });
+    }
+    /**
+     * The token's own metadata: name, description, attributes and the media URLs
+     * the metadata declares, read via tokenURI (`uri` for ERC1155, `assetURI` for
+     * lazy delivery). Does NOT wait for, or apply, the cached media -- see
+     * `getTokenMedia()` and `applyTokenMedia()`.
+     *
+     * Burnt tokens (tokenURI reverts) fall back to the marketplace API's cached
+     * copy, which already carries cached media URLs.
+     */
+    getTokenMetadata() {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j;
         return __awaiter(this, void 0, void 0, function* () {
             let tokenURI;
             let tokenSpec = '';
             let tokenId;
-            let tokenLazy = false;
             let contract;
             let bridgeContract;
             let contractFunctionName;
@@ -1253,7 +1274,6 @@ class MarketplaceListing {
                 // Lazy token
                 // @ts-expect-error TS2532: Object is possibly 'undefined'.
                 tokenId = this.listing.tokenLazyAssetId;
-                tokenLazy = true;
                 contract = this._getLazyDeliveryContract(false);
                 //@ts-expect-error TS2345: Argument of type 'Contract | undefined' is not assignable to type 'Contract'.
                 bridgeContract = this._getLazyDeliveryContract(false, true);
@@ -1265,8 +1285,9 @@ class MarketplaceListing {
                 tokenURI = yield (0, Web3Protocol_1.callWeb3)(contract, bridgeContract, contractFunctionName, [tokenId]);
             }
             catch (error) {
-                // Token might be burnt - try to get cached data from API, include token details to get name, description
-                const cachedData = yield this._fetchCachedTokenData(tokenId, tokenLazy, true);
+                // Token might be burnt - try to get cached data from API, include token details to get name, description.
+                // Reuses the cached request getTokenMedia()/getCachedTokenMetadata() already have in flight.
+                const cachedData = yield this._fetchSharedCachedToken();
                 if (cachedData) {
                     return new Token_1.default(
                     // @ts-expect-error TS2532: Object is possibly 'undefined'.
@@ -1336,23 +1357,148 @@ class MarketplaceListing {
                 throw error;
             }
             this._processTokenData(tokenData);
-            // Try to get cache optimized image
-            const cachedData = yield this._fetchCachedTokenData(tokenId, tokenLazy);
-            if (cachedData) {
-                if (cachedData.image_status == 'ok' && cachedData.image_url)
-                    tokenData.image = cachedData.image_url;
-                if (cachedData.image_status == 'ok' && cachedData.original_image_url)
-                    tokenData.original_image_url = cachedData.original_image_url;
-                if (cachedData.animation_status == 'ok' && cachedData.animation_url)
-                    tokenData.animation_url = cachedData.animation_url;
-                if (cachedData.animation_status == 'ok' && cachedData.original_animation_url)
-                    tokenData.original_animation_url = cachedData.original_animation_url;
-            }
             return new Token_1.default(
             // @ts-expect-error TS2532: Object is possibly 'undefined'.
             this.listing.tokenAddress, tokenId, tokenSpec == '', tokenData.image, tokenData.original_image_url, tokenData.animation_url, tokenData.original_animation_url, tokenData.name, tokenData.description, tokenData.attributes, tokenData, tokenURI);
         });
     }
+    /**
+     * The marketplace API's cached, CDN-optimized media for this listing's token
+     * (`/token/<address>/<id>/media`). Needs only the token address and id, so it
+     * does not wait for tokenURI or the metadata.
+     *
+     * Never rejects: resolves to `null` when the lookup fails or has no entry.
+     * Shares one request with `getCachedTokenMetadata()` (see
+     * `_fetchSharedCachedToken`).
+     */
+    getTokenMedia() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cached = yield this._fetchSharedCachedToken();
+            if (!cached)
+                return null;
+            return {
+                animation_status: cached.animation_status,
+                animation_url: cached.animation_url,
+                image_status: cached.image_status,
+                image_url: cached.image_url,
+                original_animation_url: cached.original_animation_url,
+                original_image_url: cached.original_image_url,
+            };
+        });
+    }
+    /**
+     * The token's name, description and attributes as last indexed by the
+     * marketplace API (NFT proxy), WITHOUT reading the chain. Answers in ~0.1s;
+     * `getTokenMetadata()` needs a tokenURI RPC plus the metadata fetch, and on
+     * contracts that build metadata on-chain the RPC can take seconds or fail.
+     *
+     * For showing the token's text immediately. It is an index, not the source of
+     * truth: callers must replace it with `getTokenMetadata()` when that lands.
+     * Measured on 60 live mainnet listings: indexed for 39, and for all 39 the
+     * name and description equalled the chain's.
+     *
+     * Media URLs are the metadata's own, as in `getTokenMetadata()`; cached media
+     * comes from `getTokenMedia()`. Never rejects: `null` when the token is not
+     * indexed or the lookup fails.
+     */
+    getCachedTokenMetadata() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const cached = yield this._fetchSharedCachedToken();
+            const details = cached === null || cached === void 0 ? void 0 : cached.tokenDetails;
+            if (!details)
+                return null;
+            try {
+                const { tokenId, lazy } = this._tokenRef();
+                const tokenData = Object.assign({}, (details.metadata || {}));
+                this._processTokenData(tokenData);
+                return new Token_1.default(
+                // @ts-expect-error TS2532: Object is possibly 'undefined'.
+                this.listing.tokenAddress, tokenId, lazy, tokenData.image, tokenData.original_image_url, tokenData.animation_url, tokenData.original_animation_url, (_a = tokenData.name) !== null && _a !== void 0 ? _a : details.name, tokenData.description, tokenData.attributes, tokenData, '', MarketplaceListing._isBurnAddress(details.ownerAddress));
+            }
+            catch (error) {
+                return null;
+            }
+        });
+    }
+    /**
+     * The cached-token lookup WITH token details, shared by `getTokenMedia()`,
+     * `getCachedTokenMetadata()` and the burnt-token fallback in
+     * `getTokenMetadata()`: one `/media?withTokenDetails=true` request per load
+     * instead of up to three. The answer is reused for
+     * `CACHED_TOKEN_REUSE_MS` -- long enough to cover a slow or reverting tokenURI
+     * call on the same load (seconds), short enough that a later load re-reads
+     * the API. Never rejects; a failed lookup (`null`) is not reused.
+     *
+     * Costs ~17 KB more than the plain lookup on an average listing (8.8 KB ->
+     * 26.2 KB measured on 25 live mainnet listings), in exchange for the token's
+     * text ~3x sooner than the chain read (p50 0.08s vs 0.21s; seconds on
+     * contracts whose tokenURI RPC is slow).
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    _fetchSharedCachedToken() {
+        const now = Date.now();
+        const shared = this._cachedTokenRequest;
+        if (shared && now - shared.startedAt < MarketplaceListing.CACHED_TOKEN_REUSE_MS) {
+            return shared.request;
+        }
+        const { tokenId, lazy } = this._tokenRef();
+        const request = this._fetchCachedTokenData(tokenId, lazy, true);
+        const entry = { request, startedAt: now };
+        this._cachedTokenRequest = entry;
+        request.then((result) => {
+            if (result == null && this._cachedTokenRequest === entry)
+                this._cachedTokenRequest = undefined;
+        });
+        return request;
+    }
+    /** The token id the marketplace API indexes this listing's token under. */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    _tokenRef() {
+        if (this.listing instanceof Listing_1.TokenListing)
+            return { lazy: false, tokenId: this.listing.tokenId };
+        // @ts-expect-error TS2532: Object is possibly 'undefined'.
+        return { lazy: true, tokenId: this.listing.tokenLazyAssetId };
+    }
+    static _isBurnAddress(address) {
+        const a = address === null || address === void 0 ? void 0 : address.toLowerCase();
+        return (a === '0x000000000000000000000000000000000000dead' ||
+            a === '0x0000000000000000000000000000000000000000');
+    }
+    /**
+     * Apply cached media (`getTokenMedia()`) on top of a token's metadata
+     * (`getTokenMetadata()`). A cached URL wins only when its status is `ok`;
+     * otherwise the metadata's own URL is kept. Pure: returns a new Token and
+     * leaves both inputs untouched. `media === null` returns the token as is.
+     */
+    static applyTokenMedia(token, media) {
+        if (!media)
+            return token;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const tokenData = token.tokenData ? Object.assign({}, token.tokenData) : token.tokenData;
+        let { image_url, original_image_url, animation_url, original_animation_url } = token;
+        if (media.image_status == 'ok' && media.image_url) {
+            image_url = media.image_url;
+            if (tokenData)
+                tokenData.image = media.image_url;
+        }
+        if (media.image_status == 'ok' && media.original_image_url) {
+            original_image_url = media.original_image_url;
+            if (tokenData)
+                tokenData.original_image_url = media.original_image_url;
+        }
+        if (media.animation_status == 'ok' && media.animation_url) {
+            animation_url = media.animation_url;
+            if (tokenData)
+                tokenData.animation_url = media.animation_url;
+        }
+        if (media.animation_status == 'ok' && media.original_animation_url) {
+            original_animation_url = media.original_animation_url;
+            if (tokenData)
+                tokenData.original_animation_url = media.original_animation_url;
+        }
+        return new Token_1.default(token.address, token.id, token.lazy, image_url, original_image_url, animation_url, original_animation_url, token.name, token.description, token.attributes, tokenData, token.originalURI, token.burnt);
+    }
     /**
      * Fetch metadata with server fallback
      */
@@ -1409,11 +1555,15 @@ class MarketplaceListing {
             try {
                 const apiResponse = yield fetch(`${this._getEndpoint()}/token/${(_a = this.listing) === null || _a === void 0 ? void 0 : _a.tokenAddress}/${tokenId}/media?${((_b = this.overrides) === null || _b === void 0 ? void 0 : _b.mediaOptimization) ? this.overrides.mediaOptimization : 'max_width=1280'}${tokenLazy ? '&lazy=true' : ''}${withTokenDetails ? '&withTokenDetails=true' : ''}`);
                 if (apiResponse.status === 200) {
-                    return apiResponse.json();
+                    // `return await`, not `return`: a bare return hands back the json()
+                    // promise un-awaited, so a malformed 200 body rejected PAST this catch.
+                    // getTokenDetails() starts this lookup in parallel and does not await it
+                    // on every path, so it must never reject.
+                    return yield apiResponse.json();
                 }
             }
             catch (error) {
-                // Return null if fetch fails
+                // Return null if fetch or body parsing fails
             }
             return null;
         });
@@ -1442,6 +1592,14 @@ class MarketplaceListing {
     _processTokenData(data) {
         if (data === null || data === void 0 ? void 0 : data.image) {
             data.image = this._cleanURI(data.image);
+            // Handle video files incorrectly placed in the image field
+            if (js_ts_utils_1.Media.isVideo.test(data.image) && !data.animation_url) {
+                // Move video from image to animation_url
+                data.animation_url = data.image;
+                data.original_animation_url = data.image;
+                // Clear image field or use a fallback
+                data.image = undefined;
+            }
         }
         if (data === null || data === void 0 ? void 0 : data.animation_url) {
             data.animation_url = this._cleanURI(data.animation_url);
@@ -1547,3 +1705,4 @@ MarketplaceListing._fetchWithTimeout = (url, options, timeout = 7000) => {
         new Promise((_, reject) => setTimeout(() => reject(new Error('timeout')), timeout)),
     ]);
 };
+MarketplaceListing.CACHED_TOKEN_REUSE_MS = 30000;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@manifoldxyz/marketplace-sdk",
-  "version": "4.0.2",
+  "version": "4.1.0",
   "typings": "dist/index.d.ts",
   "description": "",
   "main": "dist/index.js",
@@ -48,7 +48,7 @@
     "@manifoldxyz/js-ts-utils": "^7.5.0",
     "@ethersproject/units": "^5.7.0",
     "@manifoldxyz/contract-abis": "^1.0.0",
-    "@manifoldxyz/ens-batch-lookup-ethers": "^0.0.2",
+    "@manifoldxyz/ens-batch-lookup-ethers": "^0.1.1",
     "@manifoldxyz/frontend-provider-types": "^2.1.0",
     "@manifoldxyz/manifold-provider-client": "^0.2.0",
     "keccak256": "^1.0.6",