@xyo-network/sdk 2.102.3 → 7.0.2

package/dist/_pkg/boundwitness-builder/neutral/index.mjs

@@ -0,0 +1,310 @@
+// src/BoundWitnessBuilder.ts
+import {
+  asHash,
+  assertEx,
+  hexFromArrayBuffer,
+  toArrayBuffer
+} from "@xylabs/sdk";
+import { BoundWitnessSchema } from "../../boundwitness-model/neutral/index.mjs";
+import {
+  ObjectHasher,
+  removeEmptyFields,
+  sortFields
+} from "../../hash/neutral/index-browser.mjs";
+import { omitSchema, PayloadBuilder } from "../../payload-builder/neutral/index.mjs";
+import { Mutex } from "async-mutex";
+
+// src/GeneratedBoundWitnessFields.ts
+var GeneratedBoundWitnessFields = ["addresses", "payload_hashes", "payload_schemas", "previous_hashes"];
+
+// src/uniqueAddresses.ts
+var uniqueAddresses = (addresses, throwOnFalse = false) => {
+  const addressesSet = /* @__PURE__ */ new Set();
+  for (const address of addresses) {
+    if (addressesSet.has(address)) {
+      if (throwOnFalse) {
+        throw new Error("Duplicate address");
+      }
+      return false;
+    }
+    addressesSet.add(address);
+  }
+  return true;
+};
+
+// src/uniqueAccounts.ts
+var uniqueAccounts = (accounts, throwOnFalse = false) => {
+  return uniqueAddresses(accounts.map((account) => account.address), throwOnFalse);
+};
+
+// src/BoundWitnessBuilder.ts
+function missingSchemaMessage(payload) {
+  return `Builder: Missing Schema
+${JSON.stringify(payload, null, 2)}`;
+}
+var BoundWitnessBuilder = class _BoundWitnessBuilder extends PayloadBuilder {
+  static _buildMutex = new Mutex();
+  _accounts = [];
+  _errorHashes;
+  _errors = [];
+  _payloadHashes;
+  _payloadSchemas;
+  _payloads = [];
+  constructor(options) {
+    super({ ...options, schema: BoundWitnessSchema });
+  }
+  static validateGeneratedFields(fields) {
+    assertEx(fields.payload_hashes?.length === fields.payload_schemas?.length, () => "Payload hash/schema mismatch");
+    assertEx(!fields.payload_hashes.includes(null), () => "nulls found in hashes");
+    assertEx(!fields.payload_schemas.includes(null), () => "nulls found in schemas");
+  }
+  static async linkingFields(accounts, payloads) {
+    const addresses = accounts.map((account) => account.address.toLowerCase());
+    const previous_hashes = accounts.map((account) => account.previousHash ?? null);
+    const payload_hashes = payloads ? await this.hashes(payloads) : [];
+    const payload_schemas = payloads?.map(({ schema }) => schema) ?? [];
+    return {
+      addresses,
+      payload_hashes,
+      payload_schemas,
+      previous_hashes
+    };
+  }
+  static signature(payload, address) {
+    return payload.$signatures[this.addressIndex(payload, address)];
+  }
+  static async signatures(accounts, dataHash) {
+    const hashBytes = toArrayBuffer(dataHash);
+    const previousHashesBytes = accounts?.map((account) => account.previousHashBytes);
+    return await Promise.all(accounts.map(async (account, index) => {
+      const signature = await account.sign(hashBytes, previousHashesBytes[index]);
+      return hexFromArrayBuffer(signature[0]);
+    }));
+  }
+  static addressIndex(payload, address) {
+    const index = payload.addresses.indexOf(address);
+    if (index === -1) {
+      throw new Error("Invalid address");
+    }
+    return index;
+  }
+  static previousHash(boundWitness, address) {
+    return asHash(boundWitness.previous_hashes[this.addressIndex(boundWitness, address)])?.toLowerCase();
+  }
+  get addresses() {
+    uniqueAccounts(this._accounts, true);
+    return this._accounts.map((account) => account.address.toLowerCase());
+  }
+  get payloadSchemas() {
+    return this._payloadSchemas ?? this._payloads.map((payload) => {
+      return assertEx(payload.schema, () => missingSchemaMessage(payload));
+    });
+  }
+  get previousHashBytes() {
+    return this._accounts.map((account) => account.previousHashBytes ?? null);
+  }
+  get previousHashes() {
+    return this._accounts.map((account) => account.previousHash ?? null);
+  }
+  async sign() {
+    uniqueAccounts(this._accounts, true);
+    const hashBytes = toArrayBuffer(await this.dataHash());
+    return await Promise.all(this._accounts.map(async (account) => {
+      const signature = await account.sign(hashBytes);
+      return hexFromArrayBuffer(signature[0]);
+    }));
+  }
+  async build(sign = true) {
+    return await _BoundWitnessBuilder._buildMutex.runExclusive(async () => {
+      const dataHashableFields = await this.dataHashableFields();
+      const $signatures = sign ? await this.sign() : this.addresses.map(() => null);
+      const ret = {
+        ...this._meta,
+        ...dataHashableFields,
+        ...this._fields,
+        $signatures
+      };
+      return [
+        ret,
+        this._payloads,
+        this._errors
+      ];
+    });
+  }
+  async dataHash() {
+    const dataHashableFields = await this.dataHashableFields();
+    const hash = await ObjectHasher.hash(dataHashableFields);
+    return hash;
+  }
+  async dataHashableFields() {
+    const generatedFields = await _BoundWitnessBuilder.linkingFields(this._accounts, this._payloads);
+    _BoundWitnessBuilder.validateGeneratedFields(generatedFields);
+    const fields = {
+      ...PayloadBuilder.omitMeta(this._fields ?? {}),
+      ...generatedFields
+    };
+    return await _BoundWitnessBuilder.dataHashableFields(this._schema, fields);
+  }
+  error(payload) {
+    assertEx(this._errorHashes === void 0, () => "Can not set errors when hashes already set");
+    if (payload) {
+      this._errors.push(assertEx(sortFields(payload)));
+    }
+    return this;
+  }
+  errors(errors) {
+    if (errors) {
+      for (const error of errors) {
+        if (error !== null) {
+          this.error(error);
+        }
+      }
+    }
+    return this;
+  }
+  fields(fields) {
+    const clone = structuredClone(fields);
+    for (const field of GeneratedBoundWitnessFields) {
+      delete clone[field];
+    }
+    const withoutEmptyFields = removeEmptyFields(clone);
+    const withoutSchema = omitSchema(withoutEmptyFields);
+    const withoutClientMeta = _BoundWitnessBuilder.omitClientMeta(withoutSchema);
+    this._fields = _BoundWitnessBuilder.omitStorageMeta(withoutClientMeta);
+    return this;
+  }
+  hashes(hashes, schema) {
+    assertEx(this.payloads.length === 0, () => "Can not set hashes when payloads already set");
+    this._payloadHashes = hashes;
+    this._payloadSchemas = schema;
+    return this;
+  }
+  payload(payload) {
+    assertEx(this._payloadHashes === void 0, () => "Can not set payloads when hashes already set");
+    if (payload) {
+      this._payloads.push(assertEx(sortFields(payload)));
+    }
+    return this;
+  }
+  payloads(payloads) {
+    if (payloads)
+      for (const payload of payloads) {
+        if (payload !== null) {
+          this.payload(payload);
+        }
+      }
+    return this;
+  }
+  signer(account) {
+    uniqueAccounts([...this._accounts, account], true);
+    this._accounts?.push(account);
+    return this;
+  }
+  signers(accounts) {
+    uniqueAccounts([...this._accounts, ...accounts], true);
+    this._accounts?.push(...accounts);
+    return this;
+  }
+  sourceQuery(sourceQuery) {
+    this._meta = {
+      ...this._meta,
+      $sourceQuery: sourceQuery
+    };
+    return this;
+  }
+  /** @deprecated use signer instead */
+  witness(account) {
+    this._accounts?.push(account);
+    return this;
+  }
+  /** @deprecated use signers instead */
+  witnesses(accounts) {
+    this._accounts?.push(...accounts);
+    return this;
+  }
+};
+
+// src/combinationsByBoundwitness.ts
+import {
+  asHash as asHash2,
+  difference,
+  exists
+} from "@xylabs/sdk";
+import { isBoundWitness } from "../../boundwitness-model/neutral/index.mjs";
+import { PayloadBuilder as PayloadBuilder2 } from "../../payload-builder/neutral/index.mjs";
+var combinationsByBoundwitness = async (payloads) => {
+  const bws = new Set(payloads.filter((x) => isBoundWitness(x)));
+  const remaining = difference(new Set(payloads), bws);
+  const payloadDictionary = await PayloadBuilder2.toHashMap([...remaining]);
+  const results = [];
+  for (const bw of bws) {
+    const { payload_hashes } = bw;
+    const p = payload_hashes.map((h) => {
+      const hashKey = String(asHash2(h, true));
+      return payloadDictionary[hashKey];
+    }).filter(exists);
+    if (p.length === payload_hashes.length) {
+      const complete = [bw, ...p];
+      results.push(complete);
+    }
+  }
+  return results;
+};
+
+// src/intraBoundwitnessSchemaCombinations.ts
+import { asHash as asHash3 } from "@xylabs/sdk";
+var intraBoundwitnessSchemaCombinations = (boundwitness, schemas) => {
+  const indexMap = {};
+  for (const [index, element] of boundwitness.payload_schemas.entries()) {
+    if (!Object.hasOwn(indexMap, element)) {
+      indexMap[element] = [];
+    }
+    indexMap[element].push(index);
+  }
+  let uniqueCombinations = [[]];
+  for (const element of schemas) {
+    const newCombinations = [];
+    const indices = indexMap[element] ?? [];
+    for (const combination of uniqueCombinations) {
+      for (const index of indices) {
+        if (!combination.includes(index)) {
+          const newCombination = [...combination, index];
+          if (newCombination.length === schemas.indexOf(element) + 1) {
+            newCombinations.push(newCombination);
+          }
+        }
+      }
+    }
+    uniqueCombinations = newCombinations;
+  }
+  return uniqueCombinations.map((indexes) => {
+    return indexes.map((index) => {
+      return asHash3(boundwitness.payload_hashes[index], true);
+    });
+  });
+};
+
+// src/Query/QueryBoundWitnessBuilder.ts
+import { assertEx as assertEx2 } from "@xylabs/sdk";
+import { PayloadBuilder as PayloadBuilder3 } from "../../payload/neutral/index.mjs";
+var QueryBoundWitnessBuilder = class extends BoundWitnessBuilder {
+  _query;
+  async dataHashableFields() {
+    const fields = {
+      ...await super.dataHashableFields(),
+      query: await PayloadBuilder3.dataHash(assertEx2(this._query, () => "No Query Specified"))
+    };
+    return { ...fields };
+  }
+  query(query) {
+    this.payload(query);
+    this._query = query;
+    return this;
+  }
+};
+export {
+  BoundWitnessBuilder,
+  QueryBoundWitnessBuilder,
+  combinationsByBoundwitness,
+  intraBoundwitnessSchemaCombinations
+};

package/dist/_pkg/boundwitness-builder/neutral/intraBoundwitnessSchemaCombinations.d.ts

@@ -0,0 +1,10 @@
+import { type Hash } from '@xylabs/sdk';
+import type { BoundWitness } from '../../boundwitness-model/neutral/index.ts';
+import type { Schema } from '../../payload-model/neutral/index.ts';
+/**
+ * Returns all the possible combinations of payloads for the supplied schemas within the bound witness
+ * @param boundwitness The bound witness to search
+ * @param schemas The schemas to search for unique combinations of
+ * @returns The payload hashes corresponding to the unique combinations of the supplied schemas
+ */
+export declare const intraBoundwitnessSchemaCombinations: (boundwitness: BoundWitness, schemas: Schema[]) => Hash[][];

package/dist/_pkg/boundwitness-builder/neutral/uniqueAccounts.d.ts

@@ -0,0 +1,2 @@
+import type { AccountInstance } from '../../account-model/neutral/index.ts';
+export declare const uniqueAccounts: (accounts: AccountInstance[], throwOnFalse?: boolean) => boolean;

package/dist/_pkg/boundwitness-builder/neutral/uniqueAddresses.d.ts

@@ -0,0 +1,2 @@
+import type { XyoAddress } from '../../address/neutral/index.ts';
+export declare const uniqueAddresses: (addresses: XyoAddress[], throwOnFalse?: boolean) => boolean;

package/dist/_pkg/boundwitness-loader/neutral/Loader.d.ts

@@ -0,0 +1,20 @@
+import type { BaseParams, Hash } from '@xylabs/sdk';
+import { Base } from '@xylabs/sdk';
+import type { ArchivistInstance } from '../../archivist-model/neutral/index.ts';
+import type { Payload } from '../../sdk-protocol/neutral/index.ts';
+export interface PayloadWorkingSet {
+    archivists?: ArchivistInstance[];
+    huriEndpoints?: string[];
+    payloads?: Payload[];
+}
+export interface BoundWitnessLoaderParams extends BaseParams {
+    cache?: ArchivistInstance;
+    workingSet: PayloadWorkingSet;
+}
+export declare class BoundWitnessLoader extends Base<BoundWitnessLoaderParams> {
+    private _cache?;
+    private _createCacheMutex;
+    load(hash: Hash | Hash[]): Promise<Payload[]>;
+    private getCache;
+    private getPayload;
+}

package/dist/_pkg/boundwitness-loader/neutral/index.d.ts

@@ -0,0 +1 @@
+export * from './Loader.ts';

package/dist/_pkg/boundwitness-loader/neutral/index.mjs

@@ -0,0 +1,55 @@
+// src/Loader.ts
+import { Base, exists } from "@xylabs/sdk";
+import { MemoryArchivist } from "../../archivist-memory/neutral/index.mjs";
+import {
+  asBoundWitness,
+  Huri,
+  isAnyPayload
+} from "../../sdk-protocol/neutral/index.mjs";
+import { Mutex } from "async-mutex";
+var BoundWitnessLoader = class extends Base {
+  _cache;
+  _createCacheMutex = new Mutex();
+  async load(hash) {
+    if (Array.isArray(hash)) {
+      return (await Promise.all(hash.map((h) => this.load(h)))).flat();
+    }
+    const bw = asBoundWitness(await this.getPayload(hash));
+    if (bw) {
+      const payloads = (await Promise.all(bw.payload_hashes.map((hash2) => this.getPayload(hash2)))).filter(exists);
+      return [bw, ...payloads];
+    }
+    return [];
+  }
+  async getCache() {
+    return await this._createCacheMutex.runExclusive(async () => {
+      this._cache = this._cache ?? this.params.cache ?? await MemoryArchivist.create({ account: "random" });
+      if (this.params.workingSet.payloads) await this._cache.insert(this.params.workingSet.payloads);
+      return this._cache;
+    });
+  }
+  async getPayload(hash) {
+    const cache = await this.getCache();
+    const payloadFromCache = (await cache.get([hash])).at(0);
+    if (isAnyPayload(payloadFromCache)) {
+      return payloadFromCache;
+    }
+    for (const archivist of this.params.workingSet.archivists ?? []) {
+      const payloadFromArchivist = await archivist.get([hash]);
+      if (isAnyPayload(payloadFromArchivist)) {
+        await cache.insert([payloadFromArchivist]);
+        return payloadFromArchivist;
+      }
+    }
+    for (const huriEndpoint of this.params.workingSet.huriEndpoints ?? []) {
+      const payloadFromHuri = await new Huri(hash, { archivistUri: huriEndpoint }).fetch();
+      if (isAnyPayload(payloadFromHuri)) {
+        await cache.insert([payloadFromHuri]);
+        return payloadFromHuri;
+      }
+    }
+  }
+};
+export {
+  BoundWitnessLoader
+};

package/dist/_pkg/boundwitness-model/neutral/BoundWitness/BoundWitness.d.ts

@@ -0,0 +1,172 @@
+import * as z from 'zod/mini';
+import type { SignedSignaturesMeta, UnsignedSignaturesMeta } from './Signatures.ts';
+export declare const BoundWitnessRequiredFieldsZod: z.ZodMiniObject<{
+    addresses: z.ZodMiniArray<z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }, string>>, z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("../../../address/neutral/index.ts").XyoQuantAddress, string>>]>>;
+    payload_hashes: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHash, string>>>;
+    payload_schemas: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("../../../payload-model/neutral/index.ts").BrandedSchema<string>, string>>>;
+    previous_hashes: z.ZodMiniArray<z.ZodMiniNullable<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHash, string>>>>;
+}, z.core.$strip>;
+export type BoundWitnessRequiredFields = z.infer<typeof BoundWitnessRequiredFieldsZod>;
+export declare const BoundWitnessMetaZod: z.ZodMiniObject<{
+    $destination: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }, string>>, z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("../../../address/neutral/index.ts").XyoQuantAddress, string>>]>>;
+    $sourceQuery: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHash, string>>>;
+    $signatures: z.ZodMiniArray<z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHex, string>>, z.ZodMiniNull]>>;
+}, z.core.$strip>;
+export type BoundWitnessMeta = z.infer<typeof BoundWitnessMetaZod>;
+export declare const BoundWitnessZod: z.ZodMiniObject<{
+    schema: z.ZodMiniLiteral<"network.xyo.boundwitness" & {
+        readonly __schema: true;
+    }>;
+    addresses: z.ZodMiniArray<z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }, string>>, z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("../../../address/neutral/index.ts").XyoQuantAddress, string>>]>>;
+    payload_hashes: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHash, string>>>;
+    payload_schemas: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("../../../payload-model/neutral/index.ts").BrandedSchema<string>, string>>>;
+    previous_hashes: z.ZodMiniArray<z.ZodMiniNullable<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHash, string>>>>;
+    $destination: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }, string>>, z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("../../../address/neutral/index.ts").XyoQuantAddress, string>>]>>;
+    $sourceQuery: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHash, string>>>;
+    $signatures: z.ZodMiniArray<z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHex, string>>, z.ZodMiniNull]>>;
+}, z.core.$strip>;
+export type BoundWitness = z.infer<typeof BoundWitnessZod>;
+export declare const isBoundWitness: <T>(value: T) => value is T & {
+    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?: (Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }) | import("../../../address/neutral/index.ts").XyoQuantAddress | undefined;
+    $sourceQuery?: import("@xylabs/sdk").BrandedHash | undefined;
+};
+export declare const asBoundWitness: {
+    <T>(value: T): (T & {
+        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?: (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | import("../../../address/neutral/index.ts").XyoQuantAddress | undefined;
+        $sourceQuery?: import("@xylabs/sdk").BrandedHash | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
+        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?: (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | import("../../../address/neutral/index.ts").XyoQuantAddress | undefined;
+        $sourceQuery?: import("@xylabs/sdk").BrandedHash | undefined;
+    };
+};
+export declare const toBoundWitness: {
+    <T>(value: T): (T & {
+        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?: (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | import("../../../address/neutral/index.ts").XyoQuantAddress | undefined;
+        $sourceQuery?: import("@xylabs/sdk").BrandedHash | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
+        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?: (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | import("../../../address/neutral/index.ts").XyoQuantAddress | undefined;
+        $sourceQuery?: import("@xylabs/sdk").BrandedHash | undefined;
+    };
+};
+export declare const AnyBoundWitnessZod: z.ZodMiniObject<{
+    schema: z.ZodMiniLiteral<"network.xyo.boundwitness" & {
+        readonly __schema: true;
+    }>;
+    addresses: z.ZodMiniArray<z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }, string>>, z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("../../../address/neutral/index.ts").XyoQuantAddress, string>>]>>;
+    payload_hashes: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHash, string>>>;
+    payload_schemas: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("../../../payload-model/neutral/index.ts").BrandedSchema<string>, string>>>;
+    previous_hashes: z.ZodMiniArray<z.ZodMiniNullable<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHash, string>>>>;
+    $destination: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }, string>>, z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("../../../address/neutral/index.ts").XyoQuantAddress, string>>]>>;
+    $sourceQuery: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHash, string>>>;
+    $signatures: z.ZodMiniArray<z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHex, string>>, z.ZodMiniNull]>>;
+}, z.core.$loose>;
+export type AnyBoundWitness = z.infer<typeof AnyBoundWitnessZod>;
+export type Unsigned<T extends BoundWitness> = Omit<T, '$signatures'> & UnsignedSignaturesMeta;
+export type Signed<T extends BoundWitness> = Omit<T, '$signatures'> & SignedSignaturesMeta;
+export type PossiblySigned<T extends BoundWitness> = Unsigned<T> | Signed<T>;

package/dist/_pkg/boundwitness-model/neutral/BoundWitness/BoundWitnessJsonSchema.d.ts

@@ -0,0 +1,36 @@
+export declare const BoundWitnessJsonSchema: () => {
+    $id: string;
+    additionalProperties: boolean;
+    properties: {
+        addresses: {
+            items: {
+                type: string;
+            };
+            type: string;
+        };
+        payload_hashes: {
+            items: {
+                type: string;
+            };
+            type: string;
+        };
+        payload_schemas: {
+            items: {
+                type: string;
+            };
+            type: string;
+        };
+        previous_hashes: {
+            items: {
+                nullable: boolean;
+                type: string;
+            };
+            type: string;
+        };
+        schema: {
+            type: string;
+        };
+    };
+    required: string[];
+    type: string;
+};

package/dist/_pkg/boundwitness-model/neutral/BoundWitness/BoundWitnessSchema.d.ts

@@ -0,0 +1,4 @@
+export declare const BoundWitnessSchema: "network.xyo.boundwitness" & {
+    readonly __schema: true;
+};
+export type BoundWitnessSchema = typeof BoundWitnessSchema;