@xyo-network/sdk-protocol 7.0.4

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

@@ -0,0 +1,281 @@
+// src/BoundWitnessWrapper.ts
+import {
+  asHash,
+  assertEx,
+  isNumber,
+  isObject
+} from "@xylabs/sdk";
+import {
+  asBoundWitness,
+  BoundWitnessSchema,
+  isBoundWitness
+} from "../../boundwitness-model/neutral/index.mjs";
+import { BoundWitnessValidator } from "../../boundwitness-validator/neutral/index.mjs";
+import { PayloadBuilder } from "../../payload-builder/neutral/index.mjs";
+import {
+  isPayloadWrapperBase,
+  PayloadWrapper,
+  PayloadWrapperBase
+} from "../../payload-wrapper/neutral/index.mjs";
+var isBoundWitnessWrapper = (value) => {
+  if (isPayloadWrapperBase(value)) {
+    return typeof value.payloadsDataHashMap === "function";
+  }
+  return false;
+};
+var BoundWitnessWrapper = class _BoundWitnessWrapper extends PayloadWrapperBase {
+  _payloadDataMap;
+  _payloadMap;
+  boundwitness;
+  moduleErrors;
+  payloads = [];
+  constructor(boundwitness, payloads = [], moduleErrors) {
+    super(boundwitness);
+    this.boundwitness = boundwitness;
+    this.payloads = payloads;
+    this.moduleErrors = moduleErrors;
+  }
+  static as(value) {
+    return value instanceof this ? value : void 0;
+  }
+  static async load(address) {
+    const wrapper = await PayloadWrapper.load(address);
+    const payload = wrapper?.payload;
+    assertEx(payload && isBoundWitness(payload), () => "Attempt to load non-boundwitness");
+    const boundWitness = payload && isBoundWitness(payload) ? payload : void 0;
+    return boundWitness ? this.wrap(boundWitness) : null;
+  }
+  static parse(obj, payloads) {
+    let hydratedObj;
+    switch (typeof obj) {
+      case "string": {
+        hydratedObj = JSON.parse(obj);
+        break;
+      }
+      case "object": {
+        if (isObject(obj)) {
+          hydratedObj = obj;
+        }
+        break;
+      }
+    }
+    if (hydratedObj) {
+      if (isBoundWitnessWrapper(hydratedObj)) {
+        return hydratedObj;
+      }
+      if (isBoundWitness(hydratedObj)) {
+        const wrapper = new _BoundWitnessWrapper(hydratedObj, payloads ?? []);
+        return wrapper;
+      }
+    }
+    throw new Error(`Unable to parse [${typeof obj}]`);
+  }
+  static tryParse(obj, payloads) {
+    if (obj === void 0) return void 0;
+    try {
+      return this.parse(obj, payloads);
+    } catch {
+      return void 0;
+    }
+  }
+  static wrap(obj, payloads) {
+    switch (typeof obj) {
+      case "object": {
+        if (obj instanceof this) {
+          return obj;
+        }
+        return obj instanceof PayloadWrapper && obj.schema() === BoundWitnessSchema ? this.parse(obj.payload, payloads) : this.parse(obj, payloads);
+      }
+    }
+  }
+  static async wrappedDataHashMap(boundWitnesses) {
+    const result = {};
+    await Promise.all(
+      boundWitnesses.map(async (payload) => {
+        const bw = this.parse(payload);
+        const dataHash = String(await bw.dataHash());
+        result[dataHash] = bw;
+      })
+    );
+    return result;
+  }
+  get addresses() {
+    return this.boundwitness.addresses;
+  }
+  get payloadHashes() {
+    return this.boundwitness.payload_hashes;
+  }
+  get payloadSchemas() {
+    return this.boundwitness.payload_schemas;
+  }
+  get previousHashes() {
+    return this.boundwitness.previous_hashes;
+  }
+  async dig(depth) {
+    if (depth === 0) return this;
+    const innerBoundwitnessIndex = this.payloadSchemas.indexOf(BoundWitnessSchema);
+    if (innerBoundwitnessIndex !== -1) {
+      const innerBoundwitnessHash = String(asHash(this.payloadHashes[innerBoundwitnessIndex], true));
+      const allHashMap = await PayloadBuilder.toAllHashMap(this.payloads);
+      const innerBoundwitnessPayload = asBoundWitness(
+        allHashMap[innerBoundwitnessHash]
+      );
+      const innerBoundwitness = innerBoundwitnessPayload ? new _BoundWitnessWrapper(innerBoundwitnessPayload, await PayloadBuilder.filterExclude(this.payloads, innerBoundwitnessHash)) : void 0;
+      if (innerBoundwitness) {
+        return innerBoundwitness.dig(isNumber(depth) ? depth - 1 : void 0);
+      }
+    }
+    assertEx(depth === 0, () => `Dig failed [Remaining Depth: ${depth}]`);
+    return this;
+  }
+  async getMissingPayloads() {
+    const payloadMap = await this.payloadsDataHashMap();
+    return this.payloadHashes.filter((hash) => {
+      const hashKey = String(asHash(hash, true));
+      return !Object.hasOwn(payloadMap, hashKey);
+    });
+  }
+  async getWrappedPayloads() {
+    return this.payloads.map((payload) => PayloadWrapper.wrap(payload));
+  }
+  hashesBySchema(schema) {
+    const result = [];
+    for (const [index, payloadSchema] of this.payloadSchemas.entries()) {
+      if (payloadSchema === schema) {
+        result.push(asHash(this.payloadHashes[index], true));
+      }
+    }
+    return result;
+  }
+  async payloadsByDataHashes(hashes) {
+    const map = await this.payloadsDataHashMap();
+    return hashes.map((hash) => {
+      const hashKey = String(hash);
+      return assertEx(map[hashKey], () => "Hash not found");
+    });
+  }
+  async payloadsByHashes(hashes) {
+    const map = await this.payloadsHashMap();
+    return hashes.map((hash) => {
+      const hashKey = String(hash);
+      return assertEx(map[hashKey], () => "Hash not found");
+    });
+  }
+  payloadsBySchema(schema) {
+    return this.payloads.filter((payload) => payload?.schema === schema);
+  }
+  async payloadsDataHashMap() {
+    this._payloadDataMap = this._payloadDataMap ?? await PayloadBuilder.toDataHashMap(this.payloads);
+    return this._payloadDataMap;
+  }
+  async payloadsHashMap() {
+    this._payloadMap = this._payloadMap ?? await PayloadBuilder.toHashMap(this.payloads);
+    return this._payloadMap;
+  }
+  prev(address) {
+    return this.previousHashes[this.addresses.indexOf(address)];
+  }
+  toResult() {
+    return [this.boundwitness, this.payloads];
+  }
+  async validate() {
+    const validator = new BoundWitnessValidator(this.boundwitness);
+    return await validator.validate();
+  }
+};
+
+// src/QueryBoundWitnessWrapper.ts
+import {
+  asHash as asHash2,
+  assertEx as assertEx2,
+  exists
+} from "@xylabs/sdk";
+import { isQueryBoundWitness } from "../../boundwitness-model/neutral/index.mjs";
+import { PayloadBuilder as PayloadBuilder2 } from "../../payload/neutral/index.mjs";
+import { PayloadWrapper as PayloadWrapper2 } from "../../payload-wrapper/neutral/index.mjs";
+var QueryBoundWitnessWrapper = class _QueryBoundWitnessWrapper extends BoundWitnessWrapper {
+  _payloadsWithoutQuery;
+  _query;
+  static parseQuery(obj, payloads) {
+    assertEx2(!Array.isArray(obj), () => "Array can not be converted to QueryBoundWitnessWrapper");
+    switch (typeof obj) {
+      case "object": {
+        const castWrapper = obj;
+        const result = castWrapper instanceof this ? castWrapper : isQueryBoundWitness(obj) ? new _QueryBoundWitnessWrapper(
+          obj,
+          payloads
+        ) : void 0;
+        if (result === void 0) {
+          throw new Error("Unable to parse. Failed isQueryBoundWitness.");
+        }
+        return result;
+      }
+    }
+    throw new Error(`Unable to parse [${typeof obj}]`);
+  }
+  static tryParseQuery(obj) {
+    if (obj === void 0) return void 0;
+    try {
+      return this.parseQuery(obj);
+    } catch {
+      return void 0;
+    }
+  }
+  async getPayloadsWithoutQuery() {
+    if (!this._payloadsWithoutQuery) {
+      const payloadsWithoutQuery = await PayloadBuilder2.filterExclude(this.payloads, asHash2(this.payload.query, true));
+      this._payloadsWithoutQuery = payloadsWithoutQuery.map((payload) => PayloadWrapper2.wrap(payload)).filter(exists);
+    }
+    return this._payloadsWithoutQuery;
+  }
+  async getQuery() {
+    const payloadMap = await this.payloadsDataHashMap();
+    const queryHash = String(asHash2(this.boundwitness.query, true));
+    this._query = this._query ?? payloadMap[queryHash];
+    return assertEx2(this._query, () => `Missing Query [${JSON.stringify(this.boundwitness)}]`);
+  }
+};
+
+// src/SchemaType.ts
+import { HashRegEx, HexRegExMinMax } from "@xylabs/sdk";
+import { XyoAddressRegEx } from "../../address/neutral/index.mjs";
+import { SchemaRegEx } from "../../payload-model/neutral/index.mjs";
+import { payloadJsonSchema } from "../../payload-wrapper/neutral/index.mjs";
+var SignatureRegEx = HexRegExMinMax(64, 5261);
+var boundWitnessProperties = {
+  ...payloadJsonSchema.properties,
+  addresses: { items: { type: "string", pattern: XyoAddressRegEx.source }, type: "array" },
+  payload_hashes: { items: { type: "string", pattern: HashRegEx.source }, type: "array" },
+  payload_schemas: { items: { type: "string", pattern: SchemaRegEx.source }, type: "array" },
+  previous_hashes: {
+    items: {
+      type: "string",
+      pattern: HashRegEx.source,
+      nullable: true
+    },
+    type: "array"
+  },
+  root: { type: "string", pattern: HashRegEx.source },
+  $destination: { items: { type: "string", pattern: HashRegEx.source }, type: "array" },
+  $sourceQuery: { type: "string", pattern: HashRegEx.source },
+  $sources: { items: { type: "string", pattern: HashRegEx.source }, type: "array" },
+  $signatures: { items: { type: "string", pattern: SignatureRegEx.source }, type: "array" }
+};
+var boundWitnessJsonSchema = {
+  ...payloadJsonSchema,
+  $id: "https://schemas.xyo.network/2.0/boundwitness",
+  additionalProperties: false,
+  properties: boundWitnessProperties,
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+  required: [...payloadJsonSchema.required, "addresses", "payload_hashes", "payload_schemas", "previous_hashes"],
+  type: "object"
+};
+export {
+  BoundWitnessWrapper,
+  QueryBoundWitnessWrapper,
+  SignatureRegEx,
+  boundWitnessJsonSchema,
+  boundWitnessProperties,
+  isBoundWitnessWrapper
+};
+//# sourceMappingURL=index.mjs.map

package/dist/_pkg/config-payload-plugin/neutral/Payload.d.ts

@@ -0,0 +1,44 @@
+import type { AnyObject, WithAdditional } from '@xylabs/sdk';
+import * as z from 'zod/mini';
+export declare const ConfigPayloadZod: z.ZodMiniObject<{
+    schema: z.ZodMiniLiteral<"network.xyo.config" & {
+        readonly __schema: true;
+    }>;
+    config: z.ZodMiniString<string>;
+}, z.core.$strip>;
+export type ConfigPayload<T extends AnyObject | undefined = undefined> = WithAdditional<z.infer<typeof ConfigPayloadZod>, T>;
+export declare const isConfigPayload: <T>(value: T) => value is T & {
+    schema: "network.xyo.config" & {
+        readonly __schema: true;
+    };
+    config: string;
+};
+export declare const asConfigPayload: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.config" & {
+            readonly __schema: true;
+        };
+        config: string;
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
+        schema: "network.xyo.config" & {
+            readonly __schema: true;
+        };
+        config: string;
+    };
+};
+export declare const toConfigPayload: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.config" & {
+            readonly __schema: true;
+        };
+        config: string;
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
+        schema: "network.xyo.config" & {
+            readonly __schema: true;
+        };
+        config: string;
+    };
+};
+//# sourceMappingURL=Payload.d.ts.map

package/dist/_pkg/config-payload-plugin/neutral/Plugin.d.ts

@@ -0,0 +1,7 @@
+export declare const ConfigPayloadPlugin: () => import("../../payload-plugin/neutral/index.ts").PayloadPlugin<{
+    schema: "network.xyo.config" & {
+        readonly __schema: true;
+    };
+    config: string;
+}>;
+//# sourceMappingURL=Plugin.d.ts.map

package/dist/_pkg/config-payload-plugin/neutral/Schema.d.ts

@@ -0,0 +1,5 @@
+export declare const ConfigSchema: "network.xyo.config" & {
+    readonly __schema: true;
+};
+export type ConfigSchema = typeof ConfigSchema;
+//# sourceMappingURL=Schema.d.ts.map

package/dist/_pkg/config-payload-plugin/neutral/Template.d.ts

@@ -0,0 +1,3 @@
+import type { ConfigPayload } from './Payload.ts';
+export declare const configPayloadTemplate: () => ConfigPayload;
+//# sourceMappingURL=Template.d.ts.map

package/dist/_pkg/config-payload-plugin/neutral/index.d.ts

@@ -0,0 +1,5 @@
+export * from './Payload.ts';
+export { ConfigPayloadPlugin, ConfigPayloadPlugin as default } from './Plugin.ts';
+export * from './Schema.ts';
+export * from './Template.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/_pkg/config-payload-plugin/neutral/index.mjs

@@ -0,0 +1,44 @@
+// src/Payload.ts
+import {
+  zodAsFactory,
+  zodIsFactory,
+  zodToFactory
+} from "@xylabs/sdk";
+import { PayloadZodOfSchema } from "../../payload-model/neutral/index.mjs";
+import * as z from "zod/mini";
+
+// src/Schema.ts
+import { asSchema } from "../../payload-model/neutral/index.mjs";
+var ConfigSchema = asSchema("network.xyo.config", true);
+
+// src/Payload.ts
+var ConfigPayloadZod = z.extend(PayloadZodOfSchema(ConfigSchema), { config: z.string() });
+var isConfigPayload = zodIsFactory(ConfigPayloadZod);
+var asConfigPayload = zodAsFactory(ConfigPayloadZod, "asConfigPayload");
+var toConfigPayload = zodToFactory(ConfigPayloadZod, "toConfigPayload");
+
+// src/Plugin.ts
+import { createPayloadPlugin } from "../../payload-plugin/neutral/index.mjs";
+
+// src/Template.ts
+var configPayloadTemplate = () => ({
+  config: "",
+  schema: ConfigSchema
+});
+
+// src/Plugin.ts
+var ConfigPayloadPlugin = () => createPayloadPlugin({
+  schema: ConfigSchema,
+  template: configPayloadTemplate
+});
+export {
+  ConfigPayloadPlugin,
+  ConfigPayloadZod,
+  ConfigSchema,
+  asConfigPayload,
+  configPayloadTemplate,
+  ConfigPayloadPlugin as default,
+  isConfigPayload,
+  toConfigPayload
+};
+//# sourceMappingURL=index.mjs.map

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

@@ -0,0 +1,6 @@
+export * from '../../address/neutral/index.ts';
+export * from '../../data/neutral/index.ts';
+export * from '../../hash/neutral/index-browser.ts';
+export * from '../../schema-name-validator/neutral/index.ts';
+export * from '../../wasm/neutral/index.ts';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,7 @@
+// src/index.ts
+export * from "../../address/neutral/index.mjs";
+export * from "../../data/neutral/index.mjs";
+export * from "../../hash/neutral/index-browser.mjs";
+export * from "../../schema-name-validator/neutral/index.mjs";
+export * from "../../wasm/neutral/index.mjs";
+//# sourceMappingURL=index.mjs.map

package/dist/_pkg/core-payload-plugins/neutral/index.d.ts

@@ -0,0 +1,11 @@
+export * from '../../config-payload-plugin/neutral/index.ts';
+export * from '../../domain-payload-plugin/neutral/index.ts';
+export * from '../../id-payload-plugin/neutral/index.ts';
+export * from '../../query-payload-plugin/neutral/index.ts';
+export * from '../../schema-payload-plugin/neutral/index.ts';
+export * from '../../value-payload-plugin/neutral/index.ts';
+import type { Payload } from '../../payload-model/neutral/index.ts';
+import type { PayloadPluginFunc } from '../../payload-plugin/neutral/index.ts';
+export declare const PayloadPlugins: PayloadPluginFunc<Payload>[];
+export default PayloadPlugins;
+//# sourceMappingURL=index.d.ts.map

package/dist/_pkg/core-payload-plugins/neutral/index.mjs

@@ -0,0 +1,26 @@
+// src/index.ts
+export * from "../../config-payload-plugin/neutral/index.mjs";
+export * from "../../domain-payload-plugin/neutral/index.mjs";
+export * from "../../id-payload-plugin/neutral/index.mjs";
+export * from "../../query-payload-plugin/neutral/index.mjs";
+export * from "../../schema-payload-plugin/neutral/index.mjs";
+export * from "../../value-payload-plugin/neutral/index.mjs";
+import { ConfigPayloadPlugin } from "../../config-payload-plugin/neutral/index.mjs";
+import { DomainConfigPayloadPlugin, DomainPayloadPlugin } from "../../domain-payload-plugin/neutral/index.mjs";
+import { IdPayloadPlugin } from "../../id-payload-plugin/neutral/index.mjs";
+import { QueryPayloadPlugin } from "../../query-payload-plugin/neutral/index.mjs";
+import { SchemaPayloadPlugin } from "../../schema-payload-plugin/neutral/index.mjs";
+var PayloadPlugins = [
+  SchemaPayloadPlugin,
+  DomainPayloadPlugin,
+  DomainConfigPayloadPlugin,
+  IdPayloadPlugin,
+  ConfigPayloadPlugin,
+  QueryPayloadPlugin
+];
+var index_default = PayloadPlugins;
+export {
+  PayloadPlugins,
+  index_default as default
+};
+//# sourceMappingURL=index.mjs.map

package/dist/_pkg/crypto/neutral/account-model.d.ts

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

package/dist/_pkg/crypto/neutral/account-model.mjs

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

package/dist/_pkg/crypto/neutral/account.d.ts

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

package/dist/_pkg/crypto/neutral/account.mjs

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

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

@@ -0,0 +1,10 @@
+export * from '../../account/neutral/index.ts';
+export * from '../../account-model/neutral/index.ts';
+export * from '../../elliptic/neutral/index.ts';
+export * from '../../key-model/neutral/index.ts';
+export * from '../../pqc/neutral/index.ts';
+export * from '../../previous-hash-store/neutral/index.ts';
+export * from '../../quant-account/neutral/index.ts';
+export * from '../../wallet/neutral/index.ts';
+export * from '../../wallet-model/neutral/index.ts';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,11 @@
+// src/index.ts
+export * from "../../account/neutral/index.mjs";
+export * from "../../account-model/neutral/index.mjs";
+export * from "../../elliptic/neutral/index.mjs";
+export * from "../../key-model/neutral/index.mjs";
+export * from "../../pqc/neutral/index.mjs";
+export * from "../../previous-hash-store/neutral/index.mjs";
+export * from "../../quant-account/neutral/index.mjs";
+export * from "../../wallet/neutral/index.mjs";
+export * from "../../wallet-model/neutral/index.mjs";
+//# sourceMappingURL=index.mjs.map

package/dist/_pkg/crypto/neutral/key-model.d.ts

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

package/dist/_pkg/crypto/neutral/key-model.mjs

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

package/dist/_pkg/crypto/neutral/wallet-model.d.ts

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

package/dist/_pkg/crypto/neutral/wallet-model.mjs

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

package/dist/_pkg/crypto/neutral/wallet.d.ts

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

package/dist/_pkg/crypto/neutral/wallet.mjs

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

package/dist/_pkg/data/neutral/AbstractData.d.ts

@@ -0,0 +1,16 @@
+import type { Hex } from '@xylabs/sdk';
+export interface DataInstance {
+    base58: string;
+    bytes: ArrayBufferLike;
+    hex: Hex;
+    keccak256: ArrayBufferLike;
+}
+export declare abstract class AbstractData implements DataInstance {
+    static is(value: unknown): value is AbstractData;
+    get length(): number;
+    abstract get base58(): string;
+    abstract get bytes(): ArrayBufferLike;
+    abstract get hex(): Hex;
+    abstract get keccak256(): ArrayBufferLike;
+}
+//# sourceMappingURL=AbstractData.d.ts.map

package/dist/_pkg/data/neutral/Data.d.ts

@@ -0,0 +1,13 @@
+import type { Hex } from '@xylabs/sdk';
+import { AbstractData } from './AbstractData.ts';
+export declare class Data extends AbstractData {
+    private _bytes?;
+    private _length;
+    constructor(length: number, bytes?: ArrayBufferLike, base?: number);
+    static from(data: ArrayBuffer | undefined): Data | undefined;
+    get base58(): string;
+    get bytes(): ArrayBuffer | SharedArrayBuffer;
+    get hex(): Hex;
+    get keccak256(): ArrayBufferLike;
+}
+//# sourceMappingURL=Data.d.ts.map

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

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

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

@@ -0,0 +1,53 @@
+// src/AbstractData.ts
+var AbstractData = class {
+  static is(value) {
+    return value instanceof this;
+  }
+  get length() {
+    return this.bytes.byteLength;
+  }
+};
+
+// src/Data.ts
+import { base16, base58 } from "@scure/base";
+import {
+  assertEx,
+  toArrayBuffer,
+  toUint8Array
+} from "@xylabs/sdk";
+import { keccak256 } from "ethers";
+function checkLength(bytes, length) {
+  assertEx(bytes.byteLength === length, () => `Length Mismatch: ${bytes.byteLength} !== ${length} => ${base16.encode(new Uint8Array(bytes))}`);
+}
+var Data = class _Data extends AbstractData {
+  _bytes;
+  _length;
+  constructor(length, bytes, base) {
+    super();
+    this._bytes = toUint8Array(bytes, length, base)?.buffer;
+    this._length = length;
+  }
+  static from(data) {
+    return data ? new _Data(data.byteLength, data) : void 0;
+  }
+  get base58() {
+    checkLength(this.bytes, this._length);
+    return base58.encode(new Uint8Array(this.bytes));
+  }
+  get bytes() {
+    return assertEx(this._bytes, () => "Data uninitialized");
+  }
+  get hex() {
+    checkLength(this.bytes, this._length);
+    return base16.encode(new Uint8Array(this.bytes)).toLowerCase();
+  }
+  get keccak256() {
+    checkLength(this.bytes, this._length);
+    return toArrayBuffer(keccak256(new Uint8Array(this.bytes)));
+  }
+};
+export {
+  AbstractData,
+  Data
+};
+//# sourceMappingURL=index.mjs.map

package/dist/_pkg/dns/neutral/DnsRecordType.d.ts

@@ -0,0 +1,16 @@
+export declare const DnsRecordType: {
+    readonly A: 1;
+    readonly AAAA: 28;
+    readonly CAA: 257;
+    readonly CNAME: 5;
+    readonly DNAME: 39;
+    readonly MX: 15;
+    readonly NS: 2;
+    readonly PTR: 12;
+    readonly SOA: 6;
+    readonly SPF: 99;
+    readonly SRV: 33;
+    readonly TXT: 16;
+};
+export type DnsRecordType = typeof DnsRecordType[keyof typeof DnsRecordType];
+//# sourceMappingURL=DnsRecordType.d.ts.map

package/dist/_pkg/dns/neutral/DnsReturnCode.d.ts

@@ -0,0 +1,14 @@
+export declare const DnsReturnCode: {
+    NoError: number;
+    QueryFormatError: number;
+    ServerFailed: number;
+    DomainDoesNotExist: number;
+    NotImplemented: number;
+    Refused: number;
+    NameShouldNotExist: number;
+    RRSetShouldNotExist: number;
+    NotAuthoritative: number;
+    NotInZone: number;
+};
+export type DnsReturnCode = typeof DnsReturnCode[keyof typeof DnsReturnCode];
+//# sourceMappingURL=DnsReturnCode.d.ts.map

package/dist/_pkg/dns/neutral/GoogleDnsResult.d.ts

@@ -0,0 +1,17 @@
+import type { DnsReturnCode } from './DnsReturnCode.ts';
+import type { GoogleDnsResultAnswer } from './GoogleDnsResultAnswer.ts';
+import type { GoogleDnsResultQuestion } from './GoogleDnsResultQuestion.ts';
+export interface GoogleDnsResult {
+    AD?: boolean;
+    Answer?: GoogleDnsResultAnswer[];
+    Authority?: GoogleDnsResultAnswer[];
+    CD?: boolean;
+    Comment?: string;
+    Question?: GoogleDnsResultQuestion[];
+    RA?: boolean;
+    RD?: boolean;
+    Status?: DnsReturnCode;
+    TC?: boolean;
+    edns_client_subnet?: string;
+}
+//# sourceMappingURL=GoogleDnsResult.d.ts.map