@xyo-network/boundwitness-wrapper 2.90.2 → 2.90.3

package/src/BoundWitnessWrapper.ts

@@ -1,12 +1,13 @@
 import { assertEx } from '@xylabs/assert'
 import { Hash } from '@xylabs/hex'
+import { AnyObject, isObject } from '@xylabs/object'
 import { asBoundWitness, BoundWitness, BoundWitnessSchema, isBoundWitness } from '@xyo-network/boundwitness-model'
 import { BoundWitnessValidator } from '@xyo-network/boundwitness-validator'
 import { PayloadBuilder } from '@xyo-network/payload-builder'
 import { Payload, WithMeta } from '@xyo-network/payload-model'
 import { isPayloadWrapperBase, PayloadWrapper, PayloadWrapperBase } from '@xyo-network/payload-wrapper'
 
-export const isBoundWitnessWrapper = (value?: unknown): value is PayloadWrapper => {
+export const isBoundWitnessWrapper = (value?: unknown): value is BoundWitnessWrapper => {
   if (isPayloadWrapperBase(value)) {
     return typeof (value as BoundWitnessWrapper).payloadsDataHashMap === 'function'
   }
@@ -49,23 +50,42 @@ export class BoundWitnessWrapper<
 
   static async load(address: string) {
     const wrapper = await PayloadWrapper.load(address)
-    const payload = wrapper?.jsonPayload()
+    const payload = wrapper?.payload
     assertEx(payload && isBoundWitness(payload), 'Attempt to load non-boundwitness')
 
     const boundWitness: BoundWitness | undefined = payload && isBoundWitness(payload) ? payload : undefined
     return boundWitness ? await BoundWitnessWrapper.wrap(boundWitness) : null
   }
 
-  static async parse<T extends BoundWitness, P extends Payload>(obj: unknown, payloads?: P[]): Promise<BoundWitnessWrapper<T, P>> {
-    const hydratedObj = await PayloadBuilder.build(typeof obj === 'string' ? JSON.parse(obj) : obj)
-    assertEx(!Array.isArray(hydratedObj), 'Array can not be converted to BoundWitnessWrapper')
-    switch (typeof hydratedObj) {
+  static async parse<T extends BoundWitness = BoundWitness, P extends Payload = Payload>(
+    obj: unknown,
+    payloads?: P[],
+  ): Promise<BoundWitnessWrapper<T, P>> {
+    let hydratedObj: AnyObject | undefined = undefined
+    switch (typeof obj) {
+      case 'string': {
+        hydratedObj = JSON.parse(obj)
+        break
+      }
       case 'object': {
-        return hydratedObj instanceof BoundWitnessWrapper
-          ? hydratedObj
-          : new BoundWitnessWrapper(hydratedObj, payloads ? await Promise.all(payloads?.map((payload) => PayloadBuilder.build(payload))) : [])
+        if (isObject(obj)) {
+          hydratedObj = obj
+        }
+        break
       }
     }
+
+    if (hydratedObj) {
+      if (isBoundWitnessWrapper(hydratedObj)) {
+        return hydratedObj as BoundWitnessWrapper<T, P>
+      }
+      if (isBoundWitness(hydratedObj)) {
+        //we use PayloadBuilder here since we want to use the BoundWitness as-is (no resigning), but want to add the $hash is needed
+        const bw = await PayloadBuilder.build<T>(hydratedObj as T)
+        return new BoundWitnessWrapper(bw, payloads ? await Promise.all(payloads?.map((payload) => PayloadBuilder.build(payload))) : [])
+      }
+    }
+
     throw new Error(`Unable to parse [${typeof obj}]`)
   }
 
@@ -94,7 +114,7 @@ export class BoundWitnessWrapper<
         if (obj instanceof BoundWitnessWrapper) {
           return obj
         } else if (obj instanceof PayloadWrapper && obj.schema() === BoundWitnessSchema) {
-          return await BoundWitnessWrapper.parse(obj.jsonPayload(), payloads)
+          return await BoundWitnessWrapper.parse(obj.payload, payloads)
         } else {
           return await BoundWitnessWrapper.parse(obj, payloads)
         }
@@ -120,8 +140,9 @@ export class BoundWitnessWrapper<
   ): Promise<Record<string, BoundWitnessWrapper<T>>> {
     const result: Record<string, BoundWitnessWrapper<T>> = {}
     await Promise.all(
-      boundWitnesses.map(async (payload) => {
-        result[await BoundWitnessWrapper.hash(payload)] = await BoundWitnessWrapper.parse(payload)
+      boundWitnesses.map(async (bw) => {
+        const wrapped: BoundWitnessWrapper<T> = await BoundWitnessWrapper.parse(bw)
+        result[await wrapped.dataHash()] = await BoundWitnessWrapper.parse(bw)
       }),
     )
     return result

package/src/QueryBoundWitnessWrapper.ts

@@ -0,0 +1,49 @@
+import { assertEx } from '@xylabs/assert'
+import { compact } from '@xylabs/lodash'
+import { QueryBoundWitness } from '@xyo-network/boundwitness-model'
+import { PayloadBuilder } from '@xyo-network/payload'
+import { Payload, Query } from '@xyo-network/payload-model'
+import { PayloadWrapper } from '@xyo-network/payload-wrapper'
+
+import { BoundWitnessWrapper } from './BoundWitnessWrapper'
+
+export class QueryBoundWitnessWrapper<T extends Query = Query> extends BoundWitnessWrapper<QueryBoundWitness> {
+  private _payloadsWithoutQuery: PayloadWrapper<Payload>[] | undefined
+  private _query: T | undefined
+
+  static async parseQuery<T extends Query = Query>(obj: unknown, payloads?: Payload[]): Promise<QueryBoundWitnessWrapper<T>> {
+    assertEx(!Array.isArray(obj), 'Array can not be converted to QueryBoundWitnessWrapper')
+    switch (typeof obj) {
+      case 'object': {
+        const castWrapper = obj as QueryBoundWitnessWrapper<T>
+        const wrapper =
+          castWrapper instanceof QueryBoundWitnessWrapper
+            ? castWrapper
+            : new QueryBoundWitnessWrapper<T>(
+                await PayloadBuilder.build(obj as QueryBoundWitness),
+                payloads ? await Promise.all(payloads.map((payload) => PayloadBuilder.build(payload))) : undefined,
+              )
+        /*if (!wrapper.valid) {
+          console.warn(`Parsed invalid QueryBoundWitness ${JSON.stringify(wrapper.errors.map((error) => error.message))}`)
+        }*/
+        return wrapper
+      }
+    }
+    throw new Error(`Unable to parse [${typeof obj}]`)
+  }
+
+  async getPayloadsWithoutQuery(): Promise<PayloadWrapper<Payload>[]> {
+    this._payloadsWithoutQuery =
+      this._payloadsWithoutQuery ??
+      (await Promise.all(
+        compact((await PayloadBuilder.filterExclude(this.payloads, this.payload.query)).map((payload) => PayloadWrapper.wrap(payload))),
+      ))
+    return this._payloadsWithoutQuery
+  }
+
+  async getQuery(): Promise<T> {
+    const payloadMap = await this.payloadsDataHashMap()
+    this._query = this._query ?? (payloadMap[this.boundwitness.query] as T | undefined)
+    return assertEx(this._query, () => `Missing Query [${this.boundwitness}]`)
+  }
+}

package/src/index.ts

@@ -1 +1,2 @@
 export * from './BoundWitnessWrapper'
+export * from './QueryBoundWitnessWrapper'