@xyo-network/boundwitness 2.21.11

package/src/Validator/BodyValidator.ts

@@ -0,0 +1,102 @@
+import { XyoHasher, XyoValidator } from '@xyo-network/core'
+import { XyoPayload, XyoSchemaNameValidator } from '@xyo-network/payload'
+import { validateType } from '@xyo-network/typeof'
+import uniq from 'lodash/uniq'
+
+import { XyoBoundWitness } from '../models'
+
+export class XyoBoundWitnessBodyValidator<T extends XyoBoundWitness = XyoBoundWitness> extends XyoValidator<T> {
+  private payloads?: XyoPayload[]
+  constructor(boundWitness: T, payloads?: XyoPayload[]) {
+    super(boundWitness)
+    this.payloads = payloads
+  }
+
+  public addressesUniqueness() {
+    const errors: Error[] = []
+    const { addresses } = this.obj
+    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.obj
+    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.stringKeyObj[fieldName] as [], true)
+    const [compareArray, compareArrayErrors] = validateType('array', this.stringKeyObj[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.obj.payload_hashes
+    this.payloads?.forEach((payload, index) => {
+      const calcHash = new XyoHasher(payload).hash
+      const passedHash = passedHashes?.[index]
+      if (calcHash !== passedHash) {
+        errors.push(new Error(`hash mismatch [${calcHash} !== ${passedHash}]`))
+      }
+    })
+    return errors
+  }
+
+  public payloadSchemas() {
+    const errors: Error[] = []
+    const payloadSchemas = this.obj.payload_schemas
+    if (payloadSchemas) {
+      const schemaValidators: XyoSchemaNameValidator[] = payloadSchemas.map((schema: string) => {
+        return new XyoSchemaNameValidator(schema)
+      })
+      schemaValidators.forEach((validator) => {
+        errors.push(...validator.all())
+      })
+    }
+    return errors
+  }
+
+  public previousHashes() {
+    const errors: Error[] = []
+    return errors
+  }
+
+  public schema() {
+    const errors: Error[] = []
+    const expectedSchema = 'network.xyo.boundwitness'
+    if (this.obj.schema !== expectedSchema) {
+      errors.push(new Error(`invalid schema [${expectedSchema} !== ${this.obj.schema}]`))
+    }
+    return errors
+  }
+
+  public validate() {
+    const errors: Error[] = []
+    errors.push(...this.addresses(), ...this.validateArrayLengths(), ...this.payloadHashes(), ...this.payloadSchemas(), ...this.previousHashes(), ...this.schema())
+    return errors
+  }
+}

package/src/Validator/MetaValidator.spec.ts

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

package/src/Validator/MetaValidator.ts

@@ -0,0 +1,71 @@
+import { XyoHasher, XyoValidator } from '@xyo-network/core'
+
+import { XyoBoundWitnessMeta } from '../models'
+import { isIP } from './is-ip'
+
+const MIN_ALLOWED_TIMESTAMP = 1609459200000
+const MAX_ALLOWED_TIMESTAMP = 4102444800000
+
+export class XyoBoundWitnessMetaValidator<T extends Partial<XyoBoundWitnessMeta> = Partial<XyoBoundWitnessMeta>> extends XyoValidator<T> {
+  public client() {
+    const errors: Error[] = []
+    return errors
+  }
+
+  public hash() {
+    const errors: Error[] = []
+
+    const hasher = new XyoHasher(this.obj)
+
+    const bodyHash = hasher.hash
+    if (bodyHash !== this.obj._hash) errors.push(new Error(`Body hash mismatch: [calculated: ${bodyHash}] [found: ${this.obj._hash}] [sortedStringify: ${hasher.stringified}]`))
+    return errors
+  }
+
+  public payloads() {
+    const errors: Error[] = []
+    return errors
+  }
+
+  public signatures() {
+    const errors: Error[] = []
+    return errors
+  }
+
+  public timestamp() {
+    const errors: Error[] = []
+    const { _timestamp } = this.obj
+    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.obj
+    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.obj
+    if (!_user_agent) errors.push(new Error('_user_agent missing'))
+    return errors
+  }
+
+  public validate() {
+    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/Validator/Validator.spec.ts

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

package/src/Validator/Validator.ts

@@ -0,0 +1,51 @@
+import { assertEx } from '@xylabs/sdk-js'
+import { XyoAddressValue } from '@xyo-network/account'
+import { XyoValidator } from '@xyo-network/core'
+
+import { XyoBoundWitnessWithPartialMeta } from '../models'
+import { XyoBoundWitnessBodyValidator } from './BodyValidator'
+import { XyoBoundWitnessMetaValidator } from './MetaValidator'
+
+const validateArraysSameLength = (a: unknown[], b: unknown[], message = 'Array length mismatch') => {
+  return a.length != b.length ? [Error(`${message} []`)] : []
+}
+
+const validateSignature = (hash: string, address: string, signature?: string) => {
+  if (!signature) {
+    return [Error(`Missing signature [${address}]`)]
+  }
+  if (!new XyoAddressValue(address).verify(hash, signature)) {
+    return [Error(`Invalid signature [${address}] [${signature}]`)]
+  }
+  return []
+}
+
+class XyoBoundWitnessValidator<T extends XyoBoundWitnessWithPartialMeta = XyoBoundWitnessWithPartialMeta> extends XyoValidator<T> {
+  public body: XyoBoundWitnessBodyValidator
+  public meta: XyoBoundWitnessMetaValidator
+  constructor(bw: T) {
+    super(bw)
+    this.body = new XyoBoundWitnessBodyValidator(bw, bw._payloads)
+    this.meta = new XyoBoundWitnessMetaValidator(bw)
+  }
+
+  public signatures() {
+    const hash = assertEx(this.obj._hash, 'Missing _hash')
+    return [
+      ...validateArraysSameLength(this.obj._signatures ?? [], this.obj.addresses, 'Length mismatch: address/_signature'),
+      ...this.obj.addresses.reduce<Error[]>((errors, address, index) => {
+        errors.push(...validateSignature(hash, address, this.obj._signatures?.[index]))
+        return errors
+      }, []),
+    ]
+  }
+
+  public validate() {
+    const errors: Error[] = []
+    errors.push(...this.meta.validate(), ...this.body.validate())
+    errors.push(...this.signatures())
+    return errors
+  }
+}
+
+export { XyoBoundWitnessValidator }

package/src/Validator/index.ts

@@ -0,0 +1,3 @@
+export * from './BodyValidator'
+export * from './MetaValidator'
+export * from './Validator'

package/src/Validator/ip-regex.ts

@@ -0,0 +1,39 @@
+const word = '[a-fA-F\\d:]'
+
+export interface Options {
+  readonly exact?: boolean
+  readonly includeBoundaries?: boolean
+}
+
+const boundry = (options: Options) => (options && options.includeBoundaries ? `(?:(?<=\\s|^)(?=${word})|(?<=${word})(?=\\s|$))` : '')
+
+const v4 = '(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)){3}'
+
+const v6segment = '[a-fA-F\\d]{1,4}'
+
+const v6 = `
+(?:
+(?:${v6segment}:){7}(?:${v6segment}|:)|                                    // 1:2:3:4:5:6:7::  1:2:3:4:5:6:7:8
+(?:${v6segment}:){6}(?:${v4}|:${v6segment}|:)|                             // 1:2:3:4:5:6::    1:2:3:4:5:6::8   1:2:3:4:5:6::8  1:2:3:4:5:6::1.2.3.4
+(?:${v6segment}:){5}(?::${v4}|(?::${v6segment}){1,2}|:)|                   // 1:2:3:4:5::      1:2:3:4:5::7:8   1:2:3:4:5::8    1:2:3:4:5::7:1.2.3.4
+(?:${v6segment}:){4}(?:(?::${v6segment}){0,1}:${v4}|(?::${v6segment}){1,3}|:)| // 1:2:3:4::        1:2:3:4::6:7:8   1:2:3:4::8      1:2:3:4::6:7:1.2.3.4
+(?:${v6segment}:){3}(?:(?::${v6segment}){0,2}:${v4}|(?::${v6segment}){1,4}|:)| // 1:2:3::          1:2:3::5:6:7:8   1:2:3::8        1:2:3::5:6:7:1.2.3.4
+(?:${v6segment}:){2}(?:(?::${v6segment}){0,3}:${v4}|(?::${v6segment}){1,5}|:)| // 1:2::            1:2::4:5:6:7:8   1:2::8          1:2::4:5:6:7:1.2.3.4
+(?:${v6segment}:){1}(?:(?::${v6segment}){0,4}:${v4}|(?::${v6segment}){1,6}|:)| // 1::              1::3:4:5:6:7:8   1::8            1::3:4:5:6:7:1.2.3.4
+(?::(?:(?::${v6segment}){0,5}:${v4}|(?::${v6segment}){1,7}|:))             // ::2:3:4:5:6:7:8  ::2:3:4:5:6:7:8  ::8             ::1.2.3.4
+)(?:%[0-9a-zA-Z]{1,})?                                             // %eth0            %1
+`
+  .replace(/\s*\/\/.*$/gm, '')
+  .replace(/\n/g, '')
+  .trim()
+
+// Pre-compile only the exact regexes because adding a global flag make regexes stateful
+const v46Exact = new RegExp(`(?:^${v4}$)|(?:^${v6}$)`)
+const v4exact = new RegExp(`^${v4}$`)
+const v6exact = new RegExp(`^${v6}$`)
+
+export const ipRegex = (options: Options) =>
+  options && options.exact ? v46Exact : new RegExp(`(?:${boundry(options)}${v4}${boundry(options)})|(?:${boundry(options)}${v6}${boundry(options)})`, 'g')
+
+ipRegex.v4 = (options: Options) => (options && options.exact ? v4exact : new RegExp(`${boundry(options)}${v4}${boundry(options)}`, 'g'))
+ipRegex.v6 = (options: Options) => (options && options.exact ? v6exact : new RegExp(`${boundry(options)}${v6}${boundry(options)}`, 'g'))

package/src/Validator/is-ip.ts

@@ -0,0 +1,17 @@
+import { ipRegex } from './ip-regex'
+
+export function isIP(value: string) {
+  return ipRegex({ exact: true }).test(value)
+}
+
+export function isIPv6(value: string) {
+  return ipRegex.v6({ exact: true }).test(value)
+}
+
+export function isIPv4(value: string) {
+  return ipRegex.v4({ exact: true }).test(value)
+}
+
+export function ipVersion(value: string) {
+  return isIP(value) ? (isIPv6(value) ? 6 : 4) : undefined
+}

package/src/Wrapper/Wrapper.ts

@@ -0,0 +1,27 @@
+import { XyoHasher } from '@xyo-network/core'
+import pick from 'lodash/pick'
+import { UAParser } from 'ua-parser-js'
+
+import { XyoBoundWitness, XyoBoundWitnessWithMeta } from '../models'
+
+const scrubbedFields = ['_archive', '_client', '_hash', '_signatures', '_timestamp', '_user_agent', 'addresses', 'payload_schemas', 'previous_hashes', 'payload_hashes', 'schema']
+
+export class XyoBoundWitnessWrapper<T extends XyoBoundWitness> extends XyoHasher<T> {
+  public readonly bw: T
+  constructor(bw: T) {
+    super(bw)
+    this.bw = bw
+  }
+
+  get scrubbedFields() {
+    return pick(this.bw, scrubbedFields)
+  }
+}
+
+export class XyoBoundWitnessWithMetaWrapper<T extends XyoBoundWitnessWithMeta> extends XyoBoundWitnessWrapper<T> {
+  private _userAgent?: UAParser
+  get userAgent() {
+    this._userAgent = this._userAgent ?? new UAParser(this.bw._user_agent)
+    return this._userAgent
+  }
+}

package/src/Wrapper/index.ts

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

package/src/index.ts

@@ -0,0 +1,5 @@
+export * from './Builder'
+export * from './isXyoPayloadOfSchemaType'
+export * from './models'
+export * from './Validator'
+export * from './Wrapper'

package/src/isXyoPayloadOfSchemaType.ts

@@ -0,0 +1,5 @@
+import { isXyoPayloadOfSchemaType } from '@xyo-network/payload'
+
+import { XyoBoundWitness } from './models'
+
+export const isXyoBoundWitnessPayload = isXyoPayloadOfSchemaType<XyoBoundWitness>('network.xyo.boundwitness')

package/src/models/Base/XyoBoundWitnessBase.ts

@@ -0,0 +1,10 @@
+import { XyoPayload } from '@xyo-network/payload'
+
+export type XyoBoundWitnessBase = XyoPayload<{
+  addresses: string[]
+  previous_hash?: string
+  payload_hashes: string[]
+  payload_schemas: string[]
+  previous_hashes: (string | null)[]
+  schema: string
+}>

package/src/models/Base/XyoBoundWitnessBaseSchema.ts

@@ -0,0 +1,15 @@
+//Should type as JSONSchemaType<XyoBoundWitnessBody> once ajv/eslint issue is fixed
+//https://github.com/microsoft/TypeScript/issues/44851
+export const XyoBoundWitnessBaseSchema = {
+  $id: 'https://schemas.xyo.network/2.0/boundwitness/body',
+  additionalProperties: false,
+  properties: {
+    addresses: { items: { type: 'string' }, type: 'array' },
+    payload_hashes: { items: { type: 'string' }, type: 'array' },
+    payload_schemas: { items: { type: 'string' }, type: 'array' },
+    previous_hashes: { items: { nullable: true, type: 'string' }, type: 'array' },
+    schema: { type: 'string' },
+  },
+  required: ['addresses', 'payload_hashes', 'payload_schemas', 'previous_hashes', 'schema'],
+  type: 'object',
+}

package/src/models/Base/index.ts

@@ -0,0 +1,2 @@
+export * from './XyoBoundWitnessBase'
+export * from './XyoBoundWitnessBaseSchema'

package/src/models/Meta/XyoBoundWitnessMeta.ts

@@ -0,0 +1,8 @@
+import { XyoPayloadMeta, XyoPayloadWithPartialMeta } from '@xyo-network/payload'
+
+export type XyoBoundWitnessMeta<P extends XyoPayloadWithPartialMeta = XyoPayloadWithPartialMeta> = XyoPayloadMeta<{
+  _payloads?: P[]
+  _signatures?: string[]
+  _source_ip?: string
+  _user_agent?: string
+}>

package/src/models/Meta/XyoBoundWitnessMetaSchema.ts

@@ -0,0 +1,24 @@
+//Should type as JSONSchemaType<XyoBoundWitnessMeta> once ajv/eslint issue is fixed
+//https://github.com/microsoft/TypeScript/issues/44851
+
+export const XyoBoundWitnessMetaSchemaProperties = () => {
+  return {
+    _archive: { nullable: true, type: 'string' },
+    _client: { nullable: true, type: 'string' },
+    _hash: { nullable: true, type: 'string' },
+    _payloads: { items: { type: 'object' }, nullable: true, type: 'array' },
+    _signatures: { items: { type: 'string' }, nullable: true, type: 'array' },
+    _source_ip: { nullable: true, type: 'string' },
+    _timestamp: { nullable: true, type: 'number' },
+    _user_agent: { nullable: true, type: 'string' },
+  }
+}
+
+export const XyoBoundWitnessMetaSchema = () => {
+  return {
+    $id: 'https://schemas.xyo.network/2.0/boundwitness/meta',
+    additionalProperties: false,
+    properties: XyoBoundWitnessMetaSchemaProperties,
+    type: 'object',
+  }
+}

package/src/models/Meta/index.ts

@@ -0,0 +1,2 @@
+export * from './XyoBoundWitnessMeta'
+export * from './XyoBoundWitnessMetaSchema'

package/src/models/WithXyoBoundWitnessMeta.ts

@@ -0,0 +1,6 @@
+import { XyoBoundWitnessMeta } from './Meta'
+import { XyoBoundWitness } from './XyoBoundWitness'
+
+type WithXyoBoundWitnessMeta<T extends XyoBoundWitness> = T & XyoBoundWitnessMeta
+
+export type { WithXyoBoundWitnessMeta }

package/src/models/XyoBoundWitness.ts

@@ -0,0 +1,8 @@
+import { XyoPayloadWithPartialMeta } from '@xyo-network/payload'
+
+import { XyoBoundWitnessBase } from './Base'
+import { XyoBoundWitnessMeta } from './Meta'
+
+export type XyoBoundWitness<T extends object = object> = T & XyoBoundWitnessBase
+export type XyoBoundWitnessWithMeta<T = unknown, P extends XyoPayloadWithPartialMeta = XyoPayloadWithPartialMeta> = T & XyoBoundWitnessMeta<P> & XyoBoundWitness
+export type XyoBoundWitnessWithPartialMeta<T = unknown, P extends XyoPayloadWithPartialMeta = XyoPayloadWithPartialMeta> = T & Partial<XyoBoundWitnessMeta<P>> & XyoBoundWitness

package/src/models/XyoBoundWitnessSchema.ts

@@ -0,0 +1,23 @@
+//Should type as JSONSchemaType<XyoBoundWitness> once ajv/eslint issue is fixed
+//https://github.com/microsoft/TypeScript/issues/44851
+
+import { XyoBoundWitnessMetaSchemaProperties } from './Meta'
+
+const XyoBoundWitnessSchema = () => {
+  return {
+    $id: 'https://schemas.xyo.network/2.0/boundwitness',
+    additionalProperties: false,
+    properties: {
+      ...XyoBoundWitnessMetaSchemaProperties(),
+      addresses: { items: { type: 'string' }, type: 'array' },
+      payload_hashes: { items: { type: 'string' }, type: 'array' },
+      payload_schemas: { items: { type: 'string' }, type: 'array' },
+      previous_hashes: { items: { nullable: true, type: 'string' }, type: 'array' },
+      schema: { type: 'string' },
+    },
+    required: ['addresses', 'payload_hashes', 'payload_schemas', 'previous_hashes', 'schema'],
+    type: 'object',
+  }
+}
+
+export { XyoBoundWitnessSchema }

package/src/models/index.ts

@@ -0,0 +1,5 @@
+export * from './Base'
+export * from './Meta'
+export * from './WithXyoBoundWitnessMeta'
+export * from './XyoBoundWitness'
+export * from './XyoBoundWitnessSchema'