@xyo-network/sdk-protocol 7.0.4

package/dist/_pkg/api-models/neutral/Config.d.ts

@@ -0,0 +1,25 @@
+import type { ApiReportable } from './Reportable.ts';
+interface ApiConfig extends ApiReportable {
+    /** @description The domain where the API is located */
+    apiDomain: string;
+    /** @description The apiKey used for authentication */
+    apiKey?: string;
+    /** @description Threshold for Content-Size to cause automatic gzip of request body [default = 1024] */
+    compressionThreshold?: number;
+    /** @description The jwtToken of the currently logged in user */
+    jwtToken?: string;
+    /** @description The query string, if any, that is added to the end of every request */
+    query?: string;
+    /** @description Parent that should also report events from this API */
+    reportableParent?: ApiReportable;
+    /** @description The location in the API tree where this API object is mounted */
+    root?: string;
+    /** @description Throw on error */
+    throwError?: boolean;
+    /** @description Throw on failures */
+    throwFailure?: boolean;
+    /** @deprecated use the jwtToken instead */
+    userid?: string;
+}
+export type { ApiConfig };
+//# sourceMappingURL=Config.d.ts.map

package/dist/_pkg/api-models/neutral/Envelope.d.ts

@@ -0,0 +1,15 @@
+import type { ApiError } from './Error.ts';
+import type { ApiWarning } from './Warning.ts';
+export interface ApiEnvelopeBase {
+    warning?: ApiWarning[];
+}
+export interface ApiEnvelopeSuccess<T> extends ApiEnvelopeBase {
+    data: T;
+    errors: never;
+}
+export interface ApiEnvelopeError extends ApiEnvelopeBase {
+    data: never;
+    errors: ApiError[];
+}
+export type ApiEnvelope<T> = ApiEnvelopeSuccess<T> | ApiEnvelopeError;
+//# sourceMappingURL=Envelope.d.ts.map

package/dist/_pkg/api-models/neutral/Error.d.ts

@@ -0,0 +1,5 @@
+import type { FetchClientError } from '@xylabs/sdk';
+export interface ApiError<T = unknown> extends FetchClientError<T> {
+    isError: true;
+}
+//# sourceMappingURL=Error.d.ts.map

package/dist/_pkg/api-models/neutral/Reportable.d.ts

@@ -0,0 +1,8 @@
+import type { ApiError } from './Error.ts';
+import type { ApiResponse } from './Response.ts';
+export interface ApiReportable {
+    onError?: (error: ApiError, depth: number) => void;
+    onFailure?: (response: ApiResponse, depth: number) => void;
+    onSuccess?: (response: ApiResponse, depth: number) => void;
+}
+//# sourceMappingURL=Reportable.d.ts.map

package/dist/_pkg/api-models/neutral/Response.d.ts

@@ -0,0 +1,8 @@
+import type { FetchJsonResponse } from '@xylabs/sdk';
+import type { ApiEnvelope } from './Envelope.ts';
+export type ApiResponse<T = unknown> = FetchJsonResponse<T>;
+export type ApiResponseBody<T> = T | undefined;
+export type ApiResponseTuple<T> = [T | undefined, ApiEnvelope<T | undefined>, ApiResponse<ApiEnvelope<T | undefined>>];
+export type ApiResponseTupleOrBody<T> = ApiResponseTuple<T> | ApiResponseBody<T>;
+export type ApiResponseType = 'body' | 'tuple';
+//# sourceMappingURL=Response.d.ts.map

package/dist/_pkg/api-models/neutral/Warning.d.ts

@@ -0,0 +1,2 @@
+export type ApiWarning = Error;
+//# sourceMappingURL=Warning.d.ts.map

package/dist/_pkg/api-models/neutral/index.d.ts

@@ -0,0 +1,7 @@
+export * from './Config.ts';
+export * from './Envelope.ts';
+export * from './Error.ts';
+export * from './Reportable.ts';
+export * from './Response.ts';
+export * from './Warning.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/_pkg/api-models/neutral/index.mjs

@@ -0,0 +1 @@
+//# sourceMappingURL=index.mjs.map

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

@@ -0,0 +1,2 @@
+export * from '../../boundwitness-builder/neutral/index.ts';
+//# sourceMappingURL=builder.d.ts.map

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

@@ -0,0 +1,3 @@
+// src/builder.ts
+export * from "../../boundwitness-builder/neutral/index.mjs";
+//# sourceMappingURL=builder.mjs.map

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

@@ -0,0 +1,5 @@
+export * from '../../boundwitness-builder/neutral/index.ts';
+export * from '../../boundwitness-model/neutral/index.ts';
+export * from '../../boundwitness-validator/neutral/index.ts';
+export * from '../../boundwitness-wrapper/neutral/index.ts';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,6 @@
+// src/index.ts
+export * from "../../boundwitness-builder/neutral/index.mjs";
+export * from "../../boundwitness-model/neutral/index.mjs";
+export * from "../../boundwitness-validator/neutral/index.mjs";
+export * from "../../boundwitness-wrapper/neutral/index.mjs";
+//# sourceMappingURL=index.mjs.map

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

@@ -0,0 +1,2 @@
+export * from '../../boundwitness-model/neutral/index.ts';
+//# sourceMappingURL=model.d.ts.map

package/dist/_pkg/boundwitness/neutral/model.mjs

@@ -0,0 +1,3 @@
+// src/model.ts
+export * from "../../boundwitness-model/neutral/index.mjs";
+//# sourceMappingURL=model.mjs.map

package/dist/_pkg/boundwitness/neutral/validator.d.ts

@@ -0,0 +1,2 @@
+export * from '../../boundwitness-validator/neutral/index.ts';
+//# sourceMappingURL=validator.d.ts.map

package/dist/_pkg/boundwitness/neutral/validator.mjs

@@ -0,0 +1,3 @@
+// src/validator.ts
+export * from "../../boundwitness-validator/neutral/index.mjs";
+//# sourceMappingURL=validator.mjs.map

package/dist/_pkg/boundwitness/neutral/wrapper.d.ts

@@ -0,0 +1,2 @@
+export * from '../../boundwitness-wrapper/neutral/index.ts';
+//# sourceMappingURL=wrapper.d.ts.map

package/dist/_pkg/boundwitness/neutral/wrapper.mjs

@@ -0,0 +1,3 @@
+// src/wrapper.ts
+export * from "../../boundwitness-wrapper/neutral/index.mjs";
+//# sourceMappingURL=wrapper.mjs.map

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

@@ -0,0 +1,48 @@
+import type { Hash, Hex } from '@xylabs/sdk';
+import type { AccountInstance } from '../../account-model/neutral/index.ts';
+import type { XyoAddress } from '../../address/neutral/index.ts';
+import type { BoundWitness, PossiblySigned, Signed, Unsigned } from '../../boundwitness-model/neutral/index.ts';
+import type { PayloadBuilderOptions } from '../../payload-builder/neutral/index.ts';
+import { PayloadBuilder } from '../../payload-builder/neutral/index.ts';
+import type { ModuleError, Payload, Schema, WithoutClientMeta, WithoutMeta, WithoutSchema, WithoutStorageMeta } from '../../payload-model/neutral/index.ts';
+import { GeneratedBoundWitnessFields } from './GeneratedBoundWitnessFields.ts';
+export declare class BoundWitnessBuilder<TBoundWitness extends BoundWitness = BoundWitness, TPayload extends Payload = Payload> extends PayloadBuilder<TBoundWitness, Promise<[PossiblySigned<TBoundWitness>, TPayload[], ModuleError[]]>> {
+    private static readonly _buildMutex;
+    private _accounts;
+    private _errorHashes?;
+    private _errors;
+    private _payloadHashes?;
+    private _payloadSchemas?;
+    private _payloads;
+    constructor(options?: Omit<PayloadBuilderOptions, 'schema'>);
+    private static validateGeneratedFields;
+    protected static linkingFields<T extends BoundWitness>(accounts: AccountInstance[], payloads?: Payload[]): Promise<Pick<T, GeneratedBoundWitnessFields>>;
+    protected static signature<T extends BoundWitness>(payload: T, address: XyoAddress): import("@xylabs/sdk").BrandedHex | null;
+    protected static signatures(accounts: AccountInstance[], dataHash: Hash): Promise<string[]>;
+    static addressIndex<T extends BoundWitness>(payload: T, address: XyoAddress): number;
+    static previousHash<T extends BoundWitness>(boundWitness: T, address: XyoAddress): string | undefined;
+    protected get addresses(): XyoAddress[];
+    protected get payloadSchemas(): string[];
+    protected get previousHashBytes(): (ArrayBufferLike | null)[];
+    protected get previousHashes(): (Hash | null)[];
+    protected sign(): Promise<Hex[]>;
+    build(): Promise<[Signed<TBoundWitness>, TPayload[], ModuleError[]]>;
+    build(sign: false): Promise<[Unsigned<TBoundWitness>, TPayload[], ModuleError[]]>;
+    build(sign: true): Promise<[Signed<TBoundWitness>, TPayload[], ModuleError[]]>;
+    dataHash(): Promise<import("@xylabs/sdk").BrandedHash>;
+    dataHashableFields(): Promise<WithoutMeta<TBoundWitness>>;
+    error(payload?: ModuleError): this;
+    errors(errors?: (ModuleError | null)[]): this;
+    fields(fields: WithoutSchema<Omit<WithoutStorageMeta<WithoutClientMeta<TBoundWitness>>, 'addresses' | 'payload_hashes' | 'payload_schemas' | 'previous_hashes'>>): this;
+    hashes(hashes: Hash[], schema: Schema[]): this;
+    payload(payload?: TPayload): this;
+    payloads(payloads?: (TPayload | null)[]): this;
+    signer(account: AccountInstance): this;
+    signers(accounts: AccountInstance[]): this;
+    sourceQuery(sourceQuery: Hash): this;
+    /** @deprecated use signer instead */
+    witness(account: AccountInstance): this;
+    /** @deprecated use signers instead */
+    witnesses(accounts: AccountInstance[]): this;
+}
+//# sourceMappingURL=BoundWitnessBuilder.d.ts.map

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

@@ -0,0 +1,3 @@
+export declare const GeneratedBoundWitnessFields: readonly ["addresses", "payload_hashes", "payload_schemas", "previous_hashes"];
+export type GeneratedBoundWitnessFields = typeof GeneratedBoundWitnessFields[number];
+//# sourceMappingURL=GeneratedBoundWitnessFields.d.ts.map

package/dist/_pkg/boundwitness-builder/neutral/Query/QueryBoundWitnessBuilder.d.ts

@@ -0,0 +1,9 @@
+import type { QueryBoundWitness } from '../../../boundwitness-model/neutral/index.ts';
+import type { Query, WithoutMeta } from '../../../payload-model/neutral/index.ts';
+import { BoundWitnessBuilder } from '../BoundWitnessBuilder.ts';
+export declare class QueryBoundWitnessBuilder<TBoundWitness extends QueryBoundWitness = QueryBoundWitness, TQuery extends Query = Query> extends BoundWitnessBuilder<TBoundWitness> {
+    private _query;
+    dataHashableFields(): Promise<WithoutMeta<TBoundWitness>>;
+    query<T extends TQuery>(query: T): this;
+}
+//# sourceMappingURL=QueryBoundWitnessBuilder.d.ts.map

package/dist/_pkg/boundwitness-builder/neutral/Query/index.d.ts

@@ -0,0 +1,2 @@
+export * from './QueryBoundWitnessBuilder.ts';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,10 @@
+import type { BoundWitness } from '../../boundwitness-model/neutral/index.ts';
+import type { Payload } from '../../payload-model/neutral/index.ts';
+/**
+ * Returns tuples of bound witnesses and their payloads from the supplied payloads. Omits
+ * bound witnesses where the payloads were not included in the supplied payloads.
+ * @param payloads An array of bound witnesses and payloads
+ * @returns An array of tuples of bound witnesses and their payloads
+ */
+export declare const combinationsByBoundwitness: (payloads: Payload[]) => Promise<[BoundWitness, ...Payload[]][]>;
+//# sourceMappingURL=combinationsByBoundwitness.d.ts.map

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

@@ -0,0 +1,5 @@
+export * from './BoundWitnessBuilder.ts';
+export * from './combinationsByBoundwitness.ts';
+export * from './intraBoundwitnessSchemaCombinations.ts';
+export * from './Query/index.ts';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,311 @@
+// 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
+};
+//# sourceMappingURL=index.mjs.map

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

@@ -0,0 +1,11 @@
+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[][];
+//# sourceMappingURL=intraBoundwitnessSchemaCombinations.d.ts.map

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

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

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

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