@xyo-network/payload-model 7.0.12 → 7.0.13

package/dist/node/StorageMeta/sequence/Comparer.d.ts

@@ -0,0 +1,7 @@
+import type { Compare } from '@ariestools/sdk';
+import type { Sequence } from './Sequence.ts';
+export declare const SequenceComparer: {
+    local: Compare<Sequence>;
+    qualified: Compare<Sequence>;
+};
+//# sourceMappingURL=Comparer.d.ts.map

package/dist/node/StorageMeta/sequence/Comparer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Comparer.d.ts","sourceRoot":"","sources":["../../../../src/StorageMeta/sequence/Comparer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAA;AAG9C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAc7C,eAAO,MAAM,gBAAgB;;;CAAuB,CAAA"}

package/dist/node/StorageMeta/sequence/Parser.d.ts

@@ -0,0 +1,31 @@
+import type { Hash, Hex } from '@ariestools/sdk';
+import type { XyoLegacyAddress } from '@xyo-network/address';
+import type { Epoch, LocalSequence, Nonce, QualifiedSequence, Sequence } from './Sequence.ts';
+export declare class SequenceParser {
+    protected static privateConstructorKey: string;
+    private readonly data;
+    protected constructor(privateConstructorKey: string, hex: Hex);
+    static from(sequence: Sequence, address?: XyoLegacyAddress): SequenceParser;
+    static from(timestamp: Hex, hash: Hash, address?: XyoLegacyAddress): SequenceParser;
+    static from(timestamp: Hex, hash: Hex, address?: XyoLegacyAddress): SequenceParser;
+    static from(timestamp: Hex, nonce: Nonce, address?: XyoLegacyAddress): SequenceParser;
+    static from(timestamp: Hex, hash: Hash, index?: number, address?: XyoLegacyAddress): SequenceParser;
+    static from(timestamp: Hex, hash: Hex, index?: number, address?: XyoLegacyAddress): SequenceParser;
+    static from(timestamp: Hex, nonce: Nonce, index?: number, address?: XyoLegacyAddress): SequenceParser;
+    static from(timestamp: number, hash: Hash, address?: XyoLegacyAddress): SequenceParser;
+    static from(timestamp: number, hash: Hex, address?: XyoLegacyAddress): SequenceParser;
+    static from(timestamp: number, nonce: Nonce, address?: XyoLegacyAddress): SequenceParser;
+    static from(timestamp: number, hash: Hash, index?: number, address?: XyoLegacyAddress): SequenceParser;
+    static from(timestamp: number, hash: Hex, index?: number, address?: XyoLegacyAddress): SequenceParser;
+    static from(timestamp: number, nonce: Nonce, index?: number, address?: XyoLegacyAddress): SequenceParser;
+    static parse(value: Hex | string | ArrayBufferLike): SequenceParser;
+    static toEpoch(value: number | Hex | Epoch): Epoch;
+    static toNonce(value: Hash | Hex, index?: number): Nonce;
+    private static create;
+    get address(): XyoLegacyAddress;
+    get epoch(): Epoch;
+    get localSequence(): LocalSequence;
+    get nonce(): Nonce;
+    get qualifiedSequence(): QualifiedSequence;
+}
+//# sourceMappingURL=Parser.d.ts.map

package/dist/node/StorageMeta/sequence/Parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Parser.d.ts","sourceRoot":"","sources":["../../../../src/StorageMeta/sequence/Parser.ts"],"names":[],"mappings":"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"}

package/dist/node/StorageMeta/sequence/Sequence.d.ts

@@ -0,0 +1,80 @@
+import type { Brand, Hex } from '@ariestools/sdk';
+import type { XyoLegacyAddress } from '@xyo-network/address';
+export type LocalSequence = Brand<Hex, {
+    __localSequence: true;
+}>;
+export type QualifiedSequence = Brand<Hex, {
+    __qualifiedSequence: true;
+}>;
+export type Sequence = LocalSequence | QualifiedSequence;
+export type Epoch = Brand<Hex, {
+    __epoch: true;
+}>;
+export declare const isEpoch: (value: unknown) => value is Epoch;
+export type Nonce = Brand<Hex, {
+    __nonce: true;
+}>;
+export declare const isNonce: (value: unknown) => value is Nonce;
+export declare const isLocalSequence: (value: unknown) => value is LocalSequence;
+export declare const isQualifiedSequence: (value: unknown) => value is QualifiedSequence;
+export declare const isSequence: (value: unknown) => value is Sequence;
+export declare const SequenceNonceComponentLengths: {
+    nonceIndexBytes: number;
+    nonceHashBytes: number;
+};
+export declare const SequenceComponentLengths: {
+    epochBytes: number;
+    nonceBytes: number;
+    addressBytes: number;
+    nonceIndexBytes: number;
+    nonceHashBytes: number;
+};
+export declare const SequenceComponentMinMax: {
+    minEpoch: Epoch;
+    maxEpoch: Epoch;
+    minNonce: Nonce;
+    maxNonce: Nonce;
+    minAddress: XyoLegacyAddress;
+    maxAddress: XyoLegacyAddress;
+};
+export declare const LocalSequenceConstants: {
+    localSequenceBytes: number;
+    minLocalSequence: LocalSequence;
+    maxLocalSequence: LocalSequence;
+    minEpoch: Epoch;
+    maxEpoch: Epoch;
+    minNonce: Nonce;
+    maxNonce: Nonce;
+    minAddress: XyoLegacyAddress;
+    maxAddress: XyoLegacyAddress;
+    epochBytes: number;
+    nonceBytes: number;
+    addressBytes: number;
+    nonceIndexBytes: number;
+    nonceHashBytes: number;
+};
+export declare const QualifiedSequenceConstants: {
+    qualifiedSequenceBytes: number;
+    minQualifiedSequence: QualifiedSequence;
+    maxQualifiedSequence: QualifiedSequence;
+};
+export declare const SequenceConstants: {
+    qualifiedSequenceBytes: number;
+    minQualifiedSequence: QualifiedSequence;
+    maxQualifiedSequence: QualifiedSequence;
+    localSequenceBytes: number;
+    minLocalSequence: LocalSequence;
+    maxLocalSequence: LocalSequence;
+    minEpoch: Epoch;
+    maxEpoch: Epoch;
+    minNonce: Nonce;
+    maxNonce: Nonce;
+    minAddress: XyoLegacyAddress;
+    maxAddress: XyoLegacyAddress;
+    epochBytes: number;
+    nonceBytes: number;
+    addressBytes: number;
+    nonceIndexBytes: number;
+    nonceHashBytes: number;
+};
+//# sourceMappingURL=Sequence.d.ts.map

package/dist/node/StorageMeta/sequence/Sequence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Sequence.d.ts","sourceRoot":"","sources":["../../../../src/StorageMeta/sequence/Sequence.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,iBAAiB,CAAA;AAEjD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AAG5D,MAAM,MAAM,aAAa,GAAG,KAAK,CAAC,GAAG,EAAE;IAAE,eAAe,EAAE,IAAI,CAAA;CAAE,CAAC,CAAA;AACjE,MAAM,MAAM,iBAAiB,GAAG,KAAK,CAAC,GAAG,EAAE;IAAE,mBAAmB,EAAE,IAAI,CAAA;CAAE,CAAC,CAAA;AACzE,MAAM,MAAM,QAAQ,GAAG,aAAa,GAAG,iBAAiB,CAAA;AAExD,MAAM,MAAM,KAAK,GAAG,KAAK,CAAC,GAAG,EAAE;IAAE,OAAO,EAAE,IAAI,CAAA;CAAE,CAAC,CAAA;AAEjD,eAAO,MAAM,OAAO,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,KAEjD,CAAA;AAED,MAAM,MAAM,KAAK,GAAG,KAAK,CAAC,GAAG,EAAE;IAAE,OAAO,EAAE,IAAI,CAAA;CAAE,CAAC,CAAA;AAEjD,eAAO,MAAM,OAAO,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,KAEjD,CAAA;AAED,eAAO,MAAM,eAAe,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,aAEzD,CAAA;AAED,eAAO,MAAM,mBAAmB,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,iBAE7D,CAAA;AAED,eAAO,MAAM,UAAU,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,QAEpD,CAAA;AAED,eAAO,MAAM,6BAA6B;;;CAGzC,CAAA;AAED,eAAO,MAAM,wBAAwB;;;;;;CAKpC,CAAA;AAED,eAAO,MAAM,uBAAuB;cAC+B,KAAK;cACL,KAAK;cACL,KAAK;cACL,KAAK;gBACD,gBAAgB;gBAChB,gBAAgB;CACtF,CAAA;AAED,eAAO,MAAM,sBAAsB;;sBAIwD,aAAa;sBACb,aAAa;cAbrC,KAAK;cACL,KAAK;cACL,KAAK;cACL,KAAK;gBACD,gBAAgB;gBAChB,gBAAgB;;;;;;CAStF,CAAA;AAED,eAAO,MAAM,0BAA0B;;0BAEiE,iBAAiB;0BACjB,iBAAiB;CACxH,CAAA;AAED,eAAO,MAAM,iBAAiB;;0BAJ0E,iBAAiB;0BACjB,iBAAiB;;sBAP9B,aAAa;sBACb,aAAa;cAbrC,KAAK;cACL,KAAK;cACL,KAAK;cACL,KAAK;gBACD,gBAAgB;gBAChB,gBAAgB;;;;;;CAoBtF,CAAA"}

package/dist/node/StorageMeta/sequence/SequenceZod.d.ts

@@ -0,0 +1,9 @@
+import * as z from 'zod/mini';
+import type { LocalSequence, QualifiedSequence } from './Sequence.ts';
+export declare const LocalSequenceToStringZod: z.ZodMiniString<string>;
+export declare const LocalSequenceFromStringZod: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<LocalSequence, string>>;
+export declare const QualifiedSequenceToStringZod: z.ZodMiniString<string>;
+export declare const QualifiedSequenceFromStringZod: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<QualifiedSequence, string>>;
+export declare const SequenceToStringZod: z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniString<string>]>;
+export declare const SequenceFromStringZod: z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<LocalSequence, string>>, z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<QualifiedSequence, string>>]>;
+//# sourceMappingURL=SequenceZod.d.ts.map

package/dist/node/StorageMeta/sequence/SequenceZod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SequenceZod.d.ts","sourceRoot":"","sources":["../../../../src/StorageMeta/sequence/SequenceZod.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAA;AAE7B,OAAO,KAAK,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAA;AAIrE,eAAO,MAAM,wBAAwB,yBAAgD,CAAA;AACrF,eAAO,MAAM,0BAA0B,mFAGtC,CAAA;AAGD,eAAO,MAAM,4BAA4B,yBAAoD,CAAA;AAC7F,eAAO,MAAM,8BAA8B,uFAG1C,CAAA;AAED,eAAO,MAAM,mBAAmB,6EAAoE,CAAA;AACpG,eAAO,MAAM,qBAAqB,qMAAwE,CAAA"}

package/dist/node/StorageMeta/sequence/index.d.ts

@@ -0,0 +1,5 @@
+export * from './Comparer.ts';
+export * from './Parser.ts';
+export * from './Sequence.ts';
+export * from './SequenceZod.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/node/StorageMeta/sequence/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/StorageMeta/sequence/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAA;AAC7B,cAAc,aAAa,CAAA;AAC3B,cAAc,eAAe,CAAA;AAC7B,cAAc,kBAAkB,CAAA"}

package/dist/node/Timestamp.d.ts

@@ -0,0 +1,8 @@
+import type { EmptyObject } from '@ariestools/sdk';
+/** Object with a timestamp */
+export interface Timestamp {
+    timestamp: number;
+}
+/** Add a timestamp field to any object */
+export type WithTimestamp<T extends EmptyObject = EmptyObject> = T & Timestamp;
+//# sourceMappingURL=Timestamp.d.ts.map

package/dist/node/Timestamp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Timestamp.d.ts","sourceRoot":"","sources":["../../src/Timestamp.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAA;AAElD,8BAA8B;AAC9B,MAAM,WAAW,SAAS;IACxB,SAAS,EAAE,MAAM,CAAA;CAClB;AAED,0CAA0C;AAC1C,MAAM,MAAM,aAAa,CAAC,CAAC,SAAS,WAAW,GAAG,WAAW,IAAI,CAAC,GAAG,SAAS,CAAA"}

package/dist/node/index.d.ts

@@ -0,0 +1,16 @@
+export * from './Error.ts';
+export * from './isPayloadOfSchemaType.ts';
+export * from './isPayloadOfZodType.ts';
+export * from './Payload.ts';
+export * from './PayloadBundle.ts';
+export * from './PayloadFindFilter.ts';
+export * from './PayloadHashMap.ts';
+export * from './PayloadSet/index.ts';
+export * from './PayloadValidationFunction.ts';
+export * from './PayloadValueExpression.ts';
+export * from './PayloadZod.ts';
+export * from './Query.ts';
+export * from './Schema.ts';
+export * from './StorageMeta/index.ts';
+export * from './Timestamp.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/node/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA;AAC1B,cAAc,4BAA4B,CAAA;AAC1C,cAAc,yBAAyB,CAAA;AACvC,cAAc,cAAc,CAAA;AAC5B,cAAc,oBAAoB,CAAA;AAClC,cAAc,wBAAwB,CAAA;AACtC,cAAc,qBAAqB,CAAA;AACnC,cAAc,uBAAuB,CAAA;AACrC,cAAc,gCAAgC,CAAA;AAC9C,cAAc,6BAA6B,CAAA;AAC3C,cAAc,iBAAiB,CAAA;AAC/B,cAAc,YAAY,CAAA;AAC1B,cAAc,aAAa,CAAA;AAC3B,cAAc,wBAAwB,CAAA;AACtC,cAAc,gBAAgB,CAAA"}

package/dist/node/index.mjs

@@ -0,0 +1,452 @@
+// src/Error.ts
+import {
+  HashZod as HashZod2,
+  zodAsFactory as zodAsFactory3,
+  zodIsFactory as zodIsFactory3,
+  zodToFactory as zodToFactory2
+} from "@ariestools/sdk";
+import * as z4 from "zod/mini";
+
+// src/PayloadZod.ts
+import {
+  HashZod,
+  zodAsFactory as zodAsFactory2,
+  zodIsFactory as zodIsFactory2,
+  zodToFactory
+} from "@ariestools/sdk";
+import * as z3 from "zod/mini";
+
+// src/Schema.ts
+import { zodAsFactory, zodIsFactory } from "@ariestools/sdk";
+import * as z from "zod/mini";
+var SchemaRegEx = /^(?:[a-z0-9]+\.)*[a-z0-9]+$/;
+var SchemaZod = z.pipe(z.string().check(z.regex(SchemaRegEx)), z.transform((v) => v));
+var makeSchema = (value) => {
+  return z.pipe(z.literal(value), z.transform((x) => x));
+};
+var isSchema = zodIsFactory(SchemaZod);
+var asSchema = zodAsFactory(SchemaZod, "asSchema");
+var toSchema = zodAsFactory(SchemaZod, "toSchema");
+var PayloadSchema = asSchema("network.xyo.payload", true);
+var PayloadSchemaZod = z.literal(PayloadSchema);
+
+// src/StorageMeta/Sequence.ts
+import { AsObjectFactory } from "@ariestools/sdk";
+var isSequenceStorageMeta = (value) => {
+  return value?._sequence != void 0;
+};
+var asSequenceStorageMeta = AsObjectFactory.create(isSequenceStorageMeta);
+var asOptionalSequenceStorageMeta = AsObjectFactory.createOptional(isSequenceStorageMeta);
+
+// src/StorageMeta/sequence/Parser.ts
+import {
+  assertEx,
+  isAddress,
+  toAddress,
+  toHex,
+  toUint8Array
+} from "@ariestools/sdk";
+
+// src/StorageMeta/sequence/Sequence.ts
+import { isHex } from "@ariestools/sdk";
+var isEpoch = (value) => {
+  return isHex(value) && value.length === SequenceConstants.epochBytes * 2;
+};
+var isNonce = (value) => {
+  return isHex(value) && value.length === SequenceConstants.nonceBytes * 2;
+};
+var isLocalSequence = (value) => {
+  return isHex(value) && value.length === SequenceConstants.localSequenceBytes * 2;
+};
+var isQualifiedSequence = (value) => {
+  return isHex(value) && value.length === SequenceConstants.qualifiedSequenceBytes * 2;
+};
+var isSequence = (value) => {
+  return isLocalSequence(value) || isQualifiedSequence(value);
+};
+var SequenceNonceComponentLengths = {
+  nonceIndexBytes: 4,
+  nonceHashBytes: 4
+};
+var SequenceComponentLengths = {
+  ...SequenceNonceComponentLengths,
+  epochBytes: 8,
+  nonceBytes: SequenceNonceComponentLengths.nonceIndexBytes + SequenceNonceComponentLengths.nonceHashBytes,
+  addressBytes: 20
+};
+var SequenceComponentMinMax = {
+  minEpoch: "0".repeat(SequenceComponentLengths.epochBytes * 2),
+  maxEpoch: "f".repeat(SequenceComponentLengths.epochBytes * 2),
+  minNonce: "0".repeat(SequenceComponentLengths.nonceBytes * 2),
+  maxNonce: "f".repeat(SequenceComponentLengths.nonceBytes * 2),
+  minAddress: "0".repeat(SequenceComponentLengths.addressBytes * 2),
+  maxAddress: "f".repeat(SequenceComponentLengths.addressBytes * 2)
+};
+var LocalSequenceConstants = {
+  ...SequenceComponentLengths,
+  ...SequenceComponentMinMax,
+  localSequenceBytes: SequenceComponentLengths.epochBytes + SequenceComponentLengths.nonceBytes,
+  minLocalSequence: SequenceComponentMinMax.minEpoch + SequenceComponentMinMax.minNonce,
+  maxLocalSequence: SequenceComponentMinMax.maxEpoch + SequenceComponentMinMax.maxNonce
+};
+var QualifiedSequenceConstants = {
+  qualifiedSequenceBytes: LocalSequenceConstants.localSequenceBytes + SequenceComponentLengths.addressBytes,
+  minQualifiedSequence: LocalSequenceConstants.minLocalSequence + SequenceComponentMinMax.minAddress,
+  maxQualifiedSequence: LocalSequenceConstants.maxLocalSequence + SequenceComponentMinMax.maxAddress
+};
+var SequenceConstants = {
+  ...LocalSequenceConstants,
+  ...QualifiedSequenceConstants
+};
+
+// src/StorageMeta/sequence/Parser.ts
+var SequenceParser = class _SequenceParser {
+  static privateConstructorKey = Date.now().toString();
+  data;
+  constructor(privateConstructorKey, hex) {
+    assertEx(_SequenceParser.privateConstructorKey === privateConstructorKey, () => "Use create function instead of constructor");
+    const paddedHex = toHex(hex, {
+      prefix: false,
+      bitLength: SequenceConstants[hex.length <= SequenceConstants.localSequenceBytes * 2 ? "localSequenceBytes" : "qualifiedSequenceBytes"] * 8
+    });
+    this.data = toUint8Array(paddedHex);
+  }
+  static from(timestampOrSequence, nonceOrAddress, addressOrIndex, addressOnly) {
+    if (isSequence(timestampOrSequence)) {
+      if (nonceOrAddress) {
+        assertEx(!isQualifiedSequence(timestampOrSequence), () => "Providing both a qualified sequence and a address is not allowed");
+        assertEx(isAddress(nonceOrAddress), () => "Invalid address provided");
+        const combined = timestampOrSequence + nonceOrAddress;
+        return this.create(combined);
+      }
+      return this.create(timestampOrSequence);
+    }
+    const address = typeof addressOrIndex === "number" ? addressOnly : addressOrIndex;
+    const index = typeof addressOrIndex === "number" ? addressOrIndex : void 0;
+    const epoch = this.toEpoch(timestampOrSequence);
+    const nonce = nonceOrAddress === void 0 ? void 0 : this.toNonce(nonceOrAddress, index);
+    const addressHex = address ? toHex(address, { bitLength: SequenceConstants.addressBytes * 8 }) : SequenceConstants.minAddress;
+    const hexString = epoch + nonce + addressHex;
+    assertEx(isSequence(hexString), () => `Invalid sequence [${hexString}] [${epoch}, ${nonce}, ${addressHex}]`);
+    return this.create(hexString);
+  }
+  static parse(value) {
+    const hex = toHex(value);
+    if (isSequence(hex)) {
+      return this.create(hex);
+    }
+    throw new Error(`Invalid sequence [${hex}]`);
+  }
+  // can convert a short number/hex to an epoch (treats it as the whole value) or extract an epoch from a sequence
+  static toEpoch(value) {
+    assertEx(
+      typeof value !== "number" || Number.isSafeInteger(value),
+      () => "Value must be in integer"
+    );
+    const hex = toHex(value, { prefix: false });
+    if (hex.length <= SequenceConstants.epochBytes * 2) {
+      return toHex(value, { prefix: false, bitLength: SequenceConstants.epochBytes * 8 });
+    }
+    if (isSequence(hex)) {
+      return hex.slice(0, SequenceConstants.epochBytes * 2);
+    }
+    throw new Error(`Value could not be converted to epoch [${hex}]`);
+  }
+  // can convert a short number/hex to a nonce (treats it as the whole value) or extract an nonce from a sequence
+  static toNonce(value, index = 0) {
+    assertEx(
+      typeof value !== "number" || Number.isSafeInteger(value),
+      () => "Value must be in integer"
+    );
+    const hex = toHex(value, { prefix: false });
+    if (isSequence(hex)) {
+      return hex.slice(SequenceConstants.epochBytes * 2, SequenceConstants.localSequenceBytes * 2);
+    }
+    const hashHex = toHex(hex, { prefix: false, bitLength: SequenceConstants.nonceHashBytes * 8 }).slice(-SequenceConstants.nonceHashBytes * 2);
+    const indexHex = toHex(index, { prefix: false, bitLength: SequenceConstants.nonceIndexBytes * 8 }).slice(-SequenceConstants.nonceIndexBytes * 2);
+    return (indexHex + hashHex).slice(-SequenceConstants.nonceBytes * 2);
+  }
+  static create(hex) {
+    return new _SequenceParser(this.privateConstructorKey, hex);
+  }
+  get address() {
+    const start = SequenceConstants.localSequenceBytes;
+    const end = SequenceConstants.qualifiedSequenceBytes;
+    return toAddress(this.data.slice(start, end).buffer, { prefix: false });
+  }
+  get epoch() {
+    const start = 0;
+    const end = SequenceConstants.epochBytes;
+    return toHex(this.data.slice(start, end).buffer, { prefix: false });
+  }
+  get localSequence() {
+    const start = 0;
+    const end = SequenceConstants.localSequenceBytes;
+    return toHex(this.data.slice(start, end).buffer, { prefix: false });
+  }
+  get nonce() {
+    const start = SequenceConstants.epochBytes;
+    const end = SequenceConstants.localSequenceBytes;
+    return toHex(this.data.slice(start, end).buffer, { prefix: false });
+  }
+  get qualifiedSequence() {
+    const start = 0;
+    const end = SequenceConstants.qualifiedSequenceBytes;
+    return toHex(this.data.slice(start, end).buffer, { prefix: false });
+  }
+};
+
+// src/StorageMeta/sequence/Comparer.ts
+var local = (a, b) => {
+  const aa = SequenceParser.from(a);
+  const bb = SequenceParser.from(b);
+  return aa.localSequence > bb.localSequence ? 1 : aa.localSequence < bb.localSequence ? -1 : 0;
+};
+var qualified = (a, b) => {
+  const aa = SequenceParser.from(a);
+  const bb = SequenceParser.from(b);
+  return aa.qualifiedSequence > bb.qualifiedSequence ? 1 : aa.qualifiedSequence < bb.qualifiedSequence ? -1 : 0;
+};
+var SequenceComparer = { local, qualified };
+
+// src/StorageMeta/sequence/SequenceZod.ts
+import { HexRegExMinMax, toHex as toHex2 } from "@ariestools/sdk";
+import * as z2 from "zod/mini";
+var LocalSequenceRegex = new RegExp(HexRegExMinMax(SequenceConstants.localSequenceBytes, SequenceConstants.localSequenceBytes));
+var LocalSequenceToStringZod = z2.string().check(z2.regex(LocalSequenceRegex));
+var LocalSequenceFromStringZod = z2.pipe(
+  z2.string().check(z2.regex(LocalSequenceRegex)),
+  z2.transform((v) => toHex2(v))
+);
+var QualifiedSequenceRegex = new RegExp(HexRegExMinMax(SequenceConstants.qualifiedSequenceBytes, SequenceConstants.qualifiedSequenceBytes));
+var QualifiedSequenceToStringZod = z2.string().check(z2.regex(QualifiedSequenceRegex));
+var QualifiedSequenceFromStringZod = z2.pipe(
+  z2.string().check(z2.regex(QualifiedSequenceRegex)),
+  z2.transform((v) => toHex2(v))
+);
+var SequenceToStringZod = z2.union([LocalSequenceToStringZod, QualifiedSequenceToStringZod]);
+var SequenceFromStringZod = z2.union([LocalSequenceFromStringZod, QualifiedSequenceFromStringZod]);
+
+// src/PayloadZod.ts
+var HashMetaZod = z3.object({
+  _hash: HashZod,
+  _dataHash: HashZod
+});
+var isHashMeta = zodIsFactory2(HashMetaZod);
+var asHashMeta = zodAsFactory2(HashMetaZod, "asHashMeta");
+var toHashMeta = zodToFactory(HashMetaZod, "toHashMeta");
+var SequenceMetaZod = z3.object({ _sequence: SequenceFromStringZod });
+var isSequenceMeta = zodIsFactory2(SequenceMetaZod);
+var asSequenceMeta = zodAsFactory2(SequenceMetaZod, "asSequenceMeta");
+var toSequenceMeta = zodToFactory(SequenceMetaZod, "toSequenceMeta");
+var StorageMetaZod = z3.object({
+  _hash: HashZod,
+  _dataHash: HashZod,
+  _sequence: SequenceFromStringZod
+});
+var isStorageMeta = zodIsFactory2(StorageMetaZod);
+var asStorageMeta = zodAsFactory2(StorageMetaZod, "asStorageMeta");
+var toStorageMeta = zodToFactory(StorageMetaZod, "toStorageMeta");
+var PayloadZod = z3.object({ schema: SchemaZod });
+var isPayload = zodIsFactory2(PayloadZod);
+var asPayload = zodAsFactory2(PayloadZod, "asPayload");
+var toPayload = zodToFactory(PayloadZod, "toPayload");
+var AnyPayloadZod = z3.looseObject({ schema: SchemaZod });
+var isAnyPayload = zodIsFactory2(AnyPayloadZod);
+var asAnyPayload = zodAsFactory2(AnyPayloadZod, "asAnyPayload");
+var toAnyPayload = zodToFactory(AnyPayloadZod, "toAnyPayload");
+function WithStorageMetaZod(valueZod) {
+  return z3.object({ ...valueZod.shape, ...StorageMetaZod.shape });
+}
+function WithHashMetaZod(valueZod) {
+  return z3.object({ ...valueZod.shape, ...HashMetaZod.shape });
+}
+var PayloadZodStrict = z3.strictObject({ schema: SchemaZod });
+var PayloadZodLoose = z3.looseObject({ schema: SchemaZod });
+var WithHashMetaPayloadZodLoose = z3.extend(PayloadZodLoose, HashMetaZod.shape);
+var PayloadZodOfSchema = (schema) => z3.extend(PayloadZod, { schema: z3.literal(schema) });
+var PayloadZodStrictOfSchema = (schema) => z3.extend(PayloadZodStrict, { schema: z3.literal(schema) });
+var PayloadZodLooseOfSchema = (schema) => z3.extend(PayloadZodLoose, { schema: z3.literal(schema) });
+
+// src/Error.ts
+var ModuleErrorSchema = asSchema("network.xyo.error.module", true);
+var ModuleErrorZod = z4.extend(PayloadZodOfSchema(ModuleErrorSchema), {
+  details: z4.optional(z4.custom()),
+  message: z4.optional(z4.string()),
+  name: z4.optional(z4.string()),
+  query: z4.optional(z4.union([HashZod2, SchemaZod]))
+});
+var isModuleError = zodIsFactory3(ModuleErrorZod);
+var asModuleError = zodAsFactory3(ModuleErrorZod, "asModuleError");
+var toModuleError = zodToFactory2(ModuleErrorZod, "toModuleError");
+
+// src/isPayloadOfSchemaType.ts
+function isPayloadOfSchemaType(schema) {
+  return (x) => isAnyPayload(x) && x?.schema === schema;
+}
+var isPayloadOfSchemaTypeWithSources = (schema) => {
+  return (x) => isPayloadOfSchemaType(schema)(x) && x.$sources != void 0 && Array.isArray(x.$sources);
+};
+var notPayloadOfSchemaType = (schema) => {
+  return (x) => !isAnyPayload(x) || x?.schema !== schema;
+};
+
+// src/isPayloadOfZodType.ts
+import { isDefined } from "@ariestools/sdk";
+import * as z5 from "zod/mini";
+function isPayloadOfZodType(zodSchema, schema) {
+  return (x) => {
+    if (!isAnyPayload(x)) return false;
+    if (isDefined(schema) && x.schema !== schema) return false;
+    const { schema: _, ...data } = x;
+    return z5.safeParse(zodSchema, data).success;
+  };
+}
+
+// src/PayloadBundle.ts
+import {
+  HashZod as HashZod3,
+  zodAsFactory as zodAsFactory4,
+  zodIsFactory as zodIsFactory4,
+  zodToFactory as zodToFactory3
+} from "@ariestools/sdk";
+import * as z6 from "zod/mini";
+var PayloadBundleSchema = asSchema("network.xyo.payload.bundle", true);
+var PayloadBundleFieldsZod = z6.object({
+  payloads: z6.array(PayloadZodLoose),
+  root: HashZod3
+});
+var PayloadBundleZod = z6.extend(PayloadZodOfSchema(PayloadBundleSchema), PayloadBundleFieldsZod.shape);
+var isPayloadBundle = zodIsFactory4(PayloadBundleZod);
+var asPayloadBundle = zodAsFactory4(PayloadBundleZod, "asPayloadBundle");
+var asOptionalPayloadBundle = zodToFactory3(PayloadBundleZod, "asPayloadBundle");
+
+// src/PayloadSet/PayloadSetPayload.ts
+import {
+  zodAsFactory as zodAsFactory5,
+  zodIsFactory as zodIsFactory5,
+  zodToFactory as zodToFactory4
+} from "@ariestools/sdk";
+import * as z7 from "zod/mini";
+
+// src/PayloadSet/PayloadSetSchema.ts
+var PayloadSetSchema = asSchema("network.xyo.payload.set", true);
+
+// src/PayloadSet/PayloadSetPayload.ts
+var stringNumberRecordZod = z7.record(z7.string(), z7.number());
+var PayloadSetZod = z7.object({
+  optional: z7.optional(stringNumberRecordZod),
+  required: z7.optional(stringNumberRecordZod)
+});
+var PayloadSetPayloadZod = z7.extend(PayloadZodOfSchema(PayloadSetSchema), PayloadSetZod.shape);
+var isPayloadSetPayload = zodIsFactory5(PayloadSetPayloadZod);
+var asPayloadSetPayload = zodAsFactory5(PayloadSetPayloadZod, "asPayloadSetPayload");
+var toPayloadSetPayload = zodToFactory4(PayloadSetPayloadZod, "toPayloadSetPayload");
+
+// src/Query.ts
+import { XyoAddressZod } from "@xyo-network/address";
+import * as z8 from "zod/mini";
+var queryAddressZod = z8.union([XyoAddressZod, z8.array(XyoAddressZod)]);
+var maxFrequencyZod = z8.union([
+  z8.literal("once"),
+  z8.literal("second"),
+  z8.literal("minute"),
+  z8.literal("hour"),
+  z8.literal("day"),
+  z8.literal("week"),
+  z8.literal("month"),
+  z8.literal("year")
+]);
+var QueryFieldsZod = z8.object({
+  /** @field The addresses of the intended handlers */
+  address: z8.optional(queryAddressZod),
+  /** @field The maximum XYO that can be spent executing the query */
+  budget: z8.optional(z8.number()),
+  /** @field The frequency on which this query can be rerun */
+  maxFrequency: z8.optional(maxFrequencyZod),
+  /** @field The starting point for the bidding on the query */
+  minBid: z8.optional(z8.number())
+});
+export {
+  AnyPayloadZod,
+  HashMetaZod,
+  LocalSequenceConstants,
+  LocalSequenceFromStringZod,
+  LocalSequenceToStringZod,
+  ModuleErrorSchema,
+  ModuleErrorZod,
+  PayloadBundleFieldsZod,
+  PayloadBundleSchema,
+  PayloadBundleZod,
+  PayloadSchema,
+  PayloadSchemaZod,
+  PayloadSetPayloadZod,
+  PayloadSetSchema,
+  PayloadSetZod,
+  PayloadZod,
+  PayloadZodLoose,
+  PayloadZodLooseOfSchema,
+  PayloadZodOfSchema,
+  PayloadZodStrict,
+  PayloadZodStrictOfSchema,
+  QualifiedSequenceConstants,
+  QualifiedSequenceFromStringZod,
+  QualifiedSequenceToStringZod,
+  QueryFieldsZod,
+  SchemaRegEx,
+  SchemaZod,
+  SequenceComparer,
+  SequenceComponentLengths,
+  SequenceComponentMinMax,
+  SequenceConstants,
+  SequenceFromStringZod,
+  SequenceMetaZod,
+  SequenceNonceComponentLengths,
+  SequenceParser,
+  SequenceToStringZod,
+  StorageMetaZod,
+  WithHashMetaPayloadZodLoose,
+  WithHashMetaZod,
+  WithStorageMetaZod,
+  asAnyPayload,
+  asHashMeta,
+  asModuleError,
+  asOptionalPayloadBundle,
+  asOptionalSequenceStorageMeta,
+  asPayload,
+  asPayloadBundle,
+  asPayloadSetPayload,
+  asSchema,
+  asSequenceMeta,
+  asSequenceStorageMeta,
+  asStorageMeta,
+  isAnyPayload,
+  isEpoch,
+  isHashMeta,
+  isLocalSequence,
+  isModuleError,
+  isNonce,
+  isPayload,
+  isPayloadBundle,
+  isPayloadOfSchemaType,
+  isPayloadOfSchemaTypeWithSources,
+  isPayloadOfZodType,
+  isPayloadSetPayload,
+  isQualifiedSequence,
+  isSchema,
+  isSequence,
+  isSequenceMeta,
+  isSequenceStorageMeta,
+  isStorageMeta,
+  makeSchema,
+  notPayloadOfSchemaType,
+  toAnyPayload,
+  toHashMeta,
+  toModuleError,
+  toPayload,
+  toPayloadSetPayload,
+  toSchema,
+  toSequenceMeta,
+  toStorageMeta
+};
+//# sourceMappingURL=index.mjs.map