@xyo-network/api 2.47.8 → 2.47.10

package/package.json

@@ -11,28 +11,28 @@
   "dependencies": {
     "@xylabs/assert": "^2.7.1",
     "@xylabs/delay": "^2.7.1",
-    "@xyo-network/account": "^2.47.8",
-    "@xyo-network/api-models": "^2.47.8",
-    "@xyo-network/archivist": "^2.47.8",
-    "@xyo-network/axios": "^2.47.8",
-    "@xyo-network/boundwitness-builder": "^2.47.8",
-    "@xyo-network/boundwitness-model": "^2.47.8",
-    "@xyo-network/core": "^2.47.8",
-    "@xyo-network/diviner": "^2.47.8",
-    "@xyo-network/diviner-model": "^2.47.8",
-    "@xyo-network/huri": "^2.47.8",
-    "@xyo-network/module": "^2.47.8",
-    "@xyo-network/payload-builder": "^2.47.8",
-    "@xyo-network/payload-model": "^2.47.8",
-    "@xyo-network/payload-wrapper": "^2.47.8",
-    "@xyo-network/schema-payload-plugin": "^2.47.8",
+    "@xyo-network/account": "^2.47.10",
+    "@xyo-network/api-models": "^2.47.10",
+    "@xyo-network/archivist": "^2.47.10",
+    "@xyo-network/axios": "^2.47.10",
+    "@xyo-network/boundwitness-builder": "^2.47.10",
+    "@xyo-network/boundwitness-model": "^2.47.10",
+    "@xyo-network/core": "^2.47.10",
+    "@xyo-network/diviner": "^2.47.10",
+    "@xyo-network/diviner-model": "^2.47.10",
+    "@xyo-network/huri": "^2.47.10",
+    "@xyo-network/module": "^2.47.10",
+    "@xyo-network/payload-builder": "^2.47.10",
+    "@xyo-network/payload-model": "^2.47.10",
+    "@xyo-network/payload-wrapper": "^2.47.10",
+    "@xyo-network/schema-payload-plugin": "^2.47.10",
     "lodash": "^4.17.21"
   },
   "description": "Primary SDK for using XYO Protocol 2.0",
   "devDependencies": {
     "@types/lodash": "^4.14.191",
-    "@xylabs/ts-scripts-yarn3": "^2.14.16",
-    "@xylabs/tsconfig": "^2.14.16",
+    "@xylabs/ts-scripts-yarn3": "^2.15.0",
+    "@xylabs/tsconfig": "^2.15.0",
     "typescript": "^4.9.5"
   },
   "browser": "dist/esm/index.js",
@@ -68,5 +68,5 @@
   },
   "sideEffects": false,
   "types": "dist/types/index.d.ts",
-  "version": "2.47.8"
+  "version": "2.47.10"
 }

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

@@ -1,58 +0,0 @@
-import { Account } from '@xyo-network/account'
-import { XyoApiConfig } from '@xyo-network/api-models'
-import { typeOf } from '@xyo-network/typeof'
-
-import { XyoArchivistApi } from '../../Api'
-import { XyoAccountApi } from '../Api'
-
-const timeout = 20000
-const config: XyoApiConfig = {
-  apiDomain: process.env.API_DOMAIN || 'http://localhost:8080',
-}
-
-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)
-        const account = Account.random()
-        const [data, envelope, response] = await api.account(account.addressValue.hex).challenge.post(undefined, 'tuple')
-        expect(response.status).toBe(200)
-        expect(envelope.errors).toBeUndefined()
-        expect(typeOf(data?.state)).toBe('string')
-      },
-      timeout,
-    )
-  })
-
-  /*describe('verify', function () {
-    it(
-      'success',
-      async () => {
-        const api = new XyoArchivistApi(config)
-        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)
-
-      },
-      timeout
-    )
-  })*/
-})

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

@@ -1,86 +0,0 @@
-import { assertEx } from '@xylabs/assert'
-import { Account } from '@xyo-network/account'
-import { AddressPayload, AddressSchema } from '@xyo-network/address-payload-plugin'
-import { XyoApiConfig, XyoApiResponseBody } from '@xyo-network/api-models'
-import { XyoBoundWitness } from '@xyo-network/boundwitness-model'
-import { BoundWitnessWrapper } from '@xyo-network/boundwitness-wrapper'
-import { XyoPayload } from '@xyo-network/payload-model'
-import { QueryPayload, QuerySchema } from '@xyo-network/query-payload-plugin'
-
-import { XyoApiSimple } from '../../../../Simple'
-import { XyoArchivistApi } from '../../../Api'
-import { XyoAddressesApi } from '../../Api'
-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<XyoPayload[]>
-    beforeAll(async () => {
-      const payloads = await new XyoAddressesApi(config).get()
-      expect(payloads).toBeArray()
-      const addressPayload = payloads?.find((p) => p.schema === AddressSchema) as AddressPayload
-      expect(addressPayload).toBeObject()
-      const address = addressPayload.address
-      api = new XyoArchivistApi(config).addresses.address(address)
-      result = await api.get()
-      expect(result).toBeArray()
-    })
-    it('method exists', () => {
-      expect(api).toBeDefined()
-      expect(api.get).toBeFunction()
-    })
-    describe('returns module', () => {
-      it('address', () => {
-        const addressPayload = result?.find((p) => p.schema === AddressSchema) as AddressPayload
-        expect(addressPayload).toBeObject()
-        const address = addressPayload.address
-        expect(address).toBeString()
-      })
-      it('supported queries', () => {
-        const queryPayloads = result?.filter((p) => p.schema === QuerySchema) as QueryPayload[]
-        expect(queryPayloads).toBeArray()
-        expect(queryPayloads.length).toBeGreaterThan(0)
-        queryPayloads?.map((query) => {
-          expect(query.query).toBeString()
-        })
-      })
-    })
-  })
-  describe('boundWitness', () => {
-    let address: string
-    let api: XyoApiSimple<XyoBoundWitness[]>
-    let history: XyoBoundWitness[]
-    beforeAll(async () => {
-      address = new Account({ phrase: 'test' }).addressValue.hex
-      api = new XyoArchivistApi(config).addresses.address(address).boundWitnesses
-      const result = await api.get()
-      expect(result).toBeArray()
-      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/Api/Addresses/spec/Api.spec.ts

@@ -1,38 +0,0 @@
-import { AddressPayload, AddressSchema } from '@xyo-network/address-payload-plugin'
-import { XyoApiConfig, XyoApiResponseBody } from '@xyo-network/api-models'
-import { XyoPayloads } from '@xyo-network/payload-model'
-import { QueryPayload, QuerySchema } from '@xyo-network/query-payload-plugin'
-
-import { XyoAddressesApi } from '../Api'
-
-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 root module discover containing', () => {
-      let api: XyoAddressesApi
-      let response: XyoApiResponseBody<XyoPayloads>
-      beforeAll(async () => {
-        api = new XyoAddressesApi(config)
-        response = await api.get()
-      })
-      it('address', () => {
-        expect(response).toBeArray()
-        const addressPayload = response?.find((p) => p.schema === AddressSchema) as AddressPayload
-        expect(addressPayload).toBeObject()
-        expect(addressPayload.address).toBeString()
-      })
-      it('supported queries', () => {
-        const queries = response?.filter((d) => d.schema === QuerySchema) as QueryPayload[]
-        expect(queries.length).toBeGreaterThan(0)
-      })
-    })
-  })
-})

package/src/Api/ApiUtil.spec.ts

@@ -1,61 +0,0 @@
-import { Wallet } from '@ethersproject/wallet'
-import { assertEx } from '@xylabs/assert'
-import { Account } from '@xyo-network/account'
-import { XyoApiConfig } from '@xyo-network/api-models'
-import { uuid } from '@xyo-network/core'
-
-import { XyoArchivistApi } from './Api'
-
-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 = 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')
-  const signature = await address.signMessage(message)
-  const verify = await api.account(account.public).verify.post({ message, signature })
-  const jwtToken = assertEx(verify?.token, 'Missing JWT token in response')
-  return jwtToken
-}
-
-export const getNewArchive = async (api: XyoArchivistApi) => {
-  const jwtToken = await getTokenForNewUser(api)
-  const authenticatedApi = new XyoArchivistApi({ ...api.config, jwtToken })
-  const name = getRandomArchiveName()
-  const response = await authenticatedApi.archives.archive(name).put()
-  const archive = assertEx(response?.archive, 'Missing archive in response')
-  return archive
-}
-
-export const testSchemaPrefix = 'network.xyo.schema.test.'
-export const getSchemaName = (): string => {
-  return `${testSchemaPrefix}${uuid()}`
-}
-
-export const getTimestampMinutesFromNow = (minutes = 0) => {
-  const t = new Date()
-  t.setMinutes(t.getMinutes() + minutes)
-  return +t
-}

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

@@ -1,22 +0,0 @@
-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/Schema/Api.spec.ts

@@ -1,24 +0,0 @@
-import { XyoApiConfig } from '@xyo-network/api-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/Api/Archive/Schemas/Api.spec.ts

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

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

@@ -1,39 +0,0 @@
-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/Archives/Api.spec.ts

@@ -1,12 +0,0 @@
-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

@@ -1,57 +0,0 @@
-import { BoundWitnessBuilder } from '@xyo-network/boundwitness-builder'
-
-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/Node/Api.spec.ts

@@ -1,146 +0,0 @@
-import { assertEx } from '@xylabs/assert'
-import { delay } from '@xylabs/delay'
-import { XyoApiConfig, XyoApiEnvelope } from '@xyo-network/api-models'
-import { BoundWitnessBuilder } from '@xyo-network/boundwitness-builder'
-import { XyoBoundWitness } from '@xyo-network/boundwitness-model'
-import { uuid } from '@xyo-network/core'
-import { XyoPayloadBuilder } from '@xyo-network/payload-builder'
-import { XyoPayload } from '@xyo-network/payload-model'
-
-import { XyoArchivistApi } from '../Api'
-
-const config: XyoApiConfig = {
-  apiDomain: process.env.API_DOMAIN || 'http://localhost:8080',
-}
-
-const schema = 'network.xyo.debug'
-
-const getQuery = (count = 1) => {
-  const payloads = [] as XyoPayload[]
-  for (let i = 0; i < count; i++) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    payloads.push(new XyoPayloadBuilder({ schema }).fields({ nonce: uuid() } as any).build())
-  }
-  return new BoundWitnessBuilder({ inlinePayloads: true }).payloads(payloads).build()[0]
-}
-
-const issueQuery = async (query: XyoBoundWitness = getQuery()): Promise<string> => {
-  const api = new XyoArchivistApi(config)
-  const response = await api.node('temp').post(query)
-  const id = response?.[0]?.[0]
-  expect(id).toBeDefined()
-  return assertEx(id)
-}
-
-const validateAllResponseSchemas = (response: XyoApiEnvelope<XyoPayload | undefined>[][]): boolean => {
-  return response
-    .flat()
-    .map((r) => (r as unknown as XyoPayload)?.schema)
-    .every((s) => s === schema)
-}
-
-describe('XyoArchivistNodeApi', () => {
-  describe('node', () => {
-    describe('without archive supplied', () => {
-      it('calculates the correct path', () => {
-        const api = new XyoArchivistApi(config)
-        const path = api.node().config.root
-        expect(path).toBe('/temp/')
-      })
-    })
-    describe('with archive supplied', () => {
-      const archive = 'foo'
-      it('calculates the correct path', () => {
-        const api = new XyoArchivistApi(config)
-        const path = api.node(archive).config.root
-        expect(path).toBe(`/${archive}/`)
-      })
-    })
-  })
-  describe('queryResult', () => {
-    let id = '123456789'
-    describe('with valid query id', () => {
-      beforeEach(async () => {
-        id = await issueQuery()
-      })
-      it.skip('returns the query result', async () => {
-        const api = new XyoArchivistApi(config)
-        await delay(1000)
-        const [_, payload, response] = await api.node().result(id).get('tuple')
-        expect(_).toBeUndefined()
-        expect(payload).toBeDefined()
-        expect((payload as unknown as XyoPayload).schema).toBe(schema)
-        expect(response.status).toBe(200)
-      })
-    })
-    describe('without archive supplied', () => {
-      it('calculates the correct path', () => {
-        const api = new XyoArchivistApi(config)
-        const path = api.node().result(id).config.root
-        expect(path).toBe(`/query/${id}/`)
-      })
-    })
-    describe('with archive supplied', () => {
-      const archive = 'foo'
-      it('calculates the correct path', () => {
-        const api = new XyoArchivistApi(config)
-        const path = api.node(archive).result(id).config.root
-        expect(path).toBe(`/query/${id}/`)
-      })
-    })
-  })
-  describe.skip('perform', () => {
-    it('creates and issues the query and returns the result', async () => {
-      const api = new XyoArchivistApi(config)
-      const response = await api.node().perform({}, schema)
-      expect(response).toBeDefined()
-      expect((response as unknown as XyoPayload).schema).toBe(schema)
-    })
-  })
-  describe.skip('performTransaction', () => {
-    describe('with a single BoundWitness', () => {
-      describe('with a single Payload', () => {
-        it('issues the query and returns the result', async () => {
-          const api = new XyoArchivistApi(config)
-          const query = [getQuery()]
-          const response = await api.node().performTransaction(query)
-          expect(response).toBeDefined()
-          expect(Array.isArray(response)).toBeTruthy()
-          expect(validateAllResponseSchemas(response)).toBeTruthy()
-        })
-      })
-      describe('with a multiple Payloads', () => {
-        it('issues the query and returns the result', async () => {
-          const api = new XyoArchivistApi(config)
-          const query = [getQuery(2)]
-          const response = await api.node().performTransaction(query)
-          expect(response).toBeDefined()
-          expect(Array.isArray(response)).toBeTruthy()
-          expect(validateAllResponseSchemas(response)).toBeTruthy()
-        })
-      })
-    })
-    describe('with a multiple BoundWitnesses', () => {
-      describe('with a single Payload', () => {
-        it('issues the query and returns the result', async () => {
-          const api = new XyoArchivistApi(config)
-          const query = [getQuery(), getQuery()]
-          const response = await api.node().performTransaction(query)
-          expect(response).toBeDefined()
-          expect(Array.isArray(response)).toBeTruthy()
-          expect(validateAllResponseSchemas(response)).toBeTruthy()
-        })
-      })
-      describe('with a multiple Payloads', () => {
-        it('issues the query and returns the result', async () => {
-          const api = new XyoArchivistApi(config)
-          const query = [getQuery(2), getQuery(2)]
-          const response = await api.node().performTransaction(query)
-          expect(response).toBeDefined()
-          expect(Array.isArray(response)).toBeTruthy()
-          expect(validateAllResponseSchemas(response)).toBeTruthy()
-        })
-      })
-    })
-  })
-})

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

@@ -1,34 +0,0 @@
-import { BoundWitnessBuilder } from '@xyo-network/boundwitness-builder'
-
-import { getApi, getNewArchive, getTimestampMinutesFromNow } from '../ApiUtil.spec'
-
-describe('XyoArchivistPayloadApi', () => {
-  describe('find', () => {
-    const api = getApi()
-    let archive = ''
-    beforeEach(async () => {
-      archive = await getNewArchive(api)
-      expect(archive).toBeTruthy()
-    })
-    describe('when order is ascending', () => {
-      it('returns payloads greater than or equal to timestamp', async () => {
-        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 () => {
-        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)
-      })
-    })
-  })
-})