@xyo-network/crypto-contract-function-read-plugin 4.2.0 → 5.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xyo-network/crypto-contract-function-read-plugin",
-  "version": "4.2.0",
+  "version": "5.0.0",
   "description": "Typescript/Javascript Plugins for XYO Platform",
   "homepage": "https://xyo.network",
   "bugs": {
@@ -28,45 +28,49 @@
   },
   "module": "dist/neutral/index.mjs",
   "types": "dist/neutral/index.d.ts",
+  "files": [
+    "dist",
+    "src"
+  ],
   "dependencies": {
-    "@xylabs/assert": "^4.15.1",
-    "@xylabs/promise": "^4.15.1",
-    "@xyo-network/abstract-witness": "^4.3.0",
-    "@xyo-network/crypto-contract-function-read-payload-plugin": "^4.2.0",
-    "@xyo-network/crypto-nft-payload-plugin": "^4.2.0",
-    "@xyo-network/diviner-abstract": "^4.3.0",
-    "@xyo-network/module-model": "^4.3.0",
-    "@xyo-network/payload-model": "^4.3.0",
-    "@xyo-network/payloadset-plugin": "^4.3.0",
-    "@xyo-network/witness-model": "^4.3.0",
+    "@xylabs/assert": "^5.0.0",
+    "@xylabs/promise": "^5.0.0",
+    "@xyo-network/abstract-witness": "^5.0.0",
+    "@xyo-network/crypto-contract-function-read-payload-plugin": "^5.0.0",
+    "@xyo-network/crypto-nft-payload-plugin": "^5.0.0",
+    "@xyo-network/diviner-abstract": "^5.0.0",
+    "@xyo-network/module-model": "^5.0.0",
+    "@xyo-network/payload-model": "^5.0.0",
+    "@xyo-network/payloadset-plugin": "^5.0.0",
+    "@xyo-network/witness-model": "^5.0.0",
     "ethers": "^6.15.0"
   },
   "devDependencies": {
-    "@xylabs/delay": "^4.15.1",
-    "@xylabs/hex": "^4.15.1",
-    "@xylabs/object": "^4.15.1",
-    "@xylabs/ts-scripts-yarn3": "^7.0.1",
-    "@xylabs/tsconfig": "^7.0.1",
-    "@xylabs/vitest-extended": "^4.15.1",
-    "@xyo-network/archivist-memory": "^4.3.0",
-    "@xyo-network/diviner-boundwitness-memory": "^4.3.0",
-    "@xyo-network/diviner-jsonpatch": "^4.3.0",
-    "@xyo-network/diviner-jsonpath-aggregate-memory": "^4.3.0",
-    "@xyo-network/diviner-model": "^4.3.0",
-    "@xyo-network/diviner-payload-generic": "^4.3.0",
-    "@xyo-network/diviner-payload-model": "^4.3.0",
-    "@xyo-network/diviner-range": "^4.3.0",
-    "@xyo-network/diviner-temporal-indexing": "^4.3.0",
-    "@xyo-network/evm-nft-id-payload-plugin": "^4.2.0",
-    "@xyo-network/manifest": "^4.3.0",
-    "@xyo-network/module-factory-locator": "^4.3.0",
-    "@xyo-network/node-memory": "^4.3.0",
+    "@xylabs/delay": "^5.0.0",
+    "@xylabs/hex": "^5.0.0",
+    "@xylabs/object": "^5.0.0",
+    "@xylabs/ts-scripts-yarn3": "^7.0.2",
+    "@xylabs/tsconfig": "^7.0.2",
+    "@xylabs/vitest-extended": "^5.0.0",
+    "@xyo-network/archivist-memory": "^5.0.0",
+    "@xyo-network/diviner-boundwitness-memory": "^5.0.0",
+    "@xyo-network/diviner-jsonpatch": "^5.0.0",
+    "@xyo-network/diviner-jsonpath-aggregate-memory": "^5.0.0",
+    "@xyo-network/diviner-model": "^5.0.0",
+    "@xyo-network/diviner-payload-generic": "^5.0.0",
+    "@xyo-network/diviner-payload-model": "^5.0.0",
+    "@xyo-network/diviner-range": "^5.0.0",
+    "@xyo-network/diviner-temporal-indexing": "^5.0.0",
+    "@xyo-network/evm-nft-id-payload-plugin": "^5.0.0",
+    "@xyo-network/manifest": "^5.0.0",
+    "@xyo-network/module-factory-locator": "^5.0.0",
+    "@xyo-network/node-memory": "^5.0.0",
     "@xyo-network/open-zeppelin-typechain": "^3.5.4",
-    "@xyo-network/sentinel-model": "^4.3.0",
-    "@xyo-network/wallet": "^4.3.0",
-    "@xyo-network/wallet-model": "^4.3.0",
-    "@xyo-network/witness-blockchain-abstract": "^4.3.0",
-    "@xyo-network/witness-timestamp": "^4.3.0",
+    "@xyo-network/sentinel-model": "^5.0.0",
+    "@xyo-network/wallet": "^5.0.0",
+    "@xyo-network/wallet-model": "^5.0.0",
+    "@xyo-network/witness-blockchain-abstract": "^5.0.0",
+    "@xyo-network/witness-timestamp": "^5.0.0",
     "async-mutex": "^0.5.0",
     "typescript": "^5.8.3",
     "vitest": "^3.2.4"

package/src/spec/AddressToContract/AddressToContractIndex/Contract.Sentinel.Node.spec.ts

@@ -0,0 +1,167 @@
+import '@xylabs/vitest-extended'
+
+import { MemoryArchivist } from '@xyo-network/archivist-memory'
+import type { CryptoContractFunctionCall } from '@xyo-network/crypto-contract-function-read-payload-plugin'
+import {
+  CryptoContractFunctionCallSchema,
+  isErc721ContractInfo,
+  isErc1155ContractInfo,
+} from '@xyo-network/crypto-contract-function-read-payload-plugin'
+import { MemoryBoundWitnessDiviner } from '@xyo-network/diviner-boundwitness-memory'
+import { JsonPatchDiviner } from '@xyo-network/diviner-jsonpatch'
+import { asDivinerInstance } from '@xyo-network/diviner-model'
+import { GenericPayloadDiviner } from '@xyo-network/diviner-payload-generic'
+import type { PayloadDivinerQueryPayload } from '@xyo-network/diviner-payload-model'
+import { PayloadDivinerQuerySchema } from '@xyo-network/diviner-payload-model'
+import {
+  TemporalIndexingDiviner,
+  TemporalIndexingDivinerDivinerQueryToIndexQueryDiviner,
+  TemporalIndexingDivinerIndexCandidateToIndexDiviner,
+  TemporalIndexingDivinerIndexQueryResponseToDivinerQueryResponseDiviner,
+  TemporalIndexingDivinerStateToIndexCandidateDiviner,
+} from '@xyo-network/diviner-temporal-indexing'
+import type { ModuleManifest, 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 {
+  ERC721__factory, ERC721Enumerable__factory, ERC1155__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 { getProviderFromEnv } from '@xyo-network/witness-blockchain-abstract'
+import { TimestampWitness } from '@xyo-network/witness-timestamp'
+import type { Provider } from 'ethers'
+import {
+  beforeAll,
+  describe, expect, it,
+} from 'vitest'
+
+import { CryptoContractDiviner } from '../../../Diviner/index.ts'
+import type { CryptoContractFunctionReadWitnessParams } from '../../../Witness.ts'
+import { CryptoContractFunctionReadWitness } from '../../../Witness.ts'
+import erc721IndexNodeManifest from './Contract.Sentinel.Erc721.Index.json' with { type: 'json' }
+import erc1155IndexNodeManifest from './Contract.Sentinel.Erc1155.Index.json' with { type: 'json' }
+import sentinelNodeManifest from './Contract.Sentinel.Node.json' with { type: 'json' }
+
+const maxProviders = 32
+
+describe.skip('Contract Node', () => {
+  type TokenType = 'ERC721' | 'ERC1155'
+  const cases: [TokenType, string][] = [
+    ['ERC721', '0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D'],
+    ['ERC1155', '0xEdB61f74B0d09B2558F1eeb79B247c1F363Ae452'],
+    ['ERC1155', '0x2A6d6a082C410a195157EC4caf67CB9fD718f087'],
+    ['ERC1155', '0x33FD426905F149f8376e227d0C9D3340AaD17aF1'],
+    ['ERC1155', '0x7DaEC605E9e2a1717326eeDFd660601e2753A057'],
+    ['ERC1155', '0xCaf94eB06D4dE233c45B353723C387D3E440f3d6'],
+    ['ERC1155', '0xbF42C1972877F39e102807E5E80ed2ff5D16aa5f'],
+  ]
+  const getProviders = () => {
+    const providers: Provider[] = []
+    for (let i = 0; i < maxProviders; i++) {
+      providers.push(getProviderFromEnv())
+    }
+    return providers
+  }
+  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(MemoryArchivist.factory())
+    locator.register(MemoryBoundWitnessDiviner.factory())
+    locator.register(GenericPayloadDiviner.factory())
+    locator.register(TimestampWitness.factory())
+
+    locator.register(CryptoContractDiviner.factory())
+
+    locator.register(TemporalIndexingDivinerDivinerQueryToIndexQueryDiviner.factory(), CryptoContractDiviner.labels)
+
+    locator.register(TemporalIndexingDivinerIndexCandidateToIndexDiviner.factory(), CryptoContractDiviner.labels)
+
+    locator.register(TemporalIndexingDivinerIndexQueryResponseToDivinerQueryResponseDiviner.factory(), CryptoContractDiviner.labels)
+
+    locator.register(TemporalIndexingDivinerStateToIndexCandidateDiviner.factory(), CryptoContractDiviner.labels)
+
+    locator.register(TemporalIndexingDiviner.factory(), CryptoContractDiviner.labels)
+    locator.register(
+
+      new ModuleFactory(CryptoContractFunctionReadWitness, {
+        config: { abi: ERC721__factory.abi },
+        providers: getProviders(),
+      } as CryptoContractFunctionReadWitnessParams),
+      { 'network.xyo.evm.interface': 'Erc721' },
+    )
+    locator.register(
+
+      new ModuleFactory(CryptoContractFunctionReadWitness, {
+        config: { abi: ERC721Enumerable__factory.abi },
+        providers: getProviders(),
+      } as CryptoContractFunctionReadWitnessParams),
+      { 'network.xyo.evm.interface': 'Erc721Enumerable' },
+    )
+    locator.register(
+
+      new ModuleFactory(CryptoContractFunctionReadWitness, {
+        config: { abi: ERC1155__factory.abi },
+        providers: getProviders(),
+      } as CryptoContractFunctionReadWitnessParams),
+      { 'network.xyo.evm.interface': 'Erc1155' },
+    )
+    locator.register(JsonPatchDiviner.factory())
+    locator.register(TemporalIndexingDiviner.factory())
+    const publicChildren: ModuleManifest[] = [
+      ...(erc721IndexNodeManifest as PackageManifestPayload).nodes,
+      ...(erc1155IndexNodeManifest as PackageManifestPayload).nodes,
+    ]
+    const manifest = new ManifestWrapper(sentinelNodeManifest as PackageManifestPayload, wallet, locator, publicChildren)
+    node = await manifest.loadNodeFromIndex(0)
+  })
+  describe('Sentinel', () => {
+    it.each(cases)('With %s (%s)', async (_, address) => {
+      const collectionSentinel = asSentinelInstance(await node.resolve('NftInfoSentinel'))
+      expect(collectionSentinel).toBeDefined()
+      const collectionCallPayload: CryptoContractFunctionCall = { address, schema: CryptoContractFunctionCallSchema }
+      const report = await collectionSentinel?.report([collectionCallPayload])
+      let foundAny = false
+      const erc721 = report?.find(isErc721ContractInfo)
+      if (erc721) {
+        foundAny = true
+        expect(erc721?.results?.name).toBe('BoredApeYachtClub')
+        expect(erc721?.results?.symbol).toBe('BAYC')
+      }
+      const erc1155 = report?.find(isErc1155ContractInfo)
+      if (erc1155) {
+        foundAny = true
+        expect(erc1155?.results?.uri).toBeDefined()
+      }
+      expect(foundAny).toBe(true)
+    })
+  })
+  describe('ERC721 Index', () => {
+    const erc721Cases = cases.filter(([type]) => type === 'ERC721')
+    it.each(erc721Cases)('With %s (%s)', async (_, address) => {
+      const diviner = asDivinerInstance(await node.resolve('Erc721IndexDiviner'))
+      expect(diviner).toBeDefined()
+      const query = { address, schema: PayloadDivinerQuerySchema } as PayloadDivinerQueryPayload
+      const result = await diviner?.divine([query])
+      expect(result).toBeDefined()
+      expect(result).toBeArrayOfSize(1)
+    })
+  })
+  describe('ERC1155 Index', () => {
+    const erc1155 = cases.filter(([type]) => type === 'ERC1155')
+    it.each(erc1155)('With %s (%s)', async (_, address) => {
+      const diviner = asDivinerInstance(await node.resolve('Erc1155IndexDiviner'))
+      expect(diviner).toBeDefined()
+      const query = { address, schema: PayloadDivinerQuerySchema } as PayloadDivinerQueryPayload
+      const result = await diviner?.divine([query])
+      expect(result).toBeDefined()
+      expect(result).toBeArrayOfSize(1)
+    })
+  })
+})

package/src/spec/AddressToContract/CollectionInfo/Sentinel.collection.spec.ts

@@ -0,0 +1,162 @@
+/* eslint-disable max-statements */
+
+import '@xylabs/vitest-extended'
+
+import type {
+  ContractInfo,
+  CryptoContractFunctionCall,
+} from '@xyo-network/crypto-contract-function-read-payload-plugin'
+import {
+  ContractInfoSchema,
+  CryptoContractFunctionCallSchema,
+} from '@xyo-network/crypto-contract-function-read-payload-plugin'
+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 { getProviderFromEnv } from '@xyo-network/witness-blockchain-abstract'
+import { asWitnessInstance } from '@xyo-network/witness-model'
+import type { Provider } from 'ethers'
+import {
+  afterAll,
+  describe, expect, it,
+} from 'vitest'
+
+import { CryptoContractDiviner } from '../../../Diviner/index.ts'
+import type { CryptoContractFunctionReadWitnessParams } from '../../../Witness.ts'
+import { CryptoContractFunctionReadWitness } 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
+}
+
+const tokenCount = 0
+const maxProviders = 32
+
+describe('Erc721Sentinel', () => {
+  // const address = '0x562fC2927c77cB975680088566ADa1dC6cB8b5Ea' //Random ERC721
+  const address = '0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D' // Bored Apes
+
+  const getProviders = () => {
+    const providers: Provider[] = []
+    for (let i = 0; i < maxProviders; i++) {
+      providers.push(getProviderFromEnv())
+    }
+    return providers
+  }
+
+  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(CryptoContractDiviner.factory())
+
+      locator.register(
+
+        new ModuleFactory(CryptoContractFunctionReadWitness, {
+          config: { abi: ERC721__factory.abi },
+          providers: getProviders(),
+        } as CryptoContractFunctionReadWitnessParams),
+        { 'network.xyo.evm.interface': 'Erc721' },
+      )
+
+      locator.register(
+
+        new ModuleFactory(CryptoContractFunctionReadWitness, {
+          config: { abi: ERC721Enumerable__factory.abi },
+          providers: getProviders(),
+        } as CryptoContractFunctionReadWitnessParams),
+        { 'network.xyo.evm.interface': 'Erc721Enumerable' },
+      )
+
+      locator.register(
+
+        new ModuleFactory(CryptoContractFunctionReadWitness, {
+          config: { abi: ERC1155__factory.abi },
+          providers: getProviders(),
+        } as CryptoContractFunctionReadWitnessParams),
+        { '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: CryptoContractFunctionCall = { address, schema: CryptoContractFunctionCallSchema }
+      profile('collectionReport')
+      const report = await collectionSentinel?.report([collectionCallPayload])
+      profile('collectionReport')
+      profile('tokenCallSetup')
+      const info = report?.find(isPayloadOfSchemaType<ContractInfo>(ContractInfoSchema))
+
+      expect(info?.results?.name).toBe('BoredApeYachtClub')
+      expect(info?.results?.symbol).toBe('BAYC')
+    })
+    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/AddressToContract/ManualTokenIteration/Sentinel.token.spec.ts

@@ -0,0 +1,203 @@
+/* eslint-disable max-statements */
+
+import '@xylabs/vitest-extended'
+
+import { hexFromHexString } from '@xylabs/hex'
+import type {
+  ContractInfo,
+  CryptoContractFunctionCall,
+  CryptoContractFunctionCallResult,
+} from '@xyo-network/crypto-contract-function-read-payload-plugin'
+import {
+  ContractInfoSchema,
+  CryptoContractFunctionCallResultSchema,
+  CryptoContractFunctionCallSchema,
+} from '@xyo-network/crypto-contract-function-read-payload-plugin'
+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 { getProviderFromEnv } from '@xyo-network/witness-blockchain-abstract'
+import { asWitnessInstance } from '@xyo-network/witness-model'
+import { Semaphore } from 'async-mutex'
+import type { Provider } from 'ethers'
+import {
+  afterAll,
+  describe, expect, it,
+} from 'vitest'
+
+import { CryptoContractDiviner } from '../../../Diviner/index.ts'
+import type { CryptoContractFunctionReadWitnessParams } from '../../../Witness.ts'
+import { CryptoContractFunctionReadWitness } 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
+const maxProviders = 32
+
+describe('Erc721Sentinel', () => {
+  // const address = '0x562fC2927c77cB975680088566ADa1dC6cB8b5Ea' //Random ERC721
+  const address = '0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D' // Bored Apes
+
+  const getProviders = () => {
+    const providers: Provider[] = []
+    for (let i = 0; i < maxProviders; i++) {
+      providers.push(getProviderFromEnv())
+    }
+    return providers
+  }
+
+  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(CryptoContractDiviner.factory())
+
+      locator.register(
+        new ModuleFactory(CryptoContractFunctionReadWitness, {
+          config: { abi: ERC721__factory.abi },
+          providers: getProviders(),
+        } as CryptoContractFunctionReadWitnessParams),
+        { 'network.xyo.evm.interface': 'Erc721' },
+      )
+
+      locator.register(
+        new ModuleFactory(CryptoContractFunctionReadWitness, {
+          config: { abi: ERC721Enumerable__factory.abi },
+          providers: getProviders(),
+        } as CryptoContractFunctionReadWitnessParams),
+        { 'network.xyo.evm.interface': 'Erc721Enumerable' },
+      )
+
+      locator.register(
+        new ModuleFactory(CryptoContractFunctionReadWitness, {
+          config: { abi: ERC1155__factory.abi },
+          providers: getProviders(),
+        } as CryptoContractFunctionReadWitnessParams),
+        { '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: CryptoContractFunctionCall = { address, schema: CryptoContractFunctionCallSchema }
+      profile('collectionReport')
+      const report = await collectionSentinel?.report([collectionCallPayload])
+      profile('collectionReport')
+      profile('tokenCallSetup')
+      const info = report?.find(isPayloadOfSchemaType<ContractInfo>(ContractInfoSchema))
+
+      const totalSupply = info?.results?.totalSupply ? BigInt(hexFromHexString(info.results.totalSupply as string, { prefix: true })) : 0n
+      expect(totalSupply).toBeGreaterThan(0n)
+
+      const chunkSize = 100n
+      const maxChunks = totalSupply / chunkSize
+      const chunks: CryptoContractFunctionCall[][] = []
+
+      let offset = 0n
+      while (offset < totalSupply && chunks.length < maxChunks) {
+        offset = BigInt(chunks.length) * chunkSize
+
+        const chunkList: CryptoContractFunctionCall[] = []
+
+        for (let i = offset; i < offset + chunkSize && i < totalSupply; i++) {
+          const call: CryptoContractFunctionCall = {
+            address,
+            args: [`0x${BigInt(i).toString(16)}`],
+            functionName: 'tokenByIndex',
+            schema: CryptoContractFunctionCallSchema,
+          }
+          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<CryptoContractFunctionCallResult>(CryptoContractFunctionCallResultSchema))
+        expect(BigInt(tokenInfoPayloads.length)).toBe(totalSupply)
+      }
+    }, 30_000)
+    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/AddressToTotalSupplyIndex/Erc721.TotalSupply.Index.spec.ts

@@ -0,0 +1,120 @@
+import '@xylabs/vitest-extended'
+
+import {
+  CryptoContractFunctionCallSchema,
+  isCryptoContractFunctionCallResult,
+  isCryptoContractFunctionCallSuccess,
+} from '@xyo-network/crypto-contract-function-read-payload-plugin'
+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 { getProviderFromEnv } from '@xyo-network/witness-blockchain-abstract'
+import { TimestampWitness } from '@xyo-network/witness-timestamp'
+import type { Provider } from 'ethers'
+import {
+  beforeAll, describe, expect,
+  it,
+} from 'vitest'
+
+import { CryptoContractDiviner } from '../../Diviner/index.ts'
+import type { CryptoContractFunctionReadWitnessParams } from '../../Witness.ts'
+import { CryptoContractFunctionReadWitness } from '../../Witness.ts'
+import erc721TotalSupplyIndexManifest from './Erc721.TotalSupply.Index.json' with { type: 'json' }
+
+const maxProviders = 32
+
+describe.skipIf(!process.env.INFURA_PROJECT_ID)('Erc721.TotalSupply.Index', () => {
+  let wallet: WalletInstance
+  let node: MemoryNode
+
+  const getProviders = () => {
+    const providers: Provider[] = []
+    for (let i = 0; i < maxProviders; i++) {
+      providers.push(getProviderFromEnv())
+    }
+    return providers
+  }
+  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(CryptoContractDiviner.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(CryptoContractFunctionReadWitness, {
+        config: { abi: ERC721Enumerable__factory.abi },
+        providers: getProviders(),
+      } as CryptoContractFunctionReadWitnessParams),
+      { '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: CryptoContractFunctionCallSchema,
+        }
+        const observations = await sentinel?.report([input])
+        expect(observations?.length).toBe(3)
+        const totalSupply = observations?.filter(isCryptoContractFunctionCallResult).find(isCryptoContractFunctionCallSuccess)
+        expect(totalSupply).toBeDefined()
+        expect(totalSupply?.result).toBeString()
+        const totalSupplyValue = totalSupply?.result as string
+        expect(Number.parseInt(totalSupplyValue)).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 result', async (address) => {
+        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/NftIndexToNftIdIndex/Erc721.NftId.Index.spec.ts

@@ -0,0 +1,133 @@
+import '@xylabs/vitest-extended'
+
+import { delay } from '@xylabs/delay'
+import { CryptoContractFunctionCallSchema } from '@xyo-network/crypto-contract-function-read-payload-plugin'
+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 { getProviderFromEnv } from '@xyo-network/witness-blockchain-abstract'
+import { TimestampWitness } from '@xyo-network/witness-timestamp'
+import type { Provider } from 'ethers'
+import {
+  beforeAll, describe, expect,
+  it,
+} from 'vitest'
+
+import { CryptoContractDiviner } from '../../Diviner/index.ts'
+import type { CryptoContractFunctionReadWitnessParams } from '../../Witness.ts'
+import { CryptoContractFunctionReadWitness } from '../../Witness.ts'
+import nodeManifest from './Erc721.NftId.Index.json' with { type: 'json' }
+
+const maxProviders = 32
+
+describe.skipIf(!process.env.INFURA_PROJECT_ID)('Erc721.NftId.Index', () => {
+  let wallet: WalletInstance
+  let node: MemoryNode
+
+  const getProviders = () => {
+    const providers: Provider[] = []
+    for (let i = 0; i < maxProviders; i++) {
+      providers.push(getProviderFromEnv())
+    }
+    return providers
+  }
+  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(CryptoContractDiviner.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(CryptoContractFunctionReadWitness, {
+        config: { abi: ERC721Enumerable__factory.abi },
+        providers: getProviders(),
+      } as CryptoContractFunctionReadWitnessParams),
+      { '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 tokenIndexes = Array.from({ length: tokensToCheck }).map((_, tokenIndex) => {
+      // Add one to prevent 0 index
+      return tokenIndex + 1
+    })
+    describe('Sentinel', () => {
+      it.each(cases)('returns NftIndexes', async (address) => {
+        const sentinel = asSentinelInstance(await node.resolve('Sentinel'))
+        const chainId = 1
+        const inputs = tokenIndexes.map((_, tokenIndex) => {
+          return {
+            address,
+            args: [`0x${BigInt(tokenIndex).toString(16)}`],
+            chainId,
+            functionName: 'tokenByIndex',
+            schema: CryptoContractFunctionCallSchema,
+          }
+        })
+        const observations = await sentinel?.report(inputs)
+        const nftId = observations?.filter(isNftId)
+        expect(nftId?.length).toBe(tokensToCheck)
+        for (const nftIndex of nftId ?? []) {
+          expect(nftIndex.address).toBe(address)
+          expect(nftIndex.chainId).toBe(chainId)
+        }
+      })
+    })
+    describe.skip('Index', () => {
+      it.each(cases)('returns indexed NftIndex results', async (address) => {
+        await delay(100)
+        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, tokensToCheck - 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/src/spec/TotalSupplyToNftIndexIndex/Erc721.NftIndex.Index.spec.ts

@@ -0,0 +1,127 @@
+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 { 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 { getProviderFromEnv } from '@xyo-network/witness-blockchain-abstract'
+import { TimestampWitness } from '@xyo-network/witness-timestamp'
+import type { Provider } from 'ethers'
+import {
+  beforeAll, describe, expect,
+  it,
+} from 'vitest'
+
+import { CryptoContractDiviner } from '../../Diviner/index.ts'
+import type { CryptoContractFunctionReadWitnessParams } from '../../Witness.ts'
+import { CryptoContractFunctionReadWitness } from '../../Witness.ts'
+import nodeManifest from './Erc721.NftIndex.Index.json' with { type: 'json' }
+
+const maxProviders = 32
+
+describe.skipIf(!process.env.INFURA_PROJECT_ID).skip('Erc721.NftIndex.Index', () => {
+  let wallet: WalletInstance
+  let node: MemoryNode
+
+  const getProviders = () => {
+    const providers: Provider[] = []
+    for (let i = 0; i < maxProviders; i++) {
+      providers.push(getProviderFromEnv())
+    }
+    return providers
+  }
+  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(CryptoContractDiviner.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(CryptoContractFunctionReadWitness, {
+        config: { abi: ERC721Enumerable__factory.abi },
+        providers: getProviders(),
+      } as CryptoContractFunctionReadWitnessParams),
+      { '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 totalSupply = 2710
+    describe('Sentinel', () => {
+      it.each(cases)('returns NftIndexes', async (address) => {
+        const sentinel = asSentinelInstance(await node.resolve('Sentinel'))
+        const chainId = 1
+        const input = {
+          address,
+          args: [],
+          chainId,
+          functionName: 'totalSupply',
+          result: `${totalSupply}`,
+          schema: 'network.xyo.crypto.contract.function.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.skip('Index', () => {
+      it.each(cases)('returns indexed NftIndex results', async (address) => {
+        await delay(100)
+        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/src/spec/Witness.spec.ts

@@ -0,0 +1,46 @@
+import '@xylabs/vitest-extended'
+
+import type { CryptoContractFunctionCall, CryptoContractFunctionCallResult } from '@xyo-network/crypto-contract-function-read-payload-plugin'
+import {
+  CryptoContractFunctionCallResultSchema,
+  CryptoContractFunctionCallSchema,
+  CryptoContractFunctionReadWitnessConfigSchema,
+} from '@xyo-network/crypto-contract-function-read-payload-plugin'
+import { ERC20__factory } from '@xyo-network/open-zeppelin-typechain'
+import type { Payload } from '@xyo-network/payload-model'
+import { isPayloadOfSchemaType } from '@xyo-network/payload-model'
+import { getProviderFromEnv } from '@xyo-network/witness-blockchain-abstract'
+import {
+  describe, expect,
+  it,
+} from 'vitest'
+
+import { CryptoContractFunctionReadWitness } from '../Witness.ts'
+
+const validateObservation = (observation: Payload[]) => {
+  const results = observation.filter(isPayloadOfSchemaType<CryptoContractFunctionCallResult>(CryptoContractFunctionCallResultSchema))
+  expect(results.length).toBeGreaterThan(0)
+  expect(observation.length).toEqual(results.length)
+}
+
+describe.skipIf(!process.env.INFURA_PROJECT_ID)('CryptoWalletNftWitness', () => {
+  const address = '0x55296f69f40ea6d20e478533c15a6b08b654e758' // XYO ERC20
+  const functionName = 'balanceOf'
+  const args = ['0xaDe7DFBC532A01dB67BFEA3b728D4eA22869f381'] // Random Holder
+  const provider = getProviderFromEnv()
+  describe('observe', () => {
+    describe('with no address or chainId in query', () => {
+      it('uses values from config', async () => {
+        const witness = await CryptoContractFunctionReadWitness.create({
+          config: { abi: ERC20__factory.abi, schema: CryptoContractFunctionReadWitnessConfigSchema },
+          providers: [provider],
+        })
+        const call: CryptoContractFunctionCall = {
+          address, args, functionName, schema: CryptoContractFunctionCallSchema,
+        }
+        const observation = await witness.observe([call])
+        validateObservation(observation)
+      })
+    })
+  })
+})

package/typedoc.json

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