@xyo-network/sdk 7.0.3 → 7.0.5

package/dist/_pkg/schema-cache/neutral/SchemaCache.d.ts

@@ -1,42 +0,0 @@
-import type { SchemaResolution, SchemaResolutionSource } from '../../domain-payload-plugin/neutral/index.ts';
-import type { FetchedPayload } from '../../huri/neutral/index.ts';
-import type { SchemaPayload } from '../../schema-payload-plugin/neutral/index.ts';
-import type { SchemaNameToValidatorMap } from './SchemaNameToValidatorMap.ts';
-export interface SchemaCacheEntry extends FetchedPayload<SchemaPayload> {
-    /** Provenance of the schema definition when resolved via the domain schema authority */
-    source?: SchemaResolutionSource;
-}
-export declare class SchemaCache<T extends SchemaNameToValidatorMap = SchemaNameToValidatorMap> {
-    /**
-     * Object representing `null` since LRU Cache types
-     * only allow for types that derive from object
-     */
-    protected static readonly NULL: SchemaCacheEntry;
-    private static _instance?;
-    private _cache;
-    private _resolutions;
-    private _validators;
-    private getDebounce;
-    onSchemaCached?: (name: string, entry: SchemaCacheEntry) => void;
-    proxy?: string;
-    private constructor();
-    static get instance(): SchemaCache<SchemaNameToValidatorMap>;
-    private cacheSchemaIfValid;
-    private cacheSchemas;
-    private fetchSchema;
-    /**
-     * A map of cached schema (by name) to payload validators for the schema. A schema
-     * must be cached via `get('schema.name')` before it's validator can be used as
-     * they are compiled dynamically at runtime upon retrieval.
-     */
-    get validators(): T;
-    get(schema?: string): Promise<SchemaCacheEntry | undefined | null>;
-    /**
-     * Resolve a schema name to its domain-published authoritative definition (SPEC.md in
-     * @xyo-network/domain-payload-plugin), with provenance and a richer status than get():
-     * 'resolved' | 'not-published' | 'unreachable'. Resolved definitions are cached and
-     * their validators compiled, exactly as with get(). 'unreachable' results are
-     * retryable: they are not cached as permanent negatives.
-     */
-    resolve(schema?: string): Promise<SchemaResolution | undefined>;
-}

package/dist/_pkg/schema-cache/neutral/SchemaNameToValidatorMap.d.ts

@@ -1,11 +0,0 @@
-import type { Payload } from '../../payload-model/neutral/index.ts';
-/**
- * Used in conjunction with schema validation to support compile time type assertion
- * for known schema types.
- */
-export type NarrowPayload<T extends Payload = Payload> = ((x: Payload) => x is T) | undefined;
-/**
- * Used to map known schemas (byt their string name) to the validators which assert their types
- */
-export interface SchemaNameToValidatorMap {
-}

package/dist/_pkg/schema-cache/neutral/TtlLruCache.d.ts

@@ -1,12 +0,0 @@
-export interface TtlLruCacheOpts {
-    max: number;
-    ttl: number;
-}
-export declare class TtlLruCache<K, V> {
-    private readonly map;
-    private readonly max;
-    private readonly ttl;
-    constructor(opts: TtlLruCacheOpts);
-    get(key: K): V | undefined;
-    set(key: K, value: V): void;
-}

package/dist/_pkg/schema-cache/neutral/index.d.ts

@@ -1,4 +0,0 @@
-export * from './Debounce.ts';
-export * from './SchemaCache.ts';
-export * from './SchemaNameToValidatorMap.ts';
-export * from './TtlLruCache.ts';

package/dist/_pkg/schema-cache/neutral/index.mjs

@@ -1,177 +0,0 @@
-// src/Debounce.ts
-import { delay, isDefined } from "@xylabs/sdk";
-var Debounce = class {
-  map = /* @__PURE__ */ new Map();
-  async one(key, closure, timeout = 1e4) {
-    const startTime = Date.now();
-    while (isDefined(this.map.get(key))) {
-      await delay(100);
-      if (Date.now() - startTime > timeout) {
-        throw new Error(`Debounce timed out [${String(key)}]`);
-      }
-    }
-    try {
-      this.map.set(key, 1);
-      return await closure();
-    } finally {
-      this.map.delete(key);
-    }
-  }
-};
-
-// src/SchemaCache.ts
-import {
-  FetchClientError,
-  handleError,
-  isDefined as isDefined2,
-  isString
-} from "@xylabs/sdk";
-import { DomainPayloadWrapper, DomainSchemaResolver } from "../../domain-payload-plugin/neutral/index.mjs";
-import { SchemaSchema } from "../../schema-payload-plugin/neutral/index.mjs";
-import { Ajv } from "ajv";
-
-// src/TtlLruCache.ts
-var TtlLruCache = class {
-  map = /* @__PURE__ */ new Map();
-  max;
-  ttl;
-  constructor(opts) {
-    this.max = opts.max;
-    this.ttl = opts.ttl;
-  }
-  get(key) {
-    const entry = this.map.get(key);
-    if (entry === void 0) return void 0;
-    if (entry.expires <= Date.now()) {
-      this.map.delete(key);
-      return void 0;
-    }
-    this.map.delete(key);
-    this.map.set(key, entry);
-    return entry.value;
-  }
-  set(key, value) {
-    if (this.map.has(key)) this.map.delete(key);
-    this.map.set(key, { value, expires: Date.now() + this.ttl });
-    if (this.map.size > this.max) {
-      const oldest = this.map.keys().next().value;
-      if (oldest !== void 0) this.map.delete(oldest);
-    }
-  }
-};
-
-// src/SchemaCache.ts
-var getSchemaNameFromSchema = (schema) => {
-  if (isString(schema.$id)) {
-    return schema.$id;
-  }
-};
-var SchemaCache = class _SchemaCache {
-  /**
-   * Object representing `null` since LRU Cache types
-   * only allow for types that derive from object
-   */
-  static NULL = { payload: { definition: {}, schema: SchemaSchema } };
-  static _instance;
-  _cache = new TtlLruCache({ max: 500, ttl: 1e3 * 60 * 5 });
-  _resolutions = new TtlLruCache({ max: 500, ttl: 1e3 * 60 * 5 });
-  _validators = {};
-  // prevents double discovery
-  getDebounce = new Debounce();
-  onSchemaCached;
-  proxy;
-  constructor(proxy) {
-    this.proxy = proxy;
-  }
-  static get instance() {
-    this._instance ??= new _SchemaCache();
-    return this._instance;
-  }
-  cacheSchemaIfValid(entry) {
-    if (!isDefined2(entry?.payload?.definition)) {
-      return;
-    }
-    const ajv = new Ajv({ strict: false });
-    const validator = ajv.compile(entry.payload.definition);
-    const schemaName = getSchemaNameFromSchema(entry.payload.definition);
-    if (isString(schemaName)) {
-      this._cache.set(schemaName, entry);
-      const key = schemaName;
-      this._validators[key] = validator;
-      this.onSchemaCached?.(schemaName, entry);
-    }
-  }
-  cacheSchemas(aliasEntries) {
-    for (const entry of aliasEntries?.filter((entry2) => entry2.payload.schema === SchemaSchema) ?? []) {
-      this.cacheSchemaIfValid(entry);
-    }
-  }
-  async fetchSchema(schema) {
-    try {
-      const resolution = await this.resolve(schema);
-      if (resolution?.status === "resolved") {
-        return;
-      }
-      const domain = await DomainPayloadWrapper.discover(schema, this.proxy);
-      await domain?.fetch();
-      this.cacheSchemas(domain?.aliases);
-      if (this._cache.get(schema) === void 0 && resolution?.status !== "unreachable") {
-        this._cache.set(schema, _SchemaCache.NULL);
-      }
-    } catch (error) {
-      if (error instanceof FetchClientError) {
-        console.log(`Fetch Url: ${error.config.url}`);
-      }
-      handleError(error, (error2) => {
-        console.error(`fetchSchema threw: ${error2.message}`);
-      });
-    }
-  }
-  /**
-   * A map of cached schema (by name) to payload validators for the schema. A schema
-   * must be cached via `get('schema.name')` before it's validator can be used as
-   * they are compiled dynamically at runtime upon retrieval.
-   */
-  get validators() {
-    return this._validators;
-  }
-  async get(schema) {
-    if (isString(schema)) {
-      await this.getDebounce.one(schema, async () => {
-        if (this._cache.get(schema) === void 0) {
-          await this.fetchSchema(schema);
-        }
-      });
-      const value = this._cache.get(schema);
-      return value === _SchemaCache.NULL ? null : value;
-    }
-    return void 0;
-  }
-  /**
-   * Resolve a schema name to its domain-published authoritative definition (SPEC.md in
-   * @xyo-network/domain-payload-plugin), with provenance and a richer status than get():
-   * 'resolved' | 'not-published' | 'unreachable'. Resolved definitions are cached and
-   * their validators compiled, exactly as with get(). 'unreachable' results are
-   * retryable: they are not cached as permanent negatives.
-   */
-  async resolve(schema) {
-    if (!isString(schema)) return void 0;
-    await this.getDebounce.one(`resolve:${schema}`, async () => {
-      const existing = this._resolutions.get(schema);
-      if (existing === void 0 || existing.status === "unreachable") {
-        const resolver = new DomainSchemaResolver();
-        const resolution = await resolver.resolve(schema, { proxy: this.proxy });
-        this._resolutions.set(schema, resolution);
-        if (resolution.status === "resolved" && isDefined2(resolution.payload)) {
-          this.cacheSchemaIfValid({ payload: resolution.payload, source: resolution.source });
-        }
-      }
-    });
-    return this._resolutions.get(schema);
-  }
-};
-export {
-  Debounce,
-  SchemaCache,
-  TtlLruCache
-};

package/dist/_pkg/schema-name-validator/neutral/SchemaNameValidator.d.ts

@@ -1,42 +0,0 @@
-/**
- * Validates a XYO schema name's structure
- */
-export declare class SchemaNameValidator {
-    private _parts?;
-    private _rootDomain?;
-    private _schema?;
-    constructor(schema?: string);
-    /**
-     * Checks whether the schema is all lowercase
-     *
-     * @returns boolean
-     */
-    get isLowercase(): boolean;
-    /**
-     * Levels in the schema
-     *
-     * @returns number
-     */
-    get levels(): number | undefined;
-    /**
-     * The schema converted into a string array split on '.'
-     *
-     * @returns string[]
-     */
-    get parts(): string[] | undefined;
-    /**
-     * The rootDomain is the first two levels of the schema, in reverse order
-     * This can be used to determine who 'owns' that schema, based on domain
-     * registration
-     *
-     * @returns string
-     */
-    get rootDomain(): string | undefined;
-    get schema(): string | undefined;
-    set schema(schema: string | undefined);
-    /**
-     * Run all static validations
-     * @returns Error[]
-     */
-    all(): Error[];
-}

package/dist/_pkg/schema-name-validator/neutral/index.d.ts

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

package/dist/_pkg/schema-name-validator/neutral/index.mjs

@@ -1,68 +0,0 @@
-// src/SchemaNameValidator.ts
-var SchemaNameValidator = class {
-  _parts;
-  _rootDomain;
-  _schema;
-  constructor(schema) {
-    this._schema = schema;
-  }
-  /**
-   * Checks whether the schema is all lowercase
-   *
-   * @returns boolean
-   */
-  get isLowercase() {
-    return this.schema === this.schema?.toLowerCase();
-  }
-  /**
-   * Levels in the schema
-   *
-   * @returns number
-   */
-  get levels() {
-    return this.parts?.length;
-  }
-  /**
-   * The schema converted into a string array split on '.'
-   *
-   * @returns string[]
-   */
-  get parts() {
-    this._parts = this._parts ?? this.schema?.split(".");
-    return this._parts;
-  }
-  /**
-   * The rootDomain is the first two levels of the schema, in reverse order
-   * This can be used to determine who 'owns' that schema, based on domain
-   * registration
-   *
-   * @returns string
-   */
-  get rootDomain() {
-    this._rootDomain = this._rootDomain ?? domainLevel(this, 1);
-    return this._rootDomain;
-  }
-  get schema() {
-    return this._schema;
-  }
-  set schema(schema) {
-    this._schema = schema;
-  }
-  /**
-   * Run all static validations
-   * @returns Error[]
-   */
-  all() {
-    const errors = [];
-    if ((this.schema?.length ?? 0) === 0) errors.push(new Error("schema missing"));
-    else if ((this.levels ?? 0) < 3) errors.push(new Error(`schema levels < 3 [${this.levels}, ${this.schema}]`));
-    else if (!this.isLowercase) errors.push(new Error(`schema not lowercase [${this.schema}]`));
-    return errors;
-  }
-};
-function domainLevel(validator, level) {
-  return validator.parts?.slice(0, level + 1).toReversed().join(".");
-}
-export {
-  SchemaNameValidator
-};

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

@@ -1,95 +0,0 @@
-import * as z from 'zod/mini';
-export declare const SchemaPayloadZod: z.ZodMiniObject<{
-    schema: z.ZodMiniLiteral<"network.xyo.schema" & {
-        readonly __schema: true;
-    }>;
-    definition: z.ZodMiniObject<{
-        $id: z.ZodMiniOptional<z.ZodMiniString<string>>;
-    }, z.core.$loose>;
-    extends: z.ZodMiniOptional<z.ZodMiniString<string>>;
-    name: z.ZodMiniOptional<z.ZodMiniString<string>>;
-    version: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
-}, z.core.$strip>;
-export type SchemaPayload = z.infer<typeof SchemaPayloadZod>;
-/**
- * Identity function for determining if an object is a Schema
- */
-export declare const isSchemaPayload: <T>(value: T) => value is T & {
-    schema: "network.xyo.schema" & {
-        readonly __schema: true;
-    };
-    definition: {
-        [x: string]: unknown;
-        $id?: string | undefined;
-    };
-    extends?: string | undefined;
-    name?: string | undefined;
-    version?: number | undefined;
-};
-export declare const asSchemaPayload: {
-    <T>(value: T): (T & {
-        schema: "network.xyo.schema" & {
-            readonly __schema: true;
-        };
-        definition: {
-            [x: string]: unknown;
-            $id?: string | undefined;
-        };
-        extends?: string | undefined;
-        name?: string | undefined;
-        version?: number | undefined;
-    }) | undefined;
-    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
-        schema: "network.xyo.schema" & {
-            readonly __schema: true;
-        };
-        definition: {
-            [x: string]: unknown;
-            $id?: string | undefined;
-        };
-        extends?: string | undefined;
-        name?: string | undefined;
-        version?: number | undefined;
-    };
-};
-export declare const toSchemaPayload: {
-    <T>(value: T): (T & {
-        schema: "network.xyo.schema" & {
-            readonly __schema: true;
-        };
-        definition: {
-            [x: string]: unknown;
-            $id?: string | undefined;
-        };
-        extends?: string | undefined;
-        name?: string | undefined;
-        version?: number | undefined;
-    }) | undefined;
-    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
-        schema: "network.xyo.schema" & {
-            readonly __schema: true;
-        };
-        definition: {
-            [x: string]: unknown;
-            $id?: string | undefined;
-        };
-        extends?: string | undefined;
-        name?: string | undefined;
-        version?: number | undefined;
-    };
-};
-/**
- * Identity function for determining if an object is a Schema with sources
- */
-export declare const isSchemaPayloadWithSources: (x?: unknown) => x is import("../../payload-model/neutral/index.ts").WithSources<{
-    schema: "network.xyo.schema" & {
-        readonly __schema: true;
-    };
-    definition: {
-        [x: string]: unknown;
-        $id?: string | undefined;
-    };
-    extends?: string | undefined;
-    name?: string | undefined;
-    version?: number | undefined;
-}>;

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

@@ -1,12 +0,0 @@
-export declare const SchemaPayloadPlugin: () => import("../../payload-plugin/neutral/index.ts").PayloadPlugin<{
-    schema: "network.xyo.schema" & {
-        readonly __schema: true;
-    };
-    definition: {
-        [x: string]: unknown;
-        $id?: string | undefined;
-    };
-    extends?: string | undefined;
-    name?: string | undefined;
-    version?: number | undefined;
-}>;

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

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

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

@@ -1,2 +0,0 @@
-import type { SchemaPayload } from './Payload.ts';
-export declare const schemaPayloadTemplate: () => SchemaPayload;

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

@@ -1,4 +0,0 @@
-export * from './Payload.ts';
-export { SchemaPayloadPlugin as default, SchemaPayloadPlugin } from './Plugin.ts';
-export * from './Schema.ts';
-export * from './Template.ts';

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

@@ -1,59 +0,0 @@
-// 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 SchemaSchema = asSchema("network.xyo.schema", true);
-
-// src/Payload.ts
-var optionalStringZod = z.optional(z.string());
-var schemaDefinitionZod = z.looseObject({ $id: optionalStringZod });
-var SchemaPayloadZod = z.extend(PayloadZodOfSchema(SchemaSchema), {
-  /** The schema definition body (JSON Schema); `$id`, when present, identifies the schema */
-  definition: schemaDefinitionZod,
-  /** The schema this schema extends (if any) */
-  extends: z.optional(z.string()),
-  /** @deprecated use definition.$id instead */
-  name: z.optional(z.string()),
-  /** The version of the schema major * 1,000,000 + minor * 1,000 + patch */
-  version: z.optional(z.number())
-});
-var isSchemaPayload = zodIsFactory(SchemaPayloadZod);
-var asSchemaPayload = zodAsFactory(SchemaPayloadZod, "asSchemaPayload");
-var toSchemaPayload = zodToFactory(SchemaPayloadZod, "toSchemaPayload");
-var isSchemaPayloadWithSources = isPayloadOfSchemaTypeWithSources(SchemaSchema);
-
-// src/Plugin.ts
-import { createPayloadPlugin } from "../../payload-plugin/neutral/index.mjs";
-
-// src/Template.ts
-var schemaPayloadTemplate = () => ({
-  definition: {
-    $id: "",
-    $schema: "http://json-schema.org/draft-07/schema#"
-  },
-  schema: SchemaSchema
-});
-
-// src/Plugin.ts
-var SchemaPayloadPlugin = () => createPayloadPlugin({
-  schema: SchemaSchema,
-  template: schemaPayloadTemplate
-});
-export {
-  SchemaPayloadPlugin,
-  SchemaPayloadZod,
-  SchemaSchema,
-  asSchemaPayload,
-  SchemaPayloadPlugin as default,
-  isSchemaPayload,
-  isSchemaPayloadWithSources,
-  schemaPayloadTemplate,
-  toSchemaPayload
-};

package/dist/_pkg/sdk-protocol/_pkg/account/neutral/Account.d.ts

@@ -1,37 +0,0 @@
-import type { Hash } from '@xylabs/sdk';
-import type { AccountAlgorithm, AccountConfig, AccountInstance, JwtParts, SignJwtOptions, SignJwtResult, VerifyJwtOptions, VerifyJwtResult } from '../../account-model/neutral/index.ts';
-import type { XyoAddress } from '../../address/neutral/index.ts';
-import type { PrivateKeyInstance, PublicKeyInstance } from '../../key-model/neutral/index.ts';
-import type { PreviousHashStore } from '../../previous-hash-store-model/neutral/index.ts';
-import { HDNodeWallet } from 'ethers';
-import { EllipticKey } from './Key/index.ts';
-export declare class Account extends EllipticKey implements AccountInstance {
-    static previousHashStore: PreviousHashStore | undefined;
-    static readonly uniqueName: string;
-    protected static _addressMap: Record<string, WeakRef<AccountInstance>>;
-    protected static _protectedConstructorKey: symbol;
-    private readonly _privateKey;
-    private readonly _signingMutex;
-    protected _node: HDNodeWallet | undefined;
-    protected _previousHash?: ArrayBufferLike;
-    readonly algorithm: AccountAlgorithm;
-    protected constructor(key: unknown, privateKey: PrivateKeyInstance, node?: HDNodeWallet);
-    static create(opts?: AccountConfig): Promise<AccountInstance>;
-    static decodeJwt(token: string): JwtParts;
-    static fromPrivateKey(key: ArrayBufferLike | bigint | string): Promise<AccountInstance>;
-    static isAddress(address: XyoAddress): boolean;
-    static random(): Promise<AccountInstance>;
-    static verifyJwt(token: string, options?: VerifyJwtOptions): Promise<VerifyJwtResult>;
-    get address(): XyoAddress;
-    get addressBytes(): ArrayBufferLike;
-    get previousHash(): import("@xylabs/sdk").BrandedHash | undefined;
-    get previousHashBytes(): ArrayBufferLike | undefined;
-    get private(): PrivateKeyInstance;
-    get public(): PublicKeyInstance;
-    initialize(): Promise<this>;
-    loadPreviousHash(previousHash?: ArrayBufferLike | string): Promise<this>;
-    sign(hash: ArrayBufferLike, previousHash: ArrayBufferLike | undefined): Promise<[ArrayBufferLike, Hash?]>;
-    signJwt(options: SignJwtOptions): Promise<SignJwtResult>;
-    verify(msg: ArrayBufferLike, signature: ArrayBufferLike): Promise<boolean>;
-    verifyUniqueAddress(): AccountInstance | this;
-}

package/dist/_pkg/sdk-protocol/_pkg/account/neutral/Jwt/base64url.d.ts

@@ -1,4 +0,0 @@
-export declare function base64urlEncode(bytes: Uint8Array): string;
-export declare function base64urlDecode(value: string): Uint8Array;
-export declare function base64urlEncodeJson(value: unknown): string;
-export declare function base64urlDecodeJson<T>(value: string): T;

package/dist/_pkg/sdk-protocol/_pkg/account/neutral/Jwt/createJwt.d.ts

@@ -1,2 +0,0 @@
-import type { AccountInstance, SignJwtOptions, SignJwtResult } from '../../../account-model/neutral/index.ts';
-export declare function createJwt(account: AccountInstance, options: SignJwtOptions): Promise<SignJwtResult>;

package/dist/_pkg/sdk-protocol/_pkg/account/neutral/Jwt/decodeJwt.d.ts

@@ -1,2 +0,0 @@
-import type { JwtParts } from '../../../account-model/neutral/index.ts';
-export declare function decodeJwt(token: string): JwtParts;

package/dist/_pkg/sdk-protocol/_pkg/account/neutral/Jwt/digest.d.ts

@@ -1,3 +0,0 @@
-export declare function sha256Bytes(input: Uint8Array): Uint8Array;
-export declare function stripHexPrefix(value: string): string;
-export declare function normalizeAddress(value: string): string;

package/dist/_pkg/sdk-protocol/_pkg/account/neutral/Jwt/index.d.ts

@@ -1,5 +0,0 @@
-export * from './base64url.ts';
-export * from './createJwt.ts';
-export * from './decodeJwt.ts';
-export * from './digest.ts';
-export * from './verifyJwt.ts';

package/dist/_pkg/sdk-protocol/_pkg/account/neutral/Jwt/verifyJwt.d.ts

@@ -1,2 +0,0 @@
-import type { VerifyJwtOptions, VerifyJwtResult } from '../../../account-model/neutral/index.ts';
-export declare function verifyJwt(token: string, options?: VerifyJwtOptions): Promise<VerifyJwtResult>;

package/dist/_pkg/sdk-protocol/_pkg/account/neutral/Key/AddressValue.d.ts

@@ -1,10 +0,0 @@
-import type { AddressValueInstance } from '../../../key-model/neutral/index.ts';
-import { EllipticKey } from './EllipticKey.ts';
-export declare class AddressValue extends EllipticKey implements AddressValueInstance {
-    private _isAddress;
-    constructor(address: ArrayBufferLike);
-    static addressFromAddressOrPublicKey(bytes: ArrayBufferLike): ArrayBufferLike;
-    static addressFromPublicKey(key: ArrayBufferLike): ArrayBufferLike;
-    static initialize(): Promise<boolean>;
-    static isAddress(value: unknown): boolean;
-}

package/dist/_pkg/sdk-protocol/_pkg/account/neutral/Key/EllipticKey.d.ts

@@ -1,3 +0,0 @@
-import { Data } from '../../../data/neutral/index.ts';
-export declare class EllipticKey extends Data {
-}

package/dist/_pkg/sdk-protocol/_pkg/account/neutral/Key/PrivateKey.d.ts

@@ -1,13 +0,0 @@
-import type { PrivateKeyInstance, PublicKeyInstance } from '../../../key-model/neutral/index.ts';
-import { EllipticKey } from './EllipticKey.ts';
-export declare class PrivateKey extends EllipticKey implements PrivateKeyInstance {
-    protected static privateConstructorKey: string;
-    protected _isPrivateKey: boolean;
-    protected _public: PublicKeyInstance;
-    protected constructor(privateConstructorKey: string, value: ArrayBufferLike, publicKey: PublicKeyInstance);
-    static create(value: ArrayBufferLike | bigint): Promise<PrivateKey>;
-    static isPrivateKey(value: unknown): boolean;
-    get public(): PublicKeyInstance;
-    sign(hash: ArrayBufferLike): Promise<ArrayBufferLike>;
-    verify(msg: ArrayBufferLike, signature: ArrayBufferLike): Promise<boolean>;
-}

package/dist/_pkg/sdk-protocol/_pkg/account/neutral/Key/PublicKey.d.ts

@@ -1,13 +0,0 @@
-import type { AddressValueInstance, PublicKeyInstance } from '../../../key-model/neutral/index.ts';
-import { EllipticKey } from './EllipticKey.ts';
-export declare class PublicKey extends EllipticKey implements PublicKeyInstance {
-    protected static privateConstructorKey: string;
-    private _address;
-    private _isPublicKey;
-    protected constructor(privateConstructorKey: string, bytes: ArrayBufferLike);
-    static create(bytes: ArrayBufferLike): Promise<PublicKey>;
-    static fromPrivate(bytes: ArrayBufferLike | bigint): Promise<PublicKeyInstance>;
-    static isPublicKey(value: unknown): boolean;
-    get address(): AddressValueInstance;
-    verify(msg: ArrayBuffer, signature: ArrayBuffer): Promise<boolean>;
-}

package/dist/_pkg/sdk-protocol/_pkg/account/neutral/Key/index.d.ts

@@ -1,4 +0,0 @@
-export * from './AddressValue.ts';
-export * from './EllipticKey.ts';
-export * from './PrivateKey.ts';
-export * from './PublicKey.ts';