@xyo-network/sdk-protocol 7.0.4

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

@@ -0,0 +1,67 @@
+// src/createPlugin.ts
+import { assertEx } from "@xylabs/sdk";
+import { PayloadBuilder } from "../../payload-builder/neutral/index.mjs";
+import { PayloadValidator } from "../../payload-validator/neutral/index.mjs";
+import { PayloadWrapper } from "../../payload-wrapper/neutral/index.mjs";
+var defaultPayloadPluginFunctions = (schema) => {
+  return {
+    build: () => {
+      return new PayloadBuilder({ schema });
+    },
+    schema,
+    validate: (payload) => {
+      return new PayloadValidator(payload);
+    },
+    wrap: (payload) => {
+      return PayloadWrapper.wrap(payload);
+    }
+  };
+};
+var createPayloadPlugin = (plugin) => {
+  return {
+    ...defaultPayloadPluginFunctions(assertEx(plugin.schema, () => "schema field required to create plugin")),
+    ...plugin
+  };
+};
+
+// src/Resolver.ts
+import { isDefined } from "@xylabs/sdk";
+import { PayloadSchema } from "../../payload-model/neutral/index.mjs";
+var PayloadPluginResolver = class {
+  schema = PayloadSchema;
+  _plugins = {};
+  defaultPlugin;
+  constructor(plugins, defaultPlugin = createPayloadPlugin({ schema: PayloadSchema })) {
+    for (const plugin of plugins ?? []) this.register(plugin);
+    this.defaultPlugin = defaultPlugin;
+  }
+  /** @description Create list of plugins, optionally filtered by ability to witness/divine */
+  plugins() {
+    const result = Object.values(this._plugins);
+    return result;
+  }
+  register(plugin) {
+    this._plugins[plugin.schema] = plugin;
+    return this;
+  }
+  resolve(value) {
+    return isDefined(value) ? this._plugins[typeof value === "string" ? value : value.schema] ?? this.defaultPlugin : this.defaultPlugin;
+  }
+  /** @description Create list of schema, optionally filtered by ability to witness/divine */
+  schemas() {
+    const result = Array.from(Object.values(this._plugins), (value) => value.schema);
+    return result;
+  }
+  validate(payload) {
+    return this.resolve(payload).validate?.(payload);
+  }
+  wrap(payload) {
+    return this.resolve(payload).wrap?.(payload);
+  }
+};
+export {
+  PayloadPluginResolver,
+  createPayloadPlugin,
+  defaultPayloadPluginFunctions
+};
+//# sourceMappingURL=index.mjs.map

package/dist/_pkg/payload-validator/neutral/Validator.d.ts

@@ -0,0 +1,18 @@
+import type { Promisable, Validator } from '@xylabs/sdk';
+import { ValidatorBase } from '@xylabs/sdk';
+import type { Payload } from '../../payload-model/neutral/index.ts';
+export interface AllValidator {
+    all(): Error[];
+}
+export type AllValidatorFactory = (schema: string) => AllValidator;
+export declare class PayloadValidator<T extends Payload = Payload> extends ValidatorBase<T> implements Validator<T> {
+    protected static schemaNameValidatorFactory: AllValidatorFactory;
+    private _schemaValidator?;
+    protected payload: Payload;
+    constructor(payload: T);
+    static setSchemaNameValidatorFactory(factory: AllValidatorFactory): void;
+    get schemaValidator(): AllValidator;
+    schemaName(): Error[];
+    validate(): Promisable<Error[]>;
+}
+//# sourceMappingURL=Validator.d.ts.map

package/dist/_pkg/payload-validator/neutral/index.d.ts

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

package/dist/_pkg/payload-validator/neutral/index.mjs

@@ -0,0 +1,40 @@
+// src/Validator.ts
+import { isUndefined, ValidatorBase } from "@xylabs/sdk";
+import { SchemaNameValidator } from "../../schema-name-validator/neutral/index.mjs";
+var defaultSchemaNameValidatorFactory = (schema) => new SchemaNameValidator(schema);
+var PayloadValidator = class _PayloadValidator extends ValidatorBase {
+  static schemaNameValidatorFactory = defaultSchemaNameValidatorFactory;
+  _schemaValidator;
+  payload;
+  constructor(payload) {
+    super(payload);
+    this.payload = payload;
+  }
+  static setSchemaNameValidatorFactory(factory) {
+    this.schemaNameValidatorFactory = factory;
+  }
+  get schemaValidator() {
+    this._schemaValidator = this._schemaValidator ?? _PayloadValidator.schemaNameValidatorFactory?.(this.payload.schema);
+    if (isUndefined(this._schemaValidator)) {
+      console.warn(`No schema name validator set [${this.payload.schema}]`);
+    }
+    return this._schemaValidator;
+  }
+  schemaName() {
+    const errors = [];
+    if (this.obj.schema === void 0) {
+      errors.push(new Error("schema missing"));
+    } else {
+      errors.push(...this.schemaValidator?.all() ?? []);
+    }
+    return errors;
+  }
+  validate() {
+    const errors = [...this.schemaName()];
+    return errors;
+  }
+};
+export {
+  PayloadValidator
+};
+//# sourceMappingURL=index.mjs.map

package/dist/_pkg/payload-wrapper/neutral/PayloadDataWrapper.d.ts

@@ -0,0 +1,18 @@
+import type { XyoAddress } from '../../address/neutral/index.ts';
+import type { Payload } from '../../payload-model/neutral/index.ts';
+import type { PayloadLoaderFactory } from './PayloadWrapperBase.ts';
+import { PayloadWrapperBase } from './PayloadWrapperBase.ts';
+export declare const isPayloadDataWrapper: (value?: unknown) => value is PayloadDataWrapper;
+export declare class PayloadDataWrapper<TPayload extends Payload = Payload> extends PayloadWrapperBase<TPayload> {
+    protected static loaderFactory: PayloadLoaderFactory | null;
+    protected constructor(payload: TPayload);
+    static as<T extends Payload = Payload>(value: unknown): PayloadDataWrapper<T> | null;
+    static load(address: XyoAddress): Promise<PayloadDataWrapper<Payload> | null>;
+    static parse<T extends Payload>(payload?: unknown): PayloadDataWrapper<T> | undefined;
+    static setLoaderFactory(factory: PayloadLoaderFactory | null): void;
+    static tryParse<T extends Payload>(obj: unknown): PayloadDataWrapper<T> | undefined;
+    static wrap<T extends Payload>(payload?: T | PayloadDataWrapper<T>): PayloadDataWrapper<T>;
+    static wrappedMap<T extends Payload>(payloads: (T | PayloadDataWrapper<T>)[]): Promise<Record<string, PayloadDataWrapper<T>>>;
+    validate(): Promise<Error[]>;
+}
+//# sourceMappingURL=PayloadDataWrapper.d.ts.map

package/dist/_pkg/payload-wrapper/neutral/PayloadWrapper.d.ts

@@ -0,0 +1,6 @@
+import type { Payload } from '../../payload-model/neutral/index.ts';
+import { PayloadDataWrapper } from './PayloadDataWrapper.ts';
+export declare const isPayloadWrapper: (value?: unknown) => value is PayloadWrapper;
+export declare class PayloadWrapper<TPayload extends Payload = Payload> extends PayloadDataWrapper<TPayload> {
+}
+//# sourceMappingURL=PayloadWrapper.d.ts.map

package/dist/_pkg/payload-wrapper/neutral/PayloadWrapperBase.d.ts

@@ -0,0 +1,23 @@
+import type { Promisable } from '@xylabs/sdk';
+import type { XyoAddress } from '../../address/neutral/index.ts';
+import type { Payload } from '../../payload-model/neutral/index.ts';
+export type PayloadLoader = (address: XyoAddress) => Promise<Payload | null>;
+export type PayloadLoaderFactory = () => PayloadLoader;
+export declare const isPayloadWrapperBase: (value?: unknown) => value is PayloadWrapperBase;
+export declare class PayloadWrapperBase<TPayload extends Payload = Payload> {
+    private _errors?;
+    payload: TPayload;
+    protected constructor(payload: TPayload);
+    static unwrap<TPayload extends Payload = Payload>(payload?: TPayload): TPayload | undefined;
+    static unwrap<TPayload extends Payload = Payload, TWrapper extends PayloadWrapperBase<TPayload> = PayloadWrapperBase<TPayload>>(payload: TPayload | TWrapper): TPayload;
+    static unwrap<TPayload extends Payload = Payload, TWrapper extends PayloadWrapperBase<TPayload> = PayloadWrapperBase<TPayload>>(payload: (TPayload | TWrapper)[]): TPayload[];
+    static unwrapSinglePayload<TPayload extends Payload = Payload>(payload?: TPayload): TPayload | undefined;
+    static unwrapSinglePayload<TPayload extends Payload = Payload, TWrapper extends PayloadWrapperBase<TPayload> = PayloadWrapperBase<TPayload>>(payload: TPayload | TWrapper): TPayload;
+    dataHash(): Promise<import("@xylabs/sdk").BrandedHash>;
+    getErrors(): Promise<Error[]>;
+    getValid(): Promise<boolean>;
+    hash(): Promise<import("@xylabs/sdk").BrandedHash>;
+    schema(): string;
+    validate(): Promisable<Error[]>;
+}
+//# sourceMappingURL=PayloadWrapperBase.d.ts.map

package/dist/_pkg/payload-wrapper/neutral/SchemaType.d.ts

@@ -0,0 +1,6 @@
+import type { Payload } from '../../payload-model/neutral/index.ts';
+import type { JSONSchemaType } from 'ajv';
+export declare const Uint256RegEx: RegExp;
+export declare const payloadPropertiesJsonSchema: JSONSchemaType<Payload>['properties'];
+export declare const payloadJsonSchema: JSONSchemaType<Payload>;
+//# sourceMappingURL=SchemaType.d.ts.map

package/dist/_pkg/payload-wrapper/neutral/index.d.ts

@@ -0,0 +1,4 @@
+export * from './PayloadWrapper.ts';
+export * from './PayloadWrapperBase.ts';
+export * from './SchemaType.ts';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,157 @@
+// src/PayloadDataWrapper.ts
+import { assertEx as assertEx2 } from "@xylabs/sdk";
+import { PayloadValidator } from "../../payload-validator/neutral/index.mjs";
+
+// src/PayloadWrapperBase.ts
+import { assertEx } from "@xylabs/sdk";
+import { PayloadBuilder } from "../../payload-builder/neutral/index.mjs";
+import { isAnyPayload } from "../../payload-model/neutral/index.mjs";
+var isPayloadWrapperBase = (value) => {
+  return value instanceof PayloadWrapperBase;
+};
+var PayloadWrapperBase = class {
+  _errors;
+  payload;
+  constructor(payload) {
+    this.payload = payload;
+  }
+  static unwrap(payload) {
+    return Array.isArray(payload) ? payload.map((payload2) => this.unwrapSinglePayload(payload2)) : this.unwrapSinglePayload(payload);
+  }
+  static unwrapSinglePayload(payload) {
+    if (payload === void 0) {
+      return;
+    }
+    if (Array.isArray(payload)) {
+      throw new TypeError("Can not unwrap value that is an array");
+    }
+    if (isPayloadWrapperBase(payload)) {
+      return payload.payload;
+    }
+    if (isAnyPayload(payload)) {
+      return payload;
+    }
+    throw new TypeError("Can not unwrap an object that is not a PayloadWrapper or Payload");
+  }
+  async dataHash() {
+    return await PayloadBuilder.dataHash(this.payload);
+  }
+  async getErrors() {
+    this._errors = this._errors ?? await this.validate();
+    return this._errors;
+  }
+  async getValid() {
+    const errors = await this.getErrors();
+    return errors.length === 0;
+  }
+  async hash() {
+    return await PayloadBuilder.hash(this.payload);
+  }
+  // intentionally a function to prevent confusion with payload
+  schema() {
+    return assertEx(this.payload?.schema, () => "Missing payload schema");
+  }
+  validate() {
+    return [];
+  }
+};
+
+// src/PayloadDataWrapper.ts
+var PayloadDataWrapper = class _PayloadDataWrapper extends PayloadWrapperBase {
+  static loaderFactory = null;
+  constructor(payload) {
+    super(payload);
+  }
+  static as(value) {
+    return value instanceof this ? value : null;
+  }
+  static async load(address) {
+    if (this.loaderFactory === null) {
+      console.warn("No loader factory set");
+      return null;
+    }
+    const payload = await this.loaderFactory()(address);
+    return payload ? new _PayloadDataWrapper(payload) : null;
+  }
+  static parse(payload) {
+    const hydratedObj = typeof payload === "string" ? JSON.parse(payload) : payload;
+    return this.wrap(hydratedObj);
+  }
+  static setLoaderFactory(factory) {
+    this.loaderFactory = factory;
+  }
+  static tryParse(obj) {
+    if (obj === void 0 || obj === null) return;
+    try {
+      return this.parse(obj);
+    } catch {
+      return void 0;
+    }
+  }
+  static wrap(payload) {
+    assertEx2(!Array.isArray(payload), () => "Array can not be converted to PayloadWrapper");
+    switch (typeof payload) {
+      case "object": {
+        if (payload instanceof this) {
+          return payload;
+        }
+        const wrappedPayload = isPayloadWrapperBase(payload) ? payload.payload : payload;
+        return new _PayloadDataWrapper(wrappedPayload);
+      }
+      default: {
+        throw new Error(`Can only parse objects [${typeof payload}]`);
+      }
+    }
+  }
+  static async wrappedMap(payloads) {
+    const result = {};
+    await Promise.all(
+      payloads.map(async (payload) => {
+        const wrapper = this.wrap(payload);
+        const dataHash = String(await wrapper.dataHash());
+        result[dataHash] = wrapper;
+      })
+    );
+    return result;
+  }
+  async validate() {
+    const validator = new PayloadValidator(this.payload);
+    return await validator.validate();
+  }
+};
+
+// src/PayloadWrapper.ts
+var isPayloadWrapper = (value) => {
+  return isPayloadWrapperBase(value);
+};
+var PayloadWrapper = class extends PayloadDataWrapper {
+};
+
+// src/SchemaType.ts
+import { HashRegEx, HexRegExMinMax } from "@xylabs/sdk";
+import { SchemaRegEx } from "../../payload-model/neutral/index.mjs";
+var Uint256RegEx = HexRegExMinMax(0, 32);
+var payloadPropertiesJsonSchema = {
+  $sources: {
+    type: "array",
+    items: { type: "string", pattern: HashRegEx.source }
+  },
+  schema: { pattern: SchemaRegEx.source, type: "string" }
+};
+var payloadJsonSchema = {
+  $id: "https://schemas.xyo.network/2.0/payload",
+  additionalProperties: true,
+  properties: payloadPropertiesJsonSchema,
+  required: ["schema"],
+  type: "object"
+};
+export {
+  PayloadWrapper,
+  PayloadWrapperBase,
+  Uint256RegEx,
+  isPayloadWrapper,
+  isPayloadWrapperBase,
+  payloadJsonSchema,
+  payloadPropertiesJsonSchema
+};
+//# sourceMappingURL=index.mjs.map

package/dist/_pkg/pqc/neutral/MlDsa.d.ts

@@ -0,0 +1,20 @@
+export interface MlDsaKeyPair {
+    publicKey: Uint8Array;
+    secretKey: Uint8Array;
+}
+export declare class MlDsa {
+    static readonly bundleLength: number;
+    static readonly publicKeyLength = 1952;
+    static readonly secretKeyLength = 4032;
+    static readonly signatureLength = 3309;
+    static addressFromPublicKey(publicKey: ArrayBufferLike): ArrayBufferLike;
+    static bundle(publicKey: ArrayBufferLike, signature: ArrayBufferLike): ArrayBufferLike;
+    static keygen(seed?: ArrayBufferLike): MlDsaKeyPair;
+    static sign(secretKey: ArrayBufferLike, message: ArrayBufferLike): ArrayBufferLike;
+    static unbundle(bundle: ArrayBufferLike): {
+        publicKey: ArrayBufferLike;
+        signature: ArrayBufferLike;
+    };
+    static verify(publicKey: ArrayBufferLike, message: ArrayBufferLike, signature: ArrayBufferLike): boolean;
+}
+//# sourceMappingURL=MlDsa.d.ts.map

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

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

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

@@ -0,0 +1,47 @@
+// src/MlDsa.ts
+import { ml_dsa65 } from "@noble/post-quantum/ml-dsa.js";
+import { toUint8Array } from "@xylabs/sdk";
+import { Data } from "../../data/neutral/index.mjs";
+var MlDsa = class {
+  static bundleLength = 1952 + 3309;
+  static publicKeyLength = 1952;
+  static secretKeyLength = 4032;
+  static signatureLength = 3309;
+  static addressFromPublicKey(publicKey) {
+    const data = new Data(publicKey.byteLength, publicKey);
+    return data.keccak256.slice(12);
+  }
+  static bundle(publicKey, signature) {
+    const pk = toUint8Array(publicKey);
+    const sig = toUint8Array(signature);
+    const out = new Uint8Array(pk.byteLength + sig.byteLength);
+    out.set(pk, 0);
+    out.set(sig, pk.byteLength);
+    return out.buffer;
+  }
+  static keygen(seed) {
+    const seedBytes = seed === void 0 ? void 0 : toUint8Array(seed, 32);
+    return ml_dsa65.keygen(seedBytes);
+  }
+  static sign(secretKey, message) {
+    const sig = ml_dsa65.sign(toUint8Array(message), toUint8Array(secretKey));
+    return sig.buffer;
+  }
+  static unbundle(bundle) {
+    if (bundle.byteLength !== this.bundleLength) {
+      throw new Error(`Invalid ML-DSA signature bundle length [${bundle.byteLength} !== ${this.bundleLength}]`);
+    }
+    const bytes = toUint8Array(bundle);
+    return {
+      publicKey: bytes.slice(0, this.publicKeyLength).buffer,
+      signature: bytes.slice(this.publicKeyLength).buffer
+    };
+  }
+  static verify(publicKey, message, signature) {
+    return ml_dsa65.verify(toUint8Array(signature), toUint8Array(message), toUint8Array(publicKey));
+  }
+};
+export {
+  MlDsa
+};
+//# sourceMappingURL=index.mjs.map

package/dist/_pkg/previous-hash-store/neutral/index.d.ts

@@ -0,0 +1,4 @@
+export * from '../../previous-hash-store-indexeddb/neutral/index.ts';
+export * from '../../previous-hash-store-model/neutral/index.ts';
+export * from '../../previous-hash-store-storage/neutral/index.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/_pkg/previous-hash-store/neutral/index.mjs

@@ -0,0 +1,5 @@
+// src/index.ts
+export * from "../../previous-hash-store-indexeddb/neutral/index.mjs";
+export * from "../../previous-hash-store-model/neutral/index.mjs";
+export * from "../../previous-hash-store-storage/neutral/index.mjs";
+//# sourceMappingURL=index.mjs.map

package/dist/_pkg/previous-hash-store-indexeddb/neutral/IndexedDbPreviousHashStore.d.ts

@@ -0,0 +1,27 @@
+import type { Hash } from '@xylabs/sdk';
+import type { XyoAddress } from '../../address/neutral/index.ts';
+import type { PreviousHashStore } from '../../previous-hash-store-model/neutral/index.ts';
+import type { DBSchema } from 'idb';
+export interface PreviousHashStoreSchemaV1 extends DBSchema {
+    'previous-hash': {
+        key: string;
+        value: string;
+    };
+}
+export declare class IndexedDbPreviousHashStore implements PreviousHashStore {
+    static readonly CurrentSchemaVersion = 1;
+    private readonly db;
+    constructor();
+    /**
+     * The database name.
+     */
+    get dbName(): "xyo";
+    /**
+     * The name of the object store.
+     */
+    get storeName(): "previous-hash";
+    getItem(address: XyoAddress): Promise<Hash | null>;
+    removeItem(address: XyoAddress): Promise<void>;
+    setItem(address: XyoAddress, previousHash: string): Promise<void>;
+}
+//# sourceMappingURL=IndexedDbPreviousHashStore.d.ts.map

package/dist/_pkg/previous-hash-store-indexeddb/neutral/index.d.ts

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

package/dist/_pkg/previous-hash-store-indexeddb/neutral/index.mjs

@@ -0,0 +1,42 @@
+// src/IndexedDbPreviousHashStore.ts
+import { openDB } from "idb";
+var IndexedDbPreviousHashStore = class _IndexedDbPreviousHashStore {
+  static CurrentSchemaVersion = 1;
+  db;
+  constructor() {
+    this.db = openDB(
+      this.dbName,
+      _IndexedDbPreviousHashStore.CurrentSchemaVersion,
+      { upgrade: (db) => db.createObjectStore(this.storeName) }
+    );
+  }
+  /**
+   * The database name.
+   */
+  get dbName() {
+    return "xyo";
+  }
+  /**
+   * The name of the object store.
+   */
+  get storeName() {
+    return "previous-hash";
+  }
+  async getItem(address) {
+    const db = await this.db;
+    const value = await db.get(this.storeName, address);
+    return value ?? null;
+  }
+  async removeItem(address) {
+    const db = await this.db;
+    await db.delete(this.storeName, address);
+  }
+  async setItem(address, previousHash) {
+    const db = await this.db;
+    await db.put(this.storeName, previousHash, address);
+  }
+};
+export {
+  IndexedDbPreviousHashStore
+};
+//# sourceMappingURL=index.mjs.map

package/dist/_pkg/previous-hash-store-model/neutral/PreviousHashStore.d.ts

@@ -0,0 +1,8 @@
+import type { Hash } from '@xylabs/sdk';
+import type { XyoAddress } from '../../address/neutral/index.ts';
+export interface PreviousHashStore {
+    getItem(address: XyoAddress): Hash | null | Promise<Hash | null>;
+    removeItem(address: XyoAddress): void | Promise<void>;
+    setItem(address: XyoAddress, previousHash: Hash): void | Promise<void>;
+}
+//# sourceMappingURL=PreviousHashStore.d.ts.map

package/dist/_pkg/previous-hash-store-model/neutral/index.d.ts

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

package/dist/_pkg/previous-hash-store-model/neutral/index.mjs

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

package/dist/_pkg/previous-hash-store-storage/neutral/NamespacedStorage.d.ts

@@ -0,0 +1,10 @@
+export type StorageArea = 'local' | 'session' | 'page';
+export declare class NamespacedStorage<T> {
+    private readonly backend;
+    private readonly prefix;
+    constructor(area: StorageArea, namespace: string);
+    get(key: string): T | undefined;
+    remove(key: string): void;
+    set(key: string, value: T): void;
+}
+//# sourceMappingURL=NamespacedStorage.d.ts.map

package/dist/_pkg/previous-hash-store-storage/neutral/StoragePreviousHashStore.d.ts

@@ -0,0 +1,24 @@
+import type { Hash } from '@xylabs/sdk';
+import type { XyoAddress } from '../../address/neutral/index.ts';
+import type { PreviousHashStore } from '../../previous-hash-store-model/neutral/index.ts';
+import type { StorageArea } from './NamespacedStorage.ts';
+export type Storage = StorageArea;
+export interface StoragePreviousHashOpts {
+    namespace?: string;
+    type?: Storage;
+}
+export declare class StoragePreviousHashStore implements PreviousHashStore {
+    static readonly DefaultNamespace = "xyo-previous-hash-store";
+    static readonly DefaultStorageType: Storage;
+    private _namespace;
+    private _storage;
+    private _type;
+    constructor(opts?: StoragePreviousHashOpts);
+    private get storage();
+    get namespace(): string;
+    get type(): Storage;
+    getItem(address: XyoAddress): Promise<Hash | null>;
+    removeItem(address: XyoAddress): Promise<void>;
+    setItem(address: XyoAddress, previousHash: Hash): Promise<void>;
+}
+//# sourceMappingURL=StoragePreviousHashStore.d.ts.map

package/dist/_pkg/previous-hash-store-storage/neutral/index.d.ts

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