@xyo-network/core 2.20.17

package/src/Payload/Builder/Builder.spec.ts

@@ -0,0 +1,37 @@
+import { XyoPayloadBuilder } from './Builder'
+
+const schema = 'network.xyo.temp'
+
+const payloadHash = '57b78b1b7df3ac0369654642e879cdf2f3c95f9c5949bcb34ea3cb8309c538b4'
+
+const ADDITIONAL_FIELD_COUNT = 4
+
+describe('XyoBoundWitnessBuilder', () => {
+  test('build', () => {
+    let builder = new XyoPayloadBuilder({ schema })
+    expect(builder).toBeDefined()
+    builder = builder.fields({
+      testArray: [1, 2, 3],
+      testBoolean: true,
+      testNull: null,
+      testNullObject: { t: null, x: undefined },
+      testNumber: 5,
+      testObject: { t: 1 },
+      testSomeNullObject: { s: 1, t: null, x: undefined },
+      testString: 'hi',
+      testUndefined: undefined,
+    })
+    expect(builder).toBeDefined()
+
+    const actual = builder.build()
+
+    expect(actual).toBeDefined()
+    expect(actual._timestamp).toBeDefined()
+    expect(actual._client).toBeDefined()
+    expect(actual._hash).toBeDefined()
+    expect(actual.schema).toBeDefined()
+    expect(Object.keys(actual).length).toBe(8 + ADDITIONAL_FIELD_COUNT)
+    expect(Object.keys(actual.testSomeNullObject as object).length).toBe(2)
+    expect(actual._hash).toEqual(payloadHash)
+  })
+})

package/src/Payload/Builder/Builder.ts

@@ -0,0 +1,42 @@
+import { deepOmitUnderscoreFields, removeEmptyFields, XyoHasher } from '../../Hasher'
+import { XyoPayload } from '../models'
+
+export interface XyoPayloadBuilderOptions {
+  schema: string
+}
+
+export class XyoPayloadBuilder<T extends XyoPayload> {
+  private _fields: Partial<T> = {}
+  private _previousHash?: string
+  private _schema: string
+
+  constructor({ schema }: XyoPayloadBuilderOptions) {
+    this._schema = schema
+  }
+
+  public fields(fields?: Partial<T>) {
+    if (fields) {
+      this._fields = { ...this._fields, ...removeEmptyFields(fields) }
+    }
+    return this
+  }
+
+  public previousHash(hash?: string) {
+    this._previousHash = hash
+    return this
+  }
+
+  public hashableFields() {
+    return {
+      ...removeEmptyFields(deepOmitUnderscoreFields({ ...this._fields, previousHash: this._previousHash })),
+      schema: this._schema,
+    } as T
+  }
+
+  public build(): T {
+    const hashableFields = this.hashableFields()
+    const _hash = new XyoHasher(hashableFields).sortedHash()
+    const _timestamp = Date.now()
+    return { ...hashableFields, _client: 'js', _hash, _timestamp, schema: this._schema }
+  }
+}

package/src/Payload/Builder/index.ts

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

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

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

package/src/Payload/Validator/BodyValidator.ts

@@ -0,0 +1,34 @@
+import { WithStringIndex } from '../../models'
+import { XyoSchemaNameValidator } from '../../SchemaNameValidator'
+import { XyoPayloadBody } from '../models'
+
+class XyoPayloadBodyValidator {
+  private body: WithStringIndex<XyoPayloadBody>
+  constructor(body: XyoPayloadBody) {
+    this.body = body as WithStringIndex<XyoPayloadBody>
+  }
+
+  private _schemaValidator?: XyoSchemaNameValidator
+  get schemaValidator() {
+    this._schemaValidator = this._schemaValidator ?? new XyoSchemaNameValidator(this.body.schema ?? '')
+    return this._schemaValidator
+  }
+
+  public schemaName() {
+    const errors: Error[] = []
+    if (this.body.schema === undefined) {
+      errors.push(Error('schema missing'))
+    } else {
+      errors.push(...this.schemaValidator.all())
+    }
+    return errors
+  }
+
+  public all() {
+    const errors: Error[] = []
+    errors.push(...this.schemaName())
+    return errors
+  }
+}
+
+export { XyoPayloadBodyValidator }

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

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

package/src/Payload/Validator/MetaValidator.ts

@@ -0,0 +1,38 @@
+import { XyoHasher } from '../../Hasher'
+import { XyoPayload } from '../models'
+
+const MIN_ALLOWED_TIMESTAMP = 1609459200000
+const MAX_ALLOWED_TIMESTAMP = 4102444800000
+
+class XyoPayloadMetaValidator {
+  private payload: XyoPayload
+  constructor(payload: XyoPayload) {
+    this.payload = payload
+  }
+
+  public hash() {
+    const errors: Error[] = []
+    const wrapper = new XyoHasher(this.payload)
+
+    const bodyHash = wrapper.sortedHash()
+    if (bodyHash !== this.payload._hash) errors.push(new Error(`Body hash mismatch: [calculated: ${bodyHash}] [found: ${this.payload._hash}]`))
+    return errors
+  }
+
+  public timestamp() {
+    const errors: Error[] = []
+    const { _timestamp } = this.payload
+    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 all() {
+    const errors: Error[] = []
+    errors.push(...this.hash(), ...this.timestamp())
+    return errors
+  }
+}
+
+export { XyoPayloadMetaValidator }

package/src/Payload/Validator/Validator.spec.ts

@@ -0,0 +1,62 @@
+import { dumpErrors } from '../../lib'
+import { XyoPayload } from '../models'
+import { XyoPayloadValidator } from './Validator'
+
+const testPayloadNoSchema: XyoPayload = {
+  _hash: '44136fa355b3678a1146ad16f7e8649e94fb4fc21fe77e8310c060f61caaff8a',
+  _timestamp: 1609459255555,
+} as XyoPayload
+const testPayloadMixedCase: XyoPayload = {
+  _hash: '9a67116e05c33135f6ba23768f9a3fbbba155297ee1bb0a7e21d91fdc3835769',
+  _timestamp: 1609459255555,
+  schema: 'network.xyo.testMixedCaseSchema',
+}
+const testPayloadTooFewLevels: XyoPayload = {
+  _hash: '95206b26e3173deaac5e3f5d4510d50112b6348d3a2128b1eb6fe3ca66957628',
+  _timestamp: 1609459255555,
+  schema: 'network.xyo',
+}
+const testPayloadDoesNotExist: XyoPayload = {
+  _hash: '360b4ce36862ef2a20dd572d69283a86d351b2b4a9cd4f61ae6f7a320be81dbf',
+  _timestamp: 1609459255555,
+  schema: 'network.dfd-sf-sf-s.blahblah',
+}
+const testPayloadValid: XyoPayload = {
+  _hash: '4b5958c6d16b26d6790e33f5be45578728b0ea36e40a0d1b9c9164822341cac1',
+  _timestamp: 1609459255555,
+  schema: 'network.xyo.test',
+}
+
+test('all [missing schema]', () => {
+  const validator = new XyoPayloadValidator(testPayloadNoSchema)
+  const errors = validator.all()
+  expect(errors.length).toBe(1)
+})
+
+test('all [mixed case]', () => {
+  const validator = new XyoPayloadValidator(testPayloadMixedCase)
+  const errors = validator.all()
+  expect(errors.length).toBe(1)
+})
+
+test('all [too few levels]', () => {
+  const validator = new XyoPayloadValidator(testPayloadTooFewLevels)
+  const errors = validator.all()
+  expect(errors.length).toBe(1)
+})
+
+test('all [does not exist]', () => {
+  const validator = new XyoPayloadValidator(testPayloadDoesNotExist)
+  const errors = validator.all()
+  dumpErrors(errors)
+  expect(errors.length).toBe(0)
+})
+
+test('all [valid]', () => {
+  const validator = new XyoPayloadValidator(testPayloadValid)
+
+  let errors: Error[] = []
+  errors = validator.all()
+  dumpErrors(errors)
+  expect(errors.length).toBe(0)
+})

package/src/Payload/Validator/Validator.ts

@@ -0,0 +1,22 @@
+import { XyoPayload } from '../models'
+import { XyoPayloadBodyValidator } from './BodyValidator'
+import { XyoPayloadMetaValidator } from './MetaValidator'
+
+class XyoPayloadValidator<T extends XyoPayload = XyoPayload> {
+  protected payload: T
+  public body: XyoPayloadBodyValidator
+  public meta: XyoPayloadMetaValidator
+  constructor(payload: T) {
+    this.payload = payload
+    this.body = new XyoPayloadBodyValidator(payload)
+    this.meta = new XyoPayloadMetaValidator(payload)
+  }
+
+  public all() {
+    const errors: Error[] = []
+    errors.push(...this.meta.all(), ...this.body.all())
+    return errors
+  }
+}
+
+export { XyoPayloadValidator }

package/src/Payload/Validator/index.ts

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

package/src/Payload/Wrapper/Validator.ts

@@ -0,0 +1,20 @@
+import { XyoPayload } from '../models'
+import { XyoPayloadValidator } from '../Validator'
+import { XyoPayloadWrapper } from './Wrapper'
+
+export class XyoPayloadWrapperValidator<T extends XyoPayloadWrapper<XyoPayload> = XyoPayloadWrapper<XyoPayload>> {
+  protected wrapper: T
+  constructor(wrapper: T) {
+    this.wrapper = wrapper
+  }
+
+  public get payload() {
+    return new XyoPayloadValidator(this.wrapper.payload)
+  }
+
+  public all() {
+    const errors: Error[] = []
+    errors.push(...this.payload.all())
+    return errors
+  }
+}

package/src/Payload/Wrapper/Wrapper.ts

@@ -0,0 +1,20 @@
+import { deepOmitUnderscoreFields, deepPickUnderscoreFields, XyoHasher } from '../../Hasher'
+import { XyoPayload } from '../models'
+
+class XyoPayloadWrapper<T extends XyoPayload> extends XyoHasher<T> {
+  public readonly payload: T
+  constructor(payload: T) {
+    super(payload)
+    this.payload = payload
+  }
+
+  public get body() {
+    return deepOmitUnderscoreFields(this.payload)
+  }
+
+  public get meta() {
+    return deepPickUnderscoreFields(this.payload)
+  }
+}
+
+export { XyoPayloadWrapper }

package/src/Payload/Wrapper/index.ts

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

package/src/Payload/index.ts

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

package/src/Payload/models/Body.ts

@@ -0,0 +1,7 @@
+interface XyoPayloadBody {
+  [key: string]: unknown
+  schema: string
+  previousHash?: string
+}
+
+export type { XyoPayloadBody }

package/src/Payload/models/Meta.ts

@@ -0,0 +1,11 @@
+interface XyoPayloadMeta {
+  [key: string]: unknown
+  _hash?: string
+  _client?: string
+  _reportedHash?: string
+  _timestamp?: number
+  _observeDuration?: number
+  _archive?: string
+}
+
+export type { XyoPayloadMeta }

package/src/Payload/models/WithXyoPayloadMeta.ts

@@ -0,0 +1,6 @@
+import { XyoPayloadBody } from './Body'
+import { XyoPayloadMeta } from './Meta'
+
+type WithXyoPayloadMeta<T extends XyoPayloadBody> = T & XyoPayloadMeta
+
+export type { WithXyoPayloadMeta }

package/src/Payload/models/XyoPayload.ts

@@ -0,0 +1,6 @@
+import { XyoPayloadBody } from './Body'
+import { WithXyoPayloadMeta } from './WithXyoPayloadMeta'
+
+type XyoPayload = WithXyoPayloadMeta<XyoPayloadBody>
+
+export type { XyoPayload }

package/src/Payload/models/index.ts

@@ -0,0 +1,6 @@
+import { XyoPayloadBody } from './Body'
+import { XyoPayloadMeta } from './Meta'
+import { WithXyoPayloadMeta } from './WithXyoPayloadMeta'
+import { XyoPayload } from './XyoPayload'
+
+export type { WithXyoPayloadMeta, XyoPayload, XyoPayloadBody, XyoPayloadMeta }

package/src/Schema/Payload.ts

@@ -0,0 +1,10 @@
+import { XyoPayload } from '../Payload'
+
+export interface XyoSchemaPayload extends XyoPayload {
+  /** @deprecated use definition.$id instead */
+  name?: string
+  definition: {
+    $id?: string
+    [key: string]: unknown
+  }
+}

package/src/Schema/index.ts

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

package/src/SchemaNameValidator.ts

@@ -0,0 +1,128 @@
+import { domainExists } from './lib'
+
+/**
+ * Validates a XYO schema structure and existence
+ */
+export class XyoSchemaNameValidator {
+  public schema?: string
+  constructor(schema?: string) {
+    this.schema = schema
+  }
+
+  private _parts?: string[]
+
+  /**
+   * The schema converted into a string array split on '.'
+   *
+   * @returns string[]
+   */
+  get parts() {
+    this._parts = this._parts ?? this.schema?.split('.')
+    return this._parts
+  }
+
+  /**
+   * Levels in the schema
+   *
+   * @returns number
+   */
+  get levels(): number | undefined {
+    return this.parts?.length
+  }
+
+  /**
+   * Checks whether the schema is all lowercase
+   *
+   * @returns boolean
+   */
+  get isLowercase(): boolean {
+    return this.schema === this.schema?.toLowerCase()
+  }
+
+  /**
+   *
+   * Get a domain for the schema at a certain level
+   *
+   * @param level - Zero based level to check
+   * @returns string
+   */
+  private domainLevel(level: number): string | undefined {
+    return this.parts
+      ?.slice(0, level + 1)
+      .reverse()
+      .join('.')
+  }
+
+  private _rootDomain?: string
+
+  /**
+   * The rootDomain is the first two levels of the schema, in reverse order
+   * This can be used to determine who 'owns' that schema, based on domain
+   * registration
+   *
+   * @returns string
+   */
+  get rootDomain(): string | undefined {
+    this._rootDomain = this._rootDomain ?? this.domainLevel(1)
+    return this._rootDomain
+  }
+
+  /**
+   * Checks if the root domain validates via DNS resolution
+   *
+   * @returns boolean
+   */
+  public async rootDomainExists() {
+    return await domainExists(this.rootDomain)
+  }
+
+  /**
+   * Determines how many levels of the schema's reverse domain
+   * pass DNS resolution
+   *
+   * @returns number (0 if none exist)
+   */
+  public async domainExistanceDepth() {
+    const levels = this.levels ?? 0
+    let level = 0
+    while (level < levels) {
+      if (!(await domainExists(this.domainLevel(level)))) {
+        break
+      }
+      level += 1
+    }
+    return level
+  }
+
+  /**
+   * Run all the validations
+   * @param checkExistance - boolean
+   * @returns Error[]
+   */
+
+  public async allDynamic() {
+    const errors: Error[] = []
+    if ((this.schema?.length ?? 0) === 0) errors.push(Error('schema missing'))
+    else if (!(await this.rootDomainExists())) errors.push(Error(`schema root domain must exist [${this.rootDomain}]`))
+    return errors
+  }
+
+  /**
+   * Run all static validations
+   * @returns Error[]
+   */
+
+  public all() {
+    const errors: Error[] = []
+    if ((this.schema?.length ?? 0) === 0) errors.push(Error('schema missing'))
+    else if ((this.levels ?? 0) < 3) errors.push(Error(`schema levels < 3 [${this.levels}, ${this.schema}]`))
+    else if (!this.isLowercase) errors.push(Error(`schema not lowercase [${this.schema}]`))
+    return errors
+  }
+}
+
+/** @deprectated use XyoSchemaNameValidator instead */
+export class SchemaValidator extends XyoSchemaNameValidator {}
+
+/** @deprectated use XyoSchemaNameValidator instead */
+export class XyoSchemaValidator extends XyoSchemaNameValidator {}

package/src/Test/index.ts

@@ -0,0 +1,2 @@
+export * from './testBoundWitness'
+export * from './testPayload'

package/src/Test/testBoundWitness.ts

@@ -0,0 +1,16 @@
+import { XyoBoundWitness } from '../BoundWitness'
+
+const testBoundWitness: XyoBoundWitness = {
+  _archive: 'temp',
+  _client: 'js',
+  _hash: 'b0ffb9ebf872dc316b7be48327256c5316f7cb84d7c706861b18b86af1942dea',
+  _signatures: ['95100e5fd2012b958e96895870cfac5353c3a33a19314cfd1304ef7d01d052ec2a3ef80d6449cf88d463027fe0d868ed8cfb8b7323d37e93a08570233eea0b17'],
+  _timestamp: 1650067385598,
+  addresses: ['5346a2ce56ec4177b67092bda710e150ba6fa046'],
+  payload_hashes: ['20e14207f952a09f767ff614a648546c037fe524ace0bfe55db31f818aff1f1c'],
+  payload_schemas: ['network.xyo.test'],
+  previous_hashes: [null],
+  schema: 'network.xyo.boundwitness',
+}
+
+export { testBoundWitness }

package/src/Test/testPayload.ts

@@ -0,0 +1,17 @@
+import { XyoPayload } from '../Payload'
+
+const testSchema = 'network.xyo.test'
+const testPayload: XyoPayload = {
+  _archive: 'test',
+  _hash: '20e14207f952a09f767ff614a648546c037fe524ace0bfe55db31f818aff1f1c',
+  _timestamp: 1609459255555,
+  numberField: 1,
+  objectField: {
+    numberField: 1,
+    stringField: 'stringValue',
+  },
+  schema: testSchema,
+  stringField: 'stringValue',
+}
+
+export { testPayload, testSchema }

package/src/Wallet/Account/Account.spec.ts

@@ -0,0 +1,91 @@
+/* eslint-disable sort-keys-fix/sort-keys-fix */
+/* eslint-disable sort-keys */
+
+import { XyoAccount } from './Account'
+import { toUint8Array } from './Key'
+
+//test vectors: https://tools.ietf.org/html/rfc8032
+//test tool: https://asecuritysite.com/encryption/ethadd
+
+const testVectorPrivateKey = '7f71bc5644f8f521f7e9b73f7a391e82c05432f8a9d36c44d6b1edbf1d8db62f'
+const testVectorPublicKey = 'ed6f3b86542f45aab88ec48ab1366b462bd993fec83e234054afd8f2311fba774800fdb40c04918463b463a6044b83413a604550bfba8f8911beb65475d6528e'
+const testVectorAddress = '5e7a847447e7fec41011ae7d32d768f86605ba03'
+const testVectorHash = '4b688df40bcedbe641ddb16ff0a1842d9c67ea1c3bf63f3e0471baa664531d1a'
+const testVectorSignature = 'b61dad551e910e2793b4f9f880125b5799086510ce102fad0222c1b093c60a6bc755ca10a9068079ac8d9617416a7cd41077093061c1e9bcb2f81812086ae603'
+
+const testPrivateKey = '9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08'
+const testPublicKey = '5f81956d5826bad7d30daed2b5c8c98e72046c1ec8323da336445476183fb7ca54ba511b8b782bc5085962412e8b9879496e3b60bebee7c36987d1d5848b9a50'
+const testAddress = '2a260a110bc7b03f19c40a0bd04ff2c5dcb57594'
+
+/*const testVectors = {
+  d: 'ebb2c082fd7727890a28ac82f6bdf97bad8de9f5d7c9028692de1a255cad3e0f',
+  k: '49a0d7b786ec9cde0d0721d72804befd06571c974b191efb42ecf322ba9ddd9a',
+  h: '4b688df40bcedbe641ddb16ff0a1842d9c67ea1c3bf63f3e0471baa664531d1a',
+  r: '241097efbf8b63bf145c8961dbdf10c310efbb3b2676bbc0f8b08505c9e2f795',
+  s: '021006b7838609339e8b415a7f9acb1b661828131aef1ecbc7955dfb01f3ca0e',
+  q: '04779dd197a5df977ed2cf6cb31d82d43328b790dc6b3b7d4437a427bd5847dfcde94b724a555b6d017bb7607c3e3281daf5b1699d6ef4124975c9237b917d426f',
+}*/
+
+test('Address from Phrase', () => {
+  const wallet = XyoAccount.fromPhrase('test')
+  expect(wallet.private).toHaveLength(32)
+  expect(wallet.public).toHaveLength(64)
+  expect(wallet.addressValue).toHaveLength(20)
+  expect(wallet.private.hex).toEqual(testPrivateKey)
+  expect(wallet.public.hex).toEqual(testPublicKey)
+  expect(wallet.addressValue.hex).toEqual(testAddress)
+})
+
+test('Address from Key', () => {
+  const wallet = XyoAccount.fromPrivateKey(testVectorPrivateKey)
+  expect(wallet.private).toHaveLength(32)
+  expect(wallet.public).toHaveLength(64)
+  expect(wallet.addressValue).toHaveLength(20)
+  expect(wallet.private.hex).toEqual(testVectorPrivateKey)
+  expect(wallet.public.hex).toEqual(testVectorPublicKey)
+  expect(wallet.addressValue.hex).toEqual(testVectorAddress)
+})
+
+test('Sign-fromPrivateKey', () => {
+  const wallet = XyoAccount.fromPrivateKey(testVectorPrivateKey)
+  const signature = wallet.sign('1234567890abcdef')
+  const valid = wallet.verify('1234567890abcdef', signature)
+  expect(valid).toBeTruthy()
+})
+
+test('Sign-fromPhrase', () => {
+  const wallet = XyoAccount.fromPhrase('test')
+  const signature = wallet.sign('1234567890abcdef')
+  const valid = wallet.verify('1234567890abcdef', signature)
+  expect(valid).toBeTruthy()
+})
+
+test('Sign-testVectors', () => {
+  const wallet = XyoAccount.fromPrivateKey(testVectorPrivateKey)
+  const signature = Buffer.from(wallet.sign(toUint8Array(testVectorHash))).toString('hex')
+  const expectedSignature = testVectorSignature
+
+  expect(signature).toEqual(expectedSignature)
+  expect(signature.length).toEqual(128)
+  const valid = wallet.verify(testVectorHash, signature)
+  expect(valid).toBeTruthy()
+})
+
+test('Constructor', () => {
+  const wallet1 = new XyoAccount()
+  const wallet2 = new XyoAccount({ privateKey: wallet1.private.bytes })
+  expect(wallet1.public.hex).toEqual(wallet2.public.hex)
+  expect(wallet1.addressValue.hex).toEqual(wallet2.addressValue.hex)
+})
+
+test('Sign-random-string', () => {
+  const wallet = XyoAccount.random()
+  const signature = wallet.sign('1234567890abcdef')
+  const signaturePrime = toUint8Array(signature)
+  expect(signature.length).toBe(signaturePrime.length)
+  for (let i = 0; i < signature.length; i++) {
+    expect(signature[i]).toBe(signaturePrime[i])
+  }
+  const valid = wallet.verify('1234567890abcdef', signature)
+  expect(valid).toBeTruthy()
+})