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

package/src/spec/Sentinel.token.spec.ts

@@ -0,0 +1,131 @@
+/* eslint-disable max-statements */
+
+import '@xylabs/vitest-extended'
+
+import {
+  createProfiler, profile, profileReport,
+} from '@xylabs/profile'
+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, ERC721URIStorage__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 {
+  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 } from '../Payload.ts'
+import { EvmCallSchema } from '../Payload.ts'
+import { EvmCallWitness } from '../Witness.ts'
+import erc721TokenSentinelManifest from './Erc721TokenSentinel.json' with { type: 'json' }
+
+const profiler = createProfiler()
+
+const tokenCount = 0
+const maxProviders = 2
+
+describe('Erc721Sentinel - Token', () => {
+  // const address = '0x562fC2927c77cB975680088566ADa1dC6cB8b5Ea' //Random ERC721
+  const address = '0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D' // Bored Apes
+  // const address = '0x495f947276749Ce646f68AC8c248420045cb7b5e' //OpenSea Storefront
+  // const address = '0x6802df79bcbbf019fe5cb366ff25720d1365cfd3' //Upgradeable
+
+  const tokenId = 1
+
+  const providers = getProvidersFromEnv(maxProviders)
+
+  describe.skipIf(providers.length === 0)('report', () => {
+    it('specifying address', async () => {
+      profile(profiler, 'setup')
+      const wallet = await HDWallet.random()
+      const locator = new ModuleFactoryLocator()
+      locator.register(EvmCallDiviner.factory())
+
+      locator.register(
+        new ModuleFactory(EvmCallWitness, {
+          config: { abi: ERC721__factory.abi },
+          providers: () => getProvidersFromEnv(maxProviders),
+        } as EvmCallWitnessParams),
+        { 'network.xyo.evm.interface': 'Erc721' },
+      )
+
+      locator.register(
+        new ModuleFactory(EvmCallWitness, {
+          config: { abi: ERC721Enumerable__factory.abi },
+          providers: () => getProvidersFromEnv(maxProviders),
+        } as EvmCallWitnessParams),
+        { 'network.xyo.evm.interface': 'Erc721Enumerable' },
+      )
+
+      locator.register(
+        new ModuleFactory(EvmCallWitness, {
+          config: { abi: ERC721URIStorage__factory.abi },
+          providers: () => getProvidersFromEnv(maxProviders),
+        } as EvmCallWitnessParams),
+        { 'network.xyo.evm.interface': 'ERC721URIStorage' },
+      )
+
+      locator.register(
+        new ModuleFactory(EvmCallWitness, {
+          config: { abi: ERC1155__factory.abi },
+          providers: () => getProvidersFromEnv(maxProviders),
+        } as EvmCallWitnessParams),
+        { 'network.xyo.evm.interface': 'Erc1155' },
+      )
+
+      profile(profiler, 'setup')
+      profile(profiler, 'manifest')
+      const manifest = new ManifestWrapper(erc721TokenSentinelManifest as PackageManifestPayload, wallet, locator)
+      profile(profiler, 'manifest-load')
+      const node = await manifest.loadNodeFromIndex(0)
+      profile(profiler, 'manifest-load')
+      profile(profiler, 'manifest-resolve')
+      const mods = await node.resolve('*')
+      profile(profiler, 'manifest-resolve')
+      profile(profiler, 'manifest')
+      expect(mods.length).toBe(6)
+
+      const tokenSentinel = asSentinelInstance(await node.resolve('NftTokenInfoSentinel'))
+      expect(tokenSentinel).toBeDefined()
+
+      const tokenUriWitness = asWitnessInstance(await node.resolve('Erc721TokenURIWitness'))
+      expect(tokenUriWitness).toBeDefined()
+
+      const ownerOfWitness = asWitnessInstance(await node.resolve('Erc721OwnerOfWitness'))
+      expect(ownerOfWitness).toBeDefined()
+
+      const uriWitness = asWitnessInstance(await node.resolve('Erc1155UriWitness'))
+      expect(uriWitness).toBeDefined()
+
+      const diviner = asDivinerInstance(await node.resolve('TokenInfoDiviner'))
+      expect(diviner).toBeDefined()
+
+      const tokenCallPayload: EvmCall = {
+        address, args: [tokenId], schema: EvmCallSchema,
+      }
+      profile(profiler, 'tokenReport')
+      const report = await tokenSentinel?.report([tokenCallPayload])
+      const info = report?.find(isPayloadOfSchemaType<EvmCallResults>(EvmCallResultsSchema))
+      console.log(`info: ${JSON.stringify(info, null, 2)}`)
+      expect(info?.results?.['ownerOf']?.result).toBeString()
+      expect(info?.results?.['tokenURI']?.result).toBeString()
+    })
+    afterAll(() => {
+      const profileData = profileReport(profiler)
+      if (profileData['tokenReport']) console.log(`Timer: ${profileData['tokenReport'] / tokenCount}ms`)
+      console.log(`Profile: ${JSON.stringify(profileData, null, 2)}`)
+    })
+  })
+})

package/src/spec/Witness.spec.ts

@@ -0,0 +1,43 @@
+import '@xylabs/vitest-extended'
+
+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 { getProvidersFromEnv } from '@xyo-network/witness-evm-abstract'
+import {
+  describe, expect,
+  it,
+} from 'vitest'
+
+import { EvmCallWitnessConfigSchema } from '../model.ts'
+import type { EvmCall, EvmCallResult } from '../Payload.ts'
+import { EvmCallResultSchema, EvmCallSchema } from '../Payload.ts'
+import { EvmCallWitness } from '../Witness.ts'
+
+const validateObservation = (observation: Payload[]) => {
+  const results = observation.filter(isPayloadOfSchemaType<EvmCallResult>(EvmCallResultSchema))
+  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
+  describe('observe', () => {
+    describe('with no address or chainId in query', () => {
+      it('uses values from config', async () => {
+        const witness = await EvmCallWitness.create({
+          account: 'random',
+          config: { abi: ERC20__factory.abi, schema: EvmCallWitnessConfigSchema },
+          providers: getProvidersFromEnv,
+        })
+        const call: EvmCall = {
+          address, args, functionName, schema: EvmCallSchema,
+        }
+        const observation = await witness.observe([call])
+        validateObservation(observation)
+      })
+    })
+  })
+})

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

@@ -0,0 +1,183 @@
+/* eslint-disable max-statements */
+import '@xylabs/vitest-extended'
+
+import type { Address } from '@xylabs/hex'
+import { MemoryArchivist } from '@xyo-network/archivist-memory'
+import { 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 { JsonPathAggregateDiviner } from '@xyo-network/diviner-jsonpath-aggregate-memory'
+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 { Erc1822WitnessParams } from '@xyo-network/erc1822-witness'
+import { Erc1822Witness } from '@xyo-network/erc1822-witness'
+import type { Erc1967WitnessParams } from '@xyo-network/erc1967-witness'
+import { Erc1967Witness } from '@xyo-network/erc1967-witness'
+import type { PackageManifestPayload } from '@xyo-network/manifest'
+import { ManifestWrapper } from '@xyo-network/manifest'
+import { ModuleFactoryLocator } from '@xyo-network/module-factory-locator'
+import {
+  ModuleFactory, resolveLocalNameToAddress, resolveLocalNameToInstance, resolvePathToAddress,
+} 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 { 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 { EvmCall } from '../../../../Payload.ts'
+import { EvmCallSchema } from '../../../../Payload.ts'
+import { EvmCallWitness } 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' }
+
+describe.skip('Contract Node', () => {
+  type TokenType = 'ERC721' | 'ERC1155'
+  const cases: [TokenType, string][] = [
+    ['ERC721', '0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D'.toLowerCase()],
+    // ['ERC1155', '0xEdB61f74B0d09B2558F1eeb79B247c1F363Ae452'.toLowerCase()],
+    // ['ERC1155', '0x2A6d6a082C410a195157EC4caf67CB9fD718f087'.toLowerCase()],
+    // ['ERC1155', '0x33FD426905F149f8376e227d0C9D3340AaD17aF1'.toLowerCase()],
+    // ['ERC1155', '0x7DaEC605E9e2a1717326eeDFd660601e2753A057'.toLowerCase()],
+    // // ['ERC1155', '0xCaf94eB06D4dE233c45B353723C387D3E440f3d6'.toLowerCase()],
+    // ['ERC1155', '0xbF42C1972877F39e102807E5E80ed2ff5D16aa5f'.toLowerCase()],
+  ]
+  let wallet: WalletInstance
+  let wallet721: WalletInstance
+  let wallet1155: 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)
+    wallet721 = await HDWallet.random()
+    wallet1155 = await HDWallet.random()
+    const locator = new ModuleFactoryLocator()
+    locator.register(MemoryArchivist.factory())
+    locator.register(MemoryBoundWitnessDiviner.factory())
+    locator.register(GenericPayloadDiviner.factory())
+    locator.register(TimestampWitness.factory())
+    locator.register(EvmCallDiviner.factory())
+    locator.register(TemporalIndexingDivinerDivinerQueryToIndexQueryDiviner.factory(), EvmCallDiviner.labels)
+    locator.register(TemporalIndexingDivinerIndexCandidateToIndexDiviner.factory(), EvmCallDiviner.labels)
+    locator.register(TemporalIndexingDivinerIndexQueryResponseToDivinerQueryResponseDiviner.factory(), EvmCallDiviner.labels)
+    locator.register(TemporalIndexingDivinerStateToIndexCandidateDiviner.factory(), EvmCallDiviner.labels)
+    locator.register(TemporalIndexingDiviner.factory(), EvmCallDiviner.labels)
+    locator.register(JsonPathAggregateDiviner.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' },
+    )
+    locator.register(JsonPatchDiviner.factory())
+    locator.register(TemporalIndexingDiviner.factory())
+    locator.register(
+      new ModuleFactory(Erc1822Witness, { providers: getProvidersFromEnv } as Erc1822WitnessParams),
+    )
+    locator.register(
+      new ModuleFactory(Erc1967Witness, { providers: getProvidersFromEnv } as Erc1967WitnessParams),
+    )
+
+    const manifest = new ManifestWrapper(sentinelNodeManifest as PackageManifestPayload, wallet, locator)
+    node = await manifest.loadNodeFromIndex(0)
+
+    const manifest721 = new ManifestWrapper(erc721IndexNodeManifest as PackageManifestPayload, wallet721, locator)
+    const node721 = await manifest721.loadNodeFromIndex(0)
+
+    await node.register(node721)
+    await node.attach(node721.address, true)
+
+    const manifest1155 = new ManifestWrapper(erc1155IndexNodeManifest as PackageManifestPayload, wallet1155, locator)
+    const node1155 = await manifest1155.loadNodeFromIndex(0)
+
+    await node.register(node1155)
+    await node.attach(node1155.address, true)
+  })
+  describe('Sentinel', () => {
+    it.each(cases)('With %s (%s)', async (_, address) => {
+      const collectionSentinel = asSentinelInstance(await node.resolve('NftInfoSentinel'))
+      expect(collectionSentinel).toBeDefined()
+      const collectionCallPayload: EvmCall = { address: address.toLowerCase(), schema: EvmCallSchema }
+      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('NftInfo:Erc721IndexDiviner'))
+      expect(diviner).toBeDefined()
+      const query: PayloadDivinerQueryPayload = { address: address.toLowerCase() as Address, schema: PayloadDivinerQuerySchema }
+      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 erc1155Node = await resolveLocalNameToInstance(node, 'ERC1155Node')
+      expect(erc1155Node).toBeDefined()
+      if (erc1155Node) {
+        expect(await resolveLocalNameToAddress(erc1155Node, 'Erc1155IndexDiviner')).toBeDefined()
+        const modAddress = await resolvePathToAddress(node, 'ERC1155Node:Erc1155IndexDiviner')
+        expect(modAddress).toBeDefined()
+        if (modAddress) {
+          const diviner = asDivinerInstance(await node.resolve(modAddress))
+          expect(diviner).toBeDefined()
+          const query: PayloadDivinerQueryPayload = { address: address.toLowerCase() as Address, schema: PayloadDivinerQuerySchema }
+          const result = await diviner?.divine([query])
+          expect(result).toBeDefined()
+          expect(result).toBeArrayOfSize(1)
+        }
+      }
+    })
+  })
+})

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

@@ -0,0 +1,143 @@
+/* eslint-disable max-statements */
+
+import '@xylabs/vitest-extended'
+
+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 {
+  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 } from '../../../../Payload.ts'
+import { 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
+}
+
+const 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))
+
+      expect(info?.results?.name?.result).toBe('BoredApeYachtClub')
+      expect(info?.results?.symbol?.result).toBe('BAYC')
+    })
+    afterAll(() => {
+      const profileData = profileReport()
+      if (profileData['tokenReport']) console.log(`Timer: ${profileData['tokenReport'] / tokenCount}ms`)
+      console.log(`Profile: ${JSON.stringify(profileData, null, 2)}`)
+    })
+  })
+})