@xyo-network/sdk-protocol 7.0.4

package/dist/_pkg/hash/node/index.mjs

@@ -0,0 +1,279 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/hasEmptyFields.ts
+import { typeOf } from "@xylabs/sdk";
+var hasEmptyFields = (obj) => {
+  if (obj == null || Array.isArray(obj)) return false;
+  if (obj == void 0 || Object.keys(obj).length === 0) return true;
+  for (const [value] of Object.values(obj)) {
+    if (typeOf(value) === "object") {
+      if (hasEmptyFields(value)) return true;
+    } else if (value === void 0) {
+      return true;
+    }
+  }
+  return false;
+};
+
+// src/createNodeWorker.ts
+import { Worker } from "@xylabs/threads/master";
+var createNodeWorker = (func) => {
+  try {
+    const code = func?.toString().slice(6) ?? "";
+    return new Worker(
+      code,
+      { fromSource: true }
+    );
+  } catch {
+    throw new Error("Unable to create worker");
+  }
+};
+
+// src/ObjectHasher.ts
+import {
+  asHash,
+  assertEx,
+  hexFromArrayBuffer,
+  ObjectWrapper,
+  omitBy
+} from "@xylabs/sdk";
+import { Pool, spawn } from "@xylabs/threads/master";
+import { WasmSupport } from "../../wasm/neutral/index.mjs";
+import { sha256 } from "hash-wasm";
+
+// src/removeEmptyFields.ts
+import { typeOf as typeOf2 } from "@xylabs/sdk";
+var removeEmptyFields = (obj) => {
+  if (obj == null) return obj;
+  if (Array.isArray(obj)) {
+    const arr = obj;
+    return arr.map((value) => typeof value === "object" ? removeEmptyFields(value) : value);
+  }
+  const newObject = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (typeOf2(value) === "object") {
+      newObject[key] = removeEmptyFields(value);
+    } else if (value !== void 0) {
+      newObject[key] = value;
+    }
+  }
+  return newObject;
+};
+
+// src/sortFields.ts
+import { isObject } from "@xylabs/sdk";
+var subSort = (value) => {
+  return isObject(value) ? sortFields(value) : value;
+};
+var sortFields = (obj) => {
+  const result = {};
+  const keys = Object.keys(obj);
+  for (const key of keys.toSorted()) {
+    result[key] = subSort(obj[key]);
+  }
+  return result;
+};
+
+// src/worker/subtleHashNode.ts
+var subtleHashFunc = () => {
+  const { subtle } = __require("@xylabs/platform");
+  const { expose } = __require("@xylabs/threads/worker");
+  expose({ hash: async (data) => await subtle.digest("SHA-256", data) });
+};
+
+// src/worker/wasmHashNode.ts
+var wasmHashFunc = () => {
+  const { sha256: sha2562 } = __require("hash-wasm");
+  const { asHash: asHash2 } = __require("@xylabs/hex");
+  const { expose } = __require("@xylabs/threads/worker");
+  expose({ hash: async (data) => asHash2(await sha2562(data), true) });
+};
+
+// src/ObjectHasher.ts
+var wasmSupportStatic = new WasmSupport(["bigInt"]);
+var omitByPredicate = (prefix) => (_, key) => {
+  assertEx(typeof key === "string", () => `Invalid key type [${String(key)}, ${typeof key}]`);
+  return String(key).startsWith(prefix);
+};
+var ObjectHasher = class _ObjectHasher extends ObjectWrapper {
+  static allowHashPooling = true;
+  static allowSubtle = true;
+  static createBrowserWorker;
+  static createNodeWorker;
+  static subtleHashWorkerUrl;
+  static warnIfUsingJsHash = true;
+  static wasmHashWorkerUrl;
+  static wasmInitialized = wasmSupportStatic.initialize();
+  static wasmSupport = wasmSupportStatic;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static _subtleHashPool;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static _wasmHashPool;
+  static get subtleHashPool() {
+    if (!this.allowHashPooling || this._subtleHashPool === null) {
+      return null;
+    }
+    try {
+      return this._subtleHashPool = this._subtleHashPool ?? (this.subtleHashWorkerUrl ? this.createWorkerPool(this.subtleHashWorkerUrl, subtleHashFunc) : null);
+    } catch {
+      console.warn("Creating subtle hash worker failed");
+      this._subtleHashPool = null;
+      return null;
+    }
+  }
+  static get wasmHashPool() {
+    if (!this.allowHashPooling || this._wasmHashPool === null) {
+      return null;
+    }
+    try {
+      return this._wasmHashPool = this._wasmHashPool ?? (this.wasmHashWorkerUrl ? this.createWorkerPool(this.wasmHashWorkerUrl, wasmHashFunc) : null);
+    } catch {
+      console.warn("Creating wasm hash worker failed");
+      this._wasmHashPool = null;
+      return null;
+    }
+  }
+  static createWorker(url, func) {
+    if (url) console.debug(`createWorker: ${url.href}`);
+    return assertEx(this.createBrowserWorker?.(url) ?? this.createNodeWorker?.(func), () => "Unable to create worker");
+  }
+  static async filterExcludeByHash(objs = [], hash) {
+    const hashes = Array.isArray(hash) ? hash : [hash];
+    const pairs = await this.hashPairs(objs);
+    return pairs.filter(([_, objHash]) => !hashes.includes(objHash))?.map((pair) => pair[0]);
+  }
+  static async filterIncludeByHash(objs = [], hash) {
+    const hashes = Array.isArray(hash) ? hash : [hash];
+    const pairs = await this.hashPairs(objs);
+    return pairs.filter(([_, objHash]) => hashes.includes(objHash))?.map((pair) => pair[0]);
+  }
+  static async findByHash(objs = [], hash) {
+    const pairs = await this.hashPairs(objs);
+    return pairs.find(([_, objHash]) => objHash === hash)?.[0];
+  }
+  /**
+   * Asynchronously hashes a payload
+   * @param obj A payload
+   * @returns The payload hash
+   */
+  static async hash(obj) {
+    const stringToHash = this.stringifyHashFields(obj);
+    const enc = new TextEncoder();
+    const data = enc.encode(stringToHash);
+    if (_ObjectHasher.allowSubtle) {
+      try {
+        const hashArray = await this.subtleHash(data);
+        return hexFromArrayBuffer(hashArray, { bitLength: 256 });
+      } catch {
+        _ObjectHasher.allowSubtle = false;
+      }
+    }
+    await this.wasmInitialized;
+    if (_ObjectHasher.wasmSupport.canUseWasm) {
+      try {
+        return await this.wasmHash(data);
+      } catch {
+        _ObjectHasher.wasmSupport.allowWasm = false;
+      }
+    }
+    throw new Error("No subtle or wasm hashing available");
+  }
+  static async hashBytes(bytes) {
+    const bytesArray = new Uint8Array(bytes);
+    if (_ObjectHasher.allowSubtle) {
+      const hashArray = await this.subtleHash(bytesArray);
+      return hexFromArrayBuffer(hashArray, { bitLength: 256 });
+    }
+    await this.wasmInitialized;
+    if (_ObjectHasher.wasmSupport.canUseWasm) {
+      return await this.wasmHash(bytesArray);
+    }
+    throw new Error("No subtle or wasm hashing available");
+  }
+  static hashFields(obj) {
+    const filtered = omitBy(obj, omitByPredicate("_"));
+    const cleaned = removeEmptyFields(filtered);
+    return sortFields(cleaned);
+  }
+  /**
+   * Creates an array of payload/hash tuples based on the payloads passed in
+   * @param objs Any array of payloads
+   * @returns An array of payload/hash tuples
+   */
+  static async hashPairs(objs) {
+    return await Promise.all(objs.map(async (obj) => [obj, await this.hash(obj)]));
+  }
+  /**
+   * Creates an array of payload hashes based on the payloads passed in
+   * @param objs Any array of payloads
+   * @returns An array of payload hashes
+   */
+  static async hashes(objs) {
+    return objs ? await Promise.all(objs.map((obj) => this.hash(obj))) : void 0;
+  }
+  /**
+   * Returns a clone of the payload that is JSON safe
+   * @param obj A payload
+   * @param meta Keeps underscore (meta) fields if set to true
+   * @returns Returns a clone of the payload that is JSON safe
+   */
+  static json(payload, meta = false) {
+    const source = meta ? payload : omitBy(payload, omitByPredicate("_"));
+    const cleaned = removeEmptyFields(source);
+    return sortFields(cleaned);
+  }
+  /** @deprecated us JSON instead */
+  static jsonPayload(payload, meta = false) {
+    return this.json(payload, meta);
+  }
+  static stringifyHashFields(obj) {
+    return JSON.stringify(this.hashFields(obj));
+  }
+  static async subtleHash(data) {
+    const pool = this.subtleHashPool;
+    if (pool === null) return await globalThis.crypto.subtle.digest("SHA-256", data);
+    const result = await pool.queue(async (thread) => await thread.hash(data));
+    return result;
+  }
+  static async wasmHash(data) {
+    const pool = this.wasmHashPool;
+    if (pool === null) return asHash(await sha256(data), true);
+    const result = await pool.queue(async (thread) => await thread.hash(data));
+    return result;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static createWorkerPool(url, func, size = 8) {
+    if (url) console.debug(`createWorkerPool: ${url.href}`);
+    const createFunc = () => spawn(this.createWorker(url, func));
+    return Pool(createFunc, size);
+  }
+  async hash() {
+    return await _ObjectHasher.hash(this.obj);
+  }
+  /**
+   * Returns a clone of the payload that is JSON safe
+   * @param meta Keeps underscore (meta) fields if set to true
+   * @returns Returns a clone of the payload that is JSON safe
+   */
+  json(meta = false) {
+    return _ObjectHasher.json(this.obj, meta);
+  }
+};
+
+// src/NodeObjectHasher.ts
+ObjectHasher.createNodeWorker = createNodeWorker;
+var NodeObjectHasher = class extends ObjectHasher {
+  static createNodeWorker = createNodeWorker;
+};
+export {
+  NodeObjectHasher as ObjectHasher,
+  hasEmptyFields,
+  removeEmptyFields,
+  sortFields
+};
+//# sourceMappingURL=index.mjs.map

package/dist/_pkg/hash/node/removeEmptyFields.d.ts

@@ -0,0 +1,3 @@
+import type { EmptyObject } from '@xylabs/sdk';
+export declare const removeEmptyFields: <T extends EmptyObject>(obj: T) => T;
+//# sourceMappingURL=removeEmptyFields.d.ts.map

package/dist/_pkg/hash/node/sortFields.d.ts

@@ -0,0 +1,3 @@
+import type { EmptyObject } from '@xylabs/sdk';
+export declare const sortFields: <T extends EmptyObject>(obj: T) => T;
+//# sourceMappingURL=sortFields.d.ts.map

package/dist/_pkg/hash/node/worker/index.d.ts

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

package/dist/_pkg/hash/node/worker/subtleHash.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=subtleHash.d.ts.map

package/dist/_pkg/hash/node/worker/subtleHashNode.d.ts

@@ -0,0 +1,2 @@
+export declare const subtleHashFunc: () => void;
+//# sourceMappingURL=subtleHashNode.d.ts.map

package/dist/_pkg/hash/node/worker/wasmHash.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=wasmHash.d.ts.map

package/dist/_pkg/hash/node/worker/wasmHashNode.d.ts

@@ -0,0 +1,2 @@
+export declare const wasmHashFunc: () => void;
+//# sourceMappingURL=wasmHashNode.d.ts.map

package/dist/_pkg/huri/neutral/Huri.d.ts

@@ -0,0 +1,33 @@
+import type { Hash } from '@xylabs/sdk';
+import type { XyoAddress } from '../../address/neutral/index.ts';
+import type { Payload } from '../../payload-model/neutral/index.ts';
+export type ObjectCategory = 'block' | 'payload';
+export type HuriFetchFunction = (huri: Huri) => Promise<Payload | undefined>;
+export interface HuriOptions {
+    archivistUri?: string;
+    token?: string;
+}
+export interface FetchedPayload<T extends Payload = Payload> {
+    huri?: Huri;
+    payload: T;
+}
+export declare class Huri<T extends Payload = Payload> {
+    private isHuri;
+    archive?: string;
+    archivist?: XyoAddress | string;
+    hash: Hash;
+    originalHref: string;
+    protocol?: string;
+    token?: string;
+    constructor(huri: Hash | Huri | string, { archivistUri, token }?: HuriOptions);
+    static fetch<T extends Payload = Payload>(huri: Huri): Promise<T | undefined>;
+    static isHuri(value: unknown): Huri<Payload> | undefined;
+    private static parsePath;
+    private static parseProtocol;
+    private parsePath;
+    private validateParse;
+    get href(): string;
+    fetch(): Promise<T | undefined>;
+    toString(): string;
+}
+//# sourceMappingURL=Huri.d.ts.map

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

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

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

@@ -0,0 +1,118 @@
+// src/Huri.ts
+import {
+  assertEx,
+  fetchJson,
+  isDefined,
+  isHash,
+  isString
+} from "@xylabs/sdk";
+import { AddressValue } from "../../account/neutral/index.mjs";
+var Huri = class _Huri {
+  isHuri = true;
+  archive;
+  archivist;
+  hash;
+  originalHref;
+  protocol;
+  token;
+  constructor(huri, { archivistUri, token } = {}) {
+    let huriString;
+    const existingHuri = _Huri.isHuri(huri);
+    if (existingHuri) {
+      huriString = existingHuri.href;
+    } else if (typeof huri === "string") {
+      huriString = huri;
+    } else if (huri instanceof ArrayBuffer) {
+      const addressValue = new AddressValue(huri);
+      huriString = addressValue.hex;
+    } else {
+      huriString = huri.href;
+    }
+    this.originalHref = huriString;
+    const protocol = _Huri.parseProtocol(huriString);
+    this.protocol = protocol ?? "https";
+    const path = assertEx(_Huri.parsePath(huriString), () => "Missing path");
+    this.hash = assertEx(this.parsePath(path, protocol !== void 0), () => "Missing hash");
+    assertEx(isHash(this.hash), () => `Invalid hash [${this.hash}]`);
+    if (isString(archivistUri)) {
+      const archivistUriParts = archivistUri.split("://");
+      this.protocol = archivistUriParts[0];
+      this.archivist = archivistUriParts[1];
+    }
+    this.token = token;
+    this.validateParse();
+  }
+  static async fetch(huri) {
+    const headers = isDefined(huri.token) ? { Authorization: `Bearer ${huri.token}` } : void 0;
+    const response = await fetchJson(huri.href, { headers });
+    return response.data ?? void 0;
+  }
+  static isHuri(value) {
+    if (typeof value === "object") {
+      return value.isHuri ? value : void 0;
+    }
+  }
+  static parsePath(huri) {
+    const protocolSplit = huri.split("//");
+    assertEx(protocolSplit.length <= 2, () => `Invalid format [${huri}]`);
+    if (protocolSplit.length === 1) {
+      return huri;
+    }
+    if (protocolSplit.length === 2) {
+      return protocolSplit[1];
+    }
+  }
+  static parseProtocol(huri) {
+    const protocolSplit = huri.split("//");
+    assertEx(protocolSplit.length <= 2, () => `Invalid second protocol [${protocolSplit[2]}]`);
+    const rawProtocol = protocolSplit.length === 2 ? protocolSplit.shift() : void 0;
+    if (isString(rawProtocol)) {
+      const protocolParts = rawProtocol?.split(":");
+      assertEx(protocolParts.length === 2, () => `Invalid protocol format [${rawProtocol}]`);
+      assertEx(protocolParts[1].length === 0, () => `Invalid protocol format (post :) [${rawProtocol}]`);
+      return protocolParts.shift();
+    }
+  }
+  parsePath(path, hasProtocol) {
+    const pathParts = path.split("/");
+    assertEx(!(hasProtocol && pathParts[0].length === 0), () => "Invalid protocol separator");
+    pathParts[0].length === 0 ? pathParts.shift() : null;
+    const hash = assertEx(pathParts.pop(), () => "No hash specified");
+    this.archivist = pathParts.shift() ?? "api.archivist.xyo.network";
+    this.archive = pathParts.pop();
+    assertEx(pathParts.length === 0, () => "Too many path parts");
+    return hash;
+  }
+  validateParse() {
+    assertEx(this.archivist?.length !== 0, () => "Invalid archivist length");
+    assertEx(this.archive?.length !== 0, () => "Invalid archive length");
+    assertEx(!(isString(this.archive) && !isString(this.archivist)), () => "If specifying archive, archivist is also required");
+  }
+  /*
+  The full href or the hash
+  */
+  get href() {
+    const parts = [];
+    if (isDefined(this.protocol)) {
+      parts.push(`${this.protocol}:/`);
+    }
+    if (isDefined(this.archive)) {
+      parts.push(this.archive);
+    }
+    if (isDefined(this.archivist)) {
+      parts.push(this.archivist);
+    }
+    parts.push(this.hash);
+    return parts.join("/");
+  }
+  async fetch() {
+    return await _Huri.fetch(this);
+  }
+  toString() {
+    return this.href;
+  }
+};
+export {
+  Huri
+};
+//# sourceMappingURL=index.mjs.map

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

@@ -0,0 +1,86 @@
+import type { WithSources } from '../../payload-model/neutral/index.ts';
+import * as z from 'zod/mini';
+/**
+ * The fields of an ID Payload
+ */
+export interface IdFields {
+    salt: string;
+}
+export declare const IdPayloadZod: z.ZodMiniObject<{
+    schema: z.ZodMiniLiteral<"network.xyo.id" & {
+        readonly __schema: true;
+    }>;
+    salt: z.ZodMiniString<string>;
+}, z.core.$strip>;
+/**
+ * The ID Payload
+ */
+export type Id = z.infer<typeof IdPayloadZod>;
+/**
+ * @deprecated Use `Id` instead
+ */
+export type IdPayload = Id;
+/**
+ * Identity helpers for ID Payload
+ */
+export declare const isId: <T>(value: T) => value is T & {
+    schema: "network.xyo.id" & {
+        readonly __schema: true;
+    };
+    salt: string;
+};
+export declare const asId: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.id" & {
+            readonly __schema: true;
+        };
+        salt: string;
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
+        schema: "network.xyo.id" & {
+            readonly __schema: true;
+        };
+        salt: string;
+    };
+};
+export declare const toId: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.id" & {
+            readonly __schema: true;
+        };
+        salt: string;
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
+        schema: "network.xyo.id" & {
+            readonly __schema: true;
+        };
+        salt: string;
+    };
+};
+/**
+ * @deprecated Use `asId` instead (returns undefined on failure when called without an assert config)
+ */
+export declare const asOptionalId: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.id" & {
+            readonly __schema: true;
+        };
+        salt: string;
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
+        schema: "network.xyo.id" & {
+            readonly __schema: true;
+        };
+        salt: string;
+    };
+};
+/**
+ * Identity helper for ID Payload with sources
+ */
+export declare const isIdWithSources: (x?: unknown) => x is WithSources<WithSources<{
+    schema: "network.xyo.id" & {
+        readonly __schema: true;
+    };
+    salt: string;
+}>>;
+//# sourceMappingURL=Payload.d.ts.map

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,48 @@
+// src/Payload.ts
+import {
+  zodAsFactory,
+  zodIsFactory,
+  zodToFactory
+} from "@xylabs/sdk";
+import { isPayloadOfSchemaTypeWithSources, 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 IdSchema = asSchema("network.xyo.id", true);
+
+// src/Payload.ts
+var IdPayloadZod = z.extend(PayloadZodOfSchema(IdSchema), { salt: z.string() });
+var isId = zodIsFactory(IdPayloadZod);
+var asId = zodAsFactory(IdPayloadZod, "asId");
+var toId = zodToFactory(IdPayloadZod, "toId");
+var asOptionalId = asId;
+var isIdWithSources = isPayloadOfSchemaTypeWithSources(IdSchema);
+
+// src/Plugin.ts
+import { createPayloadPlugin } from "../../payload-plugin/neutral/index.mjs";
+
+// src/Template.ts
+var idPayloadTemplate = () => ({
+  salt: "",
+  schema: IdSchema
+});
+
+// src/Plugin.ts
+var IdPayloadPlugin = () => createPayloadPlugin({
+  schema: IdSchema,
+  template: idPayloadTemplate
+});
+export {
+  IdPayloadPlugin,
+  IdPayloadZod,
+  IdSchema,
+  asId,
+  asOptionalId,
+  IdPayloadPlugin as default,
+  idPayloadTemplate,
+  isId,
+  isIdWithSources,
+  toId
+};
+//# sourceMappingURL=index.mjs.map

package/dist/_pkg/key-model/neutral/Key/AddressValue.d.ts

@@ -0,0 +1,10 @@
+import type { EllipticKeyInstance } from './EllipticKey.ts';
+export interface AddressValueInstance extends EllipticKeyInstance {
+}
+export interface AddressValueStatic {
+    new (address: ArrayBuffer): AddressValueInstance;
+    addressFromAddressOrPublicKey(bytes: ArrayBufferLike): ArrayBufferLike;
+    addressFromPublicKey(key: ArrayBufferLike): ArrayBufferLike;
+    isAddress(value: unknown): boolean;
+}
+//# sourceMappingURL=AddressValue.d.ts.map

package/dist/_pkg/key-model/neutral/Key/EllipticKey.d.ts

@@ -0,0 +1,4 @@
+import type { DataInstance } from '../../../data/neutral/index.ts';
+export interface EllipticKeyInstance extends DataInstance {
+}
+//# sourceMappingURL=EllipticKey.d.ts.map

package/dist/_pkg/key-model/neutral/Key/PrivateKey.d.ts

@@ -0,0 +1,15 @@
+import type { EllipticKeyInstance } from './EllipticKey.ts';
+import type { PublicKeyInstance } from './PublicKey.ts';
+export interface PrivateKeyConfig {
+    privateKeyData?: ArrayBufferLike;
+}
+export interface PrivateKeyInstance extends EllipticKeyInstance {
+    public: PublicKeyInstance;
+    sign: (hash: ArrayBufferLike) => ArrayBufferLike | Promise<ArrayBufferLike>;
+    verify: (msg: ArrayBufferLike, signature: ArrayBufferLike) => boolean | Promise<boolean>;
+}
+export interface PrivateKeyStatic {
+    create(value: ArrayBufferLike | bigint): Promise<PrivateKeyInstance>;
+    isPrivateKey(value: unknown): boolean;
+}
+//# sourceMappingURL=PrivateKey.d.ts.map

package/dist/_pkg/key-model/neutral/Key/PublicKey.d.ts

@@ -0,0 +1,11 @@
+import type { AddressValueInstance } from './AddressValue.ts';
+import type { EllipticKeyInstance } from './EllipticKey.ts';
+export interface PublicKeyInstance extends EllipticKeyInstance {
+    get address(): AddressValueInstance;
+    verify(msg: ArrayBufferLike, signature: ArrayBufferLike): boolean | Promise<boolean>;
+}
+export interface PublicKeyStatic {
+    create(bytes: ArrayBufferLike): Promise<PublicKeyInstance>;
+    isPublicKey(value: unknown): boolean;
+}
+//# sourceMappingURL=PublicKey.d.ts.map

package/dist/_pkg/key-model/neutral/Key/index.d.ts

@@ -0,0 +1,4 @@
+export * from './AddressValue.ts';
+export * from './PrivateKey.ts';
+export * from './PublicKey.ts';
+//# sourceMappingURL=index.d.ts.map