@xyo-network/api 2.41.10 → 2.41.12

package/src/Api/Api.spec.ts

@@ -1,207 +1,17 @@
-import { XyoAccount } from '@xyo-network/account'
-import { XyoApiConfig, XyoApiError } from '@xyo-network/api-models'
-import { BoundWitnessBuilder, XyoBoundWitness } from '@xyo-network/boundwitness'
+import { getApi } from './ApiUtil.spec'
 
-import { testPayload } from '../Test'
-import { XyoArchivistApi } from './Api'
-import { getNewArchive, getRandomArchiveName } from './ApiUtil.spec'
-
-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('postBoundWitness', () => {
-  it.each([true, false])('posts a single bound witness', async (inlinePayloads) => {
-    const builder = new BoundWitnessBuilder({ inlinePayloads }).witness(XyoAccount.random()).payload(testPayload)
-    const api = new XyoArchivistApi(configData)
-    const [boundWitness] = builder.build()
-    try {
-      const response = await api.archives.archive().block.post([boundWitness])
-
-      expect(response?.length).toEqual(1)
-    } catch (ex) {
-      const error = ex as XyoApiError
-      console.log(JSON.stringify(error.response?.data, null, 2))
-      expect(error === undefined)
-    }
-  })
-})
-
-describe('postBoundWitnesses', () => {
-  it.each([true, false])('posts multiple bound witnesses', async (inlinePayloads) => {
-    const builder = new BoundWitnessBuilder({ inlinePayloads }).witness(XyoAccount.random()).payload(testPayload)
-    const api = new XyoArchivistApi(configData)
-    const [json] = builder.build()
-    const boundWitnesses: XyoBoundWitness[] = [json, json]
-
-    //TODO: We are casting the result here since the server has not yet been updated to return the actual saved data
-
-    try {
-      const response = await api.archives.archive().block.post(boundWitnesses)
-      expect(response?.length).toEqual(2)
-    } catch (ex) {
-      const error = ex as XyoApiError
-      console.log(JSON.stringify(error, null, 2))
-      expect(error === undefined)
-    }
-  })
-})
-
-describe.skip('XyoArchivistApi', () => {
+describe('XyoArchivistApi', () => {
   describe('get', () => {
-    it('returns a new XyoArchivistApi', () => {
-      const api = new XyoArchivistApi(configData)
+    it('returns Node Description', async () => {
+      const api = getApi()
       expect(api).toBeDefined()
-    })
-  })
-
-  describe('getArchives', function () {
-    let archive = ''
-    beforeEach(() => {
-      archive = getRandomArchiveName()
-    })
-    it('gets an array of archives owned', async () => {
-      const api = new XyoArchivistApi(configData)
-      try {
-        await api.archives.archive(archive).put()
-        const archives = await api.archives.get()
-        expect(Array.isArray(archives)).toBe(true)
-        const archiveNames = archives?.map((x) => x.archive)
-        expect(archiveNames).toContain(archive)
-      } catch (ex) {
-        const error = ex as XyoApiError
-        console.log(JSON.stringify(error.response?.data, null, 2))
-        expect(error === undefined)
-      }
-    })
-  })
-
-  describe('getArchive', function () {
-    let archive = ''
-    beforeEach(() => {
-      archive = getRandomArchiveName()
-    })
-    it('gets the archive', async () => {
-      const api = new XyoArchivistApi(configData)
-      try {
-        await api.archives.archive(archive).get()
-        const response = await api.archives.archive(archive).get()
-        expect(response?.archive).toBe(archive)
-      } catch (ex) {
-        const error = ex as XyoApiError
-        console.log(JSON.stringify(error.response?.data, null, 2))
-        expect(error === undefined)
-      }
-    })
-  })
-
-  describe('putArchive', function () {
-    let archive = ''
-    beforeEach(() => {
-      archive = getRandomArchiveName()
-    })
-    it('returns the archive owned', async () => {
-      const api = new XyoArchivistApi(configData)
-      try {
-        const response = await api.archives.archive(archive).put()
-        expect(response?.archive).toEqual(archive)
-      } catch (ex) {
-        const error = ex as XyoApiError
-        console.log(JSON.stringify(error.response?.data, null, 2))
-        expect(error === undefined)
-      }
-    })
-  })
-
-  describe('getArchiveKeys', function () {
-    it('Returns the keys for the archive', async () => {
-      try {
-        const archive = getRandomArchiveName()
-        const api = new XyoArchivistApi({ ...configData })
-        const archiveApi = api.archives.archive(archive)
-        await archiveApi.put()
-        const key = await archiveApi.settings.key.post()
-        const response = await archiveApi.settings.key.get()
-        expect(response?.length).toEqual(1)
-        expect(response?.[0]).toEqual(key)
-      } catch (ex) {
-        const error = ex as XyoApiError
-        console.log(JSON.stringify(error.response?.data, null, 2))
-        expect(error === undefined)
-      }
-    })
-  })
-
-  describe('postArchiveKey', function () {
-    it('Creates an archive key', async () => {
-      try {
-        const archive = getRandomArchiveName()
-        const api = new XyoArchivistApi({ ...configData })
-        const archiveApi = api.archives.archive(archive)
-        await archiveApi.put()
-        const response = await archiveApi.settings.key.post()
-        expect(response?.keys.length).toBe(1)
-      } catch (ex) {
-        const error = ex as XyoApiError
-        console.log(JSON.stringify(error.response?.data, null, 2))
-        expect(error === undefined)
-      }
-    })
-  })
-
-  describe('findBoundWitnessesStats', function () {
-    it('returns stats for boundwitness', async () => {
-      let api = new XyoArchivistApi(configData)
-      try {
-        api = new XyoArchivistApi({ ...configData })
-        const stats = await api.archives.archive().block.stats.get()
-        expect(stats?.count).toBeGreaterThan(0)
-      } catch (ex) {
-        const error = ex as XyoApiError
-        console.log(JSON.stringify(error.response?.data, null, 2))
-        expect(error === undefined)
-      }
-    })
-  })
-
-  describe('findBoundWitnessesBefore', function () {
-    it('returns bound witnesses from before the timestamp', async () => {
-      let api = new XyoArchivistApi(configData)
-      try {
-        api = new XyoArchivistApi({ ...configData })
-        const [boundWitness] = new BoundWitnessBuilder().witness(XyoAccount.random()).build()
-        await api.archives.archive().block.post([boundWitness])
-        const timestamp = Date.now() + 10000
-        // eslint-disable-next-line deprecation/deprecation
-        const response = await api.archives.archive('temp').block.findBefore(timestamp)
-        expect(response?.length).toBe(1)
-      } catch (ex) {
-        const error = ex as XyoApiError
-        console.log(JSON.stringify(error.response?.data, null, 2))
-        expect(error === undefined)
-      }
-    })
-  })
-
-  describe('findBoundWitnessesAfter', function () {
-    it('returns bound witnesses from before the timestamp', async () => {
-      let api = new XyoArchivistApi(configData)
-      try {
-        const archive = await getNewArchive(api)
-        api = new XyoArchivistApi({ ...configData })
-        const [boundWitness] = new BoundWitnessBuilder().witness(XyoAccount.random()).build()
-        await api.archives.archive(archive).block.post([boundWitness])
-        const timestamp = Date.now() - 10000
-        const response = await api.archives.archive(archive).block.find({ order: 'asc', timestamp })
-        expect(response?.length).toBe(1)
-      } catch (ex) {
-        const error = ex as XyoApiError
-        console.log(JSON.stringify(error.response?.data, null, 2))
-        expect(error === undefined)
-      }
+      const response = await api.get()
+      expect(response).toBeObject()
+      expect(response?.address).toBeString()
+      expect(response?.queries).toBeArray()
+      expect(response?.queries?.length).toBeGreaterThan(0)
+      expect(response?.children).toBeArray()
+      expect(response?.children?.length).toBeGreaterThan(0)
     })
   })
 })

package/src/Api/Api.ts

@@ -1,10 +1,10 @@
-import { XyoAddressValue } from '@xyo-network/account'
-import { XyoApiResponseBody, XyoApiResponseTuple, XyoApiResponseTupleOrBody, XyoApiResponseType } from '@xyo-network/api-models'
+import { AddressValue } from '@xyo-network/account'
+import { XyoApiConfig } from '@xyo-network/api-models'
 import { XyoBoundWitness } from '@xyo-network/boundwitness'
-import { XyoDataLike } from '@xyo-network/core'
+import { DataLike } from '@xyo-network/core'
+import { ModuleDescription } from '@xyo-network/module'
 import { Huri, XyoPayload } from '@xyo-network/payload'
 
-import { XyoApiBase } from '../Base'
 import { XyoApiSimple } from '../Simple'
 import { XyoUserApi } from '../User'
 import { XyoAccountApi } from './Account'
@@ -13,7 +13,7 @@ import { XyoArchivistArchiveApi } from './Archive'
 import { XyoArchivistArchivesApi } from './Archives'
 import { XyoArchivistNodeApi } from './Node'
 
-export class XyoArchivistApi extends XyoApiBase {
+export class XyoArchivistApi<C extends XyoApiConfig = XyoApiConfig> extends XyoApiSimple<ModuleDescription, C> {
   private _addresses?: XyoAddressesApi
   private _archives?: XyoArchivistArchivesApi
   private _stats?: XyoApiSimple<unknown[]>
@@ -59,10 +59,10 @@ export class XyoArchivistApi extends XyoApiBase {
     return this._user
   }
 
-  public account(address: XyoDataLike) {
+  public account(address: DataLike) {
     return new XyoAccountApi({
       ...this.config,
-      root: `${this.root}wallet/${new XyoAddressValue(address).hex}/`,
+      root: `${this.root}wallet/${new AddressValue(address).hex}/`,
     })
   }
 
@@ -74,23 +74,6 @@ export class XyoArchivistApi extends XyoApiBase {
     })
   }
 
-  /** @deprecated use huri(huri) instead */
-  public async get(huri: Huri | string): Promise<XyoApiResponseBody<XyoPayload>>
-  /** @deprecated use huri(huri) instead */
-  public async get(huri: Huri | string, responseType?: 'body'): Promise<XyoApiResponseBody<XyoPayload>>
-  /** @deprecated use huri(huri) instead */
-  public async get(huri: Huri | string, responseType?: 'tuple'): Promise<XyoApiResponseTuple<XyoPayload>>
-  /** @deprecated use huri(huri) instead */
-  public async get(huri: Huri | string, responseType?: XyoApiResponseType): Promise<XyoApiResponseTupleOrBody<XyoPayload>> {
-    const huriObj = typeof huri === 'string' ? new Huri(huri) : huri
-    switch (responseType) {
-      case 'tuple':
-        return await this.getEndpoint(huriObj.href, 'tuple')
-      default:
-        return await this.getEndpoint(huriObj.href, 'body')
-    }
-  }
-
   public huri(huri: Huri | string) {
     const huriObj = typeof huri === 'string' ? new Huri(huri) : huri
     return new XyoApiSimple<XyoPayload>({
@@ -112,7 +95,7 @@ export class XyoArchivistApi extends XyoApiBase {
   }
 
   /** @deprecated use account instead */
-  public wallet(address: XyoDataLike) {
+  public wallet(address: DataLike) {
     return this.account(address)
   }
 }

package/src/Api/ApiUtil.spec.ts

@@ -1,6 +1,7 @@
 import { Wallet } from '@ethersproject/wallet'
 import { assertEx } from '@xylabs/assert'
-import { XyoAccount } from '@xyo-network/account'
+import { Account } from '@xyo-network/account'
+import { XyoApiConfig } from '@xyo-network/api-models'
 import { uuid } from '@xyo-network/core'
 
 import { XyoArchivistApi } from './Api'
@@ -9,13 +10,27 @@ test('Must have tests defined', () => {
   expect(true).toBeTruthy()
 })
 
+export const getApiConfig = (configData: Partial<XyoApiConfig> = {}): XyoApiConfig => {
+  const defaults: XyoApiConfig = {
+    apiDomain: process.env.API_DOMAIN || 'http://localhost:8080',
+    onError: (error) => error,
+    onFailure: (response) => response,
+    onSuccess: (response) => response,
+  }
+  return Object.assign({}, defaults, configData)
+}
+
+export const getApi = (configData: Partial<XyoApiConfig> = {}): XyoArchivistApi => {
+  return new XyoArchivistApi(getApiConfig(configData))
+}
+
 export const getRandomArchiveName = (): string => {
   const randomString = (Math.random() + 1).toString(36).substring(7).toLowerCase()
   return `test-archive-${randomString}`
 }
 
 export const getTokenForNewUser = async (api: XyoArchivistApi): Promise<string> => {
-  const account = XyoAccount.random()
+  const account = Account.random()
   const address = new Wallet(account.private.bytes)
   const challenge = await api.account(account.public).challenge.post()
   const message = assertEx(challenge?.state, 'Missing state from login challenge')

package/src/Api/Archive/Api.spec.ts

@@ -0,0 +1,22 @@
+import { getApi, getRandomArchiveName, getTokenForNewUser } from '../ApiUtil.spec'
+
+describe('XyoArchivistArchiveApi', () => {
+  const api = getApi()
+  const archive = getRandomArchiveName()
+  beforeEach(async () => {
+    const token = await getTokenForNewUser(api)
+    api.config.jwtToken = token
+  })
+  describe('put', () => {
+    it('creates the archive', async () => {
+      const response = await api.archives.archive(archive).put()
+      expect(response?.archive).toEqual(archive)
+    })
+  })
+  describe('get', () => {
+    it('gets the archive', async () => {
+      const response = await api.archives.archive(archive).get()
+      expect(response?.archive).toBe(archive)
+    })
+  })
+})

package/src/Api/Archive/Settings/Key/Api.spec.ts

@@ -0,0 +1,39 @@
+import { assertEx } from '@xylabs/assert'
+
+import { XyoArchiveKey } from '../../../../models'
+import { XyoArchivistApi } from '../../../Api'
+import { getApi, getRandomArchiveName, getTokenForNewUser } from '../../../ApiUtil.spec'
+
+describe('XyoArchivistArchiveSettingsKeyApi', () => {
+  let api: XyoArchivistApi
+  let archive = ''
+  beforeEach(async () => {
+    archive = getRandomArchiveName()
+    api = getApi()
+    const token = await getTokenForNewUser(api)
+    api.config.jwtToken = token
+    await api.archives.archive(archive).put()
+  })
+  describe('post', () => {
+    it('Creates an archive key', async () => {
+      const response = await api.archives.archive(archive).settings.key.post()
+      expect(response).toBeArrayOfSize(1)
+      const key = response?.[0]
+      expect(key).toBeObject()
+      expect(key?.archive).toBeString()
+      expect(key?.key).toBeString()
+    })
+  })
+  describe('get', () => {
+    let key: XyoArchiveKey
+    beforeEach(async () => {
+      const response = await api.archives.archive(archive).settings.key.post()
+      key = assertEx(response?.[0])
+    })
+    it('Returns the keys for the archive', async () => {
+      const response = await api.archives.archive(archive).settings.key.get()
+      expect(response).toBeArrayOfSize(1)
+      expect(response).toContainEqual(key)
+    })
+  })
+})

package/src/Api/Archive/Settings/Key/Api.ts

@@ -1,11 +1,4 @@
 import { XyoArchiveKey } from '../../../../models'
 import { XyoApiSimple } from '../../../../Simple'
 
-export class XyoArchivistArchiveSettingsKeyApi extends XyoApiSimple<XyoArchiveKey[]> {
-  public key(key: string) {
-    return new XyoApiSimple<XyoArchiveKey>({
-      ...this.config,
-      root: `${this.root}${key}/`,
-    })
-  }
-}
+export class XyoArchivistArchiveSettingsKeyApi extends XyoApiSimple<XyoArchiveKey[]> {}

package/src/Api/Archives/Api.spec.ts

@@ -0,0 +1,12 @@
+import { getApi } from '../ApiUtil.spec'
+
+describe('XyoArchivistArchivesApi', () => {
+  describe('get', function () {
+    it('gets an array of archives owned', async () => {
+      const api = getApi()
+      const response = await api.archives.get()
+      expect(response).toBeArray()
+      expect(response?.length).toBeGreaterThan(0)
+    })
+  })
+})

package/src/Api/Block/Api.spec.ts

@@ -0,0 +1,57 @@
+import { BoundWitnessBuilder } from '@xyo-network/boundwitness'
+
+import { testPayload } from '../../Test'
+import { getApi, getNewArchive } from '../ApiUtil.spec'
+
+describe('XyoArchivistArchiveBlockApi', () => {
+  const api = getApi()
+  describe('post', function () {
+    it.each([true, false])('posts a single bound witness', async (inlinePayloads) => {
+      const builder = new BoundWitnessBuilder({ inlinePayloads }).payload(testPayload)
+      const [bw] = builder.build()
+      const blocks = [bw]
+      const response = await api.archives.archive().block.post(blocks)
+      expect(response?.length).toEqual(blocks.length)
+    })
+    it.each([true, false])('posts multiple bound witnesses', async (inlinePayloads) => {
+      const builder = new BoundWitnessBuilder({ inlinePayloads }).payload(testPayload)
+      const [bw] = builder.build()
+      const blocks = [bw, bw]
+      const response = await api.archives.archive().block.post(blocks)
+      expect(response?.length).toEqual(blocks.length)
+    })
+  })
+  describe('stats', () => {
+    const [bw] = new BoundWitnessBuilder().build()
+    const blocks = [bw]
+    let archive = ''
+    beforeEach(async () => {
+      archive = await getNewArchive(api)
+    })
+    it('returns stats for boundwitness', async () => {
+      await api.archives.archive(archive).block.post(blocks)
+      const stats = await api.archives.archive(archive).block.stats.get()
+      expect(stats?.count).toBeGreaterThanOrEqual(blocks.length)
+    })
+  })
+  describe('find', () => {
+    const [bw] = new BoundWitnessBuilder().build()
+    const blocks = [bw]
+    let archive = ''
+    beforeEach(async () => {
+      archive = await getNewArchive(api)
+    })
+    it('returns bound witnesses from before the timestamp', async () => {
+      const timestamp = Date.now() - 10000
+      await api.archives.archive(archive).block.post(blocks)
+      const response = await api.archives.archive(archive).block.find({ order: 'asc', timestamp })
+      expect(response?.length).toBe(blocks.length)
+    })
+    it('returns bound witnesses from after the timestamp', async () => {
+      await api.archives.archive(archive).block.post(blocks)
+      const timestamp = Date.now() + 10000
+      const response = await api.archives.archive(archive).block.find({ order: 'desc', timestamp })
+      expect(response?.length).toBe(blocks.length)
+    })
+  })
+})

package/src/Api/Payload/Api.spec.ts

@@ -1,20 +1,10 @@
-import { XyoAccount } from '@xyo-network/account'
-import { XyoApiConfig, XyoApiError } from '@xyo-network/api-models'
 import { BoundWitnessBuilder } from '@xyo-network/boundwitness'
 
-import { XyoArchivistApi } from '../Api'
-import { getNewArchive, getTimestampMinutesFromNow } from '../ApiUtil.spec'
-
-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)}]`),
-}
+import { getApi, getNewArchive, getTimestampMinutesFromNow } from '../ApiUtil.spec'
 
 describe('XyoArchivistPayloadApi', () => {
   describe('find', () => {
-    const api = new XyoArchivistApi(configData)
+    const api = getApi()
     let archive = ''
     beforeEach(async () => {
       archive = await getNewArchive(api)
@@ -22,34 +12,22 @@ describe('XyoArchivistPayloadApi', () => {
     })
     describe('when order is ascending', () => {
       it('returns payloads greater than or equal to timestamp', async () => {
-        try {
-          const timestamp = getTimestampMinutesFromNow(-1)
-          const [boundWitness] = new BoundWitnessBuilder().witness(XyoAccount.random()).build()
-          const blockResult = await api.archive(archive).block.post([boundWitness])
-          expect(blockResult?.length).toBe(1)
-          const response = await api.archive(archive).block.find({ order: 'asc', timestamp })
-          expect(response?.length).toBe(1)
-        } catch (ex) {
-          const error = ex as XyoApiError
-          console.log(JSON.stringify(error.response?.data, null, 2))
-          expect(error === undefined)
-        }
+        const timestamp = getTimestampMinutesFromNow(-1)
+        const [boundWitness] = new BoundWitnessBuilder().build()
+        const blockResult = await api.archive(archive).block.post([boundWitness])
+        expect(blockResult?.length).toBe(1)
+        const response = await api.archive(archive).block.find({ order: 'asc', timestamp })
+        expect(response?.length).toBe(1)
       })
     })
     describe('when order is descending', () => {
       it('returns payloads less than or equal to timestamp', async () => {
-        try {
-          const [boundWitness] = new BoundWitnessBuilder().witness(XyoAccount.random()).build()
-          const blockResult = await api.archive(archive).block.post([boundWitness])
-          expect(blockResult?.length).toBe(1)
-          const timestamp = getTimestampMinutesFromNow(1)
-          const response = await api.archive(archive).block.find({ order: 'desc', timestamp })
-          expect(response?.length).toBe(1)
-        } catch (ex) {
-          const error = ex as XyoApiError
-          console.log(JSON.stringify(error.response?.data, null, 2))
-          expect(error === undefined)
-        }
+        const [boundWitness] = new BoundWitnessBuilder().build()
+        const blockResult = await api.archive(archive).block.post([boundWitness])
+        expect(blockResult?.length).toBe(1)
+        const timestamp = getTimestampMinutesFromNow(1)
+        const response = await api.archive(archive).block.find({ order: 'desc', timestamp })
+        expect(response?.length).toBe(1)
       })
     })
   })

package/src/Api/Payload/Schema/Api.spec.ts

@@ -1,4 +1,3 @@
-import { XyoAccount } from '@xyo-network/account'
 import { XyoApiConfig } from '@xyo-network/api-models'
 import { BoundWitnessBuilder } from '@xyo-network/boundwitness'
 import { XyoSchemaPayload, XyoSchemaSchema } from '@xyo-network/schema-payload-plugin'
@@ -24,7 +23,7 @@ describe('XyoArchivistArchiveSchemaApi', () => {
   let archive = ''
   beforeAll(async () => {
     archive = await getNewArchive(api)
-    const [boundWitness] = new BoundWitnessBuilder({ inlinePayloads: true }).witness(XyoAccount.random()).payload(payload).build()
+    const [boundWitness] = new BoundWitnessBuilder({ inlinePayloads: true }).payload(payload).build()
     await api.archives.archive(archive).block.post([boundWitness])
   })
   describe('get', () => {

package/src/Archivist/XyoRemoteArchivist.spec.ts

@@ -1,21 +1,23 @@
 import { XyoApiConfig } from '@xyo-network/api-models'
 import { ArchivistWrapper } from '@xyo-network/archivist'
+import { XyoBoundWitnessSchema } from '@xyo-network/boundwitness'
 import { PayloadWrapper } from '@xyo-network/payload'
+import { XyoIdSchema } from '@xyo-network/payload-plugins'
 
 import { XyoArchivistApi } from '../Api'
 import { XyoRemoteArchivist } from './XyoRemoteArchivist'
 import { XyoRemoteArchivistConfigSchema } from './XyoRemoteArchivistConfig'
 
 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)}]`),
+  apiDomain: process.env.API_DOMAIN || 'http://locahost:8080',
+  onError: (error) => error,
+  onFailure: (response) => response,
+  onSuccess: (response) => response,
 }
 
 const payload = {
   salt: `${Math.random() * 10000}`,
-  schema: 'network.xyo.id',
+  schema: XyoIdSchema,
 }
 
 describe('XyoRemoteArchivist', () => {
@@ -42,12 +44,12 @@ describe('XyoRemoteArchivist', () => {
   it('get returns boundwitness', async () => {
     const payload = {
       payload_hashes: ['123456'],
-      payload_schemas: ['network.xyo.id'],
-      schema: 'network.xyo.boundwitness',
+      payload_schemas: [XyoIdSchema],
+      schema: XyoBoundWitnessSchema,
     }
 
     await archivist.insert([payload])
     const getResult = await archivist.get([new PayloadWrapper(payload).hash])
-    expect(getResult?.[0].schema).toBe('network.xyo.boundwitness')
+    expect(getResult?.[0].schema).toBe(XyoBoundWitnessSchema)
   })
 })