@xyo-network/api 2.20.15

package/package.json

@@ -0,0 +1,118 @@
+{
+  "author": {
+    "email": "support@xyo.network",
+    "name": "XYO Development Team",
+    "url": "https://xyo.network"
+  },
+  "bugs": {
+    "email": "support@xyo.network",
+    "url": "https://github.com/XYOracleNetwork/sdk-xyo-client-js/issues"
+  },
+  "dependencies": {
+    "@ethersproject/providers": "^5.6.5",
+    "@xylabs/sdk-js": "^2.5.5",
+    "@xyo-network/core": "^2.20.15",
+    "@xyo-network/ethers-wrappers": "^2.6.17",
+    "@xyo-network/sdk-xyo-mongo-js": "^2.2.7",
+    "@xyo-network/sdk-xyo-typechain": "^1.0.3",
+    "ajv": "^8.11.0",
+    "axios": "^0.27.2",
+    "bn.js": "^5.2.0",
+    "bowser": "^2.11.0",
+    "elliptic": "^6.5.4",
+    "keccak256": "^1.0.6",
+    "lodash": "^4.17.21",
+    "lru-cache": "^7.10.1",
+    "mongodb": "^4.6.0",
+    "neo4j-driver": "^4.4.5",
+    "neo4j-driver-core": "^4.4.5",
+    "pako": "^2.0.4",
+    "randombytes": "^2.1.0",
+    "sha.js": "^2.4.11",
+    "systeminformation": "^5.11.15",
+    "ua-parser-js": "^1.0.2",
+    "uuid": "^8.3.2"
+  },
+  "description": "Primary SDK for using XYO Protocol 2.0",
+  "devDependencies": {
+    "@babel/core": "^7.17.10",
+    "@babel/preset-env": "^7.17.10",
+    "@types/bn.js": "^5.1.0",
+    "@types/elliptic": "^6.4.14",
+    "@types/jest": "^27.5.1",
+    "@types/json-schema": "^7.0.11",
+    "@types/lodash": "^4.14.182",
+    "@types/lru-cache": "^7.6.1",
+    "@types/node": "^17.0.32",
+    "@types/pako": "^1.0.3",
+    "@types/randombytes": "^2.0.0",
+    "@types/sha.js": "^2.4.0",
+    "@types/ua-parser-js": "^0.7.36",
+    "@types/uuid": "^8.3.4",
+    "@xylabs/eslint-config": "^2.3.22",
+    "@xylabs/rollup-config": "^1.1.17",
+    "@xylabs/ts-scripts": "^1.0.66",
+    "@xylabs/tsconfig": "^1.0.13",
+    "babel-jest": "^28.1.0",
+    "copyfiles": "^2.4.1",
+    "dotenv": "^16.0.1",
+    "eslint": "^8.15.0",
+    "ethers": "^5.6.5",
+    "jest": "^28.1.0",
+    "jest-environment-jsdom": "^28.1.0",
+    "jest-sorted": "^1.0.14",
+    "license-checker": "^25.0.1",
+    "npm-package-json-lint": "^6.3.0",
+    "npm-package-json-lint-config-default": "^5.0.0",
+    "rimraf": "^3.0.2",
+    "rollbar": "^2.25.0",
+    "rollup": "^2.72.1",
+    "ts-jest": "^28.0.2",
+    "ts-node": "^10.7.0",
+    "tslib": "^2.4.0",
+    "typedoc": "^0.22.15",
+    "typescript": "^4.6.4"
+  },
+  "browser": "dist/esm/index.js",
+  "docs": "dist/docs.json",
+  "exports": {
+    ".": {
+      "node": {
+        "import": "./dist/esm/index.js",
+        "require": "./dist/cjs/index.js"
+      },
+      "browser": {
+        "import": "./dist/esm/index.js",
+        "require": "./dist/cjs/index.js"
+      },
+      "default": "./dist/esm/index.js"
+    },
+    "./dist/docs.json": {
+      "default": "./dist/docs.json"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "dist/cjs/index.js",
+  "module": "dist/esm/index.js",
+  "homepage": "https://xyo.network",
+  "license": "LGPL-3.0-only",
+  "name": "@xyo-network/api",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/XYOracleNetwork/sdk-xyo-client-js.git"
+  },
+  "scripts": {
+    "deploy": "yarn deploy3",
+    "lint-pkg": "npmPkgJsonLint .",
+    "build": "yarn clean && tsc -p tsconfig.build.cjs.json && tsc -p tsconfig.build.esm.json && yarn gen:docs",
+    "gen:docs": "typedoc ./src/index.ts --json ./dist/docs.json --tsconfig ./tsconfig.json",
+    "license": "yarn license-checker --exclude \"MIT, ISC, Apache-2.0, BSD, BSD-2-Clause, CC-BY-4.0, Unlicense, CC-BY-3.0, CC0-1.0\""
+  },
+  "sideEffects": true,
+  "types": "dist/esm/index.d.ts",
+  "version": "2.20.15",
+  "packageManager": "yarn@3.1.1"
+}

package/rollup.config.js

@@ -0,0 +1,5 @@
+import { getRollupConfig } from '@xylabs/rollup-config'
+
+import pkg from './package.json'
+
+export default getRollupConfig({pkg, browserIndex: './src/browserIndex.ts', nodeIndex: './src/nodeIndex.ts', bundlePrefix: 'bundle/', outputs: ['cjs5', 'node', 'node-esm']})

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

@@ -0,0 +1,71 @@
+import { typeOf, XyoAccount } from '@xyo-network/core'
+
+import { XyoApiConfig, XyoApiError } from '../../models'
+import { XyoArchivistApi } from '../Api'
+import { XyoAccountApi } from './Api'
+
+const timeout = 20000
+const config: XyoApiConfig = {
+  apiDomain: process.env.API_DOMAIN || 'http://localhost:8080',
+  jwtToken: process.env.JWT_TOKEN || undefined,
+}
+
+//const describeSkipIfNoToken = config.jwtToken ? describe : describe.skip
+
+describe('XyoAuthApi', () => {
+  describe('get', () => {
+    it('returns a new XyoWalletApi', () => {
+      const api = new XyoAccountApi(config)
+      expect(api).toBeDefined()
+    })
+  })
+
+  describe('challenge', function () {
+    it(
+      'success',
+      async () => {
+        const api = new XyoArchivistApi(config)
+        try {
+          const account = XyoAccount.random()
+          const [data, envelope, response] = await api.account(account.addressValue.hex).challenge.post(undefined, 'tuple')
+          expect(response.status).toBe(200)
+          expect(envelope.error).toBeUndefined()
+          expect(typeOf(data?.state)).toBe('string')
+        } catch (ex) {
+          const error = ex as XyoApiError
+          console.log(JSON.stringify(error.response?.data, null, 2))
+          throw ex
+        }
+      },
+      timeout
+    )
+  })
+
+  /*describe('verify', function () {
+    it(
+      'success',
+      async () => {
+        const api = new XyoArchivistApi(config)
+        try {
+          const address = XyoAddress.random()
+          const challenge = (await api.wallet(address.address).challenge.post(undefined))
+          const message = assertEx(challenge?.state)
+          const [data, envelope, response] = await api
+            .wallet(`0x${address.address}`)
+            .verify.post(
+              [{ message: assertEx(challenge?.state), signature: `0x${address.signKeccakMessage(message)}` }],
+              'tuple'
+            )
+          expect(response.status).toBe(200)
+          expect(envelope.error).toBeUndefined()
+          expect(data?.length).toBe(1)
+        } catch (ex) {
+          const error = ex as AxiosError
+          console.log(JSON.stringify(error.response?.data, null, 2))
+          throw ex
+        }
+      },
+      timeout
+    )
+  })*/
+})

package/src/Archivist/Account/Api.ts

@@ -0,0 +1,32 @@
+import { XyoApiBase } from '../../Base'
+import { XyoApiSimple } from '../../Simple'
+
+export interface XyoAccountChallenge {
+  /** @field Server specific state identifier [out] */
+  state?: string
+}
+
+export interface XyoAccountVerify {
+  /** @field Message that was signed [in] */
+  message: string
+  /** @field Signature [in] */
+  signature: string
+  /** @field Token generated by server [out] */
+  token?: string
+}
+
+export class XyoAccountApi extends XyoApiBase {
+  public get challenge() {
+    return new XyoApiSimple<XyoAccountChallenge>({
+      ...this.config,
+      root: `${this.root}challenge/`,
+    })
+  }
+
+  public get verify() {
+    return new XyoApiSimple<XyoAccountVerify>({
+      ...this.config,
+      root: `${this.root}verify/`,
+    })
+  }
+}

package/src/Archivist/Account/index.ts

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

package/src/Archivist/Api.spec.ts

@@ -0,0 +1,219 @@
+import { XyoAccount, XyoBoundWitness, XyoBoundWitnessBuilder } from '@xyo-network/core'
+import { config } from 'dotenv'
+
+import { XyoApiConfig, XyoApiError } from '../models'
+import { testPayload } from '../Test'
+import { XyoArchivistApi } from './Api'
+import { getNewArchive, getRandomArchiveName } from './ApiUtil.spec'
+
+config()
+
+const configData: XyoApiConfig = {
+  apiDomain: process.env.API_DOMAIN || 'https://beta.api.archivist.xyo.network',
+  apiKey: process.env.API_KEY || undefined,
+  jwtToken: process.env.JWT_TOKEN || undefined,
+  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)}]`),
+}
+
+const describeSkipIfNoToken = configData.jwtToken || configData.apiKey ? describe : describe.skip
+
+describe('postBoundWitness', () => {
+  it.each([true, false])('posts a single bound witness', async (inlinePayloads) => {
+    const builder = new XyoBoundWitnessBuilder({ inlinePayloads }).witness(XyoAccount.random()).payload(testPayload)
+    const api = new XyoArchivistApi(configData)
+    const boundWitness: XyoBoundWitness = 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))
+      throw ex
+    }
+  })
+})
+
+describe('postBoundWitnesses', () => {
+  it.each([true, false])('posts multiple bound witnesses', async (inlinePayloads) => {
+    const builder = new XyoBoundWitnessBuilder({ 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))
+      throw ex
+    }
+  })
+})
+
+describeSkipIfNoToken('XyoArchivistApi', () => {
+  describe('get', () => {
+    it('returns a new XyoArchivistApi', () => {
+      const api = new XyoArchivistApi(configData)
+      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))
+        throw ex
+      }
+    })
+  })
+
+  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))
+        throw ex
+      }
+    })
+  })
+
+  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))
+        throw ex
+      }
+    })
+  })
+
+  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))
+        throw ex
+      }
+    })
+  })
+
+  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))
+        throw ex
+      }
+    })
+  })
+
+  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))
+        throw ex
+      }
+    })
+  })
+
+  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 XyoBoundWitnessBuilder().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)
+        const actual = response?.[0]
+        expect(actual?._timestamp).toBeTruthy()
+        expect(actual?._timestamp).toBeLessThan(timestamp)
+      } catch (ex) {
+        const error = ex as XyoApiError
+        console.log(JSON.stringify(error.response?.data, null, 2))
+        throw ex
+      }
+    })
+  })
+
+  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 XyoBoundWitnessBuilder().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)
+        const actual = response?.[0]
+        expect(actual?._timestamp).toBeTruthy()
+        expect(actual?._timestamp).toBeGreaterThan(timestamp)
+      } catch (ex) {
+        const error = ex as XyoApiError
+        console.log(JSON.stringify(error.response?.data, null, 2))
+        throw ex
+      }
+    })
+  })
+})

package/src/Archivist/Api.ts

@@ -0,0 +1,89 @@
+import { Huri, XyoAddressValue, XyoDataLike, XyoPayload } from '@xyo-network/core'
+
+import { XyoApiBase } from '../Base'
+import { XyoApiResponseBody, XyoApiResponseTuple, XyoApiResponseTupleOrBody, XyoApiResponseType } from '../models'
+import { XyoApiSimple } from '../Simple'
+import { XyoUserApi } from '../User'
+import { XyoAccountApi } from './Account'
+import { XyoArchivistArchiveApi } from './Archive'
+import { XyoArchivistArchivesApi } from './Archives'
+
+export class XyoArchivistApi extends XyoApiBase {
+  private _archives?: XyoArchivistArchivesApi
+  public get archives(): XyoArchivistArchivesApi {
+    this._archives =
+      this._archives ??
+      new XyoArchivistArchivesApi({
+        ...this.config,
+        root: `${this.root}archive/`,
+      })
+    return this._archives
+  }
+
+  private _stats?: XyoApiSimple<unknown[]>
+  public get stats() {
+    this._stats =
+      this._stats ??
+      new XyoApiSimple<unknown[]>({
+        ...this.config,
+        root: `${this.root}stats/`,
+      })
+    return this._stats
+  }
+
+  private _user?: XyoUserApi
+  public get user(): XyoUserApi {
+    this._user =
+      this._user ??
+      new XyoUserApi({
+        ...this.config,
+        root: `${this.root}user/`,
+      })
+    return this._user
+  }
+
+  public archive(archive = 'temp') {
+    const pureArchive = archive.toLowerCase()
+    return new XyoArchivistArchiveApi({
+      ...this.config,
+      root: `${this.root}archive/${pureArchive}/`,
+    })
+  }
+
+  /** @deprecated use account instead */
+  public wallet(address: XyoDataLike) {
+    return this.account(address)
+  }
+
+  public account(address: XyoDataLike) {
+    return new XyoAccountApi({
+      ...this.config,
+      root: `${this.root}wallet/${new XyoAddressValue(address).hex}/`,
+    })
+  }
+
+  public huri(huri: Huri | string) {
+    const huriObj = typeof huri === 'string' ? new Huri(huri) : huri
+    return new XyoApiSimple<XyoPayload>({
+      ...this.config,
+      root: `${this.root}${huriObj.href}/`,
+    })
+  }
+
+  /** @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')
+    }
+  }
+}

package/src/Archivist/ApiUtil.spec.ts

@@ -0,0 +1,37 @@
+import { XyoAccount } from '@xyo-network/core'
+import { Wallet } from 'ethers'
+import { v4 } from 'uuid'
+
+import { XyoArchivistApi } from './Api'
+
+test('Must have tests defined', () => {
+  expect(true).toBeTruthy()
+})
+
+export const getRandomArchiveName = (): string => {
+  const randomString = (Math.random() + 1).toString(36).substring(7).toLowerCase()
+  return `test-archive-${randomString}`
+}
+
+export const getNewArchive = async (api: XyoArchivistApi) => {
+  const account = XyoAccount.random()
+  const address = new Wallet(account.private.bytes)
+  const challenge = await api.account(account.public).challenge.post()
+  expect(challenge?.state).toBeTruthy()
+  const message = challenge?.state || ''
+  const signature = await address.signMessage(message)
+  const verify = await api.account(account.public).verify.post({ message, signature })
+  expect(verify?.token).toBeTruthy()
+  const jwtToken = verify?.token || ''
+  const authenticatedApi = new XyoArchivistApi({ ...api.config, jwtToken })
+  const name = getRandomArchiveName()
+  const response = await authenticatedApi.archives.archive(name).put()
+  const archive = response?.archive
+  expect(archive).toBeTruthy()
+  return archive || ''
+}
+
+export const testSchemaPrefix = 'network.xyo.schema.test.'
+export const getSchemaName = (): string => {
+  return `${testSchemaPrefix}${v4()}`
+}

package/src/Archivist/Archive/Api.ts

@@ -0,0 +1,60 @@
+import { XyoArchive } from '../../models'
+import { XyoApiSimple } from '../../Simple'
+import { XyoArchivistArchiveBlockApi } from '../Block'
+import { XyoArchivistPayloadApi } from '../Payload'
+import { XyoArchivistArchiveSchemaApi } from './Schema'
+import { XyoArchivistArchiveSchemasApi } from './Schemas'
+import { XyoArchivistArchiveSettingsApi } from './Settings'
+
+export class XyoArchivistArchiveApi extends XyoApiSimple<XyoArchive> {
+  private _block?: XyoArchivistArchiveBlockApi
+  public get block(): XyoArchivistArchiveBlockApi {
+    this._block =
+      this._block ??
+      new XyoArchivistArchiveBlockApi({
+        ...this.config,
+        root: `${this.root}block/`,
+      })
+    return this._block
+  }
+
+  private _payload?: XyoArchivistPayloadApi
+  public get payload(): XyoArchivistPayloadApi {
+    this._payload =
+      this._payload ??
+      new XyoArchivistPayloadApi({
+        ...this.config,
+        root: `${this.root}payload/`,
+      })
+    return this._payload
+  }
+
+  private _settings?: XyoArchivistArchiveSettingsApi
+  public get settings(): XyoArchivistArchiveSettingsApi {
+    this._settings =
+      this._settings ??
+      new XyoArchivistArchiveSettingsApi({
+        ...this.config,
+        root: `${this.root}settings/`,
+      })
+    return this._settings
+  }
+
+  private _schemas?: XyoArchivistArchiveSchemasApi
+  public get schemas(): XyoArchivistArchiveSchemasApi {
+    this._schemas =
+      this._schemas ??
+      new XyoArchivistArchiveSchemasApi({
+        ...this.config,
+        root: `${this.root}schema/`,
+      })
+    return this._schemas
+  }
+
+  public schema(schema: string): XyoArchivistArchiveSchemaApi {
+    return new XyoArchivistArchiveSchemaApi({
+      ...this.config,
+      root: `${this.root}schema/${schema}/`,
+    })
+  }
+}

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

@@ -0,0 +1,23 @@
+import { XyoApiConfig } from '../../../models'
+import { XyoArchivistApi } from '../../Api'
+
+const config: XyoApiConfig = {
+  apiDomain: process.env.API_DOMAIN || 'http://localhost:8080',
+}
+
+describe('XyoArchivistSchemaApi', () => {
+  describe('schema', () => {
+    it('calculates the correct path', () => {
+      const api = new XyoArchivistApi(config)
+      const path = api.archive('foo').schema('foo.bar.baz').config.root
+      expect(path).toBe('/archive/foo/schema/foo.bar.baz/')
+    })
+  })
+  describe('recent', () => {
+    it('calculates the correct path', () => {
+      const api = new XyoArchivistApi(config)
+      const path = api.archive('foo').schema('foo.bar.baz').recent.config.root
+      expect(path).toBe('/archive/foo/schema/foo.bar.baz/recent/')
+    })
+  })
+})

package/src/Archivist/Archive/Schema/Api.ts

@@ -0,0 +1,17 @@
+import { XyoPayload } from '@xyo-network/core'
+
+import { XyoApiBase } from '../../../Base'
+import { XyoApiSimple } from '../../../Simple'
+
+export class XyoArchivistArchiveSchemaApi extends XyoApiBase {
+  private _recent?: XyoApiSimple<XyoPayload[]>
+  public get recent(): XyoApiSimple<XyoPayload[]> {
+    this._recent =
+      this._recent ??
+      new XyoApiSimple<XyoPayload[]>({
+        ...this.config,
+        root: `${this.root}recent/`,
+      })
+    return this._recent
+  }
+}

package/src/Archivist/Archive/Schema/index.ts

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