@xyo-network/payload-model 5.3.20 → 5.3.24

package/dist/neutral/StorageMeta/DataHash.d.ts

@@ -7,7 +7,7 @@ export type WithDataHashMeta<T extends Payload = Payload> = T & DataHashMeta;
 export type WithPartialDataHashMeta<T extends Payload = Payload> = Partial<WithDataHashMeta<T>>;
 export declare const isDataHashMeta: (value: unknown) => value is DataHashMeta;
 export declare const asDataHashMeta: import("@xylabs/sdk-js").AsTypeFunction<DataHashMeta>;
-export declare const asOptionalDataHashMeta: (value: import("@xylabs/promise").AnyNonPromise) => DataHashMeta | undefined;
+export declare const asOptionalDataHashMeta: (value: import("@xylabs/sdk-js").AnyNonPromise) => DataHashMeta | undefined;
 /** @deprecated use DataHashMeta instead */
 export interface DataHashStorageMeta extends DataHashMeta {
 }
@@ -20,5 +20,5 @@ export declare const isDataHashStorageMeta: (value: unknown) => value is DataHas
 /** @deprecated use asDataHashMeta instead */
 export declare const asDataHashStorageMeta: import("@xylabs/sdk-js").AsTypeFunction<DataHashMeta>;
 /** @deprecated use asOptionalDataHashMeta instead */
-export declare const asOptionalDataHashStorageMeta: (value: import("@xylabs/promise").AnyNonPromise) => DataHashMeta | undefined;
+export declare const asOptionalDataHashStorageMeta: (value: import("@xylabs/sdk-js").AnyNonPromise) => DataHashMeta | undefined;
 //# sourceMappingURL=DataHash.d.ts.map

package/dist/neutral/StorageMeta/DataHash.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DataHash.d.ts","sourceRoot":"","sources":["../../../src/StorageMeta/DataHash.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAA;AAG1C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AAE5C,MAAM,WAAW,YAAY;IAC3B,SAAS,EAAE,IAAI,CAAA;CAChB;AAED,MAAM,MAAM,gBAAgB,CAAC,CAAC,SAAS,OAAO,GAAG,OAAO,IAAI,CAAC,GAAG,YAAY,CAAA;AAC5E,MAAM,MAAM,uBAAuB,CAAC,CAAC,SAAS,OAAO,GAAG,OAAO,IAAI,OAAO,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAAA;AAE/F,eAAO,MAAM,cAAc,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,YAExD,CAAA;AAED,eAAO,MAAM,cAAc,uDAAuD,CAAA;AAClF,eAAO,MAAM,sBAAsB,8EAA+D,CAAA;AAElG,2CAA2C;AAC3C,MAAM,WAAW,mBAAoB,SAAQ,YAAY;CAAG;AAE5D,+CAA+C;AAC/C,MAAM,MAAM,uBAAuB,CAAC,CAAC,SAAS,OAAO,GAAG,OAAO,IAAI,gBAAgB,CAAC,CAAC,CAAC,CAAA;AAEtF,sDAAsD;AACtD,MAAM,MAAM,8BAA8B,CAAC,CAAC,SAAS,OAAO,GAAG,OAAO,IAAI,uBAAuB,CAAC,CAAC,CAAC,CAAA;AAEpG,6CAA6C;AAC7C,eAAO,MAAM,qBAAqB,UAjBI,OAAO,KAAG,KAAK,IAAI,YAiBN,CAAA;AAEnD,6CAA6C;AAC7C,eAAO,MAAM,qBAAqB,uDAAiB,CAAA;AAEnD,qDAAqD;AACrD,eAAO,MAAM,6BAA6B,8EAAyB,CAAA"}
+{"version":3,"file":"DataHash.d.ts","sourceRoot":"","sources":["../../../src/StorageMeta/DataHash.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAA;AAG1C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AAE5C,MAAM,WAAW,YAAY;IAC3B,SAAS,EAAE,IAAI,CAAA;CAChB;AAED,MAAM,MAAM,gBAAgB,CAAC,CAAC,SAAS,OAAO,GAAG,OAAO,IAAI,CAAC,GAAG,YAAY,CAAA;AAC5E,MAAM,MAAM,uBAAuB,CAAC,CAAC,SAAS,OAAO,GAAG,OAAO,IAAI,OAAO,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAAA;AAE/F,eAAO,MAAM,cAAc,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,YAExD,CAAA;AAED,eAAO,MAAM,cAAc,uDAAuD,CAAA;AAClF,eAAO,MAAM,sBAAsB,6EAA+D,CAAA;AAElG,2CAA2C;AAC3C,MAAM,WAAW,mBAAoB,SAAQ,YAAY;CAAG;AAE5D,+CAA+C;AAC/C,MAAM,MAAM,uBAAuB,CAAC,CAAC,SAAS,OAAO,GAAG,OAAO,IAAI,gBAAgB,CAAC,CAAC,CAAC,CAAA;AAEtF,sDAAsD;AACtD,MAAM,MAAM,8BAA8B,CAAC,CAAC,SAAS,OAAO,GAAG,OAAO,IAAI,uBAAuB,CAAC,CAAC,CAAC,CAAA;AAEpG,6CAA6C;AAC7C,eAAO,MAAM,qBAAqB,UAjBI,OAAO,KAAG,KAAK,IAAI,YAiBN,CAAA;AAEnD,6CAA6C;AAC7C,eAAO,MAAM,qBAAqB,uDAAiB,CAAA;AAEnD,qDAAqD;AACrD,eAAO,MAAM,6BAA6B,6EAAyB,CAAA"}

package/dist/neutral/StorageMeta/Hash.d.ts

@@ -8,7 +8,7 @@ export type WithHashMeta<T extends Payload = Payload> = T & HashMeta;
 export type WithPartialHashMeta<T extends Payload = Payload> = Partial<WithHashMeta<T>>;
 export declare const isHashMeta: (value: unknown) => value is HashMeta;
 export declare const asHashMeta: import("@xylabs/sdk-js").AsTypeFunction<HashMeta>;
-export declare const asOptionalHashMeta: (value: import("@xylabs/promise").AnyNonPromise) => HashMeta | undefined;
+export declare const asOptionalHashMeta: (value: import("@xylabs/sdk-js").AnyNonPromise) => HashMeta | undefined;
 /** @deprecated use HashMeta instead */
 export interface HashStorageMeta extends HashMeta {
 }
@@ -21,5 +21,5 @@ export declare const isHashStorageMeta: (value: unknown) => value is HashMeta;
 /** @deprecated use asHashMeta instead */
 export declare const asHashStorageMeta: import("@xylabs/sdk-js").AsTypeFunction<HashMeta>;
 /** @deprecated use asOptionalHashMeta instead */
-export declare const asOptionalHashStorageMeta: (value: import("@xylabs/promise").AnyNonPromise) => HashMeta | undefined;
+export declare const asOptionalHashStorageMeta: (value: import("@xylabs/sdk-js").AnyNonPromise) => HashMeta | undefined;
 //# sourceMappingURL=Hash.d.ts.map

package/dist/neutral/StorageMeta/Hash.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Hash.d.ts","sourceRoot":"","sources":["../../../src/StorageMeta/Hash.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAA;AAG1C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AAC5C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA;AAGjD,MAAM,WAAW,QAAS,SAAQ,YAAY;IAC5C,KAAK,EAAE,IAAI,CAAA;CACZ;AAED,MAAM,MAAM,YAAY,CAAC,CAAC,SAAS,OAAO,GAAG,OAAO,IAAI,CAAC,GAAG,QAAQ,CAAA;AACpE,MAAM,MAAM,mBAAmB,CAAC,CAAC,SAAS,OAAO,GAAG,OAAO,IAAI,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAA;AAEvF,eAAO,MAAM,UAAU,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,QAEpD,CAAA;AAED,eAAO,MAAM,UAAU,mDAA+C,CAAA;AACtE,eAAO,MAAM,kBAAkB,0EAAuD,CAAA;AAEtF,uCAAuC;AACvC,MAAM,WAAW,eAAgB,SAAQ,QAAQ;CAAG;AAEpD,2CAA2C;AAC3C,MAAM,MAAM,mBAAmB,CAAC,CAAC,SAAS,OAAO,GAAG,OAAO,IAAI,YAAY,CAAC,CAAC,CAAC,CAAA;AAE9E,kDAAkD;AAClD,MAAM,MAAM,0BAA0B,CAAC,CAAC,SAAS,OAAO,GAAG,OAAO,IAAI,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAA;AAE9F,yCAAyC;AACzC,eAAO,MAAM,iBAAiB,UAjBI,OAAO,KAAG,KAAK,IAAI,QAiBV,CAAA;AAE3C,yCAAyC;AACzC,eAAO,MAAM,iBAAiB,mDAAa,CAAA;AAE3C,iDAAiD;AACjD,eAAO,MAAM,yBAAyB,0EAAqB,CAAA"}
+{"version":3,"file":"Hash.d.ts","sourceRoot":"","sources":["../../../src/StorageMeta/Hash.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAA;AAG1C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AAC5C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA;AAGjD,MAAM,WAAW,QAAS,SAAQ,YAAY;IAC5C,KAAK,EAAE,IAAI,CAAA;CACZ;AAED,MAAM,MAAM,YAAY,CAAC,CAAC,SAAS,OAAO,GAAG,OAAO,IAAI,CAAC,GAAG,QAAQ,CAAA;AACpE,MAAM,MAAM,mBAAmB,CAAC,CAAC,SAAS,OAAO,GAAG,OAAO,IAAI,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAA;AAEvF,eAAO,MAAM,UAAU,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,QAEpD,CAAA;AAED,eAAO,MAAM,UAAU,mDAA+C,CAAA;AACtE,eAAO,MAAM,kBAAkB,yEAAuD,CAAA;AAEtF,uCAAuC;AACvC,MAAM,WAAW,eAAgB,SAAQ,QAAQ;CAAG;AAEpD,2CAA2C;AAC3C,MAAM,MAAM,mBAAmB,CAAC,CAAC,SAAS,OAAO,GAAG,OAAO,IAAI,YAAY,CAAC,CAAC,CAAC,CAAA;AAE9E,kDAAkD;AAClD,MAAM,MAAM,0BAA0B,CAAC,CAAC,SAAS,OAAO,GAAG,OAAO,IAAI,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAA;AAE9F,yCAAyC;AACzC,eAAO,MAAM,iBAAiB,UAjBI,OAAO,KAAG,KAAK,IAAI,QAiBV,CAAA;AAE3C,yCAAyC;AACzC,eAAO,MAAM,iBAAiB,mDAAa,CAAA;AAE3C,iDAAiD;AACjD,eAAO,MAAM,yBAAyB,yEAAqB,CAAA"}

package/dist/neutral/StorageMeta/Sequence.d.ts

@@ -7,5 +7,5 @@ export type WithSequenceStorageMeta<T extends Payload = Payload> = T & SequenceS
 export type WithPartialSequenceStorageMeta<T extends Payload = Payload> = Partial<WithSequenceStorageMeta<T>>;
 export declare const isSequenceStorageMeta: (value: unknown) => value is SequenceStorageMeta;
 export declare const asSequenceStorageMeta: import("@xylabs/sdk-js").AsTypeFunction<SequenceStorageMeta>;
-export declare const asOptionalSequenceStorageMeta: (value: import("@xylabs/promise").AnyNonPromise) => SequenceStorageMeta | undefined;
+export declare const asOptionalSequenceStorageMeta: (value: import("@xylabs/sdk-js").AnyNonPromise) => SequenceStorageMeta | undefined;
 //# sourceMappingURL=Sequence.d.ts.map

package/dist/neutral/StorageMeta/Sequence.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Sequence.d.ts","sourceRoot":"","sources":["../../../src/StorageMeta/Sequence.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AAC5C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAA;AAEnD,MAAM,WAAW,mBAAmB;IAClC,SAAS,EAAE,QAAQ,CAAA;CACpB;AAED,MAAM,MAAM,uBAAuB,CAAC,CAAC,SAAS,OAAO,GAAG,OAAO,IAAI,CAAC,GAAG,mBAAmB,CAAA;AAC1F,MAAM,MAAM,8BAA8B,CAAC,CAAC,SAAS,OAAO,GAAG,OAAO,IAAI,OAAO,CAAC,uBAAuB,CAAC,CAAC,CAAC,CAAC,CAAA;AAE7G,eAAO,MAAM,qBAAqB,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,mBAE/D,CAAA;AAED,eAAO,MAAM,qBAAqB,8DAAgD,CAAA;AAClF,eAAO,MAAM,6BAA6B,qFAAwD,CAAA"}
+{"version":3,"file":"Sequence.d.ts","sourceRoot":"","sources":["../../../src/StorageMeta/Sequence.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AAC5C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAA;AAEnD,MAAM,WAAW,mBAAmB;IAClC,SAAS,EAAE,QAAQ,CAAA;CACpB;AAED,MAAM,MAAM,uBAAuB,CAAC,CAAC,SAAS,OAAO,GAAG,OAAO,IAAI,CAAC,GAAG,mBAAmB,CAAA;AAC1F,MAAM,MAAM,8BAA8B,CAAC,CAAC,SAAS,OAAO,GAAG,OAAO,IAAI,OAAO,CAAC,uBAAuB,CAAC,CAAC,CAAC,CAAC,CAAA;AAE7G,eAAO,MAAM,qBAAqB,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,mBAE/D,CAAA;AAED,eAAO,MAAM,qBAAqB,8DAAgD,CAAA;AAClF,eAAO,MAAM,6BAA6B,oFAAwD,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xyo-network/payload-model",
-  "version": "5.3.20",
+  "version": "5.3.24",
   "description": "Primary SDK for using XYO Protocol 2.0",
   "homepage": "https://xyo.network",
   "bugs": {
@@ -30,18 +30,24 @@
   "types": "dist/neutral/index.d.ts",
   "files": [
     "dist",
-    "src",
     "!**/*.bench.*",
     "!**/*.spec.*",
-    "!**/*.test.*"
+    "!**/*.test.*",
+    "README.md"
   ],
   "devDependencies": {
-    "@xylabs/sdk-js": "^5.0.90",
-    "@xylabs/ts-scripts-common": "~7.5.6",
-    "@xylabs/ts-scripts-yarn3": "~7.5.6",
-    "@xylabs/tsconfig": "~7.5.6",
-    "@xylabs/vitest-extended": "~5.0.90",
+    "@opentelemetry/api": "^1.9.1",
+    "@types/node": "^25.5.0",
+    "@xylabs/sdk-js": "^5.0.93",
+    "@xylabs/ts-scripts-common": "~7.6.16",
+    "@xylabs/ts-scripts-pnpm": "~7.6.16",
+    "@xylabs/tsconfig": "~7.6.16",
+    "@xylabs/vitest-extended": "~5.0.93",
+    "acorn": "^8.16.0",
+    "axios": "^1.14.0",
+    "esbuild": "^0.28.0",
     "typescript": "~5.9.3",
+    "vite": "^8.0.3",
     "vitest": "~4.1.2",
     "zod": "~4.3.6"
   },
@@ -52,4 +58,4 @@
   "publishConfig": {
     "access": "public"
   }
-}
+}

package/src/Error.ts

@@ -1,17 +0,0 @@
-import type { Hash, JsonValue } from '@xylabs/sdk-js'
-
-import { isPayloadOfSchemaType } from './isPayloadOfSchemaType.ts'
-import type { Payload } from './Payload.ts'
-import { asSchema, type Schema } from './Schema.ts'
-
-export const ModuleErrorSchema = asSchema('network.xyo.error.module', true)
-export type ModuleErrorSchema = typeof ModuleErrorSchema
-
-export type ModuleError = Payload<{
-  details?: JsonValue
-  message?: string
-  name?: string
-  query?: Hash | Schema
-}, ModuleErrorSchema>
-
-export const isModuleError = isPayloadOfSchemaType<ModuleError>(ModuleErrorSchema)

package/src/Payload.ts

@@ -1,56 +0,0 @@
-import type {
-  DeepOmitStartsWith, DeepPickStartsWith, EmptyObject, Hash,
-} from '@xylabs/sdk-js'
-
-import type { BrandedSchema, Schema } from './Schema.ts'
-
-export interface SchemaField<T extends Schema = Schema> {
-  schema: T
-}
-
-export type WithSchema<T extends EmptyObject | void = void>
-  = T extends EmptyObject ? SchemaField & T : PayloadFields
-
-/** Additional fields for a payload */
-export interface PayloadFields extends SchemaField {}
-
-export interface SourcesMetaField { $sources: Hash[] }
-
-export interface PayloadMetaFields extends SourcesMetaField {}
-
-export type WithPayload<T extends EmptyObject | void = void>
-  = T extends EmptyObject ? PayloadFields & T : PayloadFields
-
-/** Base Type for Payloads */
-export type Payload<T extends void | EmptyObject | SchemaField = void, S extends Schema | void = void>
-  = (T extends SchemaField
-    ? S extends Schema
-      /* T (w/Schema) & S provided */
-      ? WithPayload<Omit<T, 'schema'> & { schema: BrandedSchema<S> }>
-      : /* Only T (w/Schema) provided */ WithPayload<T>
-    : T extends object
-      ? S extends Schema
-      /* T (w/o Schema) & S provided */
-        ? WithPayload<T & { schema: BrandedSchema<S> }>
-        : /* Only T (w/o Schema) provided */ WithPayload<T & PayloadFields>
-      : /* Either just S or neither S or T provided */ WithPayload<{
-        schema: S extends Schema ? S : Schema
-      }>) & Partial<PayloadMetaFields>
-
-export type OverridablePayload<T extends Payload> = WithoutMeta<Omit<T, 'schema'> & PayloadFields>
-
-export type WithSources<T extends EmptyObject> = T & SourcesMetaField
-
-export type PayloadWithSources<T extends void | EmptyObject | SchemaField = void, S extends Schema | void = void> = WithSources<Payload<T, S>>
-
-export type WithAnySchema<T extends Payload> = OverridablePayload<T>
-
-export type WithoutClientMeta<T extends Payload | EmptyObject> = DeepOmitStartsWith<T, '$'> & (T extends Payload ? Payload : EmptyObject)
-export type WithoutStorageMeta<T extends Payload | EmptyObject> = DeepOmitStartsWith<T, '_'> & (T extends Payload ? Payload : EmptyObject)
-export type WithoutPrivateStorageMeta<T extends Payload | EmptyObject> = DeepOmitStartsWith<T, '__'> & (T extends Payload ? Payload : EmptyObject)
-export type WithoutMeta<T extends Payload | EmptyObject> = WithoutClientMeta<WithoutStorageMeta<T>> & (T extends Payload ? Payload : EmptyObject)
-
-export type WithoutSchema<T extends WithOptionalSchema<Payload>> = Omit<T, 'schema'>
-export type WithOptionalSchema<T extends Payload = Payload> = WithoutSchema<T> & Partial<T & SchemaField>
-
-export type WithOnlyClientMeta<T extends Payload> = DeepPickStartsWith<T, '$'>

package/src/PayloadBundle.ts

@@ -1,27 +0,0 @@
-import {
-  HashZod,
-  zodAsFactory, zodIsFactory, zodToFactory,
-} from '@xylabs/sdk-js'
-import z from 'zod'
-
-import { PayloadZodLoose, PayloadZodOfSchema } from './PayloadZod.ts'
-import { asSchema } from './Schema.ts'
-
-// payload that wraps a complete boundwitness with its payloads for use in systems such as submission queues
-export const PayloadBundleSchema = asSchema('network.xyo.payload.bundle', true)
-export type PayloadBundleSchema = typeof PayloadBundleSchema
-
-export const PayloadBundleFieldsZod = z.object({
-  payloads: PayloadZodLoose.array(),
-  root: HashZod,
-})
-
-export type PayloadBundleFields = z.infer<typeof PayloadBundleFieldsZod>
-
-export const PayloadBundleZod = PayloadZodOfSchema(PayloadBundleSchema).extend(PayloadBundleFieldsZod.shape)
-
-export type PayloadBundle = z.infer<typeof PayloadBundleZod>
-
-export const isPayloadBundle = zodIsFactory(PayloadBundleZod)
-export const asPayloadBundle = zodAsFactory(PayloadBundleZod, 'asPayloadBundle')
-export const asOptionalPayloadBundle = zodToFactory(PayloadBundleZod, 'asPayloadBundle')

package/src/PayloadFindFilter.ts

@@ -1,5 +0,0 @@
-export interface PayloadFindFilter {
-  limit?: number
-  order?: 'desc' | 'asc'
-  schema?: string | string[]
-}

package/src/PayloadHashMap.ts

@@ -1,11 +0,0 @@
-import type { Hash } from '@xylabs/sdk-js'
-
-import type { Payload } from './Payload.ts'
-
-export interface PayloadHashMap<TPayload extends Payload = Payload, TId extends string | number | symbol = Hash> {
-  // these hashes are data hashes, but reference an arbitrary root hash that matches the data hash
-  // this list can be shorter than the full list since multiple root hashes may have the same data hash
-  dataHash: Record<TId, TId>
-  // this if the full list of all payloads
-  hash: Record<TId, TPayload>
-}

package/src/PayloadSet/PayloadSetPayload.ts

@@ -1,9 +0,0 @@
-import type { Payload } from '../Payload.ts'
-import type { PayloadSetSchema } from './PayloadSetSchema.ts'
-
-export interface PayloadSet {
-  optional?: Record<string, number>
-  required?: Record<string, number>
-}
-
-export type PayloadSetPayload = Payload<PayloadSet, PayloadSetSchema>

package/src/PayloadSet/PayloadSetSchema.ts

@@ -1,4 +0,0 @@
-import { asSchema } from '../Schema.ts'
-
-export const PayloadSetSchema = asSchema('network.xyo.payload.set', true)
-export type PayloadSetSchema = typeof PayloadSetSchema

package/src/PayloadSet/index.ts

@@ -1,2 +0,0 @@
-export * from './PayloadSetPayload.ts'
-export * from './PayloadSetSchema.ts'

package/src/PayloadValidationFunction.ts

@@ -1,16 +0,0 @@
-import type { Payload } from './Payload.ts'
-
-/**
- * A function that validates the supplied payload synchronously
- */
-export type SyncPayloadValidationFunction<T extends Payload = Payload> = (payload: T) => boolean
-
-/**
- * A function that validates the supplied payload asynchronously
- */
-export type AsyncPayloadValidationFunction<T extends Payload = Payload> = (payload: T) => Promise<boolean>
-
-/**
- * A function that validates the supplied payload
- */
-export type PayloadValidationFunction<T extends Payload = Payload> = SyncPayloadValidationFunction<T> | AsyncPayloadValidationFunction<T>

package/src/PayloadValueExpression.ts

@@ -1,43 +0,0 @@
-import type { Payload } from './Payload.ts'
-
-/**
- * Type corresponding to the properties of a payload
- */
-export type PayloadProperty<
-  /**
-   * The type of payload
-   */
-  T extends Payload = Payload,
-> = keyof T
-
-/**
- * Type corresponding to the payload values
- */
-export type PayloadValue<
-  /**
-   * The type of payload
-   */
-  T extends Payload = Payload,
-  /**
-   * The property of the payload to select
-   */
-  Key extends PayloadProperty<T> = PayloadProperty<T>,
-> = T[Key]
-
-/**
- * An expressions that selects a property value from the payload
- */
-export type PayloadValueExpression<
-  /**
-   * The type of payload
-   */
-  T extends Payload = Payload,
-  /**
-   * The property of the payload to select
-   */
-  Key extends PayloadProperty<T> = PayloadProperty<T>,
-  /**
-   * The type of the selected property's value
-   */
-  TValue = PayloadValue<T, Key>,
-> = (payload: T) => TValue

package/src/PayloadZod.ts

@@ -1,78 +0,0 @@
-import {
-  HashZod,
-  zodAsFactory, zodIsFactory, zodToFactory,
-} from '@xylabs/sdk-js'
-import type { ZodRawShape } from 'zod'
-import z from 'zod'
-
-import type { Payload } from './Payload.ts'
-import type { Schema } from './Schema.ts'
-import { SchemaZod } from './Schema.ts'
-import { SequenceFromStringZod } from './StorageMeta/index.ts'
-
-export const HashMetaZod = z.object({
-  _hash: HashZod,
-  _dataHash: HashZod,
-})
-
-export type HashMeta = z.infer<typeof HashMetaZod>
-
-export type WithHashMeta<T extends Payload> = T & HashMeta
-
-export const isHashMeta = zodIsFactory(HashMetaZod)
-export const asHashMeta = zodAsFactory(HashMetaZod, 'asHashMeta')
-export const toHashMeta = zodToFactory(HashMetaZod, 'toHashMeta')
-
-export const SequenceMetaZod = z.object({ _sequence: SequenceFromStringZod })
-
-export type SequenceMeta = z.infer<typeof SequenceMetaZod>
-
-export const isSequenceMeta = zodIsFactory(SequenceMetaZod)
-export const asSequenceMeta = zodAsFactory(SequenceMetaZod, 'asSequenceMeta')
-export const toSequenceMeta = zodToFactory(SequenceMetaZod, 'toSequenceMeta')
-
-export const StorageMetaZod = z.object({
-  _hash: HashZod,
-  _dataHash: HashZod,
-  _sequence: SequenceFromStringZod,
-})
-
-export type StorageMeta = z.infer<typeof StorageMetaZod>
-
-export type WithStorageMeta<T extends Payload = Payload> = T & StorageMeta
-
-export const isStorageMeta = zodIsFactory(StorageMetaZod)
-export const asStorageMeta = zodAsFactory(StorageMetaZod, 'asStorageMeta')
-export const toStorageMeta = zodToFactory(StorageMetaZod, 'toStorageMeta')
-
-export const PayloadZod = z.object({ schema: SchemaZod })
-
-export const isPayload = zodIsFactory(PayloadZod)
-export const asPayload = zodAsFactory(PayloadZod, 'asPayload')
-export const toPayload = zodToFactory(PayloadZod, 'toPayload')
-
-export const AnyPayloadZod = PayloadZod.loose()
-
-export const isAnyPayload = zodIsFactory(AnyPayloadZod)
-export const asAnyPayload = zodAsFactory(AnyPayloadZod, 'asAnyPayload')
-export const toAnyPayload = zodToFactory(AnyPayloadZod, 'toAnyPayload')
-
-export type AnyPayload = z.infer<typeof AnyPayloadZod>
-
-export function WithStorageMetaZod<T extends ZodRawShape>(valueZod: z.ZodObject<T>) {
-  return z.object({ ...valueZod.shape, ...StorageMetaZod.shape })
-}
-
-export function WithHashMetaZod<T extends ZodRawShape>(valueZod: z.ZodObject<T>) {
-  return z.object({ ...valueZod.shape, ...HashMetaZod.shape })
-}
-
-export const PayloadZodStrict = z.strictObject({ schema: SchemaZod })
-export type PayloadZodStrict = typeof PayloadZodStrict
-
-export const PayloadZodLoose: PayloadZodStrict = z.looseObject({ schema: SchemaZod })
-export type PayloadZodLoose = typeof PayloadZodLoose
-
-export const PayloadZodOfSchema = <S extends Schema>(schema: S) => PayloadZod.extend({ schema: z.literal(schema) })
-export const PayloadZodStrictOfSchema = <S extends Schema>(schema: S) => PayloadZodStrict.extend({ schema: z.literal(schema) })
-export const PayloadZodLooseOfSchema = <S extends Schema>(schema: S) => PayloadZodLoose.extend({ schema: z.literal(schema) })

package/src/Query.ts

@@ -1,27 +0,0 @@
-import type { Address, EmptyObject } from '@xylabs/sdk-js'
-
-import type { Payload, SchemaField } from './Payload.ts'
-import type { Schema } from './Schema.ts'
-
-export interface QueryFields {
-  /** @field The addresses of the intended handlers */
-  address?: Address | Address[]
-
-  /** @field The maximum XYO that can be spent executing the query */
-  budget?: number
-
-  /** @field The frequency on which this query can be rerun */
-  maxFrequency?: 'once' | 'second' | 'minute' | 'hour' | 'day' | 'week' | 'month' | 'year'
-
-  /** @field The starting point for the bidding on the query */
-  minBid?: number
-}
-
-export type Query<T extends void | EmptyObject | SchemaField = void, S extends Schema | void = void> = Payload<
-  T extends void ? QueryFields : T & QueryFields,
-  S extends void
-    ? T extends SchemaField ? T['schema']
-      : T extends void ? Schema
-        : void
-    : S
->

package/src/Schema.ts

@@ -1,21 +0,0 @@
-import type { Brand } from '@xylabs/sdk-js'
-import { zodAsFactory, zodIsFactory } from '@xylabs/sdk-js'
-import z from 'zod'
-
-export type BrandedSchema<T extends string = string> = Brand<T, { readonly __schema: true }>
-export const SchemaRegEx = /^(?:[a-z0-9]+\.)*[a-z0-9]+$/
-
-export const SchemaZod = z.string().regex(SchemaRegEx).transform<BrandedSchema>(v => v as BrandedSchema)
-export type Schema<T extends string = string> = z.infer<typeof SchemaZod> & BrandedSchema<T>
-
-export const makeSchema = <T extends string>(value: T) => {
-  return (z.templateLiteral([z.literal(value)])).transform(x => x as (typeof x & { __schema: true }))
-}
-
-export const isSchema = zodIsFactory(SchemaZod)
-export const asSchema = zodAsFactory(SchemaZod, 'asSchema')
-export const toSchema = zodAsFactory(SchemaZod, 'toSchema')
-
-export const PayloadSchema = asSchema('network.xyo.payload', true)
-export const PayloadSchemaZod = z.literal(PayloadSchema)
-export type PayloadSchema = z.infer<typeof PayloadSchemaZod>

package/src/StorageMeta/DataHash.ts

@@ -1,36 +0,0 @@
-import type { Hash } from '@xylabs/sdk-js'
-import { AsObjectFactory, isHash } from '@xylabs/sdk-js'
-
-import type { Payload } from '../Payload.ts'
-
-export interface DataHashMeta {
-  _dataHash: Hash
-}
-
-export type WithDataHashMeta<T extends Payload = Payload> = T & DataHashMeta
-export type WithPartialDataHashMeta<T extends Payload = Payload> = Partial<WithDataHashMeta<T>>
-
-export const isDataHashMeta = (value: unknown): value is DataHashMeta => {
-  return isHash((value as WithDataHashMeta)?._dataHash)
-}
-
-export const asDataHashMeta = AsObjectFactory.create<DataHashMeta>(isDataHashMeta)
-export const asOptionalDataHashMeta = AsObjectFactory.createOptional<DataHashMeta>(isDataHashMeta)
-
-/** @deprecated use DataHashMeta instead */
-export interface DataHashStorageMeta extends DataHashMeta {}
-
-/** @deprecated use WithDataHashMeta instead */
-export type WithDataHashStorageMeta<T extends Payload = Payload> = WithDataHashMeta<T>
-
-/** @deprecated use WithPartialDataHashMeta instead */
-export type WithPartialDataHashStorageMeta<T extends Payload = Payload> = WithPartialDataHashMeta<T>
-
-/** @deprecated use isDataHashMeta instead */
-export const isDataHashStorageMeta = isDataHashMeta
-
-/** @deprecated use asDataHashMeta instead */
-export const asDataHashStorageMeta = asDataHashMeta
-
-/** @deprecated use asOptionalDataHashMeta instead */
-export const asOptionalDataHashStorageMeta = asOptionalDataHashMeta

package/src/StorageMeta/Hash.ts

@@ -1,38 +0,0 @@
-import type { Hash } from '@xylabs/sdk-js'
-import { AsObjectFactory, isHash } from '@xylabs/sdk-js'
-
-import type { Payload } from '../Payload.ts'
-import type { DataHashMeta } from './DataHash.ts'
-import { isDataHashMeta } from './DataHash.ts'
-
-export interface HashMeta extends DataHashMeta {
-  _hash: Hash
-}
-
-export type WithHashMeta<T extends Payload = Payload> = T & HashMeta
-export type WithPartialHashMeta<T extends Payload = Payload> = Partial<WithHashMeta<T>>
-
-export const isHashMeta = (value: unknown): value is HashMeta => {
-  return isDataHashMeta(value) && isHash((value as WithHashMeta)?._hash)
-}
-
-export const asHashMeta = AsObjectFactory.create<HashMeta>(isHashMeta)
-export const asOptionalHashMeta = AsObjectFactory.createOptional<HashMeta>(isHashMeta)
-
-/** @deprecated use HashMeta instead */
-export interface HashStorageMeta extends HashMeta {}
-
-/** @deprecated use WithHashMeta instead */
-export type WithHashStorageMeta<T extends Payload = Payload> = WithHashMeta<T>
-
-/** @deprecated use WithPartialHashMeta instead */
-export type WithPartialHashStorageMeta<T extends Payload = Payload> = Partial<WithHashMeta<T>>
-
-/** @deprecated use isHashMeta instead */
-export const isHashStorageMeta = isHashMeta
-
-/** @deprecated use asHashMeta instead */
-export const asHashStorageMeta = asHashMeta
-
-/** @deprecated use asOptionalHashMeta instead */
-export const asOptionalHashStorageMeta = asOptionalHashMeta

package/src/StorageMeta/Sequence.ts

@@ -1,18 +0,0 @@
-import { AsObjectFactory } from '@xylabs/sdk-js'
-
-import type { Payload } from '../Payload.ts'
-import type { Sequence } from './sequence/index.ts'
-
-export interface SequenceStorageMeta {
-  _sequence: Sequence
-}
-
-export type WithSequenceStorageMeta<T extends Payload = Payload> = T & SequenceStorageMeta
-export type WithPartialSequenceStorageMeta<T extends Payload = Payload> = Partial<WithSequenceStorageMeta<T>>
-
-export const isSequenceStorageMeta = (value: unknown): value is SequenceStorageMeta => {
-  return (value as WithSequenceStorageMeta)?._sequence != undefined
-}
-
-export const asSequenceStorageMeta = AsObjectFactory.create(isSequenceStorageMeta)
-export const asOptionalSequenceStorageMeta = AsObjectFactory.createOptional(isSequenceStorageMeta)

package/src/StorageMeta/index.ts

@@ -1,2 +0,0 @@
-export * from './Sequence.ts'
-export * from './sequence/index.ts'

package/src/StorageMeta/sequence/Comparer.ts

@@ -1,18 +0,0 @@
-import type { Compare } from '@xylabs/sdk-js'
-
-import { SequenceParser } from './Parser.ts'
-import type { Sequence } from './Sequence.ts'
-
-const local: Compare<Sequence> = (a, b) => {
-  const aa = SequenceParser.from(a)
-  const bb = SequenceParser.from(b)
-  return aa.localSequence > bb.localSequence ? 1 : aa.localSequence < bb.localSequence ? -1 : 0
-}
-
-const qualified: Compare<Sequence> = (a, b) => {
-  const aa = SequenceParser.from(a)
-  const bb = SequenceParser.from(b)
-  return aa.qualifiedSequence > bb.qualifiedSequence ? 1 : aa.qualifiedSequence < bb.qualifiedSequence ? -1 : 0
-}
-
-export const SequenceComparer = { local, qualified }

package/src/StorageMeta/sequence/Parser.ts

@@ -1,142 +0,0 @@
-import type {
-  Address,
-  Hash, Hex,
-} from '@xylabs/sdk-js'
-import {
-  assertEx,
-  isAddress,
-  toAddress,
-  toHex, toUint8Array,
-} from '@xylabs/sdk-js'
-
-import type {
-  Epoch, LocalSequence, Nonce, QualifiedSequence,
-  Sequence,
-} from './Sequence.ts'
-import {
-  isQualifiedSequence, isSequence,
-  SequenceConstants,
-} from './Sequence.ts'
-
-export class SequenceParser {
-  protected static privateConstructorKey = Date.now().toString()
-
-  private readonly data: Readonly<Uint8Array>
-
-  protected constructor(privateConstructorKey: string, hex: Hex) {
-    assertEx(SequenceParser.privateConstructorKey === privateConstructorKey, () => 'Use create function instead of constructor')
-    const paddedHex = toHex(hex, {
-      prefix: false,
-      bitLength: (hex.length <= SequenceConstants.localSequenceBytes * 2)
-        ? SequenceConstants.localSequenceBytes * 8
-        : SequenceConstants.qualifiedSequenceBytes * 8,
-    })
-    this.data = toUint8Array(paddedHex)
-  }
-
-  get address(): Address {
-    const start = SequenceConstants.localSequenceBytes
-    const end = SequenceConstants.qualifiedSequenceBytes
-    return toAddress(this.data.slice(start, end).buffer, { prefix: false })
-  }
-
-  get epoch(): Epoch {
-    const start = 0
-    const end = SequenceConstants.epochBytes
-    return toHex(this.data.slice(start, end).buffer, { prefix: false }) as Epoch
-  }
-
-  get localSequence(): LocalSequence {
-    const start = 0
-    const end = SequenceConstants.localSequenceBytes
-    return toHex(this.data.slice(start, end).buffer, { prefix: false }) as LocalSequence
-  }
-
-  get nonce(): Nonce {
-    const start = SequenceConstants.epochBytes
-    const end = SequenceConstants.localSequenceBytes
-    return toHex(this.data.slice(start, end).buffer, { prefix: false }) as Nonce
-  }
-
-  get qualifiedSequence(): QualifiedSequence {
-    const start = 0
-    const end = SequenceConstants.qualifiedSequenceBytes
-    return toHex(this.data.slice(start, end).buffer, { prefix: false }) as QualifiedSequence
-  }
-
-  static from(sequence: Sequence, address?: Address): SequenceParser
-  static from(timestamp: Hex, hash: Hash, address?: Address): SequenceParser
-  static from(timestamp: Hex, hash: Hex, address?: Address): SequenceParser
-  static from(timestamp: Hex, nonce: Nonce, address?: Address): SequenceParser
-  static from(timestamp: Hex, hash: Hash, index?: number, address?: Address): SequenceParser
-  static from(timestamp: Hex, hash: Hex, index?: number, address?: Address): SequenceParser
-  static from(timestamp: Hex, nonce: Nonce, index?: number, address?: Address): SequenceParser
-  static from(timestamp: number, hash: Hash, address?: Address): SequenceParser
-  static from(timestamp: number, hash: Hex, address?: Address): SequenceParser
-  static from(timestamp: number, nonce: Nonce, address?: Address): SequenceParser
-  static from(timestamp: number, hash: Hash, index?: number, address?: Address): SequenceParser
-  static from(timestamp: number, hash: Hex, index?: number, address?: Address): SequenceParser
-  static from(timestamp: number, nonce: Nonce, index?: number, address?: Address): SequenceParser
-  static from(
-    timestampOrSequence: Hex | number,
-    nonceOrAddress?: Hex,
-    addressOrIndex?: Address | number,
-    addressOnly?: Address,
-  ): SequenceParser {
-    const address = typeof addressOrIndex === 'number' ? addressOnly : addressOrIndex
-    const index = typeof addressOrIndex === 'number' ? addressOrIndex : undefined
-    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')
-        return new this(SequenceParser.privateConstructorKey, (timestampOrSequence + address) as Hex)
-      }
-      return new this(SequenceParser.privateConstructorKey, timestampOrSequence)
-    }
-    const epoch = SequenceParser.toEpoch(timestampOrSequence)
-    const nonce = nonceOrAddress === undefined ? undefined : SequenceParser.toNonce(nonceOrAddress, index)
-    const addressHex: Hex = address ? toHex(address, { bitLength: SequenceConstants.addressBytes * 8 }) : SequenceConstants.minAddress
-    const hexString = (epoch + nonce + addressHex) as Hex
-    assertEx(isSequence(hexString), () => `Invalid sequence [${hexString}] [${epoch}, ${nonce}, ${addressHex}]`)
-    return new this(SequenceParser.privateConstructorKey, hexString)
-  }
-
-  static parse(value: Hex | string | ArrayBufferLike): SequenceParser {
-    const hex = toHex(value)
-    if (isSequence(hex)) {
-      return new this(SequenceParser.privateConstructorKey, hex)
-    }
-    throw new Error(`Invalid sequence [${value}]`)
-  }
-
-  // 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: number | Hex | Epoch): Epoch {
-    assertEx(
-      typeof value !== 'number' || Number.isInteger(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 }) as Epoch
-    }
-    if (isSequence(hex)) {
-      return hex.slice(0, SequenceConstants.epochBytes * 2) as Epoch
-    }
-    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: Hash | Hex, index = 0): Nonce {
-    assertEx(
-      typeof value !== 'number' || Number.isInteger(value),
-      () => 'Value must be in integer',
-    )
-    const hex = toHex(value, { prefix: false })
-    if (isSequence(hex)) {
-      return hex.slice(SequenceConstants.epochBytes * 2, SequenceConstants.localSequenceBytes * 2) as Nonce
-    }
-    const hashHex = toHex((hex as string), { 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) as Nonce
-  }
-}

package/src/StorageMeta/sequence/Sequence.ts

@@ -1,80 +0,0 @@
-import type {
-  Address, Brand, Hex,
-} from '@xylabs/sdk-js'
-import { isHex } from '@xylabs/sdk-js'
-
-// we use Exclude to intentionally make the type not equal to string
-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 const isEpoch = (value: unknown): value is Epoch => {
-  return isHex(value) && (value as string).length === SequenceConstants.epochBytes * 2
-}
-
-export type Nonce = Brand<Hex, { __nonce: true }>
-
-export const isNonce = (value: unknown): value is Nonce => {
-  return isHex(value) && (value as string).length === SequenceConstants.nonceBytes * 2
-}
-
-export const isLocalSequence = (value: unknown): value is LocalSequence => {
-  return isHex(value) && (value as string).length === SequenceConstants.localSequenceBytes * 2
-}
-
-export const isQualifiedSequence = (value: unknown): value is QualifiedSequence => {
-  return isHex(value) && (value as string).length === SequenceConstants.qualifiedSequenceBytes * 2
-}
-
-export const isSequence = (value: unknown): value is Sequence => {
-  return isLocalSequence(value) || isQualifiedSequence(value)
-}
-
-export const SequenceNonceComponentLengths = {
-  nonceIndexBytes: 4,
-  nonceHashBytes: 4,
-}
-
-export const SequenceComponentLengths = {
-  ...SequenceNonceComponentLengths,
-  epochBytes: 8,
-  nonceBytes: SequenceNonceComponentLengths.nonceIndexBytes + SequenceNonceComponentLengths.nonceHashBytes,
-  addressBytes: 20,
-}
-
-export const SequenceComponentMinMax = {
-  minEpoch: '0'.repeat(SequenceComponentLengths.epochBytes * 2) as Epoch,
-  maxEpoch: 'f'.repeat(SequenceComponentLengths.epochBytes * 2) as Epoch,
-  minNonce: '0'.repeat(SequenceComponentLengths.nonceBytes * 2) as Nonce,
-  maxNonce: 'f'.repeat(SequenceComponentLengths.nonceBytes * 2) as Nonce,
-  minAddress: '0'.repeat(SequenceComponentLengths.addressBytes * 2) as Address,
-  maxAddress: 'f'.repeat(SequenceComponentLengths.addressBytes * 2) as Address,
-}
-
-export const LocalSequenceConstants = {
-  ...SequenceComponentLengths,
-  ...SequenceComponentMinMax,
-  localSequenceBytes: SequenceComponentLengths.epochBytes + SequenceComponentLengths.nonceBytes,
-  minLocalSequence: SequenceComponentMinMax.minEpoch + SequenceComponentMinMax.minNonce as LocalSequence,
-  maxLocalSequence: SequenceComponentMinMax.maxEpoch + SequenceComponentMinMax.maxNonce as LocalSequence,
-}
-
-export const QualifiedSequenceConstants = {
-  qualifiedSequenceBytes: LocalSequenceConstants.localSequenceBytes + SequenceComponentLengths.addressBytes,
-  minQualifiedSequence: LocalSequenceConstants.minLocalSequence + SequenceComponentMinMax.minAddress as QualifiedSequence,
-  maxQualifiedSequence: LocalSequenceConstants.maxLocalSequence + SequenceComponentMinMax.maxAddress as QualifiedSequence,
-}
-
-export const SequenceConstants = {
-  ...LocalSequenceConstants,
-  ...QualifiedSequenceConstants,
-}
-
-// "11111111111111112222222222222222" is and example of a local sequence string
-
-// "111111111111111122222222222222223333333333333333333333333333333333333333" is and example of a local sequence string
-// epoch = "1111111111111111"
-// nonce = "2222222222222222"
-// address = "3333333333333333333333333333333333333333"

package/src/StorageMeta/sequence/SequenceZod.ts

@@ -1,16 +0,0 @@
-import { HexRegExMinMax, toHex } from '@xylabs/sdk-js'
-import z from 'zod'
-
-import type { LocalSequence, QualifiedSequence } from './Sequence.ts'
-import { SequenceConstants } from './Sequence.ts'
-
-const LocalSequenceRegex = new RegExp(HexRegExMinMax(SequenceConstants.localSequenceBytes, SequenceConstants.localSequenceBytes))
-export const LocalSequenceToStringZod = z.string().regex(LocalSequenceRegex)
-export const LocalSequenceFromStringZod = z.string().regex(LocalSequenceRegex).transform<LocalSequence>(v => toHex(v) as LocalSequence)
-
-const QualifiedSequenceRegex = new RegExp(HexRegExMinMax(SequenceConstants.qualifiedSequenceBytes, SequenceConstants.qualifiedSequenceBytes))
-export const QualifiedSequenceToStringZod = z.string().regex(QualifiedSequenceRegex)
-export const QualifiedSequenceFromStringZod = z.string().regex(QualifiedSequenceRegex).transform<QualifiedSequence>(v => toHex(v) as QualifiedSequence)
-
-export const SequenceToStringZod = z.union([LocalSequenceToStringZod, QualifiedSequenceToStringZod])
-export const SequenceFromStringZod = z.union([LocalSequenceFromStringZod, QualifiedSequenceFromStringZod])

package/src/StorageMeta/sequence/index.ts

@@ -1,4 +0,0 @@
-export * from './Comparer.ts'
-export * from './Parser.ts'
-export * from './Sequence.ts'
-export * from './SequenceZod.ts'

package/src/Timestamp.ts

@@ -1,9 +0,0 @@
-import type { EmptyObject } from '@xylabs/sdk-js'
-
-/** 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

package/src/index.ts

@@ -1,15 +0,0 @@
-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'

package/src/isPayloadOfSchemaType.ts

@@ -1,32 +0,0 @@
-import type { Payload, WithSources } from './Payload.ts'
-import { isAnyPayload } from './PayloadZod.ts'
-
-export function isPayloadOfSchemaType<T extends Payload | never = never>(schema: T['schema']) {
-  return (x?: unknown | null): x is T => isAnyPayload(x) && x?.schema === schema
-}
-
-export const isPayloadOfSchemaTypeWithSources = <T extends Payload | never = never>(schema: T['schema']) => {
-  return (x?: unknown | null): x is WithSources<T> =>
-    isPayloadOfSchemaType<WithSources<T>>(schema)(x) && x.$sources != undefined && Array.isArray(x.$sources)
-}
-
-export const notPayloadOfSchemaType = <T extends Payload | never = never>(schema: T['schema']) => {
-  return (x?: unknown | null): x is T => !isAnyPayload(x) || x?.schema !== schema
-}
-
-// test types -- keep for future validation, but comment out
-
-/*
-type TestSchema = 'network.xyo.test'
-const TestSchema: TestSchema = 'network.xyo.test'
-
-type Test = Payload<{ field: string }, TestSchema>
-
-const testPayload: Test = { field: 'test', schema: TestSchema }
-
-const testPayloads: Payload[] = [testPayload]
-
-const isTest: Test[] = testPayloads.filter(isPayloadOfSchemaType<Payload>(TestSchema))
-
-const isTestFromMetaTyped = testMetaPayloads.filter(isPayloadOfSchemaType<Test>(TestSchema))
-*/

package/src/isPayloadOfZodType.ts

@@ -1,25 +0,0 @@
-import { isDefined } from '@xylabs/sdk-js'
-import type { ZodObject } from 'zod'
-
-import type { Payload } from './Payload.ts'
-import { isAnyPayload } from './PayloadZod.ts'
-
-/**
- * Checks if a value is a payload of a specific Zod type.
- * @param zodSchema The Zod schema to validate against
- * @param schema The schema string to match against the payload. Optional in
- * case you want to validate any payload matching the Zod schema or in case
- * schema is part of the Zod schema.
- * @returns A function that checks if a value is a payload of the specified Zod type
- */
-export function isPayloadOfZodType<
-  T extends Payload | never = never,
-  S extends ZodObject = ZodObject,
->(zodSchema: S, schema?: T['schema']) {
-  return (x?: unknown | null): x is T => {
-    if (!isAnyPayload(x)) return false
-    if (isDefined(schema) && x.schema !== schema) return false
-    const { schema: _, ...data } = x
-    return zodSchema.safeParse(data).success
-  }
-}

package/src/types.d.ts

@@ -1,6 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/* eslint-disable @typescript-eslint/no-unused-vars */
-export interface Array<T> {
-  filter<T extends S>(predicate: (value: T, index: number, array: T[]) => value is S, thisArg?: any): S[]
-  find<T extends S>(predicate: (value: T, index: number, obj: T[]) => value is S, thisArg?: any): S | undefined
-}