@xyo-network/sdk 7.0.3 → 7.0.4

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

@@ -1,310 +0,0 @@
-// 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

@@ -1,10 +0,0 @@
-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

@@ -1,2 +0,0 @@
-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

@@ -1,2 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

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

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

@@ -1,55 +0,0 @@
-// 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

@@ -1,172 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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

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