@xyo-network/evm-token-interface-diviner 4.1.1 → 5.0.0

package/dist/neutral/index.d.ts

@@ -1,88 +1,3 @@
-import { AbstractDiviner } from '@xyo-network/diviner-abstract';
-import { DivinerConfig, DivinerParams } from '@xyo-network/diviner-model';
-import { EvmContract } from '@xyo-network/evm-contract-witness';
-import { AnyConfigSchema } from '@xyo-network/module-model';
-import { Payload, Schema } from '@xyo-network/payload-model';
-import { JsonFragment } from 'ethers';
-
-/**
- * ERC20 Token Interfaces
- */
-type ERC20TokenInterfaces = 'ERC20';
-/**
- * ERC721 Token Interfaces
- */
-type ERC721TokenInterfaces = 'ERC721' | 'ERC721TokenReceiver' | 'ERC721Metadata' | 'ERC721Enumerable';
-/**
- * ERC1155 Token Interfaces
- */
-type ERC1155TokenInterfaces = 'ERC1155' | 'ERC1155TokenReceiver' | 'ERC1155Metadata_URI';
-/**
- * All Token Interfaces
- */
-type TokenInterface = ERC20TokenInterfaces | ERC721TokenInterfaces | ERC1155TokenInterfaces;
-/**
- * The schema for the EVM Token Interface Implemented payload
- */
-declare const EvmTokenInterfaceImplementedSchema = "network.xyo.evm.token.interface.implemented";
-/**
- * The schema for the EVM Token Interface Implemented payload
- */
-type EvmTokenInterfaceImplementedSchema = typeof EvmTokenInterfaceImplementedSchema;
-/**
- * The EVM Token Interface Implemented payload
- */
-type EvmTokenInterfaceImplemented = Payload<{
-    /**
-     * The contract address
-     */
-    address: string;
-    /**
-     * The chain id
-     */
-    chainId: number;
-    /**
-     * True if the contract implements the interface
-     */
-    implemented: boolean;
-    /**
-     * The specific token interface
-     */
-    tokenInterface: TokenInterface;
-}, EvmTokenInterfaceImplementedSchema>;
-/**
- * Identity function for EvmTokenInterfaceImplemented payload
- */
-declare const isEvmTokenInterfaceImplemented: (x?: unknown | null) => x is EvmTokenInterfaceImplemented;
-
-declare const EvmTokenInterfaceImplementedDivinerConfigSchema = "network.xyo.evm.token.interface.implemented.diviner.config";
-type EvmTokenInterfaceImplementedDivinerConfigSchema = typeof EvmTokenInterfaceImplementedDivinerConfigSchema;
-type EvmTokenInterfaceImplementedDivinerConfig = DivinerConfig<{
-    schema: EvmTokenInterfaceImplementedDivinerConfigSchema;
-    tokenInterfaces?: TokenInterface[];
-}>;
-type EvmTokenInterfaceImplementedDivinerParams = DivinerParams<AnyConfigSchema<EvmTokenInterfaceImplementedDivinerConfig>>;
-type DistributiveMappedType<T> = T extends string ? {
-    [K in T]: readonly JsonFragment[];
-} : never;
-type TokenInterfaceDictionary = DistributiveMappedType<TokenInterface>;
-/**
- * A diviner that checks if a contract implements a token interface
- */
-declare class EvmTokenInterfaceImplementedDiviner<TParams extends EvmTokenInterfaceImplementedDivinerParams = EvmTokenInterfaceImplementedDivinerParams> extends AbstractDiviner<TParams, EvmContract, EvmTokenInterfaceImplemented> {
-    /**
-     * The list of supported token interfaces
-     */
-    static readonly SupportedTokenInterfaces: Readonly<Record<TokenInterface, readonly JsonFragment[]>>;
-    static readonly configSchemas: Schema[];
-    static readonly defaultConfigSchema: Schema;
-    private _tokenInterfaces?;
-    /**
-     * The list of token interfaces to check against the contract
-     */
-    get tokenInterfaces(): TokenInterfaceDictionary;
-    protected divineHandler(inPayloads?: EvmContract[]): Promise<EvmTokenInterfaceImplemented[]>;
-}
-
-export { EvmTokenInterfaceImplementedDiviner, EvmTokenInterfaceImplementedDivinerConfigSchema, EvmTokenInterfaceImplementedSchema, isEvmTokenInterfaceImplemented };
-export type { ERC1155TokenInterfaces, ERC20TokenInterfaces, ERC721TokenInterfaces, EvmTokenInterfaceImplemented, EvmTokenInterfaceImplementedDivinerConfig, EvmTokenInterfaceImplementedDivinerParams, TokenInterface };
+export * from './Diviner.ts';
+export * from './Payload.ts';
+//# sourceMappingURL=index.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xyo-network/evm-token-interface-diviner",
-  "version": "4.1.1",
+  "version": "5.0.0",
   "description": "Typescript/Javascript Plugins for XYO Platform",
   "homepage": "https://xyo.network",
   "bugs": {
@@ -28,40 +28,43 @@
   },
   "module": "dist/neutral/index.mjs",
   "types": "dist/neutral/index.d.ts",
+  "files": [
+    "dist",
+    "src"
+  ],
   "dependencies": {
-    "@xylabs/assert": "^4.13.23",
-    "@xyo-network/diviner-abstract": "^4.1.7",
-    "@xyo-network/diviner-model": "^4.1.7",
-    "@xyo-network/evm-contract-witness": "^4.1.1",
-    "@xyo-network/module-model": "^4.1.7",
+    "@xylabs/assert": "^5.0.0",
+    "@xyo-network/diviner-abstract": "^5.0.0",
+    "@xyo-network/diviner-model": "^5.0.0",
+    "@xyo-network/evm-contract-witness": "^5.0.0",
+    "@xyo-network/module-model": "^5.0.0",
     "@xyo-network/open-zeppelin-typechain": "^3.5.4",
-    "@xyo-network/payload-model": "^4.1.7",
+    "@xyo-network/payload-model": "^5.0.0",
     "ethers": "^6.15.0"
   },
   "devDependencies": {
-    "@xylabs/delay": "^4.13.23",
-    "@xylabs/ts-scripts-yarn3": "^7.0.0-rc.24",
-    "@xylabs/tsconfig": "^7.0.0-rc.24",
-    "@xylabs/vitest-extended": "^4.13.23",
-    "@xyo-network/archivist-memory": "^4.1.7",
-    "@xyo-network/boundwitness-model": "^4.1.7",
-    "@xyo-network/diviner-boundwitness-memory": "^4.1.7",
-    "@xyo-network/diviner-jsonpatch": "^4.1.7",
-    "@xyo-network/diviner-payload-generic": "^4.1.7",
-    "@xyo-network/diviner-payload-memory": "^4.1.7",
-    "@xyo-network/diviner-payload-model": "^4.1.7",
-    "@xyo-network/diviner-stateful": "^4.1.7",
-    "@xyo-network/diviner-temporal-indexing": "^4.1.7",
-    "@xyo-network/manifest": "^4.1.7",
-    "@xyo-network/module-factory-locator": "^4.1.7",
-    "@xyo-network/node-memory": "^4.1.7",
+    "@xylabs/delay": "^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/boundwitness-model": "^5.0.0",
+    "@xyo-network/diviner-boundwitness-memory": "^5.0.0",
+    "@xyo-network/diviner-jsonpatch": "^5.0.0",
+    "@xyo-network/diviner-payload-generic": "^5.0.0",
+    "@xyo-network/diviner-payload-memory": "^5.0.0",
+    "@xyo-network/diviner-payload-model": "^5.0.0",
+    "@xyo-network/diviner-stateful": "^5.0.0",
+    "@xyo-network/diviner-temporal-indexing": "^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.1.7",
-    "@xyo-network/wallet": "^4.1.7",
-    "@xyo-network/wallet-model": "^4.1.7",
-    "@xyo-network/witness-evm-abstract": "^4.1.7",
-    "@xyo-network/witness-timestamp": "^4.1.7",
-    "knip": "^5.62.0",
+    "@xyo-network/sentinel-model": "^5.0.0",
+    "@xyo-network/wallet": "^5.0.0",
+    "@xyo-network/wallet-model": "^5.0.0",
+    "@xyo-network/witness-evm-abstract": "^5.0.0",
+    "@xyo-network/witness-timestamp": "^5.0.0",
     "typescript": "^5.8.3",
     "vitest": "^3.2.4"
   },

package/src/spec/Diviner.spec.ts

@@ -0,0 +1,64 @@
+import '@xylabs/vitest-extended'
+
+import {
+  EvmContractSchema, EvmContractWitness, EvmContractWitnessConfigSchema,
+} from '@xyo-network/evm-contract-witness'
+import { EvmAddressSchema, getProvidersFromEnv } from '@xyo-network/witness-evm-abstract'
+import {
+  describe, expect,
+  it,
+} from 'vitest'
+
+import { EvmTokenInterfaceImplementedDiviner, EvmTokenInterfaceImplementedDivinerConfigSchema } from '../Diviner.ts'
+import type { TokenInterface } from '../Payload.ts'
+
+describe.skipIf(!process.env.INFURA_PROJECT_ID)('EvmTokenInterfaceImplementedDiviner', () => {
+  type TestData = readonly [string, TokenInterface[]]
+  const cases: readonly TestData[] = [
+    ['0x55296f69f40ea6d20e478533c15a6b08b654e758', ['ERC20'] as TokenInterface[]], // XYO ERC20
+    ['0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D', ['ERC721', 'ERC721Metadata', 'ERC721Enumerable', 'ERC721TokenReceiver'] as TokenInterface[]], // BAYC
+    ['0x2A6d6a082C410a195157EC4caf67CB9fD718f087', ['ERC1155', 'ERC1155Metadata_URI', 'ERC1155TokenReceiver'] as TokenInterface[]], // Spider Tanks
+  ] as const
+  describe('divine', () => {
+    describe('with matching ABI', () => {
+      it.each(cases)('returns implemented true', async (address, tokenInterfaces) => {
+        const witness = await EvmContractWitness.create({
+          account: 'random',
+          config: { schema: EvmContractWitnessConfigSchema },
+          providers: getProvidersFromEnv,
+        })
+        const diviner = await EvmTokenInterfaceImplementedDiviner.create({
+          account: 'random',
+          config: { schema: EvmTokenInterfaceImplementedDivinerConfigSchema, tokenInterfaces },
+        })
+        const observations = await witness.observe([{ address, schema: EvmAddressSchema }])
+        expect(observations?.length).toBeGreaterThan(0)
+        const code = observations?.[0].code
+        const results = await diviner.divine([{
+          address, block: 0, chainId: 1, code, schema: EvmContractSchema,
+        }])
+        expect(results?.length).toBeGreaterThan(0)
+        for (const result of results ?? []) {
+          expect(result.address).toBe(address)
+          expect(result.implemented).toBeTrue()
+        }
+      })
+    })
+    describe('without matching ABI', () => {
+      it.each(cases)('returns implemented false', async (address, tokenInterfaces) => {
+        const diviner = await EvmTokenInterfaceImplementedDiviner.create({
+          account: 'random',
+          config: { schema: EvmTokenInterfaceImplementedDivinerConfigSchema, tokenInterfaces },
+        })
+        const results = await diviner.divine([{
+          address, block: 0, chainId: 1, code: '0x00', schema: EvmContractSchema,
+        }])
+        expect(results?.length).toBeGreaterThan(0)
+        for (const result of results ?? []) {
+          expect(result.address).toBe(address)
+          expect(result.implemented).toBeFalse()
+        }
+      })
+    })
+  })
+})

package/src/spec/TokenNode.spec.ts

@@ -0,0 +1,152 @@
+import '@xylabs/vitest-extended'
+
+import { assertEx } from '@xylabs/assert'
+import { delay } from '@xylabs/delay'
+import { MemoryArchivist } from '@xyo-network/archivist-memory'
+import type { BoundWitness } from '@xyo-network/boundwitness-model'
+import { isBoundWitness } from '@xyo-network/boundwitness-model'
+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 { PayloadDivinerQuerySchema } from '@xyo-network/diviner-payload-model'
+import { StatefulDiviner, StatefulDivinerParams } from '@xyo-network/diviner-stateful'
+import {
+  TemporalIndexingDiviner,
+  TemporalIndexingDivinerDivinerQueryToIndexQueryDiviner,
+  TemporalIndexingDivinerIndexCandidateToIndexDiviner,
+  TemporalIndexingDivinerIndexQueryResponseToDivinerQueryResponseDiviner,
+  TemporalIndexingDivinerStateToIndexCandidateDiviner,
+} from '@xyo-network/diviner-temporal-indexing'
+import type { EvmContract, EvmContractWitnessParams } from '@xyo-network/evm-contract-witness'
+import { EvmContractWitness, isEvmContract } from '@xyo-network/evm-contract-witness'
+import type { ModuleManifest, PackageManifestPayload } from '@xyo-network/manifest'
+import { ManifestWrapper } from '@xyo-network/manifest'
+import { ModuleFactoryLocator } from '@xyo-network/module-factory-locator'
+import {
+  creatableModule, CreatableModuleInstance, ModuleFactory, ModuleState,
+} from '@xyo-network/module-model'
+import type { MemoryNode } from '@xyo-network/node-memory'
+import { Payload } from '@xyo-network/payload-model'
+import { asSentinelInstance } from '@xyo-network/sentinel-model'
+import { HDWallet } from '@xyo-network/wallet'
+import type { WalletInstance } from '@xyo-network/wallet-model'
+import type { EvmAddress } from '@xyo-network/witness-evm-abstract'
+import { EvmAddressSchema, getProviderFromEnv } from '@xyo-network/witness-evm-abstract'
+import type { TimeStamp } from '@xyo-network/witness-timestamp'
+import { isTimestamp, TimestampWitness } from '@xyo-network/witness-timestamp'
+import type { Provider } from 'ethers'
+import {
+  beforeAll,
+  describe, expect, it,
+} from 'vitest'
+
+import { EvmTokenInterfaceImplementedDiviner } from '../Diviner.ts'
+import type { TokenInterface } from '../Payload.ts'
+import { isEvmTokenInterfaceImplemented } from '../Payload.ts'
+import contractWitnessManifest from './Contract.Witness.Index.json' with { type: 'json' }
+import tokenDivinerManifest from './Token.Diviner.Index.json' with { type: 'json' }
+import tokenNodeManifest from './TokenNode.json' with { type: 'json' }
+
+const maxProviders = 32
+
+@creatableModule<CreatableModuleInstance<StatefulDivinerParams>>()
+class TestStatefulDiviner extends StatefulDiviner {
+  callCommitState(state: ModuleState) {
+    return this.commitState(state)
+  }
+
+  callRetrieveState() {
+    return this.retrieveState()
+  }
+
+  protected override divineHandler(payloads?: Payload[]): Promise<Payload[]> {
+    return Promise.resolve(payloads ?? [])
+  }
+}
+
+describe('Contract Node', () => {
+  const chainId = 1
+  const cases: [TokenInterface, string][] = [
+    ['ERC721', '0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D'], // BAYC
+    ['ERC1155', '0x2A6d6a082C410a195157EC4caf67CB9fD718f087'], // Spider Tanks
+  ]
+  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(TemporalIndexingDivinerDivinerQueryToIndexQueryDiviner.factory())
+    locator.register(TemporalIndexingDivinerIndexCandidateToIndexDiviner.factory())
+    locator.register(TemporalIndexingDivinerIndexQueryResponseToDivinerQueryResponseDiviner.factory())
+    locator.register(TemporalIndexingDivinerStateToIndexCandidateDiviner.factory())
+    locator.register(TemporalIndexingDiviner.factory())
+    locator.register(JsonPatchDiviner.factory())
+    locator.register(TestStatefulDiviner.factory())
+    locator.register(EvmTokenInterfaceImplementedDiviner.factory())
+    locator.register(
+      new ModuleFactory(EvmContractWitness, { providers: getProviders } as EvmContractWitnessParams),
+    )
+    const publicChildren: ModuleManifest[] = [...contractWitnessManifest.nodes, ...tokenDivinerManifest.nodes]
+    const manifest = new ManifestWrapper(tokenNodeManifest as PackageManifestPayload, wallet, locator, publicChildren)
+    node = assertEx((await manifest.loadNodes()).at(0), () => 'Node not loaded')
+    const mods = await node.resolve('*')
+    expect(mods).toBeDefined()
+  })
+  describe('Contract Witness Index Node', () => {
+    it.each(cases)('With %s (%s)', async (tokenInterface, address) => {
+      const contractSentinel = asSentinelInstance(await node.resolve('EvmContractSentinel'))
+      expect(contractSentinel).toBeDefined()
+      const collectionCallPayload: EvmAddress = {
+        address, chainId, schema: EvmAddressSchema,
+      }
+      const report = await contractSentinel?.report([collectionCallPayload])
+      expect(report).toBeDefined()
+      expect(report).toBeArrayOfSize(3)
+      const [bw, timestamp, contract] = (report as [BoundWitness, TimeStamp, EvmContract]) ?? []
+      expect(isBoundWitness(bw)).toBeTrue()
+      expect(isTimestamp(timestamp)).toBeTrue()
+      expect(isEvmContract(contract)).toBeTrue()
+      expect(contract.address).toBe(address)
+      expect(contract.chainId).toBe(chainId)
+      expect(contract.code).toBeDefined()
+      const divinerName = `${tokenInterface}TokenInterfaceImplementedSentinel`
+      const tokenSentinel = asSentinelInstance(await node.resolve(divinerName))
+      expect(tokenSentinel).toBeDefined()
+      const tokenReport = await tokenSentinel?.report([contract])
+      expect(tokenReport).toBeDefined()
+      const anyInterfacesImplemented = tokenReport?.filter(isEvmTokenInterfaceImplemented).some(i => i.implemented)
+      expect(anyInterfacesImplemented).toBeTrue()
+    })
+  })
+  describe.skip('Token Diviner Index Node', () => {
+    beforeAll(async () => {
+      // Alow indexers to index
+      await delay(1000)
+    })
+    it.each(cases)('With %s (%s)', async (tokenInterface, address) => {
+      const divinerModule = await node.resolve('EvmTokenInterfaceImplementedIndexDiviner')
+      expect(divinerModule).toBeDefined()
+      const diviner = asDivinerInstance(divinerModule)
+      expect(diviner).toBeDefined()
+      const query = {
+        address, chainId, implemented: true, schema: PayloadDivinerQuerySchema, tokenInterface,
+      }
+      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