@xyo-network/evm-call-witness 4.1.1 → 5.0.0

package/src/spec/imported/AddressToContract/ManualTokenIteration/Sentinel.token.spec.ts

@@ -0,0 +1,187 @@
+/* eslint-disable max-statements */
+
+import '@xylabs/vitest-extended'
+
+import { hexFrom } from '@xylabs/hex'
+import { asDivinerInstance } from '@xyo-network/diviner-model'
+import type { PackageManifestPayload } from '@xyo-network/manifest'
+import { ManifestWrapper } from '@xyo-network/manifest'
+import { ModuleFactoryLocator } from '@xyo-network/module-factory-locator'
+import { ModuleFactory } from '@xyo-network/module-model'
+import {
+  ERC721__factory, ERC721Enumerable__factory, ERC1155__factory,
+} from '@xyo-network/open-zeppelin-typechain'
+import { isPayloadOfSchemaType } from '@xyo-network/payload-model'
+import { asSentinelInstance } from '@xyo-network/sentinel-model'
+import { HDWallet } from '@xyo-network/wallet'
+import { getProvidersFromEnv } from '@xyo-network/witness-evm-abstract'
+import { asWitnessInstance } from '@xyo-network/witness-model'
+import { Semaphore } from 'async-mutex'
+import {
+  afterAll,
+  describe, expect,
+  it,
+} from 'vitest'
+
+import type { EvmCallResults } from '../../../../Diviner.ts'
+import { EvmCallDiviner, EvmCallResultsSchema } from '../../../../Diviner.ts'
+import type { EvmCallWitnessParams } from '../../../../model.ts'
+import type { EvmCall, EvmCallResult } from '../../../../Payload.ts'
+import { EvmCallResultSchema, EvmCallSchema } from '../../../../Payload.ts'
+import { EvmCallWitness } from '../../../../Witness.ts'
+import erc721SentinelManifest from '../Erc721Sentinel.json' with { type: 'json' }
+
+const profileData: Record<string, number[]> = {}
+
+const profile = (name: string) => {
+  const timeData = profileData[name] ?? []
+  timeData.push(Date.now())
+  profileData[name] = timeData
+}
+
+const profileReport = () => {
+  let lowest = Date.now()
+  let highest = 0
+  // eslint-disable-next-line unicorn/no-array-reduce
+  const results = Object.entries(profileData).reduce<Record<string, number>>((prev, [name, readings]) => {
+    const start = readings.at(0)
+    if (start) {
+      if (start < lowest) {
+        lowest = start
+      }
+      const end = readings.at(-1) ?? Date.now()
+      if (end > highest) {
+        highest = end
+      }
+      prev[name] = end - start
+    }
+    return prev
+  }, {})
+  if (highest) {
+    results['-all-'] = highest - lowest
+  }
+  return results
+}
+
+let tokenCount = 0
+
+describe.skip('Erc721Sentinel', () => {
+  // const address = '0x562fC2927c77cB975680088566ADa1dC6cB8b5Ea' //Random ERC721
+  const address = '0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D' // Bored Apes
+
+  describe('report', () => {
+    it('specifying address', async () => {
+      profile('setup')
+      const mnemonic = 'later puppy sound rebuild rebuild noise ozone amazing hope broccoli crystal grief'
+      const wallet = await HDWallet.fromPhrase(mnemonic)
+      const locator = new ModuleFactoryLocator()
+      locator.register(EvmCallDiviner.factory())
+
+      locator.register(
+        new ModuleFactory(EvmCallWitness, {
+          config: { abi: ERC721__factory.abi },
+          providers: getProvidersFromEnv,
+        } as EvmCallWitnessParams),
+        { 'network.xyo.evm.interface': 'Erc721' },
+      )
+
+      locator.register(
+        new ModuleFactory(EvmCallWitness, {
+          config: { abi: ERC721Enumerable__factory.abi },
+          providers: getProvidersFromEnv,
+        } as EvmCallWitnessParams),
+        { 'network.xyo.evm.interface': 'Erc721Enumerable' },
+      )
+
+      locator.register(
+        new ModuleFactory(EvmCallWitness, {
+          config: { abi: ERC1155__factory.abi },
+          providers: getProvidersFromEnv,
+        } as EvmCallWitnessParams),
+        { 'network.xyo.evm.interface': 'Erc1155' },
+      )
+      profile('setup')
+      profile('manifest')
+      const manifest = new ManifestWrapper(erc721SentinelManifest as PackageManifestPayload, wallet, locator)
+      profile('manifest-load')
+      const node = await manifest.loadNodeFromIndex(0)
+      profile('manifest-load')
+      profile('manifest-resolve')
+      const mods = await node.resolve('*')
+      profile('manifest-resolve')
+      profile('manifest')
+      expect(mods.length).toBeGreaterThan(5)
+
+      const collectionSentinel = asSentinelInstance(await node.resolve('NftInfoSentinel'))
+      expect(collectionSentinel).toBeDefined()
+
+      const tokenSentinel = asSentinelInstance(await node.resolve('NftTokenInfoSentinel'))
+      expect(tokenSentinel).toBeDefined()
+
+      const nameWitness = asWitnessInstance(await node.resolve('Erc721NameWitness'))
+      expect(nameWitness).toBeDefined()
+
+      const symbolWitness = asWitnessInstance(await node.resolve('Erc721SymbolWitness'))
+      expect(symbolWitness).toBeDefined()
+
+      const diviner = asDivinerInstance(await node.resolve('Erc721ContractInfoDiviner'))
+      expect(diviner).toBeDefined()
+
+      const collectionCallPayload: EvmCall = { address, schema: EvmCallSchema }
+      profile('collectionReport')
+      const report = await collectionSentinel?.report([collectionCallPayload])
+      profile('collectionReport')
+      profile('tokenCallSetup')
+      const info = report?.find(isPayloadOfSchemaType<EvmCallResults>(EvmCallResultsSchema))
+
+      const totalSupply = info?.results?.totalSupply ? BigInt(hexFrom(info.results.totalSupply.result as string, { prefix: true })) : 0n
+      expect(totalSupply).toBeGreaterThan(0n)
+
+      const chunkSize = 100n
+      const maxChunks = totalSupply / chunkSize
+      const chunks: EvmCall[][] = []
+
+      let offset = 0n
+      while (offset < totalSupply && chunks.length < maxChunks) {
+        offset = BigInt(chunks.length) * chunkSize
+
+        const chunkList: EvmCall[] = []
+
+        for (let i = offset; i < offset + chunkSize && i < totalSupply; i++) {
+          const call: EvmCall = {
+            address,
+            args: [`0x${BigInt(i).toString(16)}`],
+            functionName: 'tokenByIndex',
+            schema: EvmCallSchema,
+          }
+          chunkList.push(call)
+        }
+        chunks.push(chunkList)
+      }
+      profile('tokenCallSetup')
+      const maxConcurrent = 8
+      if (tokenSentinel) {
+        profile('tokenReport')
+        const semaphore = new Semaphore(maxConcurrent)
+        const tokenReportArrays = await Promise.all(
+          chunks.map(async (chunk) => {
+            return await semaphore.runExclusive(async () => {
+              const result = await tokenSentinel.report(chunk)
+              return result
+            })
+          }),
+        )
+        profile('tokenReport')
+        const tokenReport = tokenReportArrays.flat()
+        tokenCount = tokenReport.length
+        const tokenInfoPayloads = tokenReport.filter(isPayloadOfSchemaType<EvmCallResult>(EvmCallResultSchema))
+        expect(BigInt(tokenInfoPayloads.length)).toBe(totalSupply)
+      }
+    })
+    afterAll(() => {
+      const profileData = profileReport()
+      if (profileData['tokenReport']) console.log(`Timer: ${profileData['tokenReport'] / tokenCount}ms`)
+      console.log(`Profile: ${JSON.stringify(profileData, null, 2)}`)
+    })
+  })
+})

package/src/spec/imported/AddressToTotalSupplyIndex/Erc721.TotalSupply.Index.spec.ts

@@ -0,0 +1,101 @@
+import '@xylabs/vitest-extended'
+
+import { delay } from '@xylabs/delay'
+import { MemoryBoundWitnessDiviner } from '@xyo-network/diviner-boundwitness-memory'
+import { asDivinerInstance } from '@xyo-network/diviner-model'
+import { GenericPayloadDiviner } from '@xyo-network/diviner-payload-generic'
+import { PayloadDivinerQuerySchema } from '@xyo-network/diviner-payload-model'
+import {
+  TemporalIndexingDiviner,
+  TemporalIndexingDivinerDivinerQueryToIndexQueryDiviner,
+  TemporalIndexingDivinerIndexCandidateToIndexDiviner,
+  TemporalIndexingDivinerIndexQueryResponseToDivinerQueryResponseDiviner,
+  TemporalIndexingDivinerStateToIndexCandidateDiviner,
+} from '@xyo-network/diviner-temporal-indexing'
+import type { PackageManifestPayload } from '@xyo-network/manifest'
+import { ManifestWrapper } from '@xyo-network/manifest'
+import { ModuleFactoryLocator } from '@xyo-network/module-factory-locator'
+import { ModuleFactory } from '@xyo-network/module-model'
+import type { MemoryNode } from '@xyo-network/node-memory'
+import { ERC721Enumerable__factory } from '@xyo-network/open-zeppelin-typechain'
+import { asSentinelInstance } from '@xyo-network/sentinel-model'
+import { HDWallet } from '@xyo-network/wallet'
+import type { WalletInstance } from '@xyo-network/wallet-model'
+import { getProvidersFromEnv } from '@xyo-network/witness-evm-abstract'
+import { TimestampWitness } from '@xyo-network/witness-timestamp'
+import {
+  beforeAll, describe, expect,
+  it,
+} from 'vitest'
+
+import { EvmCallDiviner } from '../../../Diviner.ts'
+import type { EvmCallWitnessParams } from '../../../model.ts'
+import {
+  EvmCallSchema, isEvmCallResult, isEvmCallSuccess,
+} from '../../../Payload.ts'
+import { EvmCallWitness } from '../../../Witness.ts'
+import erc721TotalSupplyIndexManifest from './Erc721.TotalSupply.Index.json' with { type: 'json' }
+
+describe.skipIf(!process.env.INFURA_PROJECT_ID)('Erc721.TotalSupply.Index', () => {
+  let wallet: WalletInstance
+  let node: MemoryNode
+
+  beforeAll(async () => {
+    const mnemonic = 'later puppy sound rebuild rebuild noise ozone amazing hope broccoli crystal grief'
+    wallet = await HDWallet.fromPhrase(mnemonic)
+    const locator = new ModuleFactoryLocator()
+    locator.register(MemoryBoundWitnessDiviner.factory())
+    locator.register(GenericPayloadDiviner.factory())
+    locator.register(TimestampWitness.factory())
+    locator.register(EvmCallDiviner.factory())
+    locator.register(TemporalIndexingDivinerDivinerQueryToIndexQueryDiviner.factory())
+    locator.register(TemporalIndexingDivinerIndexCandidateToIndexDiviner.factory())
+    locator.register(TemporalIndexingDivinerIndexQueryResponseToDivinerQueryResponseDiviner.factory())
+    locator.register(TemporalIndexingDivinerStateToIndexCandidateDiviner.factory())
+    locator.register(TemporalIndexingDiviner.factory())
+
+    locator.register(
+      new ModuleFactory(EvmCallWitness, {
+        config: { abi: ERC721Enumerable__factory.abi },
+        providers: getProvidersFromEnv,
+      } as EvmCallWitnessParams),
+      { 'network.xyo.evm.interface': 'Erc721Enumerable' },
+    )
+    const manifest = new ManifestWrapper(erc721TotalSupplyIndexManifest as PackageManifestPayload, wallet, locator)
+    node = await manifest.loadNodeFromIndex(0)
+  })
+  type TestData = readonly [string]
+  const cases: readonly TestData[] = [
+    ['0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D'], // BAYC
+  ] as const
+  describe.skipIf(!process.env.INFURA_PROJECT_ID)('Sentinel', () => {
+    describe('Sentinel', () => {
+      it.each(cases)('returns totalSupply', async (address) => {
+        const sentinel = asSentinelInstance(await node.resolve('Sentinel'))
+        const input = {
+          address, chainId: 1, schema: EvmCallSchema,
+        }
+        const observations = await sentinel?.report([input])
+        expect(observations?.length).toBe(3)
+        const totalSupply = observations?.filter(isEvmCallResult).find(isEvmCallSuccess)
+        expect(totalSupply).toBeDefined()
+        expect(totalSupply?.result).toBeString()
+        const totalSupplyValue = totalSupply?.result as string
+        expect(Number.parseInt(totalSupplyValue)).toBeNumber()
+      })
+    })
+    describe.skip('Index', () => {
+      it.each(cases)('returns indexed result', async (address) => {
+        await delay(100)
+        const diviner = asDivinerInstance(await node.resolve('IndexDiviner'))
+        expect(diviner).toBeDefined()
+        const query = {
+          address, chainId: 1, schema: PayloadDivinerQuerySchema,
+        }
+        const result = await diviner?.divine([query])
+        expect(result).toBeDefined()
+        expect(result).toBeArrayOfSize(1)
+      })
+    })
+  })
+})

package/src/spec/imported/NftIndexToNftIdIndex/Erc721.NftId.Index.spec.ts

@@ -0,0 +1,118 @@
+import '@xylabs/vitest-extended'
+
+import { delay } from '@xylabs/delay'
+import { MemoryBoundWitnessDiviner } from '@xyo-network/diviner-boundwitness-memory'
+import { JsonPatchDiviner } from '@xyo-network/diviner-jsonpatch'
+import { JsonPathAggregateDiviner } from '@xyo-network/diviner-jsonpath-aggregate-memory'
+import { asDivinerInstance } from '@xyo-network/diviner-model'
+import { GenericPayloadDiviner } from '@xyo-network/diviner-payload-generic'
+import { PayloadDivinerQuerySchema } from '@xyo-network/diviner-payload-model'
+import { RangeDiviner } from '@xyo-network/diviner-range'
+import {
+  TemporalIndexingDiviner,
+  TemporalIndexingDivinerDivinerQueryToIndexQueryDiviner,
+  TemporalIndexingDivinerIndexCandidateToIndexDiviner,
+  TemporalIndexingDivinerIndexQueryResponseToDivinerQueryResponseDiviner,
+  TemporalIndexingDivinerStateToIndexCandidateDiviner,
+} from '@xyo-network/diviner-temporal-indexing'
+import { isNftId } from '@xyo-network/evm-nft-id-payload-plugin'
+import type { PackageManifestPayload } from '@xyo-network/manifest'
+import { ManifestWrapper } from '@xyo-network/manifest'
+import { ModuleFactoryLocator } from '@xyo-network/module-factory-locator'
+import { ModuleFactory } from '@xyo-network/module-model'
+import type { MemoryNode } from '@xyo-network/node-memory'
+import { ERC721Enumerable__factory } from '@xyo-network/open-zeppelin-typechain'
+import { asSentinelInstance } from '@xyo-network/sentinel-model'
+import { HDWallet } from '@xyo-network/wallet'
+import type { WalletInstance } from '@xyo-network/wallet-model'
+import { getProvidersFromEnv } from '@xyo-network/witness-evm-abstract'
+import { TimestampWitness } from '@xyo-network/witness-timestamp'
+import {
+  beforeAll, describe, expect,
+  it,
+} from 'vitest'
+
+import { EvmCallDiviner } from '../../../Diviner.ts'
+import type { EvmCallWitnessParams } from '../../../model.ts'
+import { EvmCallSchema } from '../../../Payload.ts'
+import { EvmCallWitness } from '../../../Witness.ts'
+import nodeManifest from './Erc721.NftId.Index.json' with { type: 'json' }
+
+describe.skipIf(!process.env.INFURA_PROJECT_ID).skip('Erc721.NftId.Index', () => {
+  let wallet: WalletInstance
+  let node: MemoryNode
+
+  beforeAll(async () => {
+    const mnemonic = 'later puppy sound rebuild rebuild noise ozone amazing hope broccoli crystal grief'
+    wallet = await HDWallet.fromPhrase(mnemonic)
+    const locator = new ModuleFactoryLocator()
+    locator.register(MemoryBoundWitnessDiviner.factory())
+    locator.register(GenericPayloadDiviner.factory())
+    locator.register(TimestampWitness.factory())
+    locator.register(EvmCallDiviner.factory())
+    locator.register(TemporalIndexingDivinerDivinerQueryToIndexQueryDiviner.factory())
+    locator.register(TemporalIndexingDivinerIndexCandidateToIndexDiviner.factory())
+    locator.register(TemporalIndexingDivinerIndexQueryResponseToDivinerQueryResponseDiviner.factory())
+    locator.register(TemporalIndexingDivinerStateToIndexCandidateDiviner.factory())
+    locator.register(TemporalIndexingDiviner.factory())
+    locator.register(JsonPatchDiviner.factory())
+    locator.register(JsonPathAggregateDiviner.factory())
+    locator.register(RangeDiviner.factory())
+
+    locator.register(
+      new ModuleFactory(EvmCallWitness, {
+        config: { abi: ERC721Enumerable__factory.abi },
+        providers: getProvidersFromEnv,
+      } as EvmCallWitnessParams),
+      { 'network.xyo.evm.interface': 'Erc721Enumerable' },
+    )
+    const manifest = new ManifestWrapper(nodeManifest as PackageManifestPayload, wallet, locator)
+    node = await manifest.loadNodeFromIndex(0)
+  })
+  type TestData = readonly [string]
+  const cases: readonly TestData[] = [
+    ['0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D'], // BAYC
+  ] as const
+  describe.skipIf(!process.env.INFURA_PROJECT_ID)('Sentinel', () => {
+    const tokensToCheck = 16
+    const tokenIds = Array.from({ length: tokensToCheck }).map((_, tokenIndex) => tokenIndex)
+    const tokenIndexes = tokenIds.map(tokenId => tokenId)
+    const chainId = 1
+    const functionName = 'tokenByIndex'
+    describe('Sentinel', () => {
+      it.each(cases)('returns NftIndexes', async (address) => {
+        const sentinel = asSentinelInstance(await node.resolve('Sentinel'))
+        for (const tokenIndex of tokenIndexes) {
+          const inputs = [{
+            address, args: [`0x${BigInt(tokenIndex).toString(16)}`], chainId, functionName, schema: EvmCallSchema,
+          }]
+          const observations = await sentinel?.report(inputs)
+          const nftIds = observations?.filter(isNftId)
+          expect(nftIds?.length).toBe(1)
+          for (const nftId of nftIds ?? []) {
+            expect(nftId.address).toBe(address)
+            expect(nftId.chainId).toBe(chainId)
+            expect(nftId.tokenId).toBeString()
+            expect(tokenIds).toContain(Number(BigInt(nftId.tokenId)))
+          }
+        }
+      })
+    })
+    describe('Index', () => {
+      it.each(cases)('returns indexed NftIndex results', async (address) => {
+        await delay(100)
+        const diviner = asDivinerInstance(await node.resolve('IndexDiviner'))
+        expect(diviner).toBeDefined()
+        for (const tokenIndex of tokenIndexes) {
+          const tokenId = `0x${BigInt(tokenIndex).toString(16)}`
+          const query = {
+            address, chainId, length: 1, schema: PayloadDivinerQuerySchema, tokenId,
+          }
+          const result = await diviner?.divine([query])
+          expect(result).toBeDefined()
+          expect(result).toBeArrayOfSize(1)
+        }
+      })
+    })
+  })
+})

package/src/spec/imported/TotalSupplyToNftIndexIndex/Erc721.NftIndex.Index.spec.ts

@@ -0,0 +1,124 @@
+import '@xylabs/vitest-extended'
+
+import { MemoryBoundWitnessDiviner } from '@xyo-network/diviner-boundwitness-memory'
+import { JsonPatchDiviner } from '@xyo-network/diviner-jsonpatch'
+import { JsonPathAggregateDiviner } from '@xyo-network/diviner-jsonpath-aggregate-memory'
+import { asDivinerInstance } from '@xyo-network/diviner-model'
+import { GenericPayloadDiviner } from '@xyo-network/diviner-payload-generic'
+import { PayloadDivinerQuerySchema } from '@xyo-network/diviner-payload-model'
+import { RangeDiviner } from '@xyo-network/diviner-range'
+import {
+  TemporalIndexingDiviner,
+  TemporalIndexingDivinerDivinerQueryToIndexQueryDiviner,
+  TemporalIndexingDivinerIndexCandidateToIndexDiviner,
+  TemporalIndexingDivinerIndexQueryResponseToDivinerQueryResponseDiviner,
+  TemporalIndexingDivinerStateToIndexCandidateDiviner,
+} from '@xyo-network/diviner-temporal-indexing'
+import { isNftIndex } from '@xyo-network/evm-nft-id-payload-plugin'
+import type { PackageManifestPayload } from '@xyo-network/manifest'
+import { ManifestWrapper } from '@xyo-network/manifest'
+import { ModuleFactoryLocator } from '@xyo-network/module-factory-locator'
+import { ModuleFactory } from '@xyo-network/module-model'
+import type { MemoryNode } from '@xyo-network/node-memory'
+import { ERC721Enumerable__factory } from '@xyo-network/open-zeppelin-typechain'
+import { asSentinelInstance } from '@xyo-network/sentinel-model'
+import { HDWallet } from '@xyo-network/wallet'
+import type { WalletInstance } from '@xyo-network/wallet-model'
+import { getProvidersFromEnv } from '@xyo-network/witness-evm-abstract'
+import { TimestampWitness } from '@xyo-network/witness-timestamp'
+import {
+  beforeAll, describe, expect,
+  it,
+} from 'vitest'
+
+import { EvmCallDiviner } from '../../../Diviner.ts'
+import type { EvmCallWitnessParams } from '../../../model.ts'
+import type { EvmCallResult } from '../../../Payload.ts'
+import { EvmCallWitness } from '../../../Witness.ts'
+import nodeManifest from './Erc721.NftIndex.Index.json' with { type: 'json' }
+
+describe.runIf(process.env.INFURA_PROJECT_ID).skip('Erc721.NftIndex.Index', () => {
+  let wallet: WalletInstance
+  let node: MemoryNode
+
+  beforeAll(async () => {
+    const mnemonic = 'later puppy sound rebuild rebuild noise ozone amazing hope broccoli crystal grief'
+    wallet = await HDWallet.fromPhrase(mnemonic)
+    const locator = new ModuleFactoryLocator()
+    locator.register(MemoryBoundWitnessDiviner.factory())
+    locator.register(GenericPayloadDiviner.factory())
+    locator.register(TimestampWitness.factory())
+    locator.register(EvmCallDiviner.factory())
+    locator.register(TemporalIndexingDivinerDivinerQueryToIndexQueryDiviner.factory())
+    locator.register(TemporalIndexingDivinerIndexCandidateToIndexDiviner.factory())
+    locator.register(TemporalIndexingDivinerIndexQueryResponseToDivinerQueryResponseDiviner.factory())
+    locator.register(TemporalIndexingDivinerStateToIndexCandidateDiviner.factory())
+    locator.register(TemporalIndexingDiviner.factory())
+    locator.register(JsonPatchDiviner.factory())
+    locator.register(JsonPathAggregateDiviner.factory())
+    locator.register(RangeDiviner.factory())
+
+    locator.register(
+      new ModuleFactory(EvmCallWitness, {
+        config: { abi: ERC721Enumerable__factory.abi },
+        providers: getProvidersFromEnv,
+      } as EvmCallWitnessParams),
+      { 'network.xyo.evm.interface': 'Erc721Enumerable' },
+    )
+    const manifest = new ManifestWrapper(nodeManifest as PackageManifestPayload, wallet, locator)
+    node = await manifest.loadNodeFromIndex(0)
+  })
+  type TestData = readonly [string]
+  const cases: readonly TestData[] = [
+    ['0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D'], // BAYC
+  ] as const
+  describe('Sentinel', () => {
+    const totalSupply = 100
+    describe('Sentinel', () => {
+      it.each(cases)('returns NftIndexes', async (address) => {
+        const sentinel = asSentinelInstance(await node.resolve('Sentinel'))
+        const chainId = 1
+        const input: EvmCallResult = {
+          address,
+          args: [],
+          chainId,
+          functionName: 'totalSupply',
+          result: `${totalSupply}`,
+          schema: 'network.xyo.evm.call.result',
+        }
+
+        const observations = (await sentinel?.report([input])) ?? []
+        const nftIndexes = observations?.filter(isNftIndex)
+        expect(nftIndexes?.length).toBe(totalSupply)
+        for (const nftIndex of nftIndexes ?? []) {
+          expect(nftIndex.address).toBe(address)
+          expect(nftIndex.chainId).toBe(chainId)
+          expect(nftIndex.index).toBeNumber()
+        }
+      })
+    })
+    describe('Index', () => {
+      beforeAll(async () => {
+        const delay = (ms: number) => {
+          return new Promise(resolve => setTimeout(resolve, ms))
+        }
+        // Delay enough time for the diviners to index the results
+        await delay(4000)
+      })
+      it.each(cases)('returns indexed NftIndex results', async (address) => {
+        const diviner = asDivinerInstance(await node.resolve('IndexDiviner'))
+        expect(diviner).toBeDefined()
+        // Check we've indexed the results by sampling the first and last index
+        const sampleIndexes = [0, totalSupply - 1]
+        for (const index of sampleIndexes) {
+          const query = {
+            address, chainId: 1, index, schema: PayloadDivinerQuerySchema,
+          }
+          const result = await diviner?.divine([query])
+          expect(result).toBeDefined()
+          expect(result).toBeArrayOfSize(1)
+        }
+      })
+    })
+  })
+})

package/typedoc.json

@@ -1,5 +0,0 @@
-{
-  "$schema": "https://typedoc.org/schema.json",
-  "entryPoints": ["./src/index.ts"],
-  "tsconfig": "./tsconfig.typedoc.json"
-}

package/xy.config.ts

@@ -1,10 +0,0 @@
-import type { XyTsupConfig } from '@xylabs/ts-scripts-yarn3'
-const config: XyTsupConfig = {
-  compile: {
-    browser: {},
-    node: {},
-    neutral: { src: true },
-  },
-}
-
-export default config