@visualizevalue/mint-app-base 0.1.127 → 0.2.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Visualize Value
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/components/Token/MintTimeline.client.vue

@@ -16,7 +16,7 @@
         :block="currentBlock"
       >
         <template #after>
-          <TokenMintTimelineItem v-if="backfillComplete">
+          <TokenMintTimelineItem>
             <Account :address="collection.owner" class="account" />
 
             <span class="amount">1<span>×</span></span>
@@ -34,17 +34,12 @@
       </TokenMintTimelineVirtualScroller>
       </template>
 
-      <div v-if="! backfillComplete" v-show="! loading" ref="loadMore" class="load-more">
-        <Button @click="backfill">{{ $t('token.load_more')}}</Button>
-      </div>
-
       <Loading v-if="loading || ! currentBlock" :txt="$t('token.loading_mint_history')" />
     </slot>
   </section>
 </template>
 
 <script setup>
-import { useElementVisibility } from '@vueuse/core'
 import { useBlockNumber } from '@wagmi/vue'
 
 const config = useRuntimeConfig()
@@ -58,7 +53,6 @@ const { token, collection } = defineProps({
 const state = useOnchainStore()
 
 const mints = computed(() => state.tokenMints(token.collection, token.tokenId))
-const backfillComplete = computed(() => token.mintsBackfilledUntilBlock <= token.mintedBlock)
 
 const sortBy = ref('recent')
 const sortedMints = computed(() => {
@@ -72,46 +66,17 @@ const sortedMints = computed(() => {
 })
 
 const loading = ref(true)
-const loadMore = ref()
-const loadMoreVisible = useElementVisibility(loadMore)
-const backfill = async () => {
-  loading.value = true
-
-  try {
-    await state.backfillTokenMints(token)
-
-    // If we're not fully backfilled and we have less than 20 mints loaded,
-    // continue backfilling events.
-    while (! backfillComplete.value && mints.value?.length < 20) {
-      await delay(250)
-      await state.backfillTokenMints(token)
-    }
-  } catch (e) {
-    console.error(`Issue during backfill`, e)
-  }
-
-  loading.value = false
-}
 
 onMounted(async () => {
   loading.value = true
   try {
-    console.info(`Attempting to load + backfill token mints for #${token.tokenId}`)
     await state.fetchTokenMints(token)
-    await backfill()
   } catch (e) {
     console.error(e)
   }
   loading.value = false
 })
 
-watch(loadMoreVisible, () => {
-  // Skip if we have enough mints for the viewport or we're already loading
-  if (! loadMoreVisible.value || loading.value) return
-
-  backfill()
-})
-
 watch(currentBlock, () => {
   if (loading.value) return
 
@@ -171,11 +136,4 @@ watch(currentBlock, () => {
   }
 }
 
-
-.load-more {
-  .button {
-    display: block;
-    width: 100%;
-  }
-}
 </style>

package/composables/collections.ts

@@ -1,23 +1,14 @@
 import { getBalance, getPublicClient, readContract } from '@wagmi/core'
-import { type GetBalanceReturnType } from '@wagmi/core'
-import { parseAbiItem, type PublicClient } from 'viem'
+import { type PublicClient } from 'viem'
 import type { MintEvent } from '~/utils/types'
+import { INDEXER_SYNCED } from '~/queries/sources'
 
-export const CURRENT_STATE_VERSION = 9
-export const MAX_BLOCK_RANGE = 1800n
+export const CURRENT_STATE_VERSION = 10
 export const MINT_BLOCKS = BLOCKS_PER_DAY
 export const MAX_RENDERERS = 20
 
-const inflightRequests = new Map<string, Promise<any>>()
-function dedupe<T>(key: string, fn: () => Promise<T>): Promise<T> {
-  if (!inflightRequests.has(key)) {
-    inflightRequests.set(key, fn().finally(() => inflightRequests.delete(key)))
-  }
-  return inflightRequests.get(key)!
-}
-
 export const useOnchainStore = () => {
-  const { $wagmi } = useNuxtApp()
+  const { $wagmi, $queryClient, $queries } = useNuxtApp()
   const appConfig = useAppConfig()
   const chainId = useMainChainId()
 
@@ -103,54 +94,17 @@ export const useOnchainStore = () => {
 
         if (!this.hasArtist(address)) this.initializeArtist(address)
 
-        await this.fetchArtistProfile(address)
-
-        await this.fetchCollections(address, factory)
+        await Promise.all([
+          this.fetchArtistProfile(address),
+          this.fetchCollections(address, factory),
+        ])
       },
 
       async fetchArtistProfile (address: `0x${string}`): Promise<Artist> {
-        const client = getPublicClient($wagmi, { chainId: 1 }) as PublicClient
-        const block = await client.getBlockNumber()
-
-        // Only update once per hour
-        if (
-          this.hasArtist(address) &&
-          this.artist(address).profileUpdatedAtBlock > 0n &&
-          (block - this.artist(address).profileUpdatedAtBlock) < BLOCKS_PER_CACHE
-        ) {
-          console.info(`Artist profile already fetched...`)
-          return this.artist(address)
-        }
-
-        console.info(`Updating artist profile...`)
-
-        let ens, avatar, description,
-          url, email, twitter, github
-
-        try {
-          ens = await client.getEnsName({ address })
-
-          if (ens) {
-            [avatar, description, url, email, twitter, github] = await Promise.all([
-              client.getEnsAvatar({ name: ens }),
-              client.getEnsText({ name: ens, key: 'description' }),
-              client.getEnsText({ name: ens, key: 'url' }),
-              client.getEnsText({ name: ens, key: 'email' }),
-              client.getEnsText({ name: ens, key: 'com.twitter' }),
-              client.getEnsText({ name: ens, key: 'com.github' }),
-            ])
-          }
-        } catch (e) { }
-
-        this.artists[address].ens = ens
-        this.artists[address].avatar = avatar
-        this.artists[address].description = description
-        this.artists[address].url = url
-        this.artists[address].email = email
-        this.artists[address].twitter = twitter
-        this.artists[address].github = github
-        this.artists[address].profileUpdatedAtBlock = block
+        if (!this.hasArtist(address)) this.initializeArtist(address)
 
+        const profile = await $queryClient.fetch($queries.artistProfile, address)
+        Object.assign(this.artists[address], profile)
         return this.artist(address)
       },
 
@@ -158,95 +112,43 @@ export const useOnchainStore = () => {
         artist: `0x${string}`,
         factory: `0x${string}`
       ) {
-        const collectionAddresses: `0x${string}`[] = (await readContract($wagmi, {
-          abi: FACTORY_ABI,
-          address: factory,
-          functionName: 'getCreatorCollections',
-          args: [artist],
-          chainId,
-        })).map((a: `0x${string}`) => a.toLowerCase() as `0x${string}`)
-           .filter((a: `0x${string}`) => !this.artists[artist].collections.includes(a))
+        const collections = await $queryClient.fetch($queries.artistCollections, artist)
+        const newCollections = collections.filter(c => !this.hasCollection(c.address))
+        await Promise.all(newCollections.map(c => this.addCollection(c)))
 
-        try {
-          await Promise.all(collectionAddresses.map(address => this.fetchCollection(address)))
-
-          this.artists[artist].collections = Array.from(new Set([...this.artists[artist].collections, ...collectionAddresses]))
-        } catch (e) {
-          console.error(e)
-        }
+        this.artists[artist].collections = Array.from(new Set([
+          ...this.artists[artist].collections,
+          ...collections.map(c => c.address),
+        ]))
       },
 
       async fetchCollection (address: `0x${string}`): Promise<Collection> {
-        return dedupe(`collection:${address}`, () => this._fetchCollection(address))
-      },
-
-      async _fetchCollection (address: `0x${string}`): Promise<Collection> {
         this.ensureStoreVersion()
 
-        if (this.hasCollection(address) && this.collection(address).latestTokenId > 0n) {
-          return this.collection(address)
-        }
+        const fresh = await $queryClient.fetch($queries.collection, address)
 
-        const [data, version, initBlock, latestTokenId, owner, balance] = await Promise.all([
-          readContract($wagmi, {
-            abi: MINT_ABI,
-            address,
-            functionName: 'contractURI',
-            chainId,
-          }) as Promise<string>,
-          readContract($wagmi, {
-            abi: MINT_ABI,
-            address,
-            functionName: 'version',
-            chainId,
-          }) as Promise<bigint>,
-          readContract($wagmi, {
-            abi: MINT_ABI,
-            address,
-            functionName: 'initBlock',
-            chainId,
-          }) as Promise<bigint>,
-          readContract($wagmi, {
-            abi: MINT_ABI,
-            address,
-            functionName: 'latestTokenId',
-            chainId,
-          }) as Promise<bigint>,
-          readContract($wagmi, {
-            abi: MINT_ABI,
-            address,
-            functionName: 'owner',
-            chainId,
-          }) as Promise<`0x${string}`>,
-          getBalance($wagmi, {
-            address,
-          }) as Promise<GetBalanceReturnType>,
-        ])
+        if (this.hasCollection(address)) {
+          const existing = this.collections[address]
+          const hadNewTokens = fresh.latestTokenId > existing.latestTokenId
 
-        const artist = owner.toLowerCase() as `0x${string}`
-        const json = Buffer.from(data.substring(29), `base64`).toString()
+          // Update metadata without wiping tokens/renderers
+          existing.owner = fresh.owner
+          existing.name = fresh.name
+          existing.symbol = fresh.symbol
+          existing.description = fresh.description
+          existing.image = fresh.image
+          existing.latestTokenId = fresh.latestTokenId
+          existing.initBlock = fresh.initBlock
 
-        try {
-          const metadata = JSON.parse(json)
+          // Force token re-fetch when new tokens exist
+          if (hadNewTokens) {
+            await $queryClient.invalidate($queries.collectionTokens, address)
+          }
 
-          return await this.addCollection({
-            image: metadata.image,
-            name: metadata.name,
-            symbol: metadata.symbol,
-            version,
-            description: metadata.description,
-            address,
-            initBlock,
-            latestTokenId,
-            owner: artist,
-            tokens: {},
-            balance: balance.value,
-            renderers: [],
-          })
-        } catch (e) {
-          console.warn(`Error parsing collection`, e)
-          this.artists[artist].collections = this.artists[artist].collections.filter(c => c !== address)
+          return existing
         }
+
+        return await this.addCollection(fresh)
       },
 
       async fetchCollectionBalance (address: `0x${string}`) {
@@ -271,11 +173,11 @@ export const useOnchainStore = () => {
             const rendererArgs = { abi: RENDERER_ABI, address: rendererAddress, chainId }
 
             const [name, version] = await Promise.all([
-              await readContract($wagmi, {
+              readContract($wagmi, {
                 ...rendererArgs,
                 functionName: 'name',
               }),
-              await readContract($wagmi, {
+              readContract($wagmi, {
                 ...rendererArgs,
                 functionName: 'version',
               }),
@@ -298,43 +200,25 @@ export const useOnchainStore = () => {
       },
 
       async fetchCollectionTokens (address: `0x${string}`): Promise<Token[]> {
-        this.collections[address].latestTokenId = await readContract($wagmi, {
-          abi: MINT_ABI,
-          address,
-          functionName: 'latestTokenId',
-          chainId,
-        }) as Promise<bigint>
-
-        const collection = this.collection(address)
-
-        const existingTokenIds = new Set(Object.keys(collection.tokens).map(id => BigInt(id)))
+        const tokens = await $queryClient.fetch($queries.collectionTokens, address)
 
-        // If we have all tokens we don't need to do anything
-        if (BigInt(existingTokenIds.size) === collection.latestTokenId) return this.tokens(address)
-
-        // Collect missing token IDs
-        const missingIds: bigint[] = []
-        let id = collection.latestTokenId
-        while (id > 0n) {
-          if (!existingTokenIds.has(id)) {
-            missingIds.push(id)
+        for (const token of tokens) {
+          if (!this.collections[address].tokens[`${token.tokenId}`]) {
+            this.collections[address].tokens[`${token.tokenId}`] = token
           }
-          id--
         }
 
-        // Fetch in parallel chunks of 5
-        for (const chunk of chunkArray(missingIds, 5)) {
-          await Promise.all(chunk.map(tokenId => this.fetchToken(address, tokenId)))
+        if (tokens.length > 0) {
+          const maxId = tokens.reduce((max, t) => t.tokenId > max ? t.tokenId : max, 0n)
+          if (maxId > this.collections[address].latestTokenId) {
+            this.collections[address].latestTokenId = maxId
+          }
         }
 
         return this.tokens(address)
       },
 
       async fetchToken (address: `0x${string}`, id: number | string | bigint, tries: number = 0): Promise<void> {
-        return dedupe(`token:${address}:${id}`, () => this._fetchToken(address, id, tries))
-      },
-
-      async _fetchToken (address: `0x${string}`, id: number | string | bigint, tries: number = 0): Promise<void> {
         const client = getPublicClient($wagmi, { chainId }) as PublicClient
         const mintContract = getContract({
           address,
@@ -342,16 +226,13 @@ export const useOnchainStore = () => {
           client,
         })
 
-        if (this.collection(address).tokens[`${id}`]) {
-          console.info(`Token cached #${id}`)
+        if (this.collection(address)?.tokens[`${id}`]) {
           return
         }
 
-        // Normalize token ID
         const tokenId = BigInt(id)
 
         try {
-          console.info(`Fetching token #${tokenId}`)
           const currentBlock = await client.getBlock()
 
           const [data, dataUri] = await Promise.all([
@@ -369,12 +250,7 @@ export const useOnchainStore = () => {
             const json = Buffer.from(dataUri.substring(29), `base64`).toString()
             metadata = JSON.parse(json)
           } catch (e) {
-            metadata = {
-              name: '',
-              description: '',
-              image: '',
-              animationUrl: '',
-            }
+            metadata = { name: '', description: '', image: '', animationUrl: '' }
             console.warn(`Parsing data uri failed`, e)
           }
 
@@ -385,10 +261,8 @@ export const useOnchainStore = () => {
             description: metadata.description,
             image: metadata.image,
             animationUrl: metadata.animation_url,
-
-            mintedBlock: BigInt(`${mintedBlock}`), // Force bigint
+            mintedBlock: BigInt(`${mintedBlock}`),
             closeAt,
-
             mintsBackfilledUntilBlock: 0n,
             mintsFetchedUntilBlock: 0n,
             mints: []
@@ -396,17 +270,12 @@ export const useOnchainStore = () => {
 
           this.collections[address].tokens[`${token.tokenId}`] = token
 
-          // Update latestTokenId if this token is newer than what's cached
           if (tokenId > this.collections[address].latestTokenId) {
             this.collections[address].latestTokenId = tokenId
           }
         } catch (e) {
-          // Retry 3 times
           if (tries < 3) {
-            console.info(`Retrying fetching data ${tries + 1}`)
-            return await this._fetchToken(address, id, tries + 1)
-          } else {
-            // TODO: Handle impossible to load token
+            return await this.fetchToken(address, id, tries + 1)
           }
         }
       },
@@ -439,91 +308,13 @@ export const useOnchainStore = () => {
 
       async fetchTokenMints (token: Token) {
         const storedToken = this.collections[token.collection].tokens[token.tokenId.toString()]
-        const client = getPublicClient($wagmi, { chainId }) as PublicClient
-        const currentBlock = await client.getBlockNumber()
-        const untilBlock = token.mintedBlock + BLOCKS_PER_DAY
-
-        // We want to sync until now, or when the mint closed
-        const toBlock = currentBlock > untilBlock ? untilBlock : currentBlock
-
-        if (token.mintsFetchedUntilBlock >= toBlock) {
-          return console.info(`mints for #${token.tokenId} already fetched`)
-        }
-
-        // Initially, we want to sync backwards,
-        // but at most 5000 blocks (the general max range for an event query)
-        const maxRangeBlock = toBlock - MAX_BLOCK_RANGE
-        const fromBlock = token.mintsFetchedUntilBlock > maxRangeBlock // If we've already fetched
-          ? token.mintsFetchedUntilBlock + 1n // we want to continue where we left off
-          : maxRangeBlock > token.mintedBlock // Otherwise we'll go back as far as possible
-            ? maxRangeBlock // (to our max range)
-            : token.mintedBlock // (or all the way to when the token minted)
-
-        // Load mints in range
-        this.addTokenMints(token, await this.loadMintEvents(token, fromBlock, toBlock))
-
-        // Set sync status
-        storedToken.mintsFetchedUntilBlock = toBlock
-
-        // If this is our first fetch, mark until when we have backfilled
-        if (! token.mintsBackfilledUntilBlock) {
-          storedToken.mintsBackfilledUntilBlock = fromBlock
-        }
+        storedToken.mints = await $queryClient.fetch($queries.tokenMints, token.collection as `0x${string}`, token.tokenId)
+        storedToken.mintsFetchedUntilBlock = INDEXER_SYNCED
+        storedToken.mintsBackfilledUntilBlock = 0n
       },
 
-      async backfillTokenMints (token: Token) {
-        const storedToken = this.collections[token.collection].tokens[token.tokenId.toString()]
-
-        // If we've backfilled all the way;
-        if (storedToken.mintsBackfilledUntilBlock <= token.mintedBlock) return
-
-        // We want to fetch the tokens up until where we stopped backfilling (excluding the last block)
-        const toBlock = storedToken.mintsBackfilledUntilBlock - 1n
-
-        // We want to fetch until our max range (5000), or until when the token minted
-        const fromBlock = toBlock - MAX_BLOCK_RANGE > token.mintedBlock ? toBlock - MAX_BLOCK_RANGE : token.mintedBlock
-        console.info(`Backfilling token mints blocks ${fromBlock}-${toBlock}`)
-
-        // Finally, we update our database
-        this.addTokenMints(token, await this.loadMintEvents(token, fromBlock, toBlock), 'append')
-
-        // And save until when we have backfilled our tokens.
-        storedToken.mintsBackfilledUntilBlock = fromBlock
-      },
-
-      async loadMintEvents (token: Token, fromBlock: bigint, toBlock: bigint): Promise<MintEvent[]> {
-        const client = getPublicClient($wagmi, { chainId }) as PublicClient
-
-        const logs = await client.getLogs({
-          address: token.collection,
-          event: parseAbiItem('event NewMint(uint256 indexed tokenId, uint256 unitPrice, uint256 amount, address minter)'),
-          args: {
-            tokenId: BigInt(token.tokenId),
-          },
-          fromBlock,
-          toBlock,
-        })
-
-        console.info(`Token mints fetched from ${fromBlock}-${toBlock}`)
-
-        return logs.map(l => ({
-          tokenId: token.tokenId,
-          address: l.args.minter,
-          block: l.blockNumber,
-          logIndex: l.logIndex,
-          tx: l.transactionHash,
-          unitPrice: l.args.unitPrice,
-          amount: l.args.amount,
-          price: ( l.args.amount || 0n ) * ( l.args.unitPrice || 0n ),
-        }) as MintEvent).reverse()
-      },
-
-      addTokenMints (token: Token, mints: MintEvent[], location: 'prepend'|'append' = 'prepend') {
-        const storedToken = this.collections[token.collection].tokens[token.tokenId.toString()]
-
-        storedToken.mints = location === 'prepend'
-          ? [ ...mints, ...storedToken.mints ]
-          : [ ...storedToken.mints, ...mints ]
+      async backfillTokenMints (_token: Token) {
+        // Both indexer and RPC sources return all mints — nothing to backfill
       },
 
       async addCollection (collection: Collection) {

package/nuxt.config.ts

@@ -27,6 +27,7 @@ export default defineNuxtConfig({
       mintAmount: 1,
       mintValue: 0,
       title: 'Mint',
+      indexerEndpoints: '',
       walletConnectProjectId: '',
     },
   },

package/package.json

@@ -1,9 +1,37 @@
 {
   "name": "@visualizevalue/mint-app-base",
-  "version": "0.1.127",
+  "version": "0.2.1",
+  "license": "MIT",
   "type": "module",
   "main": "./nuxt.config.ts",
+  "files": [
+    "app",
+    "assets",
+    "components",
+    "composables",
+    "i18n.config.ts",
+    "index.d.ts",
+    "layouts",
+    "locales",
+    "middleware",
+    "pages",
+    "plugins",
+    "public",
+    "queries",
+    "server",
+    "utils",
+    "app.config.ts",
+    "app.vue",
+    "error.vue",
+    "nuxt.config.ts",
+    "tsconfig.json"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
   "dependencies": {
+    "@1001-digital/dapp-query-core": "^1.1.0",
+    "@1001-digital/dapp-query-vue": "^1.1.0",
     "@csstools/postcss-global-data": "^2.1.1",
     "@nuxtjs/i18n": "^9.5.2",
     "@pinia-plugin-persistedstate/nuxt": "^1.2.1",

package/plugins/3.dapp-query.client.ts

@@ -0,0 +1,40 @@
+import { createQueryClient } from '@1001-digital/dapp-query-core'
+import { idbCache } from '@1001-digital/dapp-query-core'
+import { dappQueryPlugin } from '@1001-digital/dapp-query-vue'
+import { createQueries, type MintQueries } from '~/queries'
+import type { QueryClient } from '@1001-digital/dapp-query-core'
+
+export default defineNuxtPlugin((nuxtApp) => {
+  const queryClient = createQueryClient({
+    cache: idbCache('mint-query'),
+    defaultStaleTime: 60_000,
+  })
+
+  const config = nuxtApp.$config.public
+  const endpoints = config.indexerEndpoints
+    ? String(config.indexerEndpoints).split(/\s+/).filter(Boolean)
+    : []
+
+  const queries = createQueries({
+    wagmi: nuxtApp.$wagmi as any,
+    chainId: Number(config.chainId),
+    factory: config.factoryAddress as `0x${string}`,
+    endpoints,
+  })
+
+  nuxtApp.vueApp.use(dappQueryPlugin, queryClient)
+
+  return {
+    provide: {
+      queryClient,
+      queries,
+    },
+  }
+})
+
+declare module '#app' {
+  interface NuxtApp {
+    $queryClient: QueryClient
+    $queries: MintQueries
+  }
+}

package/queries/index.ts

@@ -0,0 +1,144 @@
+import { graphqlSource, customSource } from '@1001-digital/dapp-query-core'
+import type { QueryDefinition } from '@1001-digital/dapp-query-core'
+import type { Config } from '@wagmi/core'
+import type { Collection, Token, MintEvent } from '~/utils/types'
+import {
+  COLLECTIONS_BY_ARTIST, COLLECTION_BY_ADDRESS,
+  ARTIFACTS_BY_COLLECTION, MINTS_BY_ARTIFACT,
+  transformCollections, transformCollection,
+  transformArtifacts, transformMints, transformProfile,
+  rpcFetchProfile, rpcFetchCollections,
+  rpcFetchCollection, rpcFetchCollectionTokens,
+  rpcFetchTokenMints,
+} from './sources'
+
+export interface MintQueries {
+  artistProfile: QueryDefinition<Partial<Artist>, [`0x${string}`]>
+  artistCollections: QueryDefinition<Collection[], [`0x${string}`]>
+  collection: QueryDefinition<Collection, [`0x${string}`]>
+  collectionTokens: QueryDefinition<Token[], [`0x${string}`]>
+  tokenMints: QueryDefinition<MintEvent[], [`0x${string}`, bigint]>
+}
+
+interface CreateQueriesConfig {
+  wagmi: Config
+  chainId: number
+  factory: `0x${string}`
+  endpoints: string[]
+}
+
+export function createQueries (config: CreateQueriesConfig): MintQueries {
+  const { wagmi, chainId, factory, endpoints } = config
+  const hasIndexer = endpoints.length > 0
+
+  const indexerProfileSource = hasIndexer
+    ? customSource<Partial<Artist>>({
+        id: 'profile-indexer',
+        fetch: async (address: unknown) => {
+          // Multi-endpoint REST failover
+          let lastError: Error | undefined
+          for (const endpoint of endpoints) {
+            try {
+              const base = endpoint.replace(/\/$/, '')
+              const res = await fetch(`${base}/profiles/${address}`)
+              if (!res.ok) throw new Error(`HTTP ${res.status}`)
+              return transformProfile(await res.json())
+            } catch (e) {
+              lastError = e instanceof Error ? e : new Error(String(e))
+            }
+          }
+          throw lastError ?? new Error('All indexer endpoints failed')
+        },
+      })
+    : null
+
+  return {
+    artistProfile: {
+      key: (address) => `profile:${address}`,
+      staleTime: 30 * 60 * 1000, // 30 min
+      sources: [
+        ...(indexerProfileSource ? [indexerProfileSource] : []),
+        customSource<Partial<Artist>>({
+          id: 'profile-rpc',
+          fetch: (address: unknown) => rpcFetchProfile(wagmi, address as `0x${string}`),
+        }),
+      ],
+    },
+
+    artistCollections: {
+      key: (artist) => `collections:${artist}`,
+      staleTime: 5 * 60 * 1000,
+      sources: [
+        ...(hasIndexer ? [graphqlSource<Collection[]>({
+          endpoints,
+          query: COLLECTIONS_BY_ARTIST,
+          variables: (artist: unknown) => ({ artist: (artist as string).toLowerCase() }),
+          transform: transformCollections,
+        })] : []),
+        customSource<Collection[]>({
+          id: 'collections-rpc',
+          fetch: (artist: unknown) => rpcFetchCollections(wagmi, chainId, artist as `0x${string}`, factory),
+        }),
+      ],
+    },
+
+    collection: {
+      key: (address) => `collection:${address}`,
+      staleTime: 5 * 60 * 1000,
+      sources: [
+        ...(hasIndexer ? [graphqlSource<Collection>({
+          endpoints,
+          query: COLLECTION_BY_ADDRESS,
+          variables: (address: unknown) => ({ address: (address as string).toLowerCase() }),
+          transform: transformCollection,
+        })] : []),
+        customSource<Collection>({
+          id: 'collection-rpc',
+          fetch: async (address: unknown) => {
+            const collection = await rpcFetchCollection(wagmi, chainId, address as `0x${string}`)
+            if (!collection) throw new Error('Collection not found via RPC')
+            return collection
+          },
+        }),
+      ],
+    },
+
+    collectionTokens: {
+      key: (collection) => `tokens:${collection}`,
+      staleTime: 5 * 60 * 1000,
+      sources: [
+        ...(hasIndexer ? [graphqlSource<Token[]>({
+          endpoints,
+          query: ARTIFACTS_BY_COLLECTION,
+          variables: (collection: unknown) => ({ collection: (collection as string).toLowerCase() }),
+          transform: transformArtifacts,
+        })] : []),
+        customSource<Token[]>({
+          id: 'tokens-rpc',
+          fetch: (collection: unknown) => rpcFetchCollectionTokens(wagmi, chainId, collection as `0x${string}`),
+        }),
+      ],
+    },
+
+    tokenMints: {
+      key: (collection, tokenId) => `mints:${collection}:${tokenId}`,
+      staleTime: 60 * 1000, // 1 min — mints change frequently during live mint
+      sources: [
+        ...(hasIndexer ? [graphqlSource<MintEvent[]>({
+          endpoints,
+          query: MINTS_BY_ARTIFACT,
+          variables: (collection: unknown, tokenId: unknown) => ({
+            collection: (collection as string).toLowerCase(),
+            artifact: String(tokenId),
+          }),
+          transform: transformMints,
+        })] : []),
+        customSource<MintEvent[]>({
+          id: 'mints-rpc',
+          fetch: (collection: unknown, tokenId: unknown) =>
+            rpcFetchTokenMints(wagmi, chainId, collection as `0x${string}`, BigInt(tokenId as string | bigint)),
+        }),
+      ],
+    },
+  }
+}

package/queries/sources.ts

@@ -0,0 +1,419 @@
+import { getBalance, getPublicClient, readContract } from '@wagmi/core'
+import { type GetBalanceReturnType } from '@wagmi/core'
+import { parseAbiItem, type PublicClient } from 'viem'
+import type { Config } from '@wagmi/core'
+import type { Collection, Token, MintEvent } from '~/utils/types'
+import { BLOCKS_PER_DAY } from '@visualizevalue/mint-utils/time'
+
+// Sentinel: marks data as fully synced from the indexer.
+export const INDEXER_SYNCED = BigInt(Number.MAX_SAFE_INTEGER)
+
+// Ponder response types (bigints come as strings from GraphQL)
+
+interface PonderCollection {
+  address: string
+  artist: { address: string }
+  owner: string
+  image: string
+  name: string
+  symbol: string
+  description: string
+  init_block: string
+  latest_token_id: string
+}
+
+interface PonderArtifact {
+  collection: { address: string }
+  id: string
+  name: string
+  description: string
+  image: string
+  animation_url: string
+  created_block: string
+}
+
+interface PonderMint {
+  artifact: { id: string }
+  hash: string
+  block_number: string
+  log_index: number
+  amount: string
+  unit_price: string
+  price: string
+  account: string
+}
+
+interface PonderProfile {
+  ens: string | null
+  data: {
+    avatar: string
+    description: string
+    links: {
+      url: string
+      email: string
+      twitter: string
+      github: string
+    }
+  }
+}
+
+
+export const COLLECTIONS_BY_ARTIST = `
+  query($artist: String!) {
+    collections(
+      where: { artist: $artist }
+      orderBy: "init_block"
+      orderDirection: "desc"
+      limit: 1000
+    ) {
+      items {
+        address artist { address } owner image name symbol description
+        init_block latest_token_id
+      }
+    }
+  }
+`
+
+export const COLLECTION_BY_ADDRESS = `
+  query($address: String!) {
+    collection(address: $address) {
+      address artist { address } owner image name symbol description
+      init_block latest_token_id
+    }
+  }
+`
+
+export const ARTIFACTS_BY_COLLECTION = `
+  query($collection: String!) {
+    artifacts(
+      where: { collection: $collection }
+      orderBy: "id"
+      orderDirection: "desc"
+      limit: 1000
+    ) {
+      items {
+        collection { address } id name description image animation_url created_block
+      }
+    }
+  }
+`
+
+export const MINTS_BY_ARTIFACT = `
+  query($collection: String!, $artifact: BigInt!) {
+    mints(
+      where: { collection: $collection, artifact: $artifact }
+      orderBy: "block_number"
+      orderDirection: "desc"
+      limit: 1000
+    ) {
+      items {
+        artifact { id } hash block_number log_index
+        amount unit_price price account
+      }
+    }
+  }
+`
+
+
+export function transformCollections (data: { collections: { items: PonderCollection[] } }): Collection[] {
+  return data.collections.items.map(toCollection)
+}
+
+export function transformCollection (data: { collection: PonderCollection | null }): Collection {
+  if (!data.collection) throw new Error('Collection not found in indexer')
+  return toCollection(data.collection)
+}
+
+export function transformArtifacts (data: { artifacts: { items: PonderArtifact[] } }): Token[] {
+  return data.artifacts.items.map(toToken)
+}
+
+export function transformMints (data: { mints: { items: PonderMint[] } }): MintEvent[] {
+  return data.mints.items.map(toMintEvent)
+}
+
+
+export function transformProfile (raw: PonderProfile): Partial<Artist> {
+  return {
+    ens: raw.ens || '',
+    avatar: raw.data?.avatar || '',
+    description: raw.data?.description || '',
+    url: raw.data?.links?.url || '',
+    email: raw.data?.links?.email || '',
+    twitter: raw.data?.links?.twitter || '',
+    github: raw.data?.links?.github || '',
+    profileUpdatedAtBlock: INDEXER_SYNCED,
+  }
+}
+
+
+export async function rpcFetchProfile (
+  wagmi: Config,
+  address: `0x${string}`,
+): Promise<Partial<Artist>> {
+  const client = getPublicClient(wagmi, { chainId: 1 })
+  if (!client) return {}
+
+  const block = await client.getBlockNumber()
+
+  let ens, avatar, description, url, email, twitter, github
+
+  try {
+    ens = await client.getEnsName({ address })
+    if (ens) {
+      [avatar, description, url, email, twitter, github] = await Promise.all([
+        client.getEnsAvatar({ name: ens }),
+        client.getEnsText({ name: ens, key: 'description' }),
+        client.getEnsText({ name: ens, key: 'url' }),
+        client.getEnsText({ name: ens, key: 'email' }),
+        client.getEnsText({ name: ens, key: 'com.twitter' }),
+        client.getEnsText({ name: ens, key: 'com.github' }),
+      ])
+    }
+  } catch (e) { }
+
+  return { ens, avatar, description, url, email, twitter, github, profileUpdatedAtBlock: block }
+}
+
+export async function rpcFetchCollections (
+  wagmi: Config,
+  chainId: number,
+  artist: `0x${string}`,
+  factory: `0x${string}`,
+): Promise<Collection[]> {
+  const addresses: `0x${string}`[] = (await readContract(wagmi, {
+    abi: FACTORY_ABI,
+    address: factory,
+    functionName: 'getCreatorCollections',
+    args: [artist],
+    chainId,
+  })).map((a: `0x${string}`) => a.toLowerCase() as `0x${string}`)
+
+  const collections = await Promise.all(addresses.map(a => rpcFetchCollection(wagmi, chainId, a)))
+  return collections.filter((c): c is Collection => c !== null)
+}
+
+export async function rpcFetchCollection (
+  wagmi: Config,
+  chainId: number,
+  address: `0x${string}`,
+): Promise<Collection | null> {
+  try {
+    const [data, version, initBlock, latestTokenId, owner, balance] = await Promise.all([
+      readContract(wagmi, { abi: MINT_ABI, address, functionName: 'contractURI', chainId }) as Promise<string>,
+      readContract(wagmi, { abi: MINT_ABI, address, functionName: 'version', chainId }) as Promise<bigint>,
+      readContract(wagmi, { abi: MINT_ABI, address, functionName: 'initBlock', chainId }) as Promise<bigint>,
+      readContract(wagmi, { abi: MINT_ABI, address, functionName: 'latestTokenId', chainId }) as Promise<bigint>,
+      readContract(wagmi, { abi: MINT_ABI, address, functionName: 'owner', chainId }) as Promise<`0x${string}`>,
+      getBalance(wagmi, { address }) as Promise<GetBalanceReturnType>,
+    ])
+
+    const artistAddr = owner.toLowerCase() as `0x${string}`
+    const json = Buffer.from(data.substring(29), 'base64').toString()
+    const metadata = JSON.parse(json)
+
+    return {
+      image: metadata.image,
+      name: metadata.name,
+      symbol: metadata.symbol,
+      version,
+      description: metadata.description,
+      address,
+      initBlock,
+      latestTokenId,
+      owner: artistAddr,
+      tokens: {},
+      balance: balance.value,
+      renderers: [],
+    }
+  } catch (e) {
+    console.warn(`RPC: Error fetching collection ${address}`, e)
+    return null
+  }
+}
+
+export async function rpcFetchCollectionTokens (
+  wagmi: Config,
+  chainId: number,
+  collection: `0x${string}`,
+): Promise<Token[]> {
+  const client = getPublicClient(wagmi, { chainId }) as PublicClient
+  const [latestTokenId, currentBlock] = await Promise.all([
+    readContract(wagmi, {
+      abi: MINT_ABI,
+      address: collection,
+      functionName: 'latestTokenId',
+      chainId,
+    }) as Promise<bigint>,
+    client.getBlock(),
+  ])
+
+  const mintContract = getContract({ address: collection, abi: MINT_ABI, client })
+  const tokens: Token[] = []
+  const ids: bigint[] = []
+  for (let id = latestTokenId; id > 0n; id--) ids.push(id)
+
+  for (const chunk of chunkArray(ids, 10)) {
+    const results = await Promise.allSettled(
+      chunk.map(id => rpcFetchSingleToken(mintContract, collection, id, currentBlock))
+    )
+    for (const r of results) {
+      if (r.status === 'fulfilled' && r.value) tokens.push(r.value)
+    }
+  }
+
+  return tokens
+}
+
+async function rpcFetchSingleToken (
+  mintContract: ReturnType<typeof getContract>,
+  collection: `0x${string}`,
+  tokenId: bigint,
+  currentBlock: Awaited<ReturnType<PublicClient['getBlock']>>,
+  tries: number = 0,
+): Promise<Token | null> {
+  try {
+    const [data, dataUri] = await Promise.all([
+      mintContract.read.get([tokenId]) as Promise<[string, string, `0x${string}`[], bigint, bigint, bigint, bigint]>,
+      mintContract.read.uri([tokenId], {
+        gas: 100_000_000_000,
+        gasPrice: currentBlock.baseFeePerGas,
+      }) as Promise<string>,
+    ])
+
+    const [_name, _description, _artifact, _renderer, mintedBlock, closeAt, _extraData] = data
+
+    let metadata
+    try {
+      const json = Buffer.from(dataUri.substring(29), 'base64').toString()
+      metadata = JSON.parse(json)
+    } catch (e) {
+      metadata = { name: '', description: '', image: '', animation_url: '' }
+    }
+
+    return {
+      tokenId,
+      collection,
+      name: metadata.name,
+      description: metadata.description,
+      image: metadata.image,
+      animationUrl: metadata.animation_url,
+      mintedBlock: BigInt(`${mintedBlock}`),
+      closeAt,
+      mintsBackfilledUntilBlock: 0n,
+      mintsFetchedUntilBlock: 0n,
+      mints: [],
+    }
+  } catch (e) {
+    if (tries < 3) return rpcFetchSingleToken(mintContract, collection, tokenId, currentBlock, tries + 1)
+    return null
+  }
+}
+
+export async function rpcFetchTokenMints (
+  wagmi: Config,
+  chainId: number,
+  collection: `0x${string}`,
+  tokenId: bigint,
+): Promise<MintEvent[]> {
+  const client = getPublicClient(wagmi, { chainId }) as PublicClient
+  const mintContract = getContract({ address: collection, abi: MINT_ABI, client })
+
+  const [tokenData, currentBlock] = await Promise.all([
+    mintContract.read.get([tokenId]) as Promise<[string, string, `0x${string}`[], bigint, bigint, bigint, bigint]>,
+    client.getBlockNumber(),
+  ])
+
+  const mintedBlock = BigInt(`${tokenData[4]}`)
+  const untilBlock = mintedBlock + BLOCKS_PER_DAY
+  const toBlock = currentBlock > untilBlock ? untilBlock : currentBlock
+
+  return loadMintEventsRange(client, collection, tokenId, mintedBlock, toBlock)
+}
+
+async function loadMintEventsRange (
+  client: PublicClient,
+  collection: `0x${string}`,
+  tokenId: bigint,
+  fromBlock: bigint,
+  toBlock: bigint,
+): Promise<MintEvent[]> {
+  try {
+    const logs = await client.getLogs({
+      address: collection,
+      event: parseAbiItem('event NewMint(uint256 indexed tokenId, uint256 unitPrice, uint256 amount, address minter)'),
+      args: { tokenId },
+      fromBlock,
+      toBlock,
+    })
+
+    return logs.map(l => ({
+      tokenId,
+      address: l.args.minter,
+      block: l.blockNumber,
+      logIndex: l.logIndex,
+      tx: l.transactionHash,
+      unitPrice: l.args.unitPrice,
+      amount: l.args.amount,
+      price: (l.args.amount || 0n) * (l.args.unitPrice || 0n),
+    }) as MintEvent).reverse()
+  } catch (e) {
+    if (toBlock - fromBlock > 100n) {
+      const mid = fromBlock + (toBlock - fromBlock) / 2n
+      const [a, b] = await Promise.all([
+        loadMintEventsRange(client, collection, tokenId, fromBlock, mid),
+        loadMintEventsRange(client, collection, tokenId, mid + 1n, toBlock),
+      ])
+      return [...a, ...b]
+    }
+    throw e
+  }
+}
+
+
+function toCollection (raw: PonderCollection): Collection {
+  return {
+    address: raw.address.toLowerCase() as `0x${string}`,
+    owner: (raw.owner || raw.artist.address).toLowerCase() as `0x${string}`,
+    version: 0n,
+    image: raw.image || '',
+    name: raw.name || '',
+    symbol: raw.symbol || '',
+    description: raw.description || '',
+    initBlock: BigInt(raw.init_block || '0'),
+    latestTokenId: BigInt(raw.latest_token_id || '0'),
+    balance: 0n,
+    tokens: {},
+    renderers: [],
+  }
+}
+
+function toToken (raw: PonderArtifact): Token {
+  const mintedBlock = BigInt(raw.created_block || '0')
+  return {
+    collection: raw.collection.address.toLowerCase() as `0x${string}`,
+    tokenId: BigInt(raw.id),
+    name: raw.name || '',
+    description: raw.description || '',
+    image: raw.image || '',
+    animationUrl: raw.animation_url || undefined,
+    closeAt: mintedBlock + BLOCKS_PER_DAY,
+    mintedBlock,
+    mintsFetchedUntilBlock: 0n,
+    mintsBackfilledUntilBlock: 0n,
+    mints: [],
+  }
+}
+
+function toMintEvent (raw: PonderMint): MintEvent {
+  return {
+    tokenId: BigInt(raw.artifact.id),
+    address: raw.account.toLowerCase() as `0x${string}`,
+    block: BigInt(raw.block_number),
+    logIndex: raw.log_index,
+    tx: raw.hash,
+    unitPrice: BigInt(raw.unit_price || '0'),
+    amount: BigInt(raw.amount || '0'),
+    price: BigInt(raw.price || '0'),
+  }
+}

package/.env.example

@@ -1,50 +0,0 @@
-# =========================
-#           BASE
-# =========================
-NITRO_PRESET=node_cluster
-NUXT_SSR=false
-NUXT_DEVTOOLS=true
-NUXT_PUBLIC_DOMAIN=localhost
-NUXT_PUBLIC_TITLE=Mint
-NUXT_PUBLIC_DESCRIPTION=To mint is a human right.
-
-# =========================
-#       MINT DEFAULTS
-# =========================
-# NUXT_PUBLIC_MINT_AMOUNT=1
-# NUXT_PUBLIC_MINT_VALUE=5
-
-# =========================
-#       ARTIST SCOPE
-# =========================
-NUXT_PUBLIC_CREATOR_ADDRESS=0xc8f8e2f59dd95ff67c3d39109eca2e2a017d4c8a
-
-# =========================
-#         SERVICES
-# =========================
-NUXT_PUBLIC_WALLET_CONNECT_PROJECT_ID=
-NUXT_PUBLIC_IPFS_GATEWAY=
-NUXT_PUBLIC_ARWEAVE_GATEWAY=
-
-# =========================
-#         MAINNET
-# =========================
-# NUXT_PUBLIC_BLOCK_EXPLORER=https://etherscan.io
-# NUXT_PUBLIC_FACTORY_ADDRESS=0xd717Fe677072807057B03705227EC3E3b467b670
-# NUXT_PUBLIC_CHAIN_ID=1
-# NUXT_PUBLIC_RPC1=https://eth.llamarpc.com
-# NUXT_PUBLIC_RPC2=https://eth.drpc.org
-# NUXT_PUBLIC_RPC3=https://1rpc.io/eth
-
-# This should always be present if on other networks, so we can fetch ENS data
-NUXT_PUBLIC_MAINNET_RPC1=https://eth.llamarpc.com
-
-# =========================
-#         SEPOLIA
-# =========================
-NUXT_PUBLIC_BLOCK_EXPLORER=https://sepolia.etherscan.io
-NUXT_PUBLIC_FACTORY_ADDRESS=0x750C5a6CFD40C9CaA48C31D87AC2a26101Acd517
-NUXT_PUBLIC_CHAIN_ID=11155111
-NUXT_PUBLIC_RPC1=https://ethereum-sepolia-rpc.publicnode.com
-NUXT_PUBLIC_RPC2=https://sepolia.drpc.org
-NUXT_PUBLIC_RPC3=https://1rpc.io/sepolia

package/.nuxtrc

@@ -1 +0,0 @@
-typescript.includeWorkspace = true