@feralfile/cli 2.6.0 → 2.8.0

package/dist/src/utilities/nft-indexer.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * NFT Indexer Client
  * This module provides functions to interact with NFT indexing services
@@ -48,8 +49,15 @@ const JOB_STATUS_QUERY = `
 /**
  * buildTokensListQuery builds the `tokens { items { ... } }` request body used by queryTokens.
  *
- * Selection uses only `display` and `media_assets`. The indexer merges metadata and enrichment
- * into `display`; the client does not repeat that merge by fetching raw metadata fields.
+ * Presentation comes only from `display` and `media_assets`. The indexer merges metadata and
+ * enrichment into `display`; the client does not repeat that merge by fetching raw metadata fields.
+ *
+ * `chain` and `standard` are selected because the row is the only place either fact is known.
+ * `detectTokenStandard` has an address and a chain name and nothing else, so it answers `erc721` for
+ * every EVM contract — which wrote `erc721` into playlists for every ERC-1155 token `find` reached by
+ * owner or by contract. The indexer stores what the token actually is (`erc721`, `erc1155`, `fa2`)
+ * beside its CAIP-2 `chain` (`eip155:1`, `tezos:mainnet`), so the row answers both questions and
+ * detection drops to a fallback. Do not remove these two fields from the selection.
  *
  * @param {Object} [params]
  * @param {Array<string>} [params.token_cids]
@@ -74,6 +82,8 @@ function buildTokensListQuery(params = {}) {
           token_number
           current_owner
           burned
+          chain
+          standard
           display {
             name
             description
@@ -106,10 +116,18 @@ function initializeIndexer(_config) {
     logger.debug('[NFT Indexer] Using endpoint:', GRAPHQL_ENDPOINT);
 }
 /**
- * Detect token standard based on chain and contract address
+ * detectTokenStandard guesses a token standard from a chain name and an address.
+ *
+ * This is the last-resort fallback, not the answer. It sees no token — only a
+ * chain name and an address format — so it cannot tell ERC-721 from ERC-1155
+ * and answers `erc721` for every EVM contract. It is still needed in two
+ * places: a lookup by coordinate has to build *some* CID before the indexer has
+ * been asked anything (see buildTokenCID), and a token row that arrived without
+ * a `standard` field has nothing better to offer.
  *
- * Determines the appropriate ERC/token standard for the given blockchain
- * and contract format.
+ * Prefer, in order: the indexer row's own `standard`, a caller's assertion, and
+ * only then this. On-chain detection is deliberately not attempted here — the
+ * indexer already stores the answer and selecting it costs nothing.
  *
  * @param {string} chain - Blockchain network
  * @param {string} contractAddress - Contract address
@@ -121,18 +139,34 @@ function detectTokenStandard(chain, contractAddress) {
     if (lowerChain === 'tezos' || contractAddress.startsWith('KT')) {
         return 'fa2';
     }
-    // Ethereum uses ERC721
-    // TODO: Enhance with on-chain detection for ERC1155 support
+    // Ethereum: erc721 is a guess, not a reading. Only the indexer row or a
+    // caller's assertion can distinguish an ERC-1155 token from an ERC-721 one.
     if (lowerChain === 'ethereum') {
         return 'erc721';
     }
     return 'other';
 }
 /**
- * Token standards the indexer keys CIDs on. An asserted standard outside this
- * set says nothing the CID can carry, so detection decides instead.
+ * Token standards the indexer keys CIDs on. A standard outside this set —
+ * asserted by a caller or arriving on a row — says nothing the CID can carry,
+ * so detection decides instead.
  */
 const CID_STANDARDS = new Set(['erc721', 'erc1155', 'fa2']);
+/**
+ * normalizeCidStandard returns a standard the CID format can carry, or ''.
+ *
+ * Both the indexer row and a caller's assertion are untrusted strings from
+ * outside this module ('ERC1155', ' fa2 ', 'ERC-1155', undefined). Anything not
+ * in CID_STANDARDS is treated as absent rather than passed through, so a
+ * misspelled standard never reaches a CID or a DP-1 `provenance.contract`.
+ *
+ * @param {unknown} value - Candidate standard
+ * @returns {string} Normalized standard, or '' when it is not one we can use
+ */
+function normalizeCidStandard(value) {
+    const normalized = typeof value === 'string' ? value.trim().toLowerCase() : '';
+    return CID_STANDARDS.has(normalized) ? normalized : '';
+}
 /**
  * resolveTokenStandard picks the standard a CID is built with.
  *
@@ -149,11 +183,77 @@ const CID_STANDARDS = new Set(['erc721', 'erc1155', 'fa2']);
  * @returns {string} Token standard for the CID
  */
 function resolveTokenStandard(chain, contractAddress, asserted) {
-    const normalized = typeof asserted === 'string' ? asserted.trim().toLowerCase() : '';
-    if (CID_STANDARDS.has(normalized)) {
-        return normalized;
+    return normalizeCidStandard(asserted) || detectTokenStandard(chain, contractAddress);
+}
+/**
+ * CAIP-2 namespaces mapped to the chain values DP-1 `provenance.contract` allows.
+ *
+ * The indexer names a token's chain in CAIP-2 (`eip155:1`, `tezos:mainnet`),
+ * which is authoritative: it comes from the row rather than from the caller's
+ * guess at which network an address belongs to. Namespaces outside this map
+ * have no DP-1 equivalent, so they fall back to the caller's chain name.
+ */
+const CAIP2_NAMESPACE_TO_DP1_CHAIN = {
+    eip155: 'evm',
+    tezos: 'tezos',
+    bitmark: 'bitmark',
+};
+/**
+ * dp1ChainFromCaip2 derives a DP-1 chain from a CAIP-2 chain id.
+ *
+ * @param {unknown} caip2Chain - CAIP-2 chain id from an indexer row, e.g. `eip155:1`
+ * @returns {string} DP-1 chain (`evm`, `tezos`, `bitmark`), or '' when unknown or absent
+ */
+function dp1ChainFromCaip2(caip2Chain) {
+    if (typeof caip2Chain !== 'string') {
+        return '';
     }
-    return detectTokenStandard(chain, contractAddress);
+    const namespace = caip2Chain.trim().toLowerCase().split(':')[0];
+    return CAIP2_NAMESPACE_TO_DP1_CHAIN[namespace] || '';
+}
+/**
+ * Client chain names mapped to the chain values DP-1 `provenance.contract` allows.
+ *
+ * This is for DP-1 provenance output, NOT for indexer queries: the indexer uses
+ * `eth`/`tez`/`bmk` while DP-1 uses `evm`/`tezos`/`bitmark`. It answers only for
+ * tokens that reached us without an indexer row — a caller-supplied coordinate.
+ */
+const CHAIN_NAME_TO_DP1_CHAIN = {
+    ethereum: 'evm',
+    polygon: 'evm',
+    arbitrum: 'evm',
+    optimism: 'evm',
+    base: 'evm',
+    zora: 'evm',
+    tezos: 'tezos', // DP1 spec uses 'tezos', not 'tez'
+    bitmark: 'bitmark', // DP1 spec uses 'bitmark', not 'bmk'
+};
+/**
+ * resolveDp1Chain picks the DP-1 chain for a token's `provenance.contract`.
+ *
+ * The row's CAIP-2 chain and the caller's chain name are not two guesses to try
+ * in turn — they are different claims, and the row's is the network the indexer
+ * recorded. So a token carrying a row chain is answered from that chain alone:
+ * a namespace with no DP-1 equivalent becomes `other`, never the caller's name.
+ * Falling through would be actively wrong, because the owner and contract paths
+ * label every non-KT address `ethereum` before mapping — a Solana row would
+ * inherit that label and be published as an EVM contract. `other` is a true
+ * statement about a chain DP-1 cannot name; `evm` is a false one.
+ *
+ * The name map answers only when the token has no row chain at all, which is a
+ * token assembled from a caller-supplied coordinate rather than an indexer row.
+ *
+ * @param {Object} token - Token in the internal standard format
+ * @param {string} [token.caip2Chain] - CAIP-2 chain from the indexer row, when it came from one
+ * @param {string} [token.chain] - Client chain name the caller inferred
+ * @returns {string} DP-1 chain (`evm`, `tezos`, `bitmark`, or `other`)
+ */
+function resolveDp1Chain(token) {
+    const rowChain = typeof token.caip2Chain === 'string' ? token.caip2Chain.trim() : '';
+    if (rowChain) {
+        return dp1ChainFromCaip2(rowChain) || 'other';
+    }
+    return CHAIN_NAME_TO_DP1_CHAIN[String(token.chain || '').toLowerCase()] || 'other';
 }
 /**
  * Build CAIP-2 token CID for indexer v2
@@ -348,9 +448,16 @@ function getBestMediaUrl(display = {}, mediaAssets = []) {
  * is null or partial, we only use what is present (for example `Token #${token_number}` for name);
  * we do not splice in raw `metadata` or enrichment because those are not selected from GraphQL.
  *
+ * The row's own `standard` and `chain` outrank both the asserted `standard` and the `chain`
+ * argument, because they are the token's identity as the indexer recorded it while the arguments are
+ * the caller's inference — `find` by owner or by contract only knows "the address starts with 0x, so
+ * ethereum". Precedence for the standard is row → asserted → detection; the CAIP-2 `chain` is kept
+ * beside the caller's chain name (not in place of it) as `caip2Chain`, because the name still selects
+ * the CID prefix and the detection fallback while the CAIP-2 value answers DP-1's chain enum.
+ *
  * @param {Object} indexerData - Token fields from indexer GraphQL
- * @param {string} chain - Blockchain network
- * @param {string} [standard] - Asserted token standard; detected when omitted
+ * @param {string} chain - Blockchain network the caller inferred
+ * @param {string} [standard] - Asserted token standard; used when the row carries none
  * @returns {Object} Standardized token data
  */
 function mapIndexerDataToStandardFormat(indexerData, chain, standard) {
@@ -366,11 +473,14 @@ function mapIndexerDataToStandardFormat(indexerData, chain, standard) {
     const artistName = extractArtistName(display.artists);
     const name = display.name || `Token #${indexerData.token_number}`;
     const description = display.description || '';
-    const resolvedStandard = resolveTokenStandard(chain, indexerData.contract_address, standard);
+    const resolvedStandard = normalizeCidStandard(indexerData.standard) ||
+        resolveTokenStandard(chain, indexerData.contract_address, standard);
+    const caip2Chain = typeof indexerData.chain === 'string' ? indexerData.chain : '';
     return {
         success: true,
         token: {
             chain,
+            caip2Chain,
             contractAddress: indexerData.contract_address,
             tokenId: indexerData.token_number,
             standard: resolvedStandard,
@@ -470,26 +580,13 @@ function convertToDP1Item(tokenData, duration) {
             error: `Source URL too long (${sourceUrl.length} chars, max 1024)`,
         };
     }
-    // Map chain name to DP1 format (according to DP1 spec)
-    // NOTE: This is for DP1 provenance output, NOT for indexer queries
-    // The indexer uses 'eth'/'tez'/'bmk', but DP1 spec uses 'evm'/'tezos'/'bitmark'
-    const chainMap = {
-        ethereum: 'evm',
-        polygon: 'evm',
-        arbitrum: 'evm',
-        optimism: 'evm',
-        base: 'evm',
-        zora: 'evm',
-        tezos: 'tezos', // DP1 spec uses 'tezos', not 'tez'
-        bitmark: 'bitmark', // DP1 spec uses 'bitmark', not 'bmk'
-    };
     // Build via dp1-js PlaylistItemBuilder so leaf blocks match DP-1 AJV schema.
     const itemBuilder = new PlaylistItemBuilder()
         .id(itemId)
         .source(sourceUrl)
         .license('open')
         .provenance(new ProvenanceBuilder().type('onChain').contract(new ContractBuilder()
-        .chain(chainMap[token.chain.toLowerCase()] || 'other')
+        .chain(resolveDp1Chain(token))
         .standard(token.standard || detectTokenStandard(token.chain, token.contractAddress))
         .address(token.contractAddress)
         .tokenId(String(token.tokenId))));

package/dist/src/utilities/playlist-builder.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Playlist Builder Utilities
  *

package/dist/src/utilities/playlist-cast.js

@@ -1,37 +1,4 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.castPlaylist = castPlaylist;
 /**
@@ -106,7 +73,7 @@ async function castPlaylist(playlist, options = {}) {
                 };
             }
         }
-        const { verifyPlaylist } = await Promise.resolve().then(() => __importStar(require('./playlist-verifier')));
+        const { verifyPlaylist } = await import('./playlist-verifier.js');
         const verifyResult = await verifyPlaylist(current);
         if (!verifyResult.valid) {
             return {