@xyo-network/diviner 2.55.4 → 2.56.0

package/src/AddressChain/Config.ts

@@ -1,13 +0,0 @@
-import { DivinerConfig } from '@xyo-network/diviner-model'
-
-import { AddressChainSchema } from './Diviner'
-
-export type AddressChainDivinerConfigSchema = `${AddressChainSchema}.config`
-export const AddressChainDivinerConfigSchema: AddressChainDivinerConfigSchema = `${AddressChainSchema}.config`
-
-export type AddressChainDivinerConfig = DivinerConfig<{
-  address?: string
-  maxResults?: number
-  schema: AddressChainDivinerConfigSchema
-  startHash?: string
-}>

package/src/AddressChain/Diviner.ts

@@ -1,18 +0,0 @@
-import { Query } from '@xyo-network/module-model'
-import { Payload, PayloadFindFilter } from '@xyo-network/payload-model'
-
-import { AbstractDiviner } from '../AbstractDiviner'
-
-export type AddressChainSchema = 'network.xyo.diviner.address.chain'
-export const AddressChainSchema: AddressChainSchema = 'network.xyo.diviner.address.chain'
-
-export type AddressChainQuerySchema = 'network.xyo.diviner.address.chain.query'
-export const AddressChainQuerySchema: AddressChainQuerySchema = 'network.xyo.diviner.address.chain.query'
-
-export type AddressChainPayload = Payload<{ schema: AddressChainSchema }>
-export const isAddressChainPayload = (x?: Payload | null): x is AddressChainPayload => x?.schema === AddressChainSchema
-
-export type AddressChainQueryPayload = Query<{ schema: AddressChainQuerySchema } & PayloadFindFilter>
-export const isAddressChainQueryPayload = (x?: Payload | null): x is AddressChainQueryPayload => x?.schema === AddressChainQuerySchema
-
-export type AddressChainDiviner = AbstractDiviner

package/src/AddressChain/MemoryDiviner.ts

@@ -1,58 +0,0 @@
-import { assertEx } from '@xylabs/assert'
-import { ArchivistGetQuerySchema, ArchivistModule } from '@xyo-network/archivist'
-import { ArchivistWrapper } from '@xyo-network/archivist-wrapper'
-import { BoundWitness } from '@xyo-network/boundwitness-model'
-import { BoundWitnessWrapper } from '@xyo-network/boundwitness-wrapper'
-import { DivinerParams } from '@xyo-network/diviner-model'
-import { AnyConfigSchema } from '@xyo-network/module'
-import { Payload } from '@xyo-network/payload-model'
-
-import { AbstractDiviner } from '../AbstractDiviner'
-import { AddressChainDivinerConfig, AddressChainDivinerConfigSchema } from './Config'
-import { AddressChainDiviner } from './Diviner'
-
-// This diviner returns the most recent boundwitness signed by the address that can be found
-// if multiple broken chains are found, all the heads are returned
-
-export type MemoryAddressChainDivinerParams = DivinerParams<AnyConfigSchema<AddressChainDivinerConfig>>
-
-export class MemoryAddressChainDiviner<TParams extends MemoryAddressChainDivinerParams>
-  extends AbstractDiviner<TParams>
-  implements AddressChainDiviner
-{
-  static override configSchema = AddressChainDivinerConfigSchema
-
-  get queryAddress() {
-    return assertEx(this.config.address, 'Missing address')
-  }
-
-  async divine(payloads?: Payload[]): Promise<Payload[]> {
-    const result: Payload[] = []
-    assertEx(!payloads?.length, 'MemoryAddressChainDiviner.divine does not allow payloads to be sent')
-    const archivists =
-      (await this.resolve({ query: [[ArchivistGetQuerySchema]] }))?.map(
-        (archivist) => new ArchivistWrapper({ account: this.account, module: archivist as ArchivistModule }),
-      ) ?? []
-    let currentHash: string | null = assertEx(this.config.startHash, 'Missing startHash')
-    while (currentHash && result.length < (this.config.maxResults ?? 1000)) {
-      const bwPayload: BoundWitness | undefined = await this.archivistFindHash(archivists, currentHash)
-      const bw: BoundWitnessWrapper | undefined = BoundWitnessWrapper.parse(bwPayload)
-      if (bw) {
-        result.push(bw)
-        currentHash = bw.prev(this.queryAddress)
-      }
-    }
-    return result
-  }
-
-  private async archivistFindHash(archivists: ArchivistWrapper[], hash: string): Promise<BoundWitness | undefined> {
-    let index = 0
-    if (archivists[index]) {
-      const result = (await archivists[index].get([hash])).pop() as BoundWitness
-      if (result) {
-        return result
-      }
-      index++
-    }
-  }
-}

package/src/AddressChain/index.ts

@@ -1,3 +0,0 @@
-export * from './Config'
-export * from './Diviner'
-export * from './MemoryDiviner'

package/src/AddressHistory/Config.ts

@@ -1,11 +0,0 @@
-import { DivinerConfig } from '@xyo-network/diviner-model'
-
-import { AddressHistorySchema } from './Diviner'
-
-export type AddressHistoryDivinerConfigSchema = `${AddressHistorySchema}.config`
-export const AddressHistoryDivinerConfigSchema: AddressHistoryDivinerConfigSchema = `${AddressHistorySchema}.config`
-
-export type AddressHistoryDivinerConfig = DivinerConfig<{
-  address?: string
-  schema: AddressHistoryDivinerConfigSchema
-}>

package/src/AddressHistory/Diviner.ts

@@ -1,18 +0,0 @@
-import { Query } from '@xyo-network/module-model'
-import { Payload, PayloadFindFilter } from '@xyo-network/payload-model'
-
-import { AbstractDiviner } from '../AbstractDiviner'
-
-export type AddressHistorySchema = 'network.xyo.diviner.address.history'
-export const AddressHistorySchema: AddressHistorySchema = 'network.xyo.diviner.address.history'
-
-export type AddressHistoryQuerySchema = 'network.xyo.diviner.address.history.query'
-export const AddressHistoryQuerySchema: AddressHistoryQuerySchema = 'network.xyo.diviner.address.history.query'
-
-export type AddressHistoryPayload = Payload<{ schema: AddressHistorySchema }>
-export const isAddressHistoryPayload = (x?: Payload | null): x is AddressHistoryPayload => x?.schema === AddressHistorySchema
-
-export type AddressHistoryQueryPayload = Query<{ schema: AddressHistoryQuerySchema } & PayloadFindFilter>
-export const isAddressHistoryQueryPayload = (x?: Payload | null): x is AddressHistoryQueryPayload => x?.schema === AddressHistoryQuerySchema
-
-export type AddressHistoryDiviner = AbstractDiviner

package/src/AddressHistory/MemoryDiviner.ts

@@ -1,85 +0,0 @@
-import { assertEx } from '@xylabs/assert'
-import { ArchivistGetQuerySchema, ArchivistModule } from '@xyo-network/archivist'
-import { ArchivistWrapper } from '@xyo-network/archivist-wrapper'
-import { BoundWitness, BoundWitnessSchema } from '@xyo-network/boundwitness-model'
-import { BoundWitnessWrapper } from '@xyo-network/boundwitness-wrapper'
-import { DivinerParams } from '@xyo-network/diviner-model'
-import { AnyConfigSchema } from '@xyo-network/module-model'
-import { Payload } from '@xyo-network/payload-model'
-import { PayloadWrapper } from '@xyo-network/payload-wrapper'
-
-import { AbstractDiviner } from '../AbstractDiviner'
-import { AddressHistoryDivinerConfig, AddressHistoryDivinerConfigSchema } from './Config'
-import { AddressHistoryDiviner } from './Diviner'
-
-// This diviner returns the most recent boundwitness signed by the address that can be found
-// if multiple broken chains are found, all the heads are returned
-
-export type MemoryAddressHistoryDivinerParams = DivinerParams<AnyConfigSchema<AddressHistoryDivinerConfig>>
-
-export class MemoryAddressHistoryDiviner<TParams extends MemoryAddressHistoryDivinerParams>
-  extends AbstractDiviner<TParams>
-  implements AddressHistoryDiviner
-{
-  static override configSchema = AddressHistoryDivinerConfigSchema
-
-  get queryAddress() {
-    return assertEx(this.config.address, 'Missing address')
-  }
-
-  async divine(payloads?: Payload[]): Promise<Payload[]> {
-    assertEx(!payloads?.length, 'MemoryAddressHistoryDiviner.divine does not allow payloads to be sent')
-    const archivists =
-      (await this.resolve({ query: [[ArchivistGetQuerySchema]] }))?.map(
-        (archivist) => new ArchivistWrapper({ account: this.account, module: archivist as ArchivistModule }),
-      ) ?? []
-    assertEx(archivists.length > 0, 'Did not find any archivists')
-    const bwLists = (
-      await Promise.all(
-        archivists.map(async (archivist) => {
-          const all = await archivist.all()
-          return all.filter((payload) => payload.schema === BoundWitnessSchema) as BoundWitness[]
-        }),
-      )
-    ).flat()
-
-    const bwRecords = this.buildWrapperRecords(bwLists)
-
-    const chains = Object.values(this.buildAddressChains(this.queryAddress, bwRecords))
-
-    //return the heads of each chain (get the last bw on each chain)
-    return chains.map((chain) => assertEx(PayloadWrapper.unwrap(chain.shift())))
-  }
-
-  private buildAddressChains(address: string, bwRecords: Record<string, BoundWitnessWrapper>): Record<string, BoundWitnessWrapper[]> {
-    const arrayedResult = Object.entries(bwRecords).reduce<Record<string, BoundWitnessWrapper[]>>((prev, [key, value]) => {
-      prev[key] = [value]
-      return prev
-    }, {})
-    return Object.entries(bwRecords).reduce<Record<string, BoundWitnessWrapper[]>>((prev, [key, value]) => {
-      //check if key is still there (may have been deleted as prevHash)
-      if (prev[key]) {
-        const previousHash = value.prev(address)
-        if (previousHash) {
-          //if we have the previousHash, move this bw to its chain
-          if (prev[previousHash]) {
-            prev[key].push(...prev[previousHash])
-            delete prev[previousHash]
-          }
-        }
-      }
-      return prev
-    }, arrayedResult)
-  }
-
-  //build object with hashes as keys and wrappers as values
-  private buildWrapperRecords(lists: BoundWitness[]) {
-    return lists
-      .filter((bw) => bw.addresses.includes(this.queryAddress))
-      .reduce<Record<string, BoundWitnessWrapper>>((bwRecords, bw) => {
-        const wrapper = new BoundWitnessWrapper(bw)
-        bwRecords[wrapper.hash] = wrapper
-        return bwRecords
-      }, {})
-  }
-}

package/src/AddressHistory/index.ts

@@ -1,3 +0,0 @@
-export * from './Config'
-export * from './Diviner'
-export * from './MemoryDiviner'

package/src/AddressSpace/AddressSpaceDiviner.ts

@@ -1,18 +0,0 @@
-import { Query } from '@xyo-network/module-model'
-import { Payload, PayloadFindFilter } from '@xyo-network/payload-model'
-
-import { AbstractDiviner } from '../AbstractDiviner'
-
-export type AddressSpaceSchema = 'network.xyo.diviner.address.space'
-export const AddressSpaceSchema: AddressSpaceSchema = 'network.xyo.diviner.address.space'
-
-export type AddressSpaceQuerySchema = 'network.xyo.diviner.address.space.query'
-export const AddressSpaceQuerySchema: AddressSpaceQuerySchema = 'network.xyo.diviner.address.space.query'
-
-export type AddressSpacePayload = Payload<{ schema: AddressSpaceSchema }>
-export const isAddressSpacePayload = (x?: Payload | null): x is AddressSpacePayload => x?.schema === AddressSpaceSchema
-
-export type AddressSpaceQueryPayload = Query<{ schema: AddressSpaceQuerySchema } & PayloadFindFilter>
-export const isAddressSpaceQueryPayload = (x?: Payload | null): x is AddressSpaceQueryPayload => x?.schema === AddressSpaceQuerySchema
-
-export type AddressSpaceDiviner = AbstractDiviner

package/src/AddressSpace/MemoryAddressSpaceDiviner.ts

@@ -1,67 +0,0 @@
-import { assertEx } from '@xylabs/assert'
-import { AddressSchema } from '@xyo-network/address-payload-plugin'
-import { ArchivistGetQuerySchema, ArchivistModule } from '@xyo-network/archivist'
-import { ArchivistWrapper } from '@xyo-network/archivist-wrapper'
-import { BoundWitness, BoundWitnessSchema } from '@xyo-network/boundwitness-model'
-import { DivinerConfig, DivinerParams } from '@xyo-network/diviner-model'
-import { AnyConfigSchema } from '@xyo-network/module'
-import { PayloadBuilder } from '@xyo-network/payload-builder'
-import { Payload } from '@xyo-network/payload-model'
-
-import { AbstractDiviner } from '../AbstractDiviner'
-import { AddressSpaceDiviner, AddressSpaceSchema } from './AddressSpaceDiviner'
-
-export type MemoryAddressSpaceDivinerConfigSchema = `${AddressSpaceSchema}.memory.config`
-export const MemoryAddressSpaceDivinerConfigSchema: MemoryAddressSpaceDivinerConfigSchema = `${AddressSpaceSchema}.memory.config`
-
-export type MemoryAddressSpaceDivinerConfig = DivinerConfig<{
-  address?: string
-  archivists?: string[]
-  schema: MemoryAddressSpaceDivinerConfigSchema
-}>
-
-export type MemoryAddressSpaceDivinerParams<
-  TConfig extends AnyConfigSchema<MemoryAddressSpaceDivinerConfig> = AnyConfigSchema<MemoryAddressSpaceDivinerConfig>,
-> = DivinerParams<TConfig>
-
-/**
- * This Diviner returns the list of all addresses encountered for the reachable archivists
- */
-export class MemoryAddressSpaceDiviner<TParams extends MemoryAddressSpaceDivinerParams>
-  extends AbstractDiviner<TParams>
-  implements AddressSpaceDiviner
-{
-  static override configSchema = MemoryAddressSpaceDivinerConfigSchema
-
-  async divine(payloads?: Payload[]): Promise<Payload[]> {
-    assertEx(!payloads?.length, 'MemoryAddressSpaceDiviner.divine does not allow payloads to be sent')
-    const archivists = await this.archivists()
-    assertEx(archivists.length > 0, 'Did not find any archivists')
-    const bwLists = (
-      await Promise.all(
-        archivists.map(async (archivist) => {
-          const all = await archivist.all?.()
-          return (all?.filter((payload) => payload.schema === BoundWitnessSchema) as BoundWitness[]) ?? []
-        }),
-      )
-    ).flat()
-    const addresses = new Set<string>(
-      bwLists
-        .map((bw) => bw.addresses)
-        .flat()
-        .map((address) => address.toLowerCase()),
-    )
-    return [...addresses].map((address) => new PayloadBuilder({ schema: AddressSchema }).fields({ address }).build())
-  }
-
-  private async archivists(): Promise<ArchivistModule[]> {
-    if (this.config.archivists) {
-      return await this.resolve<ArchivistModule>({ address: this.config.archivists })
-    } else {
-      //get all reachable archivists
-      return (await this.resolve<ArchivistModule>({ query: [[ArchivistGetQuerySchema]] })).map(
-        (archivist) => new ArchivistWrapper({ account: this.account, module: archivist }),
-      )
-    }
-  }
-}

package/src/AddressSpace/index.ts

@@ -1,2 +0,0 @@
-export * from './AddressSpaceDiviner'
-export * from './MemoryAddressSpaceDiviner'