@xyo-network/api 2.37.6 → 2.37.7

package/package.json

@@ -11,12 +11,14 @@
   "dependencies": {
     "@xylabs/assert": "^2.6.9",
     "@xylabs/delay": "^2.6.9",
-    "@xyo-network/account": "^2.37.6",
-    "@xyo-network/archivist": "^2.37.6",
-    "@xyo-network/boundwitness": "^2.37.6",
-    "@xyo-network/core": "^2.37.6",
-    "@xyo-network/payload": "^2.37.6",
-    "@xyo-network/schema-payload-plugin": "^2.37.6",
+    "@xyo-network/account": "^2.37.7",
+    "@xyo-network/archivist": "^2.37.7",
+    "@xyo-network/boundwitness": "^2.37.7",
+    "@xyo-network/core": "^2.37.7",
+    "@xyo-network/diviner": "^2.37.7",
+    "@xyo-network/module": "^2.37.7",
+    "@xyo-network/payload": "^2.37.7",
+    "@xyo-network/schema-payload-plugin": "^2.37.7",
     "axios": "^0.27.2",
     "pako": "^2.0.4",
     "tslib": "^2.4.0"
@@ -58,5 +60,5 @@
   },
   "sideEffects": false,
   "types": "dist/esm/index.d.ts",
-  "version": "2.37.6"
+  "version": "2.37.7"
 }

package/src/Archivist/Addresses/Address/Api.spec.ts

@@ -0,0 +1,77 @@
+import { assertEx } from '@xylabs/assert'
+import { XyoAccount } from '@xyo-network/account'
+import { BoundWitnessWrapper, XyoBoundWitness } from '@xyo-network/boundwitness'
+
+import { XyoApiConfig, XyoApiResponseBody } from '../../../models'
+import { XyoApiSimple } from '../../../Simple'
+import { XyoArchivistApi } from '../../Api'
+import { XyoAddressesApi } from '../Api'
+import { ModuleDescription } from '../ModuleDescription'
+import { XyoAddressApi } from './Api'
+
+const config: XyoApiConfig = {
+  apiDomain: process.env.API_DOMAIN || 'http://localhost:8080',
+}
+
+describe('XyoAddressApi', () => {
+  describe('get', () => {
+    let api: XyoAddressApi
+    let result: XyoApiResponseBody<ModuleDescription>
+    beforeAll(async () => {
+      const address = assertEx((await new XyoAddressesApi(config).get())?.pop()?.address)
+      api = new XyoArchivistApi(config).addresses.address(address)
+      result = await api.get()
+      expect(result).toBeObject()
+    })
+    it('method exists', () => {
+      expect(api).toBeDefined()
+      expect(api.get).toBeFunction()
+    })
+    describe('returns module', () => {
+      it('address', () => {
+        expect(result?.address).toBeString()
+      })
+      it('supported queries', () => {
+        const queries = result?.queries
+        expect(queries).toBeArray()
+        expect(queries?.length).toBeGreaterThan(0)
+        queries?.map((query) => {
+          expect(query).toBeString()
+        })
+      })
+    })
+  })
+  describe('boundWitness', () => {
+    let address: string
+    let api: XyoApiSimple<XyoBoundWitness[]>
+    let history: XyoBoundWitness[]
+    beforeAll(async () => {
+      address = new XyoAccount({ phrase: 'test' }).addressValue.hex
+      api = new XyoArchivistApi(config).addresses.address(address).boundWitnesses
+      const result = await api.get()
+      expect(result).toBeArray()
+      expect(result?.length).toBeGreaterThan(0)
+      history = assertEx(result)
+    })
+    it('method exists', () => {
+      expect(api).toBeDefined()
+      expect(api.get).toBeFunction()
+    })
+    describe('return BoundWitnesses', () => {
+      it('from the address specified', () => {
+        history?.map((block) => expect(block.addresses).toContain(address))
+      })
+      it('in sequential order', () => {
+        verifyBlockChainHistory(history)
+      })
+    })
+  })
+})
+
+const verifyBlockChainHistory = (history: XyoBoundWitness[]) => {
+  for (let i = 1; i < history.length; i++) {
+    const current = history[i - 1]
+    const previous = history[i]
+    expect(current.previous_hashes).toContain(new BoundWitnessWrapper(previous).hash)
+  }
+}

package/src/Archivist/Addresses/Address/Api.ts

@@ -0,0 +1,14 @@
+import { XyoBoundWitness } from '@xyo-network/boundwitness'
+
+import { XyoApiConfig } from '../../../models'
+import { XyoApiSimple } from '../../../Simple'
+import { ModuleDescription } from '../ModuleDescription'
+
+export class XyoAddressApi<C extends XyoApiConfig = XyoApiConfig> extends XyoApiSimple<ModuleDescription, C> {
+  public get boundWitnesses(): XyoApiSimple<XyoBoundWitness[]> {
+    return new XyoApiSimple({
+      ...this.config,
+      root: `${this.root}boundwitness/`,
+    })
+  }
+}

package/src/Archivist/Addresses/Address/index.ts

@@ -0,0 +1 @@
+export * from './Api'

package/src/Archivist/Addresses/Api.spec.ts

@@ -0,0 +1,45 @@
+import { XyoApiConfig, XyoApiResponseBody } from '../../models'
+import { XyoAddressesApi } from './Api'
+import { NodeModuleDescription } from './NodeModuleDescription'
+
+const config: XyoApiConfig = {
+  apiDomain: process.env.API_DOMAIN || 'http://localhost:8080',
+}
+
+describe('XyoAddressesApi', () => {
+  describe('get', () => {
+    it('method exists', () => {
+      const api = new XyoAddressesApi(config)
+      expect(api).toBeDefined()
+      expect(api.get).toBeFunction()
+    })
+    describe('returns modules in use on the node with their', () => {
+      let api: XyoAddressesApi
+      let result: XyoApiResponseBody<NodeModuleDescription[]>
+      beforeAll(async () => {
+        api = new XyoAddressesApi(config)
+        result = await api.get()
+        expect(result).toBeArray()
+        expect(result?.length).toBeGreaterThan(0)
+      })
+      it('address', () => {
+        result?.map((module) => {
+          expect(module.address).toBeString()
+        })
+      })
+      it('supported queries', () => {
+        result?.map((module) => {
+          expect(module.queries.length).toBeGreaterThan(0)
+          module.queries.map((query) => {
+            expect(query).toBeString()
+          })
+        })
+      })
+      it('mount point', () => {
+        result?.map((module) => {
+          expect(module.url).toBeString
+        })
+      })
+    })
+  })
+})

package/src/Archivist/Addresses/Api.ts

@@ -0,0 +1,13 @@
+import { XyoApiConfig } from '../../models'
+import { XyoApiSimple } from '../../Simple'
+import { XyoAddressApi } from './Address'
+import { NodeModuleDescription } from './NodeModuleDescription'
+
+export class XyoAddressesApi<C extends XyoApiConfig = XyoApiConfig> extends XyoApiSimple<NodeModuleDescription[], C> {
+  public address(address: string): XyoAddressApi {
+    return new XyoAddressApi({
+      ...this.config,
+      root: `${this.root}${address}/`,
+    })
+  }
+}

package/src/Archivist/Addresses/ModuleDescription.ts

@@ -0,0 +1,4 @@
+export interface ModuleDescription {
+  address: string
+  queries: string[]
+}

package/src/Archivist/Addresses/NodeModuleDescription.ts

@@ -0,0 +1,5 @@
+import { ModuleDescription } from './ModuleDescription'
+
+export interface NodeModuleDescription extends ModuleDescription {
+  url: string
+}

package/src/Archivist/Addresses/index.ts

@@ -0,0 +1,3 @@
+export * from './Api'
+export * from './ModuleDescription'
+export * from './NodeModuleDescription'

package/src/Archivist/Api.ts

@@ -8,11 +8,23 @@ import { XyoApiResponseBody, XyoApiResponseTuple, XyoApiResponseTupleOrBody, Xyo
 import { XyoApiSimple } from '../Simple'
 import { XyoUserApi } from '../User'
 import { XyoAccountApi } from './Account'
+import { XyoAddressesApi } from './Addresses'
 import { XyoArchivistArchiveApi } from './Archive'
 import { XyoArchivistArchivesApi } from './Archives'
 import { XyoArchivistNodeApi } from './Node'
 
 export class XyoArchivistApi extends XyoApiBase {
+  private _addresses?: XyoAddressesApi
+  public get addresses(): XyoAddressesApi {
+    this._addresses =
+      this._addresses ??
+      new XyoAddressesApi({
+        ...this.config,
+        root: `${this.root}address/`,
+      })
+    return this._addresses
+  }
+
   private _archives?: XyoArchivistArchivesApi
   public get archives(): XyoArchivistArchivesApi {
     this._archives =

package/src/Archivist/Payload/Api.ts

@@ -1,6 +1,5 @@
 import { assertEx } from '@xylabs/assert'
-import { XyoPayloadFindFilter } from '@xyo-network/archivist'
-import { XyoPayload } from '@xyo-network/payload'
+import { XyoPayload, XyoPayloadFindFilter } from '@xyo-network/payload'
 
 import { XyoApiConfig } from '../../models'
 import { XyoApiSimple } from '../../Simple'

package/src/Archivist/XyoRemoteArchivist.ts

@@ -1,7 +1,7 @@
 import { assertEx } from '@xylabs/assert'
-import { XyoArchivist, XyoArchivistFindQuerySchema, XyoPayloadFindFilter } from '@xyo-network/archivist'
+import { XyoArchivist, XyoArchivistFindQuerySchema } from '@xyo-network/archivist'
 import { XyoBoundWitness, XyoBoundWitnessSchema } from '@xyo-network/boundwitness'
-import { PayloadWrapper, XyoPayload } from '@xyo-network/payload'
+import { PayloadWrapper, XyoPayload, XyoPayloadFindFilter } from '@xyo-network/payload'
 
 import { RemoteArchivistError } from './RemoteArchivistError'
 import { XyoRemoteArchivistConfig } from './XyoRemoteArchivistConfig'

package/src/Diviner/AddressHistoryDiviner/AddressHistoryDiviner.ts

@@ -0,0 +1,11 @@
+import { XyoDiviner } from '@xyo-network/diviner'
+import { XyoQuery } from '@xyo-network/module'
+import { XyoPayload, XyoPayloadFindFilter } from '@xyo-network/payload'
+
+export type AddressHistoryQuerySchema = 'network.xyo.diviner.address.query'
+export const AddressHistoryQuerySchema: AddressHistoryQuerySchema = 'network.xyo.diviner.address.query'
+
+export type AddressHistoryQueryPayload = XyoQuery<{ address: string; schema: AddressHistoryQuerySchema } & XyoPayloadFindFilter>
+export const isAddressHistoryQueryPayload = (x?: XyoPayload | null): x is AddressHistoryQueryPayload => x?.schema === AddressHistoryQuerySchema
+
+export type AddressHistoryDiviner = XyoDiviner

package/src/Diviner/AddressHistoryDiviner/XyoRemoteAddressHistoryDiviner.spec.ts

@@ -0,0 +1,78 @@
+import { XyoAccount } from '@xyo-network/account'
+import { BoundWitnessWrapper, XyoBoundWitness, XyoBoundWitnessSchema } from '@xyo-network/boundwitness'
+import { XyoDivinerWrapper } from '@xyo-network/diviner'
+import { XyoPayloadBuilder } from '@xyo-network/payload'
+
+import { XyoArchivistApi } from '../../Archivist'
+import { XyoApiConfig } from '../../models'
+import { XyoRemoteDivinerConfigSchema } from '../XyoRemoteDivinerConfig'
+import { AddressHistoryQuerySchema } from './AddressHistoryDiviner'
+import { XyoRemoteAddressHistoryDiviner } from './XyoRemoteAddressHistoryDiviner'
+
+const configData: XyoApiConfig = {
+  apiDomain: process.env.API_DOMAIN || 'https://beta.api.archivist.xyo.network',
+  onError: (error) => console.error(`Error: ${JSON.stringify(error)}`),
+  onFailure: (response) => response, //console.error(`Failure: ${response.statusText} [${response.status}] [${JSON.stringify(response.data)}]`),
+  onSuccess: (response) => response, //console.log(`Success: ${response.statusText} [${response.status}] [${JSON.stringify(response.data)}]`),
+}
+
+describe('XyoRemoteAddressHistoryDiviner', () => {
+  const address = new XyoAccount({ phrase: 'test' }).addressValue.hex
+  const api = new XyoArchivistApi(configData)
+  const diviner = new XyoRemoteAddressHistoryDiviner({ api, schema: XyoRemoteDivinerConfigSchema })
+
+  describe('with valid address returns', () => {
+    let result: XyoBoundWitness[]
+    beforeAll(async () => {
+      const source = new XyoPayloadBuilder({ schema: AddressHistoryQuerySchema }).fields({ address }).build()
+      result = (await new XyoDivinerWrapper(diviner).divine([source])) as XyoBoundWitness[]
+      expect(result.length).toBeGreaterThan(0)
+    })
+    it('array of Bound Witnesses', () => {
+      result.map((bw) => {
+        expect(bw.schema).toBe(XyoBoundWitnessSchema)
+      })
+    })
+    it('from address', () => {
+      expect(result.length).toBeGreaterThan(0)
+      result.map((bw) => {
+        expect(bw.addresses).toContain(address)
+      })
+    })
+  })
+  describe('with hash offset returns', () => {
+    let result: XyoBoundWitness[]
+    let hash: string
+    beforeAll(async () => {
+      let source = new XyoPayloadBuilder({ schema: AddressHistoryQuerySchema }).fields({ address }).build()
+      result = (await new XyoDivinerWrapper(diviner).divine([source])) as XyoBoundWitness[]
+      expect(result.length).toBeGreaterThan(0)
+      hash = new BoundWitnessWrapper(result?.[0]).hash
+      source = new XyoPayloadBuilder({ schema: AddressHistoryQuerySchema }).fields({ address, offset: hash }).build()
+      result = (await new XyoDivinerWrapper(diviner).divine([source])) as XyoBoundWitness[]
+      expect(result.length).toBeGreaterThan(0)
+    })
+    it('results starting at hash', () => {
+      expect(new BoundWitnessWrapper(result?.[0]).hash).toBe(hash)
+    })
+  })
+  describe('with limit returns', () => {
+    const limit = 1
+    let result: XyoBoundWitness[]
+    beforeAll(async () => {
+      const source = new XyoPayloadBuilder({ schema: AddressHistoryQuerySchema }).fields({ address, limit }).build()
+      result = (await new XyoDivinerWrapper(diviner).divine([source])) as XyoBoundWitness[]
+      expect(result.length).toBeGreaterThan(0)
+    })
+    it('number of results specified by the limit', () => {
+      expect(result.length).toBe(limit)
+    })
+  })
+  describe('with non-existent address', () => {
+    it('returns empty array', async () => {
+      const source = new XyoPayloadBuilder({ schema: AddressHistoryQuerySchema }).fields({ address: 'foo' }).build()
+      const result = await new XyoDivinerWrapper(diviner).divine([source])
+      expect(result.length).toBe(0)
+    })
+  })
+})

package/src/Diviner/AddressHistoryDiviner/XyoRemoteAddressHistoryDiviner.ts

@@ -0,0 +1,45 @@
+import { assertEx } from '@xylabs/assert'
+import { XyoBoundWitness } from '@xyo-network/boundwitness'
+import { XyoDiviner, XyoDivinerDivineQuerySchema } from '@xyo-network/diviner'
+import { XyoPayloads } from '@xyo-network/payload'
+
+import { RemoteDivinerError } from '../RemoteDivinerError'
+import { XyoRemoteDivinerConfig } from '../XyoRemoteDivinerConfig'
+import { AddressHistoryDiviner, isAddressHistoryQueryPayload } from './AddressHistoryDiviner'
+
+/** @description Diviner Context that connects to a remote Diviner using the API */
+export class XyoRemoteAddressHistoryDiviner extends XyoDiviner<XyoRemoteDivinerConfig> implements AddressHistoryDiviner {
+  public get api() {
+    return assertEx(this.config?.api, 'API not defined')
+  }
+
+  public override queries() {
+    return [XyoDivinerDivineQuerySchema, ...super.queries()]
+  }
+
+  public override async divine(payloads?: XyoPayloads): Promise<XyoBoundWitness[]> {
+    if (!payloads) return []
+    try {
+      const query = payloads.find(isAddressHistoryQueryPayload)
+      if (!query) return []
+      const { address, limit, offset } = query
+      const find: { limit?: number; offset?: string } = {}
+      if (limit) find.limit = limit
+      if (offset) find.offset = `${offset}`
+      const [data, body, response] =
+        Object.keys(find).length > 0
+          ? await this.api.addresses.address(address).boundWitnesses.find(find, 'tuple')
+          : await this.api.addresses.address(address).boundWitnesses.get('tuple')
+      if (response?.status >= 400) {
+        throw new RemoteDivinerError('divine', `${response.statusText} [${response.status}]`)
+      }
+      if (body?.error?.length) {
+        throw new RemoteDivinerError('divine', body?.error)
+      }
+      return data || []
+    } catch (ex) {
+      console.error(ex)
+      throw ex
+    }
+  }
+}

package/src/Diviner/AddressHistoryDiviner/index.ts

@@ -0,0 +1,2 @@
+export * from './AddressHistoryDiviner'
+export * from './XyoRemoteAddressHistoryDiviner'

package/src/Diviner/RemoteDivinerError.ts

@@ -0,0 +1,9 @@
+export class RemoteDivinerError extends Error {
+  constructor(action: string, error: Error['cause'], message?: string) {
+    super(`Remote Diviner [${action}] failed${message ? ` (${message})` : ''}`, { cause: error })
+  }
+  isRemoteDivinerError = true
+  static isRemoteDivinerError(error: unknown): RemoteDivinerError | undefined {
+    return (error as RemoteDivinerError).isRemoteDivinerError ? (error as RemoteDivinerError) : undefined
+  }
+}

package/src/Diviner/XyoRemoteDivinerConfig.ts

@@ -0,0 +1,12 @@
+import { XyoDivinerConfig } from '@xyo-network/diviner'
+
+import { XyoArchivistApi } from '../Archivist'
+
+export type XyoRemoteDivinerConfigSchema = 'network.xyo.diviner.remote.config'
+export const XyoRemoteDivinerConfigSchema: XyoRemoteDivinerConfigSchema = 'network.xyo.diviner.remote.config'
+
+export type XyoRemoteDivinerConfig = XyoDivinerConfig & {
+  schema: XyoRemoteDivinerConfigSchema
+  api?: XyoArchivistApi
+  archive?: string
+}

package/src/Diviner/index.ts

@@ -1 +1,2 @@
+export * from './AddressHistoryDiviner'
 export * from './LocationDiviner'

package/src/Simple.ts

@@ -1,5 +1,4 @@
-import { XyoPayloadFindFilter } from '@xyo-network/archivist'
-import { XyoPayload } from '@xyo-network/payload'
+import { XyoPayload, XyoPayloadFindFilter } from '@xyo-network/payload'
 
 import { XyoApiBase } from './Base'
 import { XyoApiConfig, XyoApiResponseBody, XyoApiResponseTuple, XyoApiResponseTupleOrBody, XyoApiResponseType } from './models'