npm - @ethersphere/bee-js - Versions diffs - 2.1.0 → 3.2.0 - Mend

@ethersphere/bee-js 2.1.0 → 3.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (160) hide show

package/README.md +3 -3
package/dist/index.browser.min.js +1 -1
package/dist/index.browser.min.js.map +1 -1
package/dist/index.min.js +1 -1
package/dist/index.min.js.map +1 -1
package/dist/src/bee-debug.d.ts +5 -1
package/dist/src/bee.d.ts +23 -46
package/dist/src/modules/chunk.d.ts +2 -10
package/dist/src/modules/debug/status.d.ts +10 -4
package/dist/src/types/debug.d.ts +19 -0
package/dist/src/types/index.d.ts +31 -2
package/dist/src/utils/bytes.d.ts +1 -1
package/dist/src/utils/error.d.ts +21 -2
package/dist/src/utils/expose.d.ts +1 -0
package/dist/src/utils/http.d.ts +7 -9
package/dist/src/utils/stamps.d.ts +12 -0
package/dist/src/utils/type.d.ts +6 -0
package/package.json +28 -27
package/.babelrc.js +0 -33
package/.depcheckrc.json +0 -27
package/.editorconfig +0 -6
package/.eslintignore +0 -1
package/.eslintrc.js +0 -109
package/.gitattributes +0 -1
package/.github/config.yaml +0 -23
package/.github/workflows/check.yaml +0 -57
package/.github/workflows/publish_npmjs.yaml +0 -20
package/.github/workflows/release_github.yaml +0 -20
package/.github/workflows/tests.yaml +0 -128
package/.huskyrc +0 -5
package/.prettierrc +0 -13
package/.vscode/launch.json +0 -49
package/.vscode/settings.json +0 -39
package/CHANGELOG.md +0 -520
package/CODEOWNERS +0 -1
package/CODE_OF_CONDUCT.md +0 -76
package/commitlint.config.js +0 -3
package/dist/src/modules/stamps.d.ts +0 -4
package/jest-puppeteer.config.js +0 -5
package/jest.config.ts +0 -85
package/src/bee-debug.ts +0 -601
package/src/bee.ts +0 -1087
package/src/chunk/bmt.ts +0 -55
package/src/chunk/cac.ts +0 -79
package/src/chunk/serialize.ts +0 -16
package/src/chunk/signer.ts +0 -141
package/src/chunk/soc.ts +0 -190
package/src/chunk/span.ts +0 -33
package/src/feed/index.ts +0 -217
package/src/feed/json.ts +0 -33
package/src/feed/topic.ts +0 -23
package/src/feed/type.ts +0 -12
package/src/index.ts +0 -24
package/src/modules/bytes.ts +0 -70
package/src/modules/bzz.ts +0 -179
package/src/modules/chunk.ts +0 -69
package/src/modules/debug/balance.ts +0 -63
package/src/modules/debug/chequebook.ts +0 -175
package/src/modules/debug/chunk.ts +0 -39
package/src/modules/debug/connectivity.ts +0 -61
package/src/modules/debug/settlements.ts +0 -33
package/src/modules/debug/stamps.ts +0 -96
package/src/modules/debug/states.ts +0 -35
package/src/modules/debug/status.ts +0 -34
package/src/modules/debug/tag.ts +0 -19
package/src/modules/debug/transactions.ts +0 -79
package/src/modules/feed.ts +0 -105
package/src/modules/pinning.ts +0 -74
package/src/modules/pss.ts +0 -49
package/src/modules/soc.ts +0 -40
package/src/modules/stamps.ts +0 -59
package/src/modules/status.ts +0 -13
package/src/modules/stewardship.ts +0 -32
package/src/modules/tag.ts +0 -83
package/src/types/debug.ts +0 -204
package/src/types/index.ts +0 -561
package/src/types/ky-universal/common.d.ts +0 -17
package/src/types/ky-universal/hooks.d.ts +0 -103
package/src/types/ky-universal/index.d.ts +0 -125
package/src/types/ky-universal/options.d.ts +0 -235
package/src/types/ky-universal/response.d.ts +0 -38
package/src/types/ky-universal/retry.d.ts +0 -39
package/src/types/tar-js.d.ts +0 -1
package/src/types/webpack-bundle-analyzer/index.d.ts +0 -13
package/src/utils/bytes.ts +0 -144
package/src/utils/collection.ts +0 -151
package/src/utils/data.browser.ts +0 -68
package/src/utils/data.ts +0 -48
package/src/utils/error.ts +0 -23
package/src/utils/eth.ts +0 -229
package/src/utils/expose.ts +0 -48
package/src/utils/file.ts +0 -40
package/src/utils/hash.ts +0 -16
package/src/utils/headers.ts +0 -63
package/src/utils/hex.ts +0 -186
package/src/utils/http.ts +0 -141
package/src/utils/merge.ts +0 -34
package/src/utils/pss.ts +0 -16
package/src/utils/stream.ts +0 -146
package/src/utils/tar.ts +0 -30
package/src/utils/type.ts +0 -394
package/src/utils/uint64.ts +0 -31
package/src/utils/url.ts +0 -52
package/test/bee.sh +0 -187
package/test/data/1.txt +0 -1
package/test/data/2.txt +0 -0
package/test/data/empty +0 -0
package/test/data/sub/3.txt +0 -1
package/test/data/sub//303/251 +0 -0
package/test/data/sub//360/237/230/216 +0 -0
package/test/integration/bee-class.browser.spec.ts +0 -272
package/test/integration/bee-class.spec.ts +0 -648
package/test/integration/bee-debug-class.spec.ts +0 -114
package/test/integration/chunk/bmt.spec.ts +0 -33
package/test/integration/chunk/cac.spec.ts +0 -27
package/test/integration/chunk/soc.spec.ts +0 -38
package/test/integration/feed/index.spec.ts +0 -84
package/test/integration/modules/bytes.spec.ts +0 -23
package/test/integration/modules/bzz.spec.ts +0 -265
package/test/integration/modules/chunk.spec.ts +0 -29
package/test/integration/modules/debug/balance.spec.ts +0 -70
package/test/integration/modules/debug/chequebook.spec.ts +0 -64
package/test/integration/modules/debug/connectivity.spec.ts +0 -69
package/test/integration/modules/debug/settlements.spec.ts +0 -34
package/test/integration/modules/debug/states.spec.ts +0 -34
package/test/integration/modules/debug/status.spec.ts +0 -65
package/test/integration/modules/debug/tag.spec.ts +0 -27
package/test/integration/modules/debug/transactions.spec.ts +0 -10
package/test/integration/modules/feed.spec.ts +0 -61
package/test/integration/modules/pinning.spec.ts +0 -155
package/test/integration/modules/pss.spec.ts +0 -105
package/test/integration/modules/status.spec.ts +0 -10
package/test/integration/modules/stewardship.spec.ts +0 -32
package/test/integration/modules/tag.spec.ts +0 -51
package/test/test-type-sequencer.js +0 -36
package/test/testpage/testpage.html +0 -20
package/test/tests-setup.ts +0 -94
package/test/unit/assertions.ts +0 -460
package/test/unit/bee-class.spec.ts +0 -976
package/test/unit/bee-debug-class.spec.ts +0 -435
package/test/unit/chunk/bmt.spec.ts +0 -16
package/test/unit/chunk/cac.spec.ts +0 -29
package/test/unit/chunk/serialize.spec.ts +0 -24
package/test/unit/chunk/signer.spec.ts +0 -140
package/test/unit/chunk/soc.spec.ts +0 -25
package/test/unit/chunk/span.spec.ts +0 -38
package/test/unit/feed/json.spec.ts +0 -73
package/test/unit/nock.ts +0 -151
package/test/unit/utils/bytes.spec.ts +0 -32
package/test/unit/utils/collection.spec.ts +0 -22
package/test/unit/utils/eth.spec.ts +0 -224
package/test/unit/utils/hex.spec.ts +0 -115
package/test/unit/utils/stream.spec.ts +0 -30
package/test/unit/utils/type.spec.ts +0 -32
package/test/unit/utils/uint64.spec.ts +0 -102
package/test/utils.ts +0 -426
package/tsconfig.json +0 -18
package/tsconfig.test.json +0 -11
package/typedoc.json +0 -7
package/webpack.config.ts +0 -141

package/test/integration/modules/tag.spec.ts DELETED Viewed

@@ -1,51 +0,0 @@
-import * as tag from '../../../src/modules/tag'
-import { beeKy, commonMatchers } from '../../utils'
-const BEE_KY = beeKy()
-commonMatchers()
-describe('modules/tag', () => {
-  it('should list tags', async () => {
-    await tag.createTag(BEE_KY)
-    const tags = await tag.getAllTags(BEE_KY)
-    expect(tags).toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({
-          total: expect.any(Number),
-          processed: expect.any(Number),
-          synced: expect.any(Number),
-          uid: expect.any(Number),
-          startedAt: expect.any(String),
-        }),
-      ]),
-    )
-  })
-  it('should create empty tag', async () => {
-    const tag1 = await tag.createTag(BEE_KY)
-    expect(tag1.total).toBe(0)
-    expect(tag1.processed).toBe(0)
-    expect(tag1.synced).toBe(0)
-    expect(Number.isInteger(tag1.uid)).toBeTruthy()
-    expect(tag1.startedAt).toBeType('string')
-  })
-  it('should retrieve previously created empty tag', async () => {
-    const tag1 = await tag.createTag(BEE_KY)
-    const tag2 = await tag.retrieveTag(BEE_KY, tag1.uid)
-    expect(tag1).toEqual(tag2)
-    expect(tag1).toEqual(
-      expect.objectContaining({
-        total: expect.any(Number),
-        processed: expect.any(Number),
-        synced: expect.any(Number),
-        uid: expect.any(Number),
-        startedAt: expect.any(String),
-      }),
-    )
-  })
-})

package/test/test-type-sequencer.js DELETED Viewed

@@ -1,36 +0,0 @@
-// eslint-disable-next-line @typescript-eslint/no-var-requires
-const Sequencer = require('@jest/test-sequencer').default
-/**
- * Jest Sequencer that allows to specify order of execution of tests.
- * We are using it to first execute unit tests and then integration when
- * whole test suite is run.
- *
- * https://jestjs.io/docs/next/configuration#testsequencer-string
- */
-class TestTypeSequencer extends Sequencer {
-  order = ['unit', 'integration']
-  getType(test) {
-    for (const type of this.order) {
-      if (test.path.includes(type)) {
-        return type
-      }
-    }
-  }
-  sort(tests) {
-    // Test structure information
-    // https://github.com/facebook/jest/blob/6b8b1404a1d9254e7d5d90a8934087a9c9899dab/packages/jest-runner/src/types.ts#L17-L21
-    const copyTests = Array.from(tests)
-    return copyTests.sort((testA, testB) => {
-      const typeA = this.getType(testA)
-      const typeB = this.getType(testB)
-      return this.order.indexOf(typeA) - this.order.indexOf(typeB)
-    })
-  }
-}
-module.exports = TestTypeSequencer

package/test/testpage/testpage.html DELETED Viewed

@@ -1,20 +0,0 @@
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>BeeJS testing page - Upload</title>
-  <script src="../../dist/index.browser.js"></script>
-</head>
-<body>
-  <div>
-    <!-- Upload file -->
-    <input type="file" id="upload-file" />
-  </div>
-  <div>
-    <!-- Upload directory -->
-    <input type="file" id="upload-directory" webkitdirectory mozdirectory />
-  </div>
-</body>
-</html>

package/test/tests-setup.ts DELETED Viewed

@@ -1,94 +0,0 @@
-/* eslint-disable no-console */
-import ky from 'ky-universal'
-import { createPostageBatch, getPostageBatch } from '../src/modules/debug/stamps'
-import { BatchId, Ky } from '../src'
-export default async function testsSetup(): Promise<void> {
-  try {
-    const beeDebugKy = ky.create({
-      prefixUrl: process.env.BEE_DEBUG_API_URL || 'http://localhost:1635',
-      timeout: false,
-    })
-    const beeDebugPeerKy = ky.create({
-      prefixUrl: process.env.BEE_PEER_DEBUG_API_URL || 'http://localhost:11635',
-      timeout: false,
-    })
-    if (process.env.BEE_POSTAGE) {
-      try {
-        if (!(await getPostageBatch(beeDebugKy, process.env.BEE_POSTAGE as BatchId)).usable) {
-          delete process.env.BEE_POSTAGE
-          console.log('BEE_POSTAGE stamp was found but is not usable')
-        } else {
-          console.log('Using configured BEE_POSTAGE stamp.')
-        }
-      } catch (e) {
-        delete process.env.BEE_POSTAGE
-        console.log('BEE_POSTAGE stamp was not found')
-      }
-    }
-    if (process.env.BEE_PEER_POSTAGE) {
-      try {
-        if (!(await getPostageBatch(beeDebugPeerKy, process.env.BEE_PEER_POSTAGE as BatchId)).usable) {
-          delete process.env.BEE_PEER_POSTAGE
-          console.log('BEE_PEER_POSTAGE stamp was found but is not usable')
-        } else {
-          console.log('Using configured BEE_PEER_POSTAGE stamp.')
-        }
-      } catch (e) {
-        delete process.env.BEE_PEER_POSTAGE
-        console.log('BEE_PEER_POSTAGE stamp was not found')
-      }
-    }
-    if (!process.env.BEE_POSTAGE || !process.env.BEE_PEER_POSTAGE) {
-      console.log('Creating postage stamps...')
-      const stampsOrder: { ky: Ky; env: string }[] = []
-      if (!process.env.BEE_POSTAGE) {
-        stampsOrder.push({ ky: beeDebugKy, env: 'BEE_POSTAGE' })
-      }
-      if (!process.env.BEE_PEER_POSTAGE) {
-        stampsOrder.push({ ky: beeDebugPeerKy, env: 'BEE_PEER_POSTAGE' })
-      }
-      const stamps = await Promise.all(stampsOrder.map(async order => createPostageBatch(order.ky, '1', 20)))
-      for (let i = 0; i < stamps.length; i++) {
-        process.env[stampsOrder[i].env] = stamps[i]
-        console.log(`${stampsOrder[i].env}: ${stamps[i]}`)
-      }
-      console.log('Waiting for the stamps to be usable')
-      let allUsable = true
-      do {
-        for (let i = 0; i < stamps.length; i++) {
-          // eslint-disable-next-line max-depth
-          try {
-            // eslint-disable-next-line max-depth
-            if (!(await getPostageBatch(stampsOrder[i].ky, stamps[i] as BatchId)).usable) {
-              allUsable = false
-              break
-            } else {
-              allUsable = true
-            }
-          } catch (e) {
-            allUsable = false
-            break
-          }
-        }
-        // eslint-disable-next-line no-loop-func
-        await new Promise<void>(resolve => setTimeout(() => resolve(), 1_000))
-      } while (!allUsable)
-      console.log('Usable, yey!')
-    }
-  } catch (e) {
-    // It is possible that for unit tests the Bee nodes does not run
-    // so we are only logging errors and not leaving them to propagate
-    console.error(e)
-  }
-}

package/test/unit/assertions.ts DELETED Viewed

@@ -1,460 +0,0 @@
-/* eslint-disable */
-import { BeeArgumentError, BeeOptions } from '../../src'
-import { makeBytes } from '../../src/utils/bytes'
-export function testBatchIdAssertion(executor: (input: unknown) => void): void {
-  it('should throw exception for bad BatchId', async () => {
-    await expect(() => executor(1)).rejects.toThrow(TypeError)
-    await expect(() => executor(true)).rejects.toThrow(TypeError)
-    await expect(() => executor({})).rejects.toThrow(TypeError)
-    await expect(() => executor(null)).rejects.toThrow(TypeError)
-    await expect(() => executor(undefined)).rejects.toThrow(TypeError)
-    await expect(() => executor([])).rejects.toThrow(TypeError)
-    await expect(() => executor('')).rejects.toThrow(TypeError)
-    // Not an valid hexstring (ZZZ)
-    await expect(() => executor('ZZZfb5a872396d9693e5c9f9d7233cfa93f395c093371017ff44aa9ae6564cdd')).rejects.toThrow(
-      TypeError,
-    )
-    // Prefixed hexstring is not accepted
-    await expect(() => executor('0x634fb5a872396d9693e5c9f9d7233cfa93f395c093371017ff44aa9ae6564cdd')).rejects.toThrow(
-      TypeError,
-    )
-  })
-}
-export function testDataAssertions(executor: (input: unknown) => void): void {
-  it('should throw exception for bad Data', async () => {
-    await expect(() => executor(1)).rejects.toThrow(TypeError)
-    await expect(() => executor(true)).rejects.toThrow(TypeError)
-    await expect(() => executor(null)).rejects.toThrow(TypeError)
-    await expect(() => executor(undefined)).rejects.toThrow(TypeError)
-    await expect(() => executor([])).rejects.toThrow(TypeError)
-    await expect(() => executor({})).rejects.toThrow(TypeError)
-  })
-}
-export function testFileDataAssertions(executor: (input: unknown) => void): void {
-  it('should throw exception for bad FileData', async () => {
-    await expect(() => executor(1)).rejects.toThrow(TypeError)
-    await expect(() => executor(true)).rejects.toThrow(TypeError)
-    await expect(() => executor(null)).rejects.toThrow(TypeError)
-    await expect(() => executor(undefined)).rejects.toThrow(TypeError)
-    await expect(() => executor([])).rejects.toThrow(TypeError)
-    await expect(() => executor({})).rejects.toThrow(TypeError)
-    await expect(() => executor({ name: 'some file' })).rejects.toThrow(TypeError)
-    // eslint-disable-next-line @typescript-eslint/no-empty-function
-    await expect(() => executor({ pipe: () => {} })).rejects.toThrow(TypeError)
-  })
-}
-export function testUploadOptionsAssertions(executor: (input: unknown) => void): void {
-  it('should throw exception for bad UploadOptions', async () => {
-    await expect(() => executor(1)).rejects.toThrow(TypeError)
-    await expect(() => executor(true)).rejects.toThrow(TypeError)
-    await expect(() => executor([])).rejects.toThrow(TypeError)
-    await expect(() => executor('string')).rejects.toThrow(TypeError)
-    await expect(() => executor({ pin: 'plur' })).rejects.toThrow(TypeError)
-    await expect(() => executor({ pin: 1 })).rejects.toThrow(TypeError)
-    await expect(() => executor({ pin: {} })).rejects.toThrow(TypeError)
-    await expect(() => executor({ pin: [] })).rejects.toThrow(TypeError)
-    await expect(() => executor({ encrypt: 'plur' })).rejects.toThrow(TypeError)
-    await expect(() => executor({ encrypt: 1 })).rejects.toThrow(TypeError)
-    await expect(() => executor({ encrypt: {} })).rejects.toThrow(TypeError)
-    await expect(() => executor({ encrypt: [] })).rejects.toThrow(TypeError)
-    await expect(() => executor({ tag: 'plur' })).rejects.toThrow(TypeError)
-    await expect(() => executor({ tag: true })).rejects.toThrow(TypeError)
-    await expect(() => executor({ tag: {} })).rejects.toThrow(TypeError)
-    await expect(() => executor({ tag: [] })).rejects.toThrow(TypeError)
-    await expect(() => executor({ tag: -1 })).rejects.toThrow(BeeArgumentError)
-  })
-}
-export function testRequestOptionsAssertions(
-  executor: (input: unknown, beeOptions?: BeeOptions) => void,
-  testFetch = true,
-): void {
-  it('should throw exception for bad RequestOptions', async () => {
-    await expect(() => executor(1)).rejects.toThrow(TypeError)
-    await expect(() => executor(true)).rejects.toThrow(TypeError)
-    await expect(() => executor([])).rejects.toThrow(TypeError)
-    await expect(() => executor(() => {})).rejects.toThrow(TypeError)
-    await expect(() => executor('string')).rejects.toThrow(TypeError)
-    await expect(() => executor({ timeout: 'plur' })).rejects.toThrow(TypeError)
-    await expect(() => executor({ timeout: true })).rejects.toThrow(TypeError)
-    await expect(() => executor({ timeout: {} })).rejects.toThrow(TypeError)
-    await expect(() => executor({ timeout: [] })).rejects.toThrow(TypeError)
-    await expect(() => executor({ timeout: -1 })).rejects.toThrow(BeeArgumentError)
-    await expect(() => executor({ retry: 'plur' })).rejects.toThrow(TypeError)
-    await expect(() => executor({ retry: true })).rejects.toThrow(TypeError)
-    await expect(() => executor({ retry: {} })).rejects.toThrow(TypeError)
-    await expect(() => executor({ retry: [] })).rejects.toThrow(TypeError)
-    await expect(() => executor({ retry: -1 })).rejects.toThrow(BeeArgumentError)
-    await expect(() => executor({ fetch: 'plur' })).rejects.toThrow(TypeError)
-    await expect(() => executor({ fetch: true })).rejects.toThrow(TypeError)
-    await expect(() => executor({ fetch: {} })).rejects.toThrow(TypeError)
-    await expect(() => executor({ fetch: [] })).rejects.toThrow(TypeError)
-    await expect(() => executor({ fetch: -1 })).rejects.toThrow(TypeError)
-    await expect(() => executor({ fetch: 1 })).rejects.toThrow(TypeError)
-  })
-  if (testFetch) {
-    it('should use per-call request options instead of instance request options', async () => {
-      const instanceFetch = jest.fn()
-      const instanceMessage = 'instance error'
-      const instanceError = { message: instanceMessage }
-      instanceFetch.mockRejectedValue(instanceError)
-      await expect(() => executor({}, { retry: 0, fetch: instanceFetch })).rejects.toThrow(instanceMessage)
-      expect(instanceFetch.mock.calls.length).toEqual(1)
-      const callFetch = jest.fn()
-      const callMessage = 'call error'
-      const callError = { message: callMessage }
-      callFetch.mockRejectedValue(callError)
-      await expect(() => executor({ fetch: callFetch }, { retry: 0, fetch: instanceFetch })).rejects.toThrow(
-        callMessage,
-      )
-      expect(instanceFetch.mock.calls.length).toEqual(1) // The count did not change from last call
-      expect(callFetch.mock.calls.length).toEqual(1)
-    })
-  }
-}
-export function testPostageBatchOptionsAssertions(executor: (input: unknown) => void): void {
-  it('should throw exception for bad PostageBatch', async () => {
-    await expect(() => executor(1)).rejects.toThrow(TypeError)
-    await expect(() => executor(true)).rejects.toThrow(TypeError)
-    await expect(() => executor([])).rejects.toThrow(TypeError)
-    await expect(() => executor('string')).rejects.toThrow(TypeError)
-    await expect(() => executor({ gasPrice: 'plur' })).rejects.toThrow(TypeError)
-    await expect(() => executor({ gasPrice: true })).rejects.toThrow(TypeError)
-    await expect(() => executor({ gasPrice: {} })).rejects.toThrow(TypeError)
-    await expect(() => executor({ gasPrice: [] })).rejects.toThrow(TypeError)
-    await expect(() => executor({ gasPrice: -1 })).rejects.toThrow(BeeArgumentError)
-    await expect(() => executor({ immutableFlag: 'plur' })).rejects.toThrow(TypeError)
-    await expect(() => executor({ immutableFlag: 1 })).rejects.toThrow(TypeError)
-    await expect(() => executor({ immutableFlag: null })).rejects.toThrow(TypeError)
-    await expect(() => executor({ immutableFlag: {} })).rejects.toThrow(TypeError)
-    await expect(() => executor({ immutableFlag: [] })).rejects.toThrow(TypeError)
-  })
-}
-export function testCashoutOptionsAssertions(executor: (input: unknown) => void): void {
-  it('should throw exception for bad CashoutOptions', async () => {
-    await expect(() => executor(1)).rejects.toThrow(TypeError)
-    await expect(() => executor(true)).rejects.toThrow(TypeError)
-    await expect(() => executor([])).rejects.toThrow(TypeError)
-    await expect(() => executor('string')).rejects.toThrow(TypeError)
-    await expect(() => executor({ gasPrice: 'plur' })).rejects.toThrow(TypeError)
-    await expect(() => executor({ gasPrice: true })).rejects.toThrow(TypeError)
-    await expect(() => executor({ gasPrice: {} })).rejects.toThrow(TypeError)
-    await expect(() => executor({ gasPrice: [] })).rejects.toThrow(TypeError)
-    await expect(() => executor({ gasPrice: -1 })).rejects.toThrow(BeeArgumentError)
-    await expect(() => executor({ gasLimit: 'plur' })).rejects.toThrow(TypeError)
-    await expect(() => executor({ gasLimit: true })).rejects.toThrow(TypeError)
-    await expect(() => executor({ gasLimit: {} })).rejects.toThrow(TypeError)
-    await expect(() => executor({ gasLimit: [] })).rejects.toThrow(TypeError)
-    await expect(() => executor({ gasLimit: -1 })).rejects.toThrow(BeeArgumentError)
-  })
-}
-export function testFileUploadOptionsAssertions(executor: (input: unknown) => void): void {
-  it('should throw exception for bad FileUploadOptions', async () => {
-    await expect(() => executor({ contentType: true })).rejects.toThrow(TypeError)
-    await expect(() => executor({ contentType: 1 })).rejects.toThrow(TypeError)
-    await expect(() => executor({ contentType: {} })).rejects.toThrow(TypeError)
-    await expect(() => executor({ contentType: [] })).rejects.toThrow(TypeError)
-    await expect(() => executor({ size: 'plur' })).rejects.toThrow(TypeError)
-    await expect(() => executor({ size: true })).rejects.toThrow(TypeError)
-    await expect(() => executor({ size: {} })).rejects.toThrow(TypeError)
-    await expect(() => executor({ size: [] })).rejects.toThrow(TypeError)
-    await expect(() => executor({ size: -1 })).rejects.toThrow(BeeArgumentError)
-  })
-}
-export function testCollectionUploadOptionsAssertions(executor: (input: unknown) => void): void {
-  it('should throw exception for bad CollectionUploadOptions', async () => {
-    await expect(() => executor({ indexDocument: true })).rejects.toThrow(TypeError)
-    await expect(() => executor({ indexDocument: 1 })).rejects.toThrow(TypeError)
-    await expect(() => executor({ indexDocument: {} })).rejects.toThrow(TypeError)
-    await expect(() => executor({ indexDocument: [] })).rejects.toThrow(TypeError)
-    await expect(() => executor({ errorDocument: true })).rejects.toThrow(TypeError)
-    await expect(() => executor({ errorDocument: 1 })).rejects.toThrow(TypeError)
-    await expect(() => executor({ errorDocument: {} })).rejects.toThrow(TypeError)
-    await expect(() => executor({ errorDocument: [] })).rejects.toThrow(TypeError)
-  })
-}
-export function testReferenceAssertions(executor: (input: unknown) => void): void {
-  it('should throw exception for bad Reference', async () => {
-    await expect(() => executor(1)).rejects.toThrow(TypeError)
-    await expect(() => executor(true)).rejects.toThrow(TypeError)
-    await expect(() => executor({})).rejects.toThrow(TypeError)
-    await expect(() => executor(null)).rejects.toThrow(TypeError)
-    await expect(() => executor(undefined)).rejects.toThrow(TypeError)
-    await expect(() => executor([])).rejects.toThrow(TypeError)
-    await expect(() => executor('')).rejects.toThrow(TypeError)
-    // Not an valid hexstring (ZZZ)
-    await expect(() => executor('ZZZfb5a872396d9693e5c9f9d7233cfa93f395c093371017ff44aa9ae6564cdd')).rejects.toThrow(
-      TypeError,
-    )
-    // Prefixed hexstring is not accepted
-    await expect(() => executor('0x634fb5a872396d9693e5c9f9d7233cfa93f395c093371017ff44aa9ae6564cdd')).rejects.toThrow(
-      TypeError,
-    )
-    // Length mismatch
-    await expect(() => executor('4fb5a872396d9693e5c9f9d7233cfa93f395c093371017ff44aa9ae6564cdd')).rejects.toThrow(
-      TypeError,
-    )
-  })
-}
-export function testAddressPrefixAssertions(executor: (input: unknown) => void): void {
-  it('should throw exception for bad AddressPrefix', async () => {
-    await expect(() => executor(1)).rejects.toThrow(TypeError)
-    await expect(() => executor(true)).rejects.toThrow(TypeError)
-    await expect(() => executor({})).rejects.toThrow(TypeError)
-    await expect(() => executor(null)).rejects.toThrow(TypeError)
-    await expect(() => executor(undefined)).rejects.toThrow(TypeError)
-    await expect(() => executor([])).rejects.toThrow(TypeError)
-    await expect(() => executor('')).rejects.toThrow(TypeError)
-    // Not an valid hexstring (ZZZ)
-    await expect(() => executor('ZZZf')).rejects.toThrow(TypeError)
-    // Prefixed hexstring is not accepted
-    await expect(() => executor('0x634f')).rejects.toThrow(TypeError)
-    // Does not allow longer string then the PSS_TARGET_HEX_LENGTH_MAX
-    await expect(() => executor('1236412')).rejects.toThrow(BeeArgumentError)
-  })
-}
-export function testPublicKeyAssertions(executor: (input: unknown) => void): void {
-  it('should throw exception for bad PublicKey', async () => {
-    await expect(() => executor(1)).rejects.toThrow(TypeError)
-    await expect(() => executor(true)).rejects.toThrow(TypeError)
-    await expect(() => executor({})).rejects.toThrow(TypeError)
-    await expect(() => executor([])).rejects.toThrow(TypeError)
-    // Not an valid hexstring (ZZZ)
-    await expect(() => executor('ZZZfb5a872396d9693e5c9f9d7233cfa93f395c093371017ff44aa9ae6564cdd')).rejects.toThrow(
-      TypeError,
-    )
-    // Prefixed hexstring is not accepted
-    await expect(() => executor('0x634fb5a872396d9693e5c9f9d7233cfa93f395c093371017ff44aa9ae6564cdd')).rejects.toThrow(
-      TypeError,
-    )
-    // Length mismatch
-    await expect(() => executor('4fb5a872396d9693e5c9f9d7233cfa93f395c093371017ff44aa9ae6564cdd')).rejects.toThrow(
-      TypeError,
-    )
-  })
-}
-export function testPssMessageHandlerAssertions(executor: (input: unknown) => void): void {
-  it('should throw exception for bad PssMessageHandler', async () => {
-    await expect(() => executor(1)).rejects.toThrow(TypeError)
-    await expect(() => executor(true)).rejects.toThrow(TypeError)
-    await expect(() => executor({})).rejects.toThrow(TypeError)
-    await expect(() => executor(null)).rejects.toThrow(TypeError)
-    await expect(() => executor(undefined)).rejects.toThrow(TypeError)
-    await expect(() => executor([])).rejects.toThrow(TypeError)
-    await expect(() => executor('')).rejects.toThrow(TypeError)
-    await expect(() => {
-      return executor({ onMessage() {} })
-    }).rejects.toThrow(TypeError)
-    await expect(() => {
-      return executor({ onMessage() {}, onError: '' })
-    }).rejects.toThrow(TypeError)
-    await expect(() => {
-      return executor({ onMessage() {}, onError: [] })
-    }).rejects.toThrow(TypeError)
-    await expect(() => {
-      return executor({ onMessage() {}, onError: {} })
-    }).rejects.toThrow(TypeError)
-    await expect(() => {
-      return executor({ onMessage() {}, onError: true })
-    }).rejects.toThrow(TypeError)
-    await expect(() => {
-      return executor({ onError() {}, onMessage: true })
-    }).rejects.toThrow(TypeError)
-    await expect(() => {
-      return executor({ onError() {}, onMessage: {} })
-    }).rejects.toThrow(TypeError)
-    await expect(() => {
-      return executor({ onError() {}, onMessage: [] })
-    }).rejects.toThrow(TypeError)
-    await expect(() => {
-      return executor({ onError() {}, onMessage: '' })
-    }).rejects.toThrow(TypeError)
-    await expect(() => {
-      return executor({ onError() {}, onMessage: 1 })
-    }).rejects.toThrow(TypeError)
-  })
-}
-export function testTopicAssertions(executor: (input: unknown) => void): void {
-  it('should throw exception for bad Topic', async () => {
-    await expect(() => executor(1)).rejects.toThrow(TypeError)
-    await expect(() => executor(true)).rejects.toThrow(TypeError)
-    await expect(() => executor({})).rejects.toThrow(TypeError)
-    await expect(() => executor(null)).rejects.toThrow(TypeError)
-    await expect(() => executor(undefined)).rejects.toThrow(TypeError)
-    await expect(() => executor([])).rejects.toThrow(TypeError)
-  })
-}
-export function testFeedTopicAssertions(executor: (input: unknown) => void): void {
-  it('should throw exception for bad Topic', async () => {
-    await expect(() => executor(1)).rejects.toThrow(TypeError)
-    await expect(() => executor(true)).rejects.toThrow(TypeError)
-    await expect(() => executor({})).rejects.toThrow(TypeError)
-    await expect(() => executor(null)).rejects.toThrow(TypeError)
-    await expect(() => executor(undefined)).rejects.toThrow(TypeError)
-    await expect(() => executor([])).rejects.toThrow(TypeError)
-    // Not an valid hexstring (ZZZ)
-    await expect(() => executor('ZZZfb5a872396d9693e5c9f9d7233cfa93f395c093371017ff44aa9ae6564cdd')).rejects.toThrow(
-      TypeError,
-    )
-    // Length mismatch
-    await expect(() => executor('4fb5a872396d9693e5c9f9d7233cfa93f395c093371017ff44aa9ae6564cdd')).rejects.toThrow(
-      TypeError,
-    )
-  })
-}
-export function testEthAddressAssertions(executor: (input: unknown) => void): void {
-  it('should throw exception for bad EthAddress', async () => {
-    await expect(() => executor(1)).rejects.toThrow(TypeError)
-    await expect(() => executor(true)).rejects.toThrow(TypeError)
-    await expect(() => executor({})).rejects.toThrow(TypeError)
-    await expect(() => executor(null)).rejects.toThrow(TypeError)
-    await expect(() => executor(undefined)).rejects.toThrow(TypeError)
-    await expect(() => executor([])).rejects.toThrow(TypeError)
-    // Not an valid hexstring (ZZZ)
-    await expect(() => executor('ZZZfb5a872396d9693e5c9f9d7233cfa93f395c093371017ff44aa9ae6564cdd')).rejects.toThrow(
-      TypeError,
-    )
-    // Length mismatch
-    await expect(() => executor('4fb5a872396d9693e5c9f9d7233cfa93f395c093371017ff44aa9ae6564cdd')).rejects.toThrow(
-      TypeError,
-    )
-    // Bytes length mismatch
-    await expect(() => executor(makeBytes(19))).rejects.toThrow(TypeError)
-  })
-}
-export function testMakeSignerAssertions(executor: (input: unknown) => void, optionals = true): void {
-  it('should throw exception for bad Signer', async () => {
-    await expect(() => executor(1)).rejects.toThrow(TypeError)
-    await expect(() => executor(true)).rejects.toThrow(TypeError)
-    await expect(() => executor({})).rejects.toThrow(TypeError)
-    await expect(() => executor([])).rejects.toThrow(TypeError)
-    if (optionals) {
-      await expect(() => executor(null)).rejects.toThrow(TypeError)
-      await expect(() => executor(undefined)).rejects.toThrow(TypeError)
-    }
-    // Not an valid hexstring (ZZZ)
-    await expect(() => executor('ZZZfb5a872396d9693e5c9f9d7233cfa93f395c093371017ff44aa9ae6564cdd')).rejects.toThrow(
-      TypeError,
-    )
-    // Hex Length mismatch
-    await expect(() => executor('4fb5a872396d9693e5c9f9d7233cfa93f395c093371017ff44aa9ae6564cdd')).rejects.toThrow(
-      TypeError,
-    )
-    // Bytes Length mismatch
-    await expect(() => executor(makeBytes(31))).rejects.toThrow(TypeError)
-    await expect(() => executor({ address: makeBytes(19), sign: () => {} })).rejects.toThrow(TypeError)
-    await expect(() => executor({ address: '', sign: () => {} })).rejects.toThrow(TypeError)
-    await expect(() => executor({ address: undefined, sign: () => {} })).rejects.toThrow(TypeError)
-    await expect(() => executor({ address: null, sign: () => {} })).rejects.toThrow(TypeError)
-    await expect(() => executor({ address: [], sign: () => {} })).rejects.toThrow(TypeError)
-    await expect(() => executor({ address: {}, sign: () => {} })).rejects.toThrow(TypeError)
-    await expect(() => executor({ address: makeBytes(20), sign: null })).rejects.toThrow(TypeError)
-    await expect(() => executor({ address: makeBytes(20), sign: undefined })).rejects.toThrow(TypeError)
-    await expect(() => executor({ address: makeBytes(20), sign: 'asd' })).rejects.toThrow(TypeError)
-    await expect(() => executor({ address: makeBytes(20), sign: [] })).rejects.toThrow(TypeError)
-    await expect(() => executor({ address: makeBytes(20), sign: {} })).rejects.toThrow(TypeError)
-  })
-}
-export function testFeedTypeAssertions(executor: (input: unknown) => void, optionals = true): void {
-  it('should throw exception for bad FeedType', async () => {
-    await expect(() => executor(1)).rejects.toThrow(TypeError)
-    await expect(() => executor(true)).rejects.toThrow(TypeError)
-    await expect(() => executor({})).rejects.toThrow(TypeError)
-    await expect(() => executor([])).rejects.toThrow(TypeError)
-    await expect(() => executor('asd')).rejects.toThrow(TypeError)
-    if (optionals) {
-      await expect(() => executor('')).rejects.toThrow(TypeError)
-      await expect(() => executor(null)).rejects.toThrow(TypeError)
-      await expect(() => executor(undefined)).rejects.toThrow(TypeError)
-    }
-  })
-}
-export function testAddressAssertions(executor: (input: unknown) => void, optionals = true): void {
-  it('should throw exception for bad Address', async () => {
-    await expect(() => executor(1)).rejects.toThrow(TypeError)
-    await expect(() => executor(true)).rejects.toThrow(TypeError)
-    await expect(() => executor({})).rejects.toThrow(TypeError)
-    await expect(() => executor([])).rejects.toThrow(TypeError)
-    await expect(() => executor('asd')).rejects.toThrow(TypeError)
-    // Not an valid hexstring (ZZZ)
-    await expect(() => executor('ZZZfb5a872396d9693e5c9f9d7233cfa93f395c093371017ff44aa9ae6564cdd')).rejects.toThrow(
-      TypeError,
-    )
-    // Hex Length mismatch
-    await expect(() => executor('4fb5a872396d9693e5c9f9d7233cfa93f395c093371017ff44aa9ae6564cdd')).rejects.toThrow(
-      TypeError,
-    )
-    if (optionals) {
-      await expect(() => executor('')).rejects.toThrow(TypeError)
-      await expect(() => executor(null)).rejects.toThrow(TypeError)
-      await expect(() => executor(undefined)).rejects.toThrow(TypeError)
-    }
-  })
-}