@xyo-network/core 2.20.17

package/src/BoundWitness/Validator/Validator.ts

@@ -0,0 +1,51 @@
+import { assertEx } from '@xylabs/sdk-js'
+
+import { XyoAddressValue } from '../../Wallet'
+import { XyoBoundWitness } 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 {
+  private bw: XyoBoundWitness
+  public body: XyoBoundWitnessBodyValidator
+  public meta: XyoBoundWitnessMetaValidator
+  constructor(bw: XyoBoundWitness) {
+    this.bw = bw
+    this.body = new XyoBoundWitnessBodyValidator(bw, bw._payloads)
+    this.meta = new XyoBoundWitnessMetaValidator(bw)
+  }
+
+  public signatures() {
+    const hash = assertEx(this.bw._hash, 'Missing _hash')
+    return [
+      ...validateArraysSameLength(this.bw._signatures ?? [], this.bw.addresses, 'Length mismatch: address/_signature'),
+      ...this.bw.addresses.reduce<Error[]>((errors, address, index) => {
+        errors.push(...validateSignature(hash, address, this.bw._signatures?.[index]))
+        return errors
+      }, []),
+    ]
+  }
+
+  public all() {
+    const errors: Error[] = []
+    errors.push(...this.meta.all(), ...this.body.all())
+    errors.push(...this.signatures())
+    return errors
+  }
+}
+
+export { XyoBoundWitnessValidator }

package/src/BoundWitness/Validator/index.ts

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

package/src/BoundWitness/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/BoundWitness/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/BoundWitness/Wrapper/Wrapper.ts

@@ -0,0 +1,34 @@
+import pick from 'lodash/pick'
+import { UAParser } from 'ua-parser-js'
+
+import { XyoHasher } from '../../Hasher'
+import { XyoBoundWitness } from '../models'
+import { XyoBoundWitnessValidator } from '../Validator'
+
+const scrubbedFields = ['_archive', '_client', '_hash', '_signatures', '_timestamp', '_user_agent', 'addresses', 'payload_schemas', 'previous_hashes', 'payload_hashes', 'schema']
+
+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)
+  }
+
+  private _validator?: XyoBoundWitnessValidator
+  get validator() {
+    this._validator = this._validator ?? new XyoBoundWitnessValidator(this.bw)
+    return this._validator
+  }
+
+  private _userAgent?: UAParser
+  get userAgent() {
+    this._userAgent = this._userAgent ?? new UAParser(this.bw._user_agent)
+    return this._userAgent
+  }
+}
+
+export { XyoBoundWitnessWrapper }

package/src/BoundWitness/Wrapper/index.ts

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

package/src/BoundWitness/index.ts

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

package/src/BoundWitness/models/Body/XyoBoundWitnessBody.ts

@@ -0,0 +1,13 @@
+import { XyoPayloadBody } from '../../../Payload'
+
+interface XyoBoundWitnessBody extends XyoPayloadBody {
+  [key: string]: unknown
+  addresses: string[]
+  previous_hash?: string
+  payload_hashes: string[]
+  payload_schemas: string[]
+  previous_hashes: (string | null)[]
+  schema: string
+}
+
+export type { XyoBoundWitnessBody }

package/src/BoundWitness/models/Body/XyoBoundWitnessBodySchema.ts

@@ -0,0 +1,17 @@
+//Should type as JSONSchemaType<XyoBoundWitnessBody> once ajv/eslint issue is fixed
+//https://github.com/microsoft/TypeScript/issues/44851
+const XyoBoundWitnessBodySchema = {
+  $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',
+}
+
+export { XyoBoundWitnessBodySchema }

package/src/BoundWitness/models/Body/index.ts

@@ -0,0 +1,2 @@
+export * from './XyoBoundWitnessBody'
+export * from './XyoBoundWitnessBodySchema'

package/src/BoundWitness/models/Meta/XyoBoundWitnessMeta.ts

@@ -0,0 +1,15 @@
+import { XyoPayloadBody } from '../../../Payload'
+
+interface XyoBoundWitnessMeta {
+  [key: string]: unknown
+  _client?: string
+  _hash?: string
+  _archive?: string
+  _payloads?: XyoPayloadBody[]
+  _signatures?: string[]
+  _timestamp?: number
+  _source_ip?: string
+  _user_agent?: string
+}
+
+export type { XyoBoundWitnessMeta }

package/src/BoundWitness/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/BoundWitness/models/Meta/index.ts

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

package/src/BoundWitness/models/WithXyoBoundWitnessMeta.ts

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

package/src/BoundWitness/models/XyoBoundWitness.ts

@@ -0,0 +1,7 @@
+import { XyoPayload } from '../../Payload'
+import { XyoBoundWitnessBody } from './Body'
+import { WithXyoBoundWitnessMeta } from './WithXyoBoundWitnessMeta'
+
+type XyoBoundWitness = WithXyoBoundWitnessMeta<XyoBoundWitnessBody & XyoPayload>
+
+export type { XyoBoundWitness }

package/src/BoundWitness/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/BoundWitness/models/index.ts

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

package/src/Hasher/XyoHasher.ts

@@ -0,0 +1,30 @@
+import shajs from 'sha.js'
+
+import { removeEmptyFields } from './removeEmptyFields'
+import { deepOmitUnderscoreFields } from './removeFields'
+import { sortFields } from './sortFields'
+
+export class XyoHasher<T extends Record<string, unknown>> {
+  public readonly obj: T
+  constructor(obj: T) {
+    this.obj = obj
+  }
+
+  get hashFields() {
+    return removeEmptyFields(deepOmitUnderscoreFields(this.obj))
+  }
+
+  public sortedStringify() {
+    const sortedEntry = sortFields(this.hashFields)
+    return JSON.stringify(sortedEntry)
+  }
+
+  public sortedHash() {
+    return this.sortedHashData().toString('hex')
+  }
+
+  private sortedHashData() {
+    const stringObject = this.sortedStringify()
+    return shajs('sha256').update(stringObject).digest()
+  }
+}

package/src/Hasher/index.ts

@@ -0,0 +1,4 @@
+export * from './removeEmptyFields'
+export * from './removeFields'
+export * from './sortFields'
+export * from './XyoHasher'

package/src/Hasher/removeEmptyFields.spec.ts

@@ -0,0 +1,23 @@
+import { removeEmptyFields } from './removeEmptyFields'
+
+describe('removeEmptyFields', () => {
+  test('deep', () => {
+    const testObject = {
+      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,
+    }
+
+    const result = removeEmptyFields(testObject)
+
+    expect(Object.keys(result).length).toBe(8)
+    expect(Object.keys(result.testSomeNullObject as object).length).toBe(2)
+    expect(Object.keys(result.testNullObject as object).length).toBe(1)
+  })
+})

package/src/Hasher/removeEmptyFields.ts

@@ -0,0 +1,15 @@
+import { typeOf } from '../lib'
+
+export const removeEmptyFields = (obj: Record<string, unknown>) => {
+  if (obj === null || Array.isArray(obj)) return obj
+
+  const newObject: Record<string, unknown> = {}
+  Object.entries(obj).forEach(([key, value]) => {
+    if (typeOf(value) === 'object') {
+      newObject[key] = removeEmptyFields(value as Record<string, unknown>)
+    } else if (value !== undefined) {
+      newObject[key] = value
+    }
+  })
+  return newObject
+}

package/src/Hasher/removeFields.ts

@@ -0,0 +1,26 @@
+// eslint-disable-next-line no-restricted-imports
+import { ValueKeyIteratee } from 'lodash'
+import assign from 'lodash/assign'
+import isObject from 'lodash/isObject'
+import mapValues from 'lodash/mapValues'
+import omitBy from 'lodash/omitBy'
+import pickBy from 'lodash/pickBy'
+
+export const deepBy = <T>(obj: T, predicate: ValueKeyIteratee<T>, func: typeof omitBy | typeof pickBy) => {
+  if (Array.isArray(obj)) {
+    return obj
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const onlyObjects = pickBy<T>(obj as any, isObject)
+  const processedObjects = mapValues<T>(onlyObjects, (obj: T) => deepBy(obj, predicate, func))
+  const addBackValues = assign(processedObjects, omitBy(obj, isObject))
+  return omitBy(addBackValues, predicate) as T
+}
+
+export const deepOmitUnderscoreFields = <T>(obj: T) => {
+  return deepBy(obj, (_, key) => key.startsWith('_'), omitBy)
+}
+
+export const deepPickUnderscoreFields = <T>(obj: T) => {
+  return deepBy(obj, (_, key) => key.startsWith('_'), pickBy)
+}

package/src/Hasher/sortFields.ts

@@ -0,0 +1,24 @@
+import { typeOf } from '../lib'
+
+//if an object, subsort
+const subSort = (value: unknown) => {
+  switch (typeOf(value)) {
+    case 'object':
+      return sortFields(value as Record<string, unknown>)
+    default:
+      return value
+  }
+}
+
+export const sortFields = <T extends Record<string, unknown>>(obj: T) => {
+  if (obj === null) {
+    return null
+  }
+  const result: Record<string, unknown> = {} as Record<string, unknown>
+  Object.keys(obj)
+    .sort()
+    .forEach((key) => {
+      result[key] = subSort(obj[key])
+    })
+  return result as T
+}

package/src/Huri/Huri.spec.ts

@@ -0,0 +1,93 @@
+import { delay } from '@xylabs/sdk-js'
+
+import { XyoPayload } from '../Payload'
+import { Huri } from './Huri'
+
+const hash = 'fb3606d71dcdd49a0aacc9d234e412684d577803c8a9ed9399a9d3776cc88e24'
+
+const valid = [
+  `https://${hash}`,
+  `https://api.archivist.xyo.network/temp/${hash}`,
+  `https://api.archivist.xyo.network/${hash}`,
+  `http://api.archivist.xyo.network/${hash}`,
+  `/api.archivist.xyo.network/${hash}`,
+  `//${hash}`,
+  `/${hash}`,
+  `${hash}`,
+]
+
+const validWithTempArchive = [
+  `https://api.archivist.xyo.network/temp/${hash}`,
+  `https://api.archivist.xyo.network/temp/${hash}`,
+  `http://api.archivist.xyo.network/temp/${hash}`,
+  `/api.archivist.xyo.network/temp/${hash}`,
+]
+
+const invalid = [`https:///api.archivist.xyo.network/${hash}`, `https://api.archivist.xyo.network//${hash}`]
+
+describe('Huri', () => {
+  describe('Valid Items', () => {
+    valid.map((item) => {
+      test(`valid [${item}]`, () => {
+        try {
+          const huri = new Huri(item)
+          expect(huri.hash).toBe(hash)
+        } catch (ex) {
+          console.error(`Valid Huri failed: [${item}]`)
+          console.error(ex)
+        }
+      })
+    })
+  })
+  describe('Valid Items w/archive', () => {
+    validWithTempArchive.map((item) => {
+      test(`valid w/archive [${item}]`, () => {
+        try {
+          const huri = new Huri(item)
+          expect(huri.hash).toBe(hash)
+          expect(huri.archive).toBe('temp')
+        } catch (ex) {
+          console.error(`Valid Huri w/archive failed: [${item}]`)
+          console.error(ex)
+        }
+      })
+    })
+  })
+  describe('Invalid Items', () => {
+    invalid.map((item) => {
+      test(`invalid [${item}]`, () => {
+        expect(() => new Huri(item)).toThrowError()
+      })
+    })
+  })
+  describe('Api Fetch', () => {
+    it('Valid Huri', async () => {
+      const huri = new Huri('https://beta.api.archivist.xyo.network/18f97b3e85f5bede65e7c0a85d74aee896de58ead8bc4b1b3d7300646c653057')
+      const result = await huri.fetch()
+      expect(result?.schema).toBe('network.xyo.schema')
+    })
+    it('Invalid Huri', async () => {
+      const huri = new Huri('https://beta.api.archivist.xyo.network/18f97b3e85f5bede65e7c0a85d74aee896de58ead8bc4b1b3d7300646c653bad')
+      await expect(huri.fetch()).rejects.toThrow()
+    })
+  })
+  describe('Fetch Override', () => {
+    invalid.map((item) => {
+      test(`invalid [${item}]`, async () => {
+        const oldFetch = Huri.fetch
+        Huri.fetch = async (huri: Huri) => {
+          await delay(0)
+          const payload: XyoPayload = {
+            schema: huri.hash,
+          }
+          console.log(`Payload: ${JSON.stringify(payload, null, 2)}`)
+          return payload
+        }
+        const huri = new Huri('https://beta.api.archivist.xyo.network/18f97b3e85f5bede65e7c0a85d74aee896de58ead8bc4b1b3d7300646c653057')
+        const result = await huri.fetch()
+        Huri.fetch = oldFetch
+        expect(result?.schema).toBe('18f97b3e85f5bede65e7c0a85d74aee896de58ead8bc4b1b3d7300646c653057')
+      })
+    })
+  })
+})

package/src/Huri/Huri.ts

@@ -0,0 +1,143 @@
+import { assertEx } from '@xylabs/sdk-js'
+import axios from 'axios'
+
+import { XyoPayload } from '../Payload'
+
+export type XyoObjectCategory = 'block' | 'payload'
+
+export type HuriFetchFunction = (huri: Huri) => Promise<XyoPayload | undefined>
+
+/* 
+  Valid Huri:
+
+  [<protocol>://][<archivist>/[<archive>/]]<hash>
+
+  defaults:
+    protocol: https
+    archivist: api.archivist.xyo.network
+*/
+
+export interface HuriOptions {
+  archivistUri?: string
+}
+
+export interface XyoFetchedPayload<T extends XyoPayload = XyoPayload> {
+  payload: T
+  huri?: Huri
+}
+
+export class Huri {
+  public originalHref: string
+  public protocol?: string
+  public archivist?: string
+  public archive?: string
+  public hash: string
+
+  constructor(huri: string, { archivistUri }: HuriOptions = {}) {
+    this.originalHref = huri
+
+    const protocol = Huri.parseProtocol(huri)
+    this.protocol = protocol ?? 'https'
+
+    const path = assertEx(Huri.parsePath(huri), 'Missing path')
+    this.hash = this.parsePath(path, protocol !== undefined)
+
+    //if archivistUri sent, overwrite protocol and archivist
+    if (archivistUri) {
+      const archivistUriParts = archivistUri.split('://')
+      this.protocol = archivistUriParts[0]
+      this.archivist = archivistUriParts[1]
+    }
+
+    this.validateParse()
+  }
+
+  private parsePath(path: string, hasProtocol: boolean) {
+    const pathParts = path.split('/')
+
+    //if the protocal was found, then there is not allowed to be a leading /
+    assertEx(!(hasProtocol && pathParts[0].length === 0), 'Invalid protocol seperator')
+
+    //remove leading '/' if needed
+    pathParts[0].length === 0 ? pathParts.shift() : null
+
+    //hash is assumed to be the last part
+    const hash = assertEx(pathParts.pop(), 'No hash specified')
+
+    //archivist is assumed to be the first part
+    this.archivist = pathParts.shift() ?? 'api.archivist.xyo.network'
+
+    //the archive is whatever is left
+    this.archive = pathParts.pop()
+
+    //after we pull off all the path parts, there should be nothing left
+    assertEx(pathParts.length === 0, 'Too many path parts')
+
+    return hash
+  }
+
+  private validateParse() {
+    //the archivist should not be zero length
+    assertEx(this.archivist?.length !== 0, 'Invalid archivist length')
+
+    //the archivist should not be zero length (can be undefined)
+    assertEx(this.archive?.length !== 0, 'Invalid archive length')
+
+    //the archive should not be set if the archivist is not set
+    assertEx(!(this.archive && !this.archivist), 'If specifying archive, archivist is also required')
+  }
+
+  /*
+  The full href or the hash
+  */
+
+  public get href() {
+    const parts: string[] = []
+    if (this.protocol) {
+      parts.push(`${this.protocol}:/`)
+    }
+    if (this.archive) {
+      parts.push(`${this.archive}`)
+    }
+    if (this.archivist) {
+      parts.push(`${this.archivist}`)
+    }
+    parts.push(this.hash)
+    return parts.join('/')
+  }
+
+  public toString() {
+    return this.href
+  }
+
+  public async fetch() {
+    return await Huri.fetch(this)
+  }
+
+  static async fetch(huri: Huri): Promise<XyoPayload | undefined> {
+    return (await axios.get<XyoPayload>(huri.href)).data
+  }
+
+  private static parseProtocol(huri: string) {
+    const protocolSplit = huri.split('//')
+    assertEx(protocolSplit.length <= 2, `Invalid second protocol [${protocolSplit[2]}]`)
+    const rawProtocol = protocolSplit.length === 2 ? protocolSplit.shift() : undefined
+    if (rawProtocol) {
+      const protocolParts = rawProtocol?.split(':')
+      assertEx(protocolParts.length === 2, `Invalid protocol format [${rawProtocol}]`)
+      assertEx(protocolParts[1].length === 0, `Invalid protocol format (post :) [${rawProtocol}]`)
+      return protocolParts.shift()
+    }
+  }
+
+  private static parsePath(huri: string) {
+    const protocolSplit = huri.split('//')
+    assertEx(protocolSplit.length <= 2, `Invalid format [${huri}]`)
+    if (protocolSplit.length === 1) {
+      return huri
+    }
+    if (protocolSplit.length === 2) {
+      return protocolSplit[1]
+    }
+  }
+}

package/src/Huri/index.ts

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