@xyo-network/sdk 2.102.4 → 7.0.3

package/dist/_pkg/sdk-protocol/_pkg/boundwitness-model/neutral/index.mjs

@@ -0,0 +1,130 @@
+// src/BoundWitness/BoundWitness.ts
+import {
+  HashZod,
+  zodAsFactory,
+  zodIsFactory,
+  zodToFactory
+} from "@xylabs/sdk";
+import { XyoAddressZod } from "../../address/neutral/index.mjs";
+import { PayloadZod, SchemaZod } from "../../payload-model/neutral/index.mjs";
+import * as z2 from "zod/mini";
+
+// src/BoundWitness/BoundWitnessSchema.ts
+import { asSchema } from "../../payload-model/neutral/index.mjs";
+var BoundWitnessSchema = asSchema("network.xyo.boundwitness", true);
+
+// src/BoundWitness/Signatures.ts
+import { HexZod } from "@xylabs/sdk";
+import * as z from "zod/mini";
+var signatureOrNullZod = z.union([HexZod, z.null()]);
+var SignaturesMetaZod = z.object({ $signatures: z.array(signatureOrNullZod) });
+var UnsignedSignaturesMetaZod = z.object({ $signatures: z.array(z.null()) });
+var SignedSignaturesMetaZod = z.object({ $signatures: z.array(HexZod).check(z.minLength(1)) });
+
+// src/BoundWitness/BoundWitness.ts
+var BoundWitnessRequiredFieldsZod = z2.object({
+  addresses: z2.array(XyoAddressZod),
+  payload_hashes: z2.array(HashZod),
+  payload_schemas: z2.array(SchemaZod),
+  previous_hashes: z2.array(z2.nullable(HashZod))
+});
+var BoundWitnessMetaZod = z2.extend(
+  z2.object({
+    $destination: z2.optional(XyoAddressZod),
+    $sourceQuery: z2.optional(HashZod)
+  }),
+  SignaturesMetaZod.shape
+);
+var BoundWitnessPayloadZod = z2.safeExtend(PayloadZod, { schema: z2.literal(BoundWitnessSchema) });
+var BoundWitnessWithRequiredZod = z2.safeExtend(BoundWitnessPayloadZod, BoundWitnessRequiredFieldsZod.shape);
+var BoundWitnessZod = z2.safeExtend(BoundWitnessWithRequiredZod, BoundWitnessMetaZod.shape);
+var isBoundWitness = zodIsFactory(BoundWitnessZod);
+var asBoundWitness = zodAsFactory(BoundWitnessZod, "asBoundWitness");
+var toBoundWitness = zodToFactory(BoundWitnessZod, "toBoundWitness");
+var AnyBoundWitnessZod = z2.looseObject(BoundWitnessZod.shape);
+
+// src/BoundWitness/BoundWitnessJsonSchema.ts
+var BoundWitnessJsonSchema = () => {
+  return {
+    $id: "https://schemas.xyo.network/2.0/boundwitness",
+    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"
+  };
+};
+
+// src/BoundWitness/HydratedBoundWitness.ts
+import { AnyPayloadZod } from "../../payload-model/neutral/index.mjs";
+import * as z5 from "zod/mini";
+
+// src/BoundWitness/SignedBoundWitness.ts
+import * as z3 from "zod/mini";
+var SignedBoundWitnessZod = z3.extend(BoundWitnessZod, SignedSignaturesMetaZod.shape);
+var AnySignedBoundWitnessZod = z3.looseObject(SignedBoundWitnessZod.shape);
+
+// src/BoundWitness/UnsignedBoundWitness.ts
+import * as z4 from "zod/mini";
+var UnsignedBoundWitnessZod = z4.extend(BoundWitnessZod, UnsignedSignaturesMetaZod.shape);
+var AnyUnsignedBoundWitnessZod = z4.looseObject(UnsignedBoundWitnessZod.shape);
+
+// src/BoundWitness/HydratedBoundWitness.ts
+function HydratedBoundWitnessZodBuilder(bwZod) {
+  return z5.tuple([bwZod, z5.array(AnyPayloadZod)]);
+}
+var HydratedBoundWitnessZod = HydratedBoundWitnessZodBuilder(BoundWitnessZod);
+var SignedHydratedBoundWitnessZod = HydratedBoundWitnessZodBuilder(SignedBoundWitnessZod);
+var UnsignedHydratedBoundWitnessZod = HydratedBoundWitnessZodBuilder(UnsignedBoundWitnessZod);
+
+// src/QueryBoundWitness.ts
+import {
+  HashZod as HashZod2,
+  zodAsFactory as zodAsFactory2,
+  zodIsFactory as zodIsFactory2,
+  zodToFactory as zodToFactory2
+} from "@xylabs/sdk";
+import { isStorageMeta } from "../../payload-model/neutral/index.mjs";
+import * as z6 from "zod/mini";
+var QueryBoundWitnessFieldsZod = z6.object({
+  error_hashes: z6.optional(z6.array(HashZod2)),
+  query: HashZod2
+});
+var QueryBoundWitnessZod = z6.safeExtend(BoundWitnessZod, QueryBoundWitnessFieldsZod.shape);
+var isQueryBoundWitness = zodIsFactory2(QueryBoundWitnessZod);
+var asQueryBoundWitness = zodAsFactory2(QueryBoundWitnessZod, "asQueryBoundWitness");
+var toQueryBoundWitness = zodToFactory2(QueryBoundWitnessZod, "toQueryBoundWitness");
+var isQueryBoundWitnessWithStorageMeta = (x) => isQueryBoundWitness(x) && isStorageMeta(x);
+export {
+  AnyBoundWitnessZod,
+  AnySignedBoundWitnessZod,
+  AnyUnsignedBoundWitnessZod,
+  BoundWitnessJsonSchema,
+  BoundWitnessMetaZod,
+  BoundWitnessRequiredFieldsZod,
+  BoundWitnessSchema,
+  BoundWitnessZod,
+  HydratedBoundWitnessZod,
+  HydratedBoundWitnessZodBuilder,
+  QueryBoundWitnessFieldsZod,
+  QueryBoundWitnessZod,
+  SignaturesMetaZod,
+  SignedBoundWitnessZod,
+  SignedHydratedBoundWitnessZod,
+  SignedSignaturesMetaZod,
+  UnsignedBoundWitnessZod,
+  UnsignedHydratedBoundWitnessZod,
+  UnsignedSignaturesMetaZod,
+  asBoundWitness,
+  asQueryBoundWitness,
+  isBoundWitness,
+  isQueryBoundWitness,
+  isQueryBoundWitnessWithStorageMeta,
+  toBoundWitness,
+  toQueryBoundWitness
+};

package/dist/_pkg/sdk-protocol/_pkg/boundwitness-validator/neutral/Validator.d.ts

@@ -0,0 +1,16 @@
+import type { BoundWitness } from '../../boundwitness-model/neutral/index.ts';
+import { PayloadValidator } from '../../payload-validator/neutral/index.ts';
+export declare class BoundWitnessValidator<T extends BoundWitness = BoundWitness> extends PayloadValidator<T> {
+    static validateSignature(hash: ArrayBufferLike, address: string, signature?: ArrayBufferLike): Promise<Error[]>;
+    private validateArrayLength;
+    protected get expectedSchema(): string;
+    addresses(): Error[];
+    addressesUniqueness(): Error[];
+    previousHashes(): Error[];
+    schema(): Error[];
+    schemas(): Error[];
+    signatures(): Promise<Error[]>;
+    validate(): Promise<Error[]>;
+    validateArrayLengths(): Error[];
+    validatePayloadHashesLength(): Error[];
+}

package/dist/_pkg/sdk-protocol/_pkg/boundwitness-validator/neutral/index.d.ts

@@ -0,0 +1,2 @@
+export * from './lib/index.ts';
+export * from './Validator.ts';

package/dist/_pkg/sdk-protocol/_pkg/boundwitness-validator/neutral/index.mjs

@@ -0,0 +1,176 @@
+// src/lib/util/boundWitnessArrayPropertyContains.ts
+var boundWitnessArrayPropertyContains = (bw, prop, value) => {
+  return bw[prop]?.includes(value);
+};
+
+// src/lib/util/boundWitnessArrayPropertyContainsAll.ts
+var boundWitnessArrayPropertyContainsAll = (bw, prop, values) => {
+  return values.every((v) => bw[prop]?.includes(v));
+};
+
+// src/lib/util/boundWitnessArrayPropertyContainsAny.ts
+var boundWitnessArrayPropertyContainsAny = (bw, prop, values) => {
+  if (values.length === 0) return true;
+  return values.some((value) => bw[prop]?.includes(value));
+};
+
+// src/lib/addresses/addressesContains.ts
+var addressesContains = (bw, address) => {
+  return boundWitnessArrayPropertyContains(bw, "addresses", address);
+};
+
+// src/lib/addresses/addressesContainsAll.ts
+var addressesContainsAll = (bw, addresses) => {
+  return boundWitnessArrayPropertyContainsAll(bw, "addresses", addresses);
+};
+
+// src/lib/addresses/addressesContainsAny.ts
+var addressesContainsAny = (bw, addresses) => {
+  return boundWitnessArrayPropertyContainsAny(bw, "addresses", addresses);
+};
+
+// src/lib/payloadHashes/payloadHashesContains.ts
+var payloadHashesContains = (bw, payloadHash) => {
+  return boundWitnessArrayPropertyContains(bw, "payload_hashes", payloadHash);
+};
+
+// src/lib/payloadHashes/payloadHashesContainsAll.ts
+var payloadHashesContainsAll = (bw, payloadHashes) => {
+  return boundWitnessArrayPropertyContainsAll(bw, "payload_hashes", payloadHashes);
+};
+
+// src/lib/payloadHashes/payloadHashesContainsAny.ts
+var payloadHashesContainsAny = (bw, payloadHashes) => {
+  return boundWitnessArrayPropertyContainsAny(bw, "payload_hashes", payloadHashes);
+};
+
+// src/lib/payloadSchemas/payloadSchemasContains.ts
+var payloadSchemasContains = (bw, schema) => {
+  return boundWitnessArrayPropertyContains(bw, "payload_schemas", schema);
+};
+
+// src/lib/payloadSchemas/payloadSchemasContainsAll.ts
+var payloadSchemasContainsAll = (bw, payloadSchemas) => {
+  return boundWitnessArrayPropertyContainsAll(bw, "payload_schemas", payloadSchemas);
+};
+
+// src/lib/payloadSchemas/payloadSchemasContainsAny.ts
+var payloadSchemasContainsAny = (bw, payloadSchemas) => {
+  return boundWitnessArrayPropertyContainsAny(bw, "payload_schemas", payloadSchemas);
+};
+
+// src/Validator.ts
+import {
+  toArrayBuffer,
+  uniq,
+  validateType
+} from "@xylabs/sdk";
+import { verifySignature } from "../../account-model/neutral/index.mjs";
+import { BoundWitnessSchema } from "../../boundwitness-model/neutral/index.mjs";
+import { PayloadBuilder } from "../../payload/neutral/index.mjs";
+import { PayloadValidator } from "../../payload-validator/neutral/index.mjs";
+var validateArraysSameLength = (a, b, message = "Array length mismatch") => {
+  return a.length == b.length ? [] : [new Error(`${message} []`)];
+};
+var BoundWitnessValidator = class _BoundWitnessValidator extends PayloadValidator {
+  static async validateSignature(hash, address, signature) {
+    if (!signature) {
+      return [new Error(`Missing signature [${address}]`)];
+    }
+    if (!await verifySignature(address, hash, signature)) {
+      return [new Error(`Invalid signature [${address}]`)];
+    }
+    return [];
+  }
+  validateArrayLength(fieldName, compareArrayName) {
+    const errors = [];
+    const [array, arrayErrors] = validateType("array", this.stringKeyObj[fieldName], true);
+    const [compareArray, compareArrayErrors] = validateType("array", this.stringKeyObj[compareArrayName], true);
+    if (array?.length !== compareArray?.length) {
+      errors.push(new Error(`${fieldName}/${compareArrayName} count mismatch [${array?.length} !== ${compareArray?.length}]`));
+    }
+    return [...arrayErrors, ...compareArrayErrors, ...errors];
+  }
+  get expectedSchema() {
+    return BoundWitnessSchema;
+  }
+  addresses() {
+    const errors = [...this.addressesUniqueness()];
+    return errors;
+  }
+  addressesUniqueness() {
+    const errors = [];
+    const { addresses = [] } = this.obj;
+    const uniqAddresses = uniq(addresses);
+    if (addresses?.length !== uniqAddresses?.length) errors.push(new Error("addresses must be unique"));
+    return errors;
+  }
+  previousHashes() {
+    const errors = [];
+    return errors;
+  }
+  schema() {
+    const errors = [];
+    if (this.obj.schema !== this.expectedSchema) {
+      errors.push(new Error(`invalid schema [${this.expectedSchema} !== ${this.obj.schema}]`));
+    }
+    return errors;
+  }
+  schemas() {
+    const errors = [];
+    const Schemas = this.obj.payload_schemas;
+    if (Schemas) {
+      const schemaValidators = Schemas.map((schema) => {
+        return PayloadValidator.schemaNameValidatorFactory(schema);
+      });
+      for (const validator of schemaValidators) {
+        errors.push(...validator.all());
+      }
+    }
+    return errors;
+  }
+  async signatures() {
+    const signatureErrors = await Promise.all(
+      this.obj.addresses?.map(async (address, index) => _BoundWitnessValidator.validateSignature(
+        toArrayBuffer(await PayloadBuilder.dataHash(this.payload)),
+        address,
+        toArrayBuffer(this.obj.$signatures?.[index] ?? void 0)
+      )) ?? []
+    );
+    return [
+      ...validateArraysSameLength(this.obj.$signatures ?? [], this.obj.addresses ?? [], "Length mismatch: address/signature"),
+      ...signatureErrors.flat()
+    ];
+  }
+  async validate() {
+    return [
+      ...await this.signatures(),
+      ...this.addresses(),
+      ...this.validateArrayLengths(),
+      ...this.schemas(),
+      ...this.previousHashes(),
+      ...this.schema(),
+      ...await super.validate()
+    ];
+  }
+  validateArrayLengths() {
+    const errors = [...this.validatePayloadHashesLength()];
+    return errors;
+  }
+  validatePayloadHashesLength() {
+    const errors = [...this.validateArrayLength("payload_hashes", "payload_schemas")];
+    return errors;
+  }
+};
+export {
+  BoundWitnessValidator,
+  addressesContains,
+  addressesContainsAll,
+  addressesContainsAny,
+  payloadHashesContains,
+  payloadHashesContainsAll,
+  payloadHashesContainsAny,
+  payloadSchemasContains,
+  payloadSchemasContainsAll,
+  payloadSchemasContainsAny
+};

package/dist/_pkg/sdk-protocol/_pkg/boundwitness-validator/neutral/lib/addresses/addressesContains.d.ts

@@ -0,0 +1,9 @@
+import type { XyoAddress } from '../../../../address/neutral/index.ts';
+import type { BoundWitness } from '../../../../boundwitness-model/neutral/index.ts';
+/**
+ * Checks if the boundwitness contains the addresses
+ * @param bw The boundwitness to check
+ * @param addresses The address to check for
+ * @returns True if the boundwitness contains the addresses
+ */
+export declare const addressesContains: (bw: BoundWitness, address: XyoAddress) => boolean;

package/dist/_pkg/sdk-protocol/_pkg/boundwitness-validator/neutral/lib/addresses/addressesContainsAll.d.ts

@@ -0,0 +1,9 @@
+import type { XyoAddress } from '../../../../address/neutral/index.ts';
+import type { BoundWitness } from '../../../../boundwitness-model/neutral/index.ts';
+/**
+ * Checks if the boundwitness contains all of the addresses
+ * @param bw The boundwitness to check
+ * @param addresses The addresses to check for
+ * @returns True if the boundwitness contains all of the addresses
+ */
+export declare const addressesContainsAll: (bw: BoundWitness, addresses: XyoAddress[]) => boolean;

package/dist/_pkg/sdk-protocol/_pkg/boundwitness-validator/neutral/lib/addresses/addressesContainsAny.d.ts

@@ -0,0 +1,11 @@
+import type { XyoAddress } from '../../../../address/neutral/index.ts';
+import type { BoundWitness } from '../../../../boundwitness-model/neutral/index.ts';
+/**
+ * Checks if the boundwitness contains any of the addresses. If the addresses array
+ * is empty, it will return true. This is to match the behavior or addressesContainsAll
+ * which will return true if the addresses array is empty.
+ * @param bw The boundwitness to check
+ * @param addresses The addresses to check for
+ * @returns True if the boundwitness contains any of the addresses
+ */
+export declare const addressesContainsAny: (bw: BoundWitness, addresses: XyoAddress[]) => boolean;

package/dist/_pkg/sdk-protocol/_pkg/boundwitness-validator/neutral/lib/addresses/index.d.ts

@@ -0,0 +1,3 @@
+export * from './addressesContains.ts';
+export * from './addressesContainsAll.ts';
+export * from './addressesContainsAny.ts';

package/dist/_pkg/sdk-protocol/_pkg/boundwitness-validator/neutral/lib/index.d.ts

@@ -0,0 +1,3 @@
+export * from './addresses/index.ts';
+export * from './payloadHashes/index.ts';
+export * from './payloadSchemas/index.ts';

package/dist/_pkg/sdk-protocol/_pkg/boundwitness-validator/neutral/lib/payloadHashes/index.d.ts

@@ -0,0 +1,3 @@
+export * from './payloadHashesContains.ts';
+export * from './payloadHashesContainsAll.ts';
+export * from './payloadHashesContainsAny.ts';

package/dist/_pkg/sdk-protocol/_pkg/boundwitness-validator/neutral/lib/payloadHashes/payloadHashesContains.d.ts

@@ -0,0 +1,9 @@
+import type { Hash } from '@xylabs/sdk';
+import type { BoundWitness } from '../../../../boundwitness-model/neutral/index.ts';
+/**
+ * Checks if the boundwitness contains the payload hash
+ * @param bw The boundwitness to check
+ * @param payloadHash The payload hash to check for
+ * @returns True if the boundwitness contains the payload hash
+ */
+export declare const payloadHashesContains: (bw: BoundWitness, payloadHash: Hash) => boolean;

package/dist/_pkg/sdk-protocol/_pkg/boundwitness-validator/neutral/lib/payloadHashes/payloadHashesContainsAll.d.ts

@@ -0,0 +1,9 @@
+import type { Hash } from '@xylabs/sdk';
+import type { BoundWitness } from '../../../../boundwitness-model/neutral/index.ts';
+/**
+ * Checks if the boundwitness contains all of the payload hashes
+ * @param bw The boundwitness to check
+ * @param payloadHashes The payload hashes to check for
+ * @returns True if the boundwitness contains all of the payload hashes
+ */
+export declare const payloadHashesContainsAll: (bw: BoundWitness, payloadHashes: Hash[]) => boolean;

package/dist/_pkg/sdk-protocol/_pkg/boundwitness-validator/neutral/lib/payloadHashes/payloadHashesContainsAny.d.ts

@@ -0,0 +1,11 @@
+import type { Hash } from '@xylabs/sdk';
+import type { BoundWitness } from '../../../../boundwitness-model/neutral/index.ts';
+/**
+ * Checks if the boundwitness contains any of the payload hashes. If the payload hashes array
+ * is empty, it will return true. This is to match the behavior or payload hashesContainsAll
+ * which will return true if the payload hashes array is empty.
+ * @param bw The boundwitness to check
+ * @param payloadHashes The payload hashes to check for
+ * @returns True if the boundwitness contains any of the payload hashes
+ */
+export declare const payloadHashesContainsAny: (bw: BoundWitness, payloadHashes: Hash[]) => boolean;

package/dist/_pkg/sdk-protocol/_pkg/boundwitness-validator/neutral/lib/payloadSchemas/index.d.ts

@@ -0,0 +1,3 @@
+export * from './payloadSchemasContains.ts';
+export * from './payloadSchemasContainsAll.ts';
+export * from './payloadSchemasContainsAny.ts';

package/dist/_pkg/sdk-protocol/_pkg/boundwitness-validator/neutral/lib/payloadSchemas/payloadSchemasContains.d.ts

@@ -0,0 +1,9 @@
+import type { BoundWitness } from '../../../../boundwitness-model/neutral/index.ts';
+import type { Schema } from '../../../../payload-model/neutral/index.ts';
+/**
+ * Checks if the boundwitness contains the payload schema
+ * @param bw The boundwitness to check
+ * @param schema The payload schema to check for
+ * @returns True if the boundwitness contains the payload schema
+ */
+export declare const payloadSchemasContains: (bw: BoundWitness, schema: Schema) => boolean;

package/dist/_pkg/sdk-protocol/_pkg/boundwitness-validator/neutral/lib/payloadSchemas/payloadSchemasContainsAll.d.ts

@@ -0,0 +1,9 @@
+import type { BoundWitness } from '../../../../boundwitness-model/neutral/index.ts';
+import type { Schema } from '../../../../payload-model/neutral/index.ts';
+/**
+ * Checks if the boundwitness contains all of the payload schemas
+ * @param bw The boundwitness to check
+ * @param payloadSchemas The payload schemas to check for
+ * @returns True if the boundwitness contains all of the payload schemas
+ */
+export declare const payloadSchemasContainsAll: (bw: BoundWitness, payloadSchemas: Schema[]) => boolean;

package/dist/_pkg/sdk-protocol/_pkg/boundwitness-validator/neutral/lib/payloadSchemas/payloadSchemasContainsAny.d.ts

@@ -0,0 +1,11 @@
+import type { BoundWitness } from '../../../../boundwitness-model/neutral/index.ts';
+import type { Schema } from '../../../../payload-model/neutral/index.ts';
+/**
+ * Checks if the boundwitness contains any of the payload schemas. If the payload schemas array
+ * is empty, it will return true. This is to match the behavior or payload schemasContainsAll
+ * which will return true if the payload schemas array is empty.
+ * @param bw The boundwitness to check
+ * @param payloadSchemas The payload schemas to check for
+ * @returns True if the boundwitness contains any of the payload schemas
+ */
+export declare const payloadSchemasContainsAny: (bw: BoundWitness, payloadSchemas: Schema[]) => boolean;

package/dist/_pkg/sdk-protocol/_pkg/boundwitness-validator/neutral/lib/util/BoundWitnessArrayProperty.d.ts

@@ -0,0 +1,9 @@
+import type { BoundWitness } from '../../../../boundwitness-model/neutral/index.ts';
+/**
+ * The properties of a boundwitness that are string-like arrays
+ */
+export type BoundWitnessArrayProperty = keyof Pick<BoundWitness, 'addresses' | 'payload_hashes' | 'payload_schemas'>;
+/**
+ * The value of the underlying array type for the BoundWitness array property
+ */
+export type BoundWitnessArrayPropertyValue<P extends BoundWitnessArrayProperty> = BoundWitness[P] extends (infer T)[] ? T : never;

package/dist/_pkg/sdk-protocol/_pkg/boundwitness-validator/neutral/lib/util/boundWitnessArrayPropertyContains.d.ts

@@ -0,0 +1,10 @@
+import type { BoundWitness } from '../../../../boundwitness-model/neutral/index.ts';
+import type { BoundWitnessArrayProperty, BoundWitnessArrayPropertyValue } from './BoundWitnessArrayProperty.ts';
+/**
+ * Checks if the boundwitness contains the addresses
+ * @param bw The boundwitness
+ * @param prop The boundwitness property to check
+ * @param value The value to check for in the property
+ * @returns True if the boundwitness property contains the value
+ */
+export declare const boundWitnessArrayPropertyContains: <P extends BoundWitnessArrayProperty>(bw: BoundWitness, prop: P, value: BoundWitnessArrayPropertyValue<P>) => boolean;

package/dist/_pkg/sdk-protocol/_pkg/boundwitness-validator/neutral/lib/util/boundWitnessArrayPropertyContainsAll.d.ts

@@ -0,0 +1,10 @@
+import type { BoundWitness } from '../../../../boundwitness-model/neutral/index.ts';
+import type { BoundWitnessArrayProperty, BoundWitnessArrayPropertyValue } from './BoundWitnessArrayProperty.ts';
+/**
+ * Checks if the boundwitness property contains all of the values
+ * @param bw The boundwitness
+ * @param prop The boundwitness property to check
+ * @param values The values to check for in the property
+ * @returns True if the boundwitness contains all of the values in the property
+ */
+export declare const boundWitnessArrayPropertyContainsAll: <P extends BoundWitnessArrayProperty>(bw: BoundWitness, prop: P, values: BoundWitnessArrayPropertyValue<P>[]) => boolean;

package/dist/_pkg/sdk-protocol/_pkg/boundwitness-validator/neutral/lib/util/boundWitnessArrayPropertyContainsAny.d.ts

@@ -0,0 +1,12 @@
+import type { BoundWitness } from '../../../../boundwitness-model/neutral/index.ts';
+import type { BoundWitnessArrayProperty, BoundWitnessArrayPropertyValue } from './BoundWitnessArrayProperty.ts';
+/**
+ * Checks if the boundwitness contains any of the values in the property. If the values array
+ * is empty, it will return true. This is to match the behavior or boundWitnessContainsAll
+ * which will return true if the values array is empty.
+ * @param bw The boundwitness
+ * @param prop The boundwitness property to check
+ * @param value The values to check for in the property
+ * @returns True if the boundwitness contains any of the values in the property
+ */
+export declare const boundWitnessArrayPropertyContainsAny: <P extends BoundWitnessArrayProperty>(bw: BoundWitness, prop: P, values: BoundWitnessArrayPropertyValue<P>[]) => boolean;

package/dist/_pkg/sdk-protocol/_pkg/boundwitness-validator/neutral/lib/util/index.d.ts

@@ -0,0 +1,3 @@
+export * from './boundWitnessArrayPropertyContains.ts';
+export * from './boundWitnessArrayPropertyContainsAll.ts';
+export * from './boundWitnessArrayPropertyContainsAny.ts';

package/dist/_pkg/sdk-protocol/_pkg/boundwitness-wrapper/neutral/BoundWitnessWrapper.d.ts

@@ -0,0 +1,59 @@
+import { type Hash } from '@xylabs/sdk';
+import type { XyoAddress } from '../../address/neutral/index.ts';
+import type { BoundWitness } from '../../boundwitness-model/neutral/index.ts';
+import type { Payload, WithoutPrivateStorageMeta } from '../../payload-model/neutral/index.ts';
+import { PayloadWrapper, PayloadWrapperBase } from '../../payload-wrapper/neutral/index.ts';
+export declare const isBoundWitnessWrapper: <T extends BoundWitness = BoundWitness, P extends Payload = Payload>(value?: unknown) => value is BoundWitnessWrapper<T, P>;
+export declare class BoundWitnessWrapper<TBoundWitness extends BoundWitness = BoundWitness, TPayload extends Payload = Payload> extends PayloadWrapperBase<TBoundWitness> {
+    private _payloadDataMap;
+    private _payloadMap;
+    boundwitness: TBoundWitness;
+    moduleErrors?: Payload[];
+    payloads: TPayload[];
+    protected constructor(boundwitness: TBoundWitness, payloads?: TPayload[], moduleErrors?: Payload[]);
+    static as<T extends BoundWitness = BoundWitness>(value: unknown): BoundWitnessWrapper<T, Payload> | undefined;
+    static load(address: XyoAddress): Promise<BoundWitnessWrapper<{
+        schema: "network.xyo.boundwitness" & {
+            readonly __schema: true;
+        };
+        addresses: ((Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | import("../../address/neutral/index.ts").XyoQuantAddress)[];
+        payload_hashes: import("@xylabs/sdk").BrandedHash[];
+        payload_schemas: import("../../payload-model/neutral/index.ts").BrandedSchema<string>[];
+        previous_hashes: (import("@xylabs/sdk").BrandedHash | null)[];
+        $signatures: (import("@xylabs/sdk").BrandedHex | null)[];
+        $destination?: import("../../address/neutral/index.ts").XyoQuantAddress | (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | undefined;
+        $sourceQuery?: import("@xylabs/sdk").BrandedHash | undefined;
+    }, Payload> | null>;
+    static parse<T extends BoundWitness = BoundWitness, P extends Payload = Payload>(obj: unknown, payloads?: P[]): BoundWitnessWrapper<T, P>;
+    static tryParse<T extends BoundWitness, P extends Payload>(obj: unknown, payloads?: P[]): BoundWitnessWrapper<T, P> | undefined;
+    static wrap<T extends BoundWitness, P extends Payload>(obj: PayloadWrapperBase<T> | WithoutPrivateStorageMeta<T>, payloads?: P[]): BoundWitnessWrapper<T, P>;
+    static wrappedDataHashMap<T extends BoundWitness>(boundWitnesses: (T | BoundWitnessWrapper<T>)[]): Promise<Record<string, BoundWitnessWrapper<T>>>;
+    get addresses(): ((Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }) | import("../../address/neutral/index.ts").XyoQuantAddress)[];
+    get payloadHashes(): import("@xylabs/sdk").BrandedHash[];
+    get payloadSchemas(): import("../../payload-model/neutral/index.ts").BrandedSchema<string>[];
+    get previousHashes(): (import("@xylabs/sdk").BrandedHash | null)[];
+    dig(depth?: number): Promise<BoundWitnessWrapper<TBoundWitness>>;
+    getMissingPayloads(): Promise<import("@xylabs/sdk").BrandedHash[]>;
+    getWrappedPayloads(): Promise<PayloadWrapper<TPayload>[]>;
+    hashesBySchema(schema: string): string[];
+    payloadsByDataHashes(hashes: Hash[]): Promise<TPayload[]>;
+    payloadsByHashes(hashes: Hash[]): Promise<TPayload[]>;
+    payloadsBySchema<T extends TPayload>(schema: string): T[];
+    payloadsDataHashMap(): Promise<Partial<Record<Hash, TPayload>>>;
+    payloadsHashMap(): Promise<Partial<Record<Hash, TPayload>>>;
+    prev(address: XyoAddress): import("@xylabs/sdk").BrandedHash | null;
+    toResult(): (TBoundWitness | TPayload[])[];
+    validate(): Promise<Error[]>;
+}

package/dist/_pkg/sdk-protocol/_pkg/boundwitness-wrapper/neutral/QueryBoundWitnessWrapper.d.ts

@@ -0,0 +1,13 @@
+import { type Promisable } from '@xylabs/sdk';
+import type { QueryBoundWitness } from '../../boundwitness-model/neutral/index.ts';
+import type { Payload, Query } from '../../payload-model/neutral/index.ts';
+import { PayloadWrapper } from '../../payload-wrapper/neutral/index.ts';
+import { BoundWitnessWrapper } from './BoundWitnessWrapper.ts';
+export declare class QueryBoundWitnessWrapper<T extends Query = Query> extends BoundWitnessWrapper<QueryBoundWitness> {
+    private _payloadsWithoutQuery;
+    private _query;
+    static parseQuery<T extends Query = Query>(obj: unknown, payloads?: Payload[]): QueryBoundWitnessWrapper<T>;
+    static tryParseQuery<T extends Query>(obj: unknown): Promisable<QueryBoundWitnessWrapper<T> | undefined>;
+    getPayloadsWithoutQuery(): Promise<PayloadWrapper<Payload>[]>;
+    getQuery(): Promise<T>;
+}

package/dist/_pkg/sdk-protocol/_pkg/boundwitness-wrapper/neutral/SchemaType.d.ts

@@ -0,0 +1,5 @@
+import type { BoundWitness } from '../../boundwitness-model/neutral/index.ts';
+import type { JSONSchemaType } from 'ajv';
+export declare const SignatureRegEx: RegExp;
+export declare const boundWitnessProperties: JSONSchemaType<BoundWitness>['properties'];
+export declare const boundWitnessJsonSchema: JSONSchemaType<BoundWitness>;

package/dist/_pkg/sdk-protocol/_pkg/boundwitness-wrapper/neutral/index.d.ts

@@ -0,0 +1,3 @@
+export * from './BoundWitnessWrapper.ts';
+export * from './QueryBoundWitnessWrapper.ts';
+export * from './SchemaType.ts';