@xyo-network/core 2.20.17

package/dist/esm/lib/typeOf/typeOf.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeOf.js","sourceRoot":"","sources":["../../../../src/lib/typeOf/typeOf.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,MAAM,GAAG,CAAI,IAAO,EAAe,EAAE;IAChD,OAAO,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,IAAI,CAAA;AACpD,CAAC,CAAA"}

package/dist/esm/lib/typeOf/validateType.d.ts

@@ -0,0 +1,2 @@
+import { TypeOfTypes } from './TypeOfTypes';
+export declare const validateType: <T>(typeName: TypeOfTypes, value: T, optional?: boolean) => [T | undefined, Error[]];

package/dist/esm/lib/typeOf/validateType.js

@@ -0,0 +1,14 @@
+import { typeOf } from './typeOf';
+export const validateType = (typeName, value, optional = false) => {
+    switch (typeOf(value)) {
+        case typeName:
+            return [value, []];
+        default: {
+            if (optional && typeOf(value) === 'undefined') {
+                return [value, []];
+            }
+            return [undefined, [Error(`value type is not '${typeName}:${typeof value}'`)]];
+        }
+    }
+};
+//# sourceMappingURL=validateType.js.map

package/dist/esm/lib/typeOf/validateType.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateType.js","sourceRoot":"","sources":["../../../../src/lib/typeOf/validateType.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AAGjC,MAAM,CAAC,MAAM,YAAY,GAAG,CAAI,QAAqB,EAAE,KAAQ,EAAE,QAAQ,GAAG,KAAK,EAA4B,EAAE;IAC7G,QAAQ,MAAM,CAAC,KAAK,CAAC,EAAE;QACrB,KAAK,QAAQ;YACX,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAA;QACpB,OAAO,CAAC,CAAC;YACP,IAAI,QAAQ,IAAI,MAAM,CAAC,KAAK,CAAC,KAAK,WAAW,EAAE;gBAC7C,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAA;aACnB;YACD,OAAO,CAAC,SAAS,EAAE,CAAC,KAAK,CAAC,sBAAsB,QAAQ,IAAI,OAAO,KAAK,GAAG,CAAC,CAAC,CAAC,CAAA;SAC/E;KACF;AACH,CAAC,CAAA"}

package/dist/esm/models/WithStringIndex.d.ts

@@ -0,0 +1 @@
+export declare type WithStringIndex<T> = T & Record<string, unknown>;

package/dist/esm/models/WithStringIndex.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=WithStringIndex.js.map

package/dist/esm/models/WithStringIndex.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WithStringIndex.js","sourceRoot":"","sources":["../../../src/models/WithStringIndex.ts"],"names":[],"mappings":""}

package/dist/esm/models/index.d.ts

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

package/dist/esm/models/index.js

@@ -0,0 +1,2 @@
+export * from './WithStringIndex';
+//# sourceMappingURL=index.js.map

package/dist/esm/models/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/models/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAA"}

package/dist/esm/nodeIndex.d.ts

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

package/dist/esm/nodeIndex.js

@@ -0,0 +1,2 @@
+export * from './shared';
+//# sourceMappingURL=nodeIndex.js.map

package/dist/esm/nodeIndex.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodeIndex.js","sourceRoot":"","sources":["../../src/nodeIndex.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAA"}

package/dist/esm/shared.d.ts

@@ -0,0 +1,10 @@
+export * from './BoundWitness';
+export * from './Hasher';
+export * from './Huri';
+export * from './lib';
+export * from './models';
+export * from './Payload';
+export * from './Schema';
+export * from './SchemaNameValidator';
+export * from './Wallet';
+export * from './Witness';

package/dist/esm/shared.js

@@ -0,0 +1,11 @@
+export * from './BoundWitness';
+export * from './Hasher';
+export * from './Huri';
+export * from './lib';
+export * from './models';
+export * from './Payload';
+export * from './Schema';
+export * from './SchemaNameValidator';
+export * from './Wallet';
+export * from './Witness';
+//# sourceMappingURL=shared.js.map

package/dist/esm/shared.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.js","sourceRoot":"","sources":["../../src/shared.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAA;AAC9B,cAAc,UAAU,CAAA;AACxB,cAAc,QAAQ,CAAA;AACtB,cAAc,OAAO,CAAA;AACrB,cAAc,UAAU,CAAA;AACxB,cAAc,WAAW,CAAA;AACzB,cAAc,UAAU,CAAA;AACxB,cAAc,uBAAuB,CAAA;AACrC,cAAc,UAAU,CAAA;AACxB,cAAc,WAAW,CAAA"}

package/jest.config.cjs

@@ -0,0 +1,25 @@
+const generateJestConfig = ({ esModules }) => {
+  const esModuleslist = Array.isArray(esModules) ? esModules.join('|') : esModules
+  return {
+    globals: {
+      'ts-jest': {
+        tsconfig: 'tsconfig.test.json',
+      },
+    },
+    moduleNameMapper: {
+      '^(\\.{1,2}/.*)\\.js$': '$1',
+    },
+    preset: 'ts-jest/presets/default-esm',
+    setupFiles: ['dotenv/config'],
+    setupFilesAfterEnv: ['jest-sorted'],
+    testRegex: '(/__tests__/.*|(\\.|/)(test|spec))\\.tsx?$',
+    testTimeout: 20000,
+    transform: {
+      [`(${esModuleslist}).+\\.js$`]: 'babel-jest',
+      '^.+\\.tsx?$': 'ts-jest/legacy',
+    },
+    transformIgnorePatterns: [`./node_modules/(?!${esModuleslist})`],
+  }
+}
+
+module.exports = generateJestConfig({ esModules: ['is-ip', 'ip-regex', 'lodash-es', 'uuid'] })

package/package.json

@@ -0,0 +1,117 @@
+{
+  "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/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/browserIndex.js",
+  "docs": "dist/docs.json",
+  "exports": {
+    ".": {
+      "node": {
+        "import": "./dist/esm/nodeIndex.js",
+        "require": "./dist/cjs/nodeIndex.js"
+      },
+      "browser": {
+        "import": "./dist/esm/browserIndex.js",
+        "require": "./dist/cjs/browserIndex.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/core",
+  "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.17",
+  "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/BoundWitness/Builder/Builder.spec.ts

@@ -0,0 +1,86 @@
+/* eslint-disable sort-keys-fix/sort-keys-fix */
+/* eslint-disable sort-keys */
+import { XyoHasher } from '../../Hasher'
+import { XyoPayload } from '../../Payload'
+import { XyoAccount, XyoAddressValue } from '../../Wallet'
+import { XyoBoundWitnessBuilder } from './Builder'
+
+const schema = 'network.xyo.temp'
+const payload1: XyoPayload = {
+  number_field: 1,
+  object_field: {
+    number_value: 2,
+    string_value: 'yo',
+  },
+  schema,
+  string_field: 'there',
+  timestamp: 1618603439107,
+}
+const payload2: XyoPayload = {
+  timestamp: 1618603439107,
+  string_field: 'there',
+  schema,
+  object_field: {
+    string_value: 'yo',
+    number_value: 2,
+  },
+  number_field: 1,
+}
+const payloads = [payload1, payload2]
+const payloadHash = '3c817871cbf24708703e907dbc344b1b2aefcc3603d14d59c3a35a5c446410d1'
+
+describe('XyoBoundWitnessBuilder', () => {
+  describe('hash', () => {
+    it.each(payloads)('consistently hashes equivalent payload independent of the order of the keys', (payload) => {
+      const hash = new XyoHasher(payload).sortedHash()
+      expect(hash).toEqual(payloadHash)
+    })
+  })
+  describe('build', () => {
+    describe('_hash', () => {
+      it.each(payloads)('consistently hashes equivalent payloads independent of the order of the keys', (payload) => {
+        const address = XyoAccount.fromPhrase('test1')
+        let builder = new XyoBoundWitnessBuilder()
+        expect(builder).toBeDefined()
+        builder = builder.witness(address)
+        expect(builder).toBeDefined()
+        builder = builder.payload(payload)
+        expect(builder).toBeDefined()
+
+        const actual = builder.build()
+
+        expect(actual).toBeDefined()
+        expect(actual._hash).toEqual('7f3203f2d191f12c26cd1aec62b718be8848471f82831a8870f82fc669a5f35b')
+
+        if (actual._hash && actual._signatures) {
+          const addr = new XyoAddressValue(actual.addresses[0])
+          expect(addr.hex).toBe(actual.addresses[0])
+          const verify = new XyoAddressValue(actual.addresses[0]).verify(actual._hash, actual._signatures[0])
+          expect(verify).toBe(true)
+        }
+      })
+    })
+    describe('with inlinePayloads true', () => {
+      it('contains the _payloads field', () => {
+        const address = XyoAccount.fromPhrase('test2')
+        const builder = new XyoBoundWitnessBuilder({ inlinePayloads: true }).witness(address).payload(payload1)
+
+        const actual = builder.build()
+
+        expect(actual).toBeDefined()
+        expect(actual._payloads).toBeDefined()
+      })
+    })
+    describe('with inlinePayloads false', () => {
+      it('omits the _payloads field', () => {
+        const address = XyoAccount.fromPhrase('test3')
+        const builder = new XyoBoundWitnessBuilder({ inlinePayloads: false }).witness(address).payload(payload1)
+
+        const actual = builder.build()
+
+        expect(actual).toBeDefined()
+        expect(actual._payloads).toBeUndefined()
+      })
+    })
+  })
+})

package/src/BoundWitness/Builder/Builder.ts

@@ -0,0 +1,83 @@
+import { assertEx, Buffer } from '@xylabs/sdk-js'
+
+import { sortFields, XyoHasher } from '../../Hasher'
+import { XyoPayload, XyoPayloadBody } from '../../Payload'
+import { XyoAccount } from '../../Wallet'
+import { XyoBoundWitness } from '../models'
+
+export interface XyoBoundWitnessBuilderConfig {
+  /** Whether or not the payloads should be included in the metadata sent to and recorded by the ArchivistApi */
+  readonly inlinePayloads?: boolean
+}
+
+export class XyoBoundWitnessBuilder {
+  private _accounts: XyoAccount[] = []
+  private _payload_schemas: string[] = []
+  private _payloads: XyoPayload[] = []
+
+  constructor(public readonly config: XyoBoundWitnessBuilderConfig = { inlinePayloads: false }) {}
+
+  private get _payload_hashes(): string[] {
+    return this._payloads.map((payload) => {
+      return new XyoHasher(payload).sortedHash()
+    })
+  }
+
+  public witness(account: XyoAccount) {
+    this._accounts?.push(account)
+    return this
+  }
+
+  public payloads(payloads: (XyoPayload | null)[]) {
+    payloads.forEach((payload) => {
+      if (payload !== null) {
+        this.payload(payload)
+      }
+    })
+    return this
+  }
+
+  public payload(payload?: XyoPayload) {
+    if (payload) {
+      this._payload_schemas.push(payload.schema)
+      this._payloads.push(assertEx(sortFields(payload)))
+    }
+    return this
+  }
+
+  public hashableFields(): XyoBoundWitness {
+    const addresses = this._accounts.map((account) => account.addressValue.hex)
+    const previous_hashes = this._accounts.map((account) => account.previousHash?.hex ?? null)
+    return {
+      addresses: assertEx(addresses, 'Missing addresses'),
+      payload_hashes: assertEx(this._payload_hashes, 'Missing payload_hashes'),
+      payload_schemas: assertEx(this._payload_schemas, 'Missing payload_schemas'),
+      previous_hashes,
+      schema: 'network.xyo.boundwitness',
+    }
+  }
+
+  private signatures(_hash: string) {
+    return this._accounts.map((account) => Buffer.from(account.sign(Buffer.from(_hash, 'hex'))).toString('hex'))
+  }
+
+  private inlinePayloads() {
+    return this._payloads.map<XyoPayloadBody>((payload, index) => {
+      return {
+        ...payload,
+        schema: this._payload_schemas[index],
+      }
+    })
+  }
+
+  public build(): XyoBoundWitness {
+    const hashableFields = this.hashableFields() as unknown as Record<string, unknown>
+    const _hash = new XyoHasher(hashableFields).sortedHash()
+
+    const ret = { ...hashableFields, _client: 'js', _hash, _signatures: this.signatures(_hash), _timestamp: Date.now() } as XyoBoundWitness
+    if (this.config.inlinePayloads) {
+      ret._payloads = this.inlinePayloads()
+    }
+    return ret
+  }
+}

package/src/BoundWitness/Builder/index.ts

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

package/src/BoundWitness/Validator/BodyValidator.spec.ts

@@ -0,0 +1,10 @@
+import { dumpErrors } from '../../lib'
+import { testBoundWitness } from '../../Test'
+import { XyoBoundWitnessBodyValidator } from './BodyValidator'
+
+test('all', () => {
+  const validator = new XyoBoundWitnessBodyValidator(testBoundWitness)
+  const errors = validator.all()
+  dumpErrors(errors)
+  expect(errors.length).toBe(0)
+})

package/src/BoundWitness/Validator/BodyValidator.ts

@@ -0,0 +1,104 @@
+import uniq from 'lodash/uniq'
+
+import { XyoHasher } from '../../Hasher'
+import { validateType } from '../../lib'
+import { WithStringIndex } from '../../models'
+import { XyoPayload } from '../../Payload'
+import { XyoSchemaNameValidator } from '../../SchemaNameValidator'
+import { XyoBoundWitnessBody } from '../models'
+
+class XyoBoundWitnessBodyValidator {
+  private body: WithStringIndex<XyoBoundWitnessBody>
+  private payloads?: XyoPayload[]
+  constructor(body: XyoBoundWitnessBody, payloads?: XyoPayload[]) {
+    this.body = body as WithStringIndex<XyoBoundWitnessBody>
+    this.payloads = payloads
+  }
+
+  public addressesUniqueness() {
+    const errors: Error[] = []
+    const { addresses } = this.body
+    const uniqAddresses = uniq(addresses)
+    if (addresses?.length !== uniqAddresses?.length) errors.push(new Error('addresses must be unique'))
+    return errors
+  }
+
+  public addresses() {
+    const errors: Error[] = []
+    const { addresses } = this.body
+    if (!addresses?.length) errors.push(new Error('addresses missing [at least one address required]'))
+    errors.push(...this.addressesUniqueness())
+    return errors
+  }
+
+  private validateArrayLength(fieldName: string, compareArrayName: string) {
+    const errors: Error[] = []
+
+    const [array, arrayErrors] = validateType('array', this.body[fieldName] as [], true)
+    const [compareArray, compareArrayErrors] = validateType('array', this.body[compareArrayName] as [], true)
+
+    if (array?.length !== compareArray?.length) {
+      errors.push(new Error(`${fieldName}/${compareArrayName} count mismatch [${array?.length} !== ${compareArray?.length}]`))
+    }
+
+    return [...arrayErrors, ...compareArrayErrors, ...errors]
+  }
+
+  public validatePayloadHashesLength() {
+    const errors: Error[] = []
+    errors.push(...this.validateArrayLength('payload_hashes', 'payload_schemas'))
+    return errors
+  }
+
+  public validateArrayLengths() {
+    const errors: Error[] = []
+    errors.push(...this.validatePayloadHashesLength())
+    return errors
+  }
+
+  public payloadHashes() {
+    const errors: Error[] = []
+    const passedHashes = this.body.payload_hashes
+    this.payloads?.forEach((payload, index) => {
+      const calcHash = new XyoHasher(payload).sortedHash()
+      const passedHash = passedHashes[index]
+      if (calcHash !== passedHash) {
+        errors.push(new Error(`hash mismatch [${calcHash} !== ${passedHash}]`))
+      }
+    })
+    return errors
+  }
+
+  public payloadSchemas() {
+    const errors: Error[] = []
+    const schemaValidators: XyoSchemaNameValidator[] = this.body.payload_schemas.map((schema: string) => {
+      return new XyoSchemaNameValidator(schema)
+    })
+    schemaValidators.forEach((validator) => {
+      errors.push(...validator.all())
+    })
+    return errors
+  }
+
+  public previousHashes() {
+    const errors: Error[] = []
+    return errors
+  }
+
+  public schmea() {
+    const errors: Error[] = []
+    const expectedSchema = 'network.xyo.boundwitness'
+    if (this.body.schema !== expectedSchema) {
+      errors.push(new Error(`invalid schema [${expectedSchema} !== ${this.body.schema}]`))
+    }
+    return errors
+  }
+
+  public all() {
+    const errors: Error[] = []
+    errors.push(...this.addresses(), ...this.validateArrayLengths(), ...this.payloadHashes(), ...this.payloadSchemas(), ...this.previousHashes(), ...this.schmea())
+    return errors
+  }
+}
+
+export { XyoBoundWitnessBodyValidator }

package/src/BoundWitness/Validator/MetaValidator.spec.ts

@@ -0,0 +1,55 @@
+import { dumpErrors } from '../../lib'
+import { testBoundWitness } from '../../Test'
+import { XyoBoundWitness } from '../models'
+import { XyoBoundWitnessMetaValidator } from './MetaValidator'
+
+describe('XyoBoundWitnessMetaValidator', () => {
+  it('Validates valid Meta', () => {
+    const validator = new XyoBoundWitnessMetaValidator(testBoundWitness)
+    const errors = validator.all()
+    dumpErrors(errors)
+    expect(errors.length).toBe(0)
+  })
+  describe('sourceIp', () => {
+    it('Validates valid IPv4 Address', () => {
+      const bw: XyoBoundWitness = {
+        ...testBoundWitness,
+        _source_ip: '127.0.0.1',
+      }
+      const validator = new XyoBoundWitnessMetaValidator(bw)
+      const errors = validator.all()
+      dumpErrors(errors)
+      expect(errors.length).toBe(0)
+    })
+    it('Validates valid IPv6 Address', () => {
+      const bw: XyoBoundWitness = {
+        ...testBoundWitness,
+        _source_ip: '2001:0db8:85a3:0000:0000:8a2e:0370:7334',
+      }
+      const validator = new XyoBoundWitnessMetaValidator(bw)
+      const errors = validator.all()
+      dumpErrors(errors)
+      expect(errors.length).toBe(0)
+    })
+    it('Handles missing Address', () => {
+      const bw: XyoBoundWitness = {
+        ...testBoundWitness,
+        _source_ip: undefined,
+      }
+      const validator = new XyoBoundWitnessMetaValidator(bw)
+      const errors = validator.all()
+      dumpErrors(errors)
+      expect(errors.length).toBe(0)
+    })
+    it('Detects invalid Addresses', () => {
+      const bw: XyoBoundWitness = {
+        ...testBoundWitness,
+        _source_ip: 'notAnIpAddress',
+      }
+      const validator = new XyoBoundWitnessMetaValidator(bw)
+      const errors = validator.all()
+      dumpErrors(errors)
+      expect(errors.length).toBe(0)
+    })
+  })
+})

package/src/BoundWitness/Validator/MetaValidator.ts

@@ -0,0 +1,75 @@
+import { XyoHasher } from '../../Hasher'
+import { XyoBoundWitness } from '../models'
+import { isIP } from './is-ip'
+
+const MIN_ALLOWED_TIMESTAMP = 1609459200000
+const MAX_ALLOWED_TIMESTAMP = 4102444800000
+
+export class XyoBoundWitnessMetaValidator {
+  private bw: XyoBoundWitness
+  constructor(bw: XyoBoundWitness) {
+    this.bw = bw
+  }
+
+  public client() {
+    const errors: Error[] = []
+    return errors
+  }
+
+  public hash() {
+    const errors: Error[] = []
+
+    const hasher = new XyoHasher(this.bw)
+
+    const bodyHash = hasher.sortedHash()
+    if (bodyHash !== this.bw._hash) errors.push(new Error(`Body hash mismatch: [calculated: ${bodyHash}] [found: ${this.bw._hash}] [sortedStringify: ${hasher.sortedStringify()}]`))
+    return errors
+  }
+
+  public payloads() {
+    const errors: Error[] = []
+    return errors
+  }
+
+  public signatures() {
+    const errors: Error[] = []
+    return errors
+  }
+
+  public timestamp() {
+    const errors: Error[] = []
+    const { _timestamp } = this.bw
+    if (_timestamp === undefined) errors.push(new Error('Missing _timestamp'))
+    else if (_timestamp < MIN_ALLOWED_TIMESTAMP) errors.push(new Error('_timestamp is before year 2021'))
+    else if (_timestamp > MAX_ALLOWED_TIMESTAMP) errors.push(new Error('_timestamp is after year 2100'))
+    return errors
+  }
+
+  public sourceIp() {
+    const errors: Error[] = []
+    const { _source_ip } = this.bw
+    if (_source_ip && !isIP(_source_ip)) {
+      errors.push(new Error(`_source_ip invalid format [${_source_ip}]`))
+    }
+    return errors
+  }
+
+  public userAgent() {
+    const errors: Error[] = []
+    const { _user_agent } = this.bw
+    if (!_user_agent) errors.push(new Error('_user_agent missing'))
+    return errors
+  }
+
+  public all() {
+    const errors: Error[] = []
+    errors.push(...this.client(), ...this.hash(), ...this.payloads(), ...this.signatures())
+    return errors
+  }
+
+  public meta() {
+    const errors: Error[] = []
+    errors.push(...this.timestamp(), ...this.sourceIp(), ...this.userAgent())
+    return errors
+  }
+}

package/src/BoundWitness/Validator/Validator.spec.ts

@@ -0,0 +1,10 @@
+import { dumpErrors } from '../../lib'
+import { testBoundWitness } from '../../Test'
+import { XyoBoundWitnessValidator } from './Validator'
+
+test('all', () => {
+  const validator = new XyoBoundWitnessValidator(testBoundWitness)
+  const errors = validator.all()
+  dumpErrors(errors)
+  expect(errors.length).toBe(0)
+})