@xyo-network/xl1-rpc 1.16.5 → 1.16.7

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "http://json.schemastore.org/package.json",
   "name": "@xyo-network/xl1-rpc",
-  "version": "1.16.5",
+  "version": "1.16.7",
   "description": "XYO Layer One API",
   "homepage": "https://xylabs.com",
   "bugs": {
@@ -56,34 +56,34 @@
   },
   "dependencies": {
     "@metamask/json-rpc-engine": "~10.1.1",
-    "@xylabs/assert": "~5.0.22",
-    "@xylabs/axios": "~5.0.22",
-    "@xylabs/hex": "~5.0.22",
-    "@xylabs/typeof": "~5.0.22",
-    "@xyo-network/archivist-model": "~5.1.19",
-    "@xyo-network/boundwitness-model": "~5.1.19",
-    "@xyo-network/module-model": "~5.1.19",
-    "@xyo-network/node-model": "~5.1.19",
-    "@xyo-network/payload-builder": "~5.1.19",
-    "@xyo-network/payload-model": "~5.1.19",
-    "@xyo-network/xl1-protocol": "~1.13.1",
-    "@xyo-network/xl1-protocol-sdk": "~1.16.5",
+    "@xylabs/assert": "~5.0.24",
+    "@xylabs/axios": "~5.0.24",
+    "@xylabs/hex": "~5.0.24",
+    "@xylabs/typeof": "~5.0.24",
+    "@xyo-network/archivist-model": "~5.1.21",
+    "@xyo-network/boundwitness-model": "~5.1.21",
+    "@xyo-network/module-model": "~5.1.21",
+    "@xyo-network/node-model": "~5.1.21",
+    "@xyo-network/payload-builder": "~5.1.21",
+    "@xyo-network/payload-model": "~5.1.21",
+    "@xyo-network/xl1-protocol": "~1.13.6",
+    "@xyo-network/xl1-protocol-sdk": "~1.16.7",
     "axios": "~1.13.2",
     "uuid": "~13.0.0",
     "zod": "~4.1.12"
   },
   "devDependencies": {
     "@metamask/utils": "~11.8.1",
-    "@types/node": "~24.10.0",
-    "@xylabs/logger": "~5.0.22",
-    "@xylabs/object": "~5.0.22",
+    "@types/node": "~24.10.1",
+    "@xylabs/logger": "~5.0.24",
+    "@xylabs/object": "~5.0.24",
     "@xylabs/ts-scripts-yarn3": "~7.2.8",
     "@xylabs/tsconfig": "~7.2.8",
-    "@xylabs/vitest-extended": "~5.0.22",
-    "@xyo-network/account": "~5.1.19",
-    "@xyo-network/account-model": "~5.1.19",
-    "@xyo-network/chain-protocol": "~1.16.5",
-    "@xyo-network/wallet": "~5.1.19",
+    "@xylabs/vitest-extended": "~5.0.24",
+    "@xyo-network/account": "~5.1.21",
+    "@xyo-network/account-model": "~5.1.21",
+    "@xyo-network/chain-protocol": "~1.16.7",
+    "@xyo-network/wallet": "~5.1.21",
     "dotenv": "~17.2.3",
     "eslint": "^9.39.1",
     "typescript": "~5.9.3",

package/src/provider/viewer/JsonRpcXyoViewer.ts

@@ -1,5 +1,7 @@
-import type { Address, Hash } from '@xylabs/hex'
-import { isDefined } from '@xylabs/typeof'
+import {
+  type Address, asHash, type Hash,
+  isHash,
+} from '@xylabs/hex'
 import type {
   AttoXL1,
   BlockRange,
@@ -10,7 +12,10 @@ import type {
   StepIdentityString,
   XL1BlockRange,
 } from '@xyo-network/xl1-protocol'
-import { asAttoXL1, asHydratedBlock } from '@xyo-network/xl1-protocol'
+import {
+  asAttoXL1, asHydratedBlock, asXL1BlockRange,
+  isRange,
+} from '@xyo-network/xl1-protocol'
 import type {
   AccountBalanceHistoryItem,
   ForkHistory, NetworkStakeViewer, Position, TransferBalanceHistoryItem, TransferPair, XyoViewer,
@@ -40,8 +45,19 @@ export class JsonRpcXyoViewer implements XyoViewer {
     return asAttoXL1(await this.transport.sendRequest('xyoViewer_accountBalance', [address]))
   }
 
-  async accountBalanceHistory(address: Address, range?: BlockRange): Promise<AccountBalanceHistoryItem[]> {
-    return (await this.transport.sendRequest('xyoViewer_accountBalanceHistory', isDefined(range) ? [address, range] : [address])) as AccountBalanceHistoryItem[]
+  async accountBalanceHistory(address: Address): Promise<AccountBalanceHistoryItem[]>
+  async accountBalanceHistory(address: Address, head: Hash): Promise<AccountBalanceHistoryItem[]>
+  async accountBalanceHistory(address: Address, range: BlockRange): Promise<AccountBalanceHistoryItem[]>
+  async accountBalanceHistory(address: Address, headOrRange?: BlockRange | Hash): Promise<AccountBalanceHistoryItem[]> {
+    const head = asHash(headOrRange)
+    const range = asXL1BlockRange(headOrRange)
+    if (isHash(head)) {
+      return (await this.transport.sendRequest('xyoViewer_accountBalanceHistory', [address, head])) as AccountBalanceHistoryItem[]
+    }
+    if (isRange(range)) {
+      return (await this.transport.sendRequest('xyoViewer_accountBalanceHistory', [address, range])) as AccountBalanceHistoryItem[]
+    }
+    return (await this.transport.sendRequest('xyoViewer_accountBalanceHistory', [address, range])) as AccountBalanceHistoryItem[]
   }
 
   async blockByHash(hash: Hash): Promise<HydratedBlock | null> {

package/src/types/schema/NetworkStakeViewerRpcSchemas.ts

@@ -1,8 +1,8 @@
 import { BigIntToJsonZod, JsonToBigIntZod } from '@xylabs/hex'
+import { BlockNumberZod } from '@xyo-network/xl1-protocol'
 import * as z from 'zod'
 
 import type { NetworkStakeViewerRpcMethodName } from '../NetworkStakeViewerRpc.ts'
-import { BlockNumberZod } from './common/index.ts'
 import type { RpcSchemaMap } from './RpcSchemaMap.ts'
 
 export const NetworkStakeViewerRpcSchemas = {

package/src/types/schema/XyoViewerRpcSchemas.ts

@@ -2,24 +2,23 @@ import {
   BigIntToJsonZod, HashToJsonZod, HashZod, JsonToBigIntZod,
   JsonToHashZod,
 } from '@xylabs/hex'
+import { PayloadZod, WithHashMetaZod } from '@xyo-network/payload-model'
+import {
+  BlockNumberZod, BlockRangeZod, StepIdentityZod, XL1BlockRangeZod,
+} from '@xyo-network/xl1-protocol'
 import * as z from 'zod'
 
 import type { XyoViewerRpcMethodName } from '../XyoViewerRpc.ts'
 import {
   AddressZod,
-  BlockBoundWitnessWithStorageMetaZod,
   BlockBoundWitnessZod,
-  BlockNumberZod,
-  BlockRangeZod,
   JsonToStakeZod,
-  PayloadZod,
   SignedHydratedBlockZod,
   SignedHydratedTransactionZod,
   StakeToJsonZod,
-  StepIdentityZod,
   TransactionBoundWitnessZod,
   TransferPairZod,
-  TransferZodWithStorageMeta,
+  TransferZod,
 } from './common/index.ts'
 import type { RpcSchemaMap } from './RpcSchemaMap.ts'
 
@@ -216,12 +215,12 @@ export const XyoViewerRpcSchemas = {
   },
   xyoViewer_accountBalanceHistory: {
     params: {
-      to: z.tuple([AddressZod, BlockRangeZod.optional()]),
-      from: z.tuple([AddressZod, BlockRangeZod.optional()]),
+      to: z.tuple([AddressZod, z.union([XL1BlockRangeZod, HashZod]).optional()]),
+      from: z.tuple([AddressZod, z.union([XL1BlockRangeZod, HashZod]).optional()]),
     },
     result: {
-      to: z.array(z.tuple([BlockBoundWitnessZod, TransactionBoundWitnessZod.nullable(), TransferZodWithStorageMeta])),
-      from: z.array(z.tuple([BlockBoundWitnessZod, TransactionBoundWitnessZod.nullable(), TransferZodWithStorageMeta])),
+      to: z.array(z.tuple([WithHashMetaZod(BlockBoundWitnessZod), WithHashMetaZod(TransactionBoundWitnessZod).nullable(), WithHashMetaZod(TransferZod)])),
+      from: z.array(z.tuple([WithHashMetaZod(BlockBoundWitnessZod), WithHashMetaZod(TransactionBoundWitnessZod).nullable(), WithHashMetaZod(TransferZod)])),
     },
   },
   xyoViewer_transferPairBalance: {
@@ -240,8 +239,8 @@ export const XyoViewerRpcSchemas = {
       from: z.tuple([TransferPairZod]),
     },
     result: {
-      to: z.array(z.tuple([BlockBoundWitnessWithStorageMetaZod, z.union([TransactionBoundWitnessZod, z.null()]), PayloadZod])),
-      from: z.array(z.tuple([BlockBoundWitnessWithStorageMetaZod, z.union([TransactionBoundWitnessZod, z.null()]), PayloadZod])),
+      to: z.array(z.tuple([WithHashMetaZod(BlockBoundWitnessZod), WithHashMetaZod(TransactionBoundWitnessZod).nullable(), WithHashMetaZod(PayloadZod)])),
+      from: z.array(z.tuple([WithHashMetaZod(BlockBoundWitnessZod), WithHashMetaZod(TransactionBoundWitnessZod).nullable(), WithHashMetaZod(PayloadZod)])),
     },
   },
   xyoViewer_transferBalance: {
@@ -260,8 +259,8 @@ export const XyoViewerRpcSchemas = {
       from: z.tuple([AddressZod, BlockRangeZod.optional()]),
     },
     result: {
-      to: z.array(z.tuple([BlockBoundWitnessWithStorageMetaZod, z.union([TransactionBoundWitnessZod, z.null()]), PayloadZod])),
-      from: z.array(z.tuple([BlockBoundWitnessWithStorageMetaZod, z.union([TransactionBoundWitnessZod, z.null()]), PayloadZod])),
+      to: z.array(z.tuple([WithHashMetaZod(BlockBoundWitnessZod), WithHashMetaZod(TransactionBoundWitnessZod).nullable(), WithHashMetaZod(PayloadZod)])),
+      from: z.array(z.tuple([WithHashMetaZod(BlockBoundWitnessZod), WithHashMetaZod(TransactionBoundWitnessZod).nullable(), WithHashMetaZod(PayloadZod)])),
     },
   },
   xyoViewer_blockByHash: {

package/src/types/schema/common/BlockBoundWitness.ts

@@ -1,17 +1,14 @@
 import { HashZod } from '@xylabs/hex'
 import { StorageMetaZod } from '@xyo-network/payload-model'
-import { asXL1BlockNumber } from '@xyo-network/xl1-protocol'
+import { XL1BlockNumberZod } from '@xyo-network/xl1-protocol'
 import * as z from 'zod'
 
 import {
-  SignedBoundWitnessWithStorageMetaZod, SignedBoundWitnessZod, UnsignedBoundWitnessWithStorageMetaZod,
+  SignedBoundWitnessZod,
   UnsignedBoundWitnessZod,
 } from './BoundWitness.ts'
 import { ChainZod } from './Chain.ts'
 
-export const BlockNumberZod = z.number().int().nonnegative()
-export const XL1BlockNumberZod = BlockNumberZod.transform(asXL1BlockNumber)
-
 const BlockBoundWitnessFieldsZod = z.object({
   block: XL1BlockNumberZod,
   chain: ChainZod,
@@ -29,11 +26,6 @@ export const BlockBoundWitnessZod = UnsignedBoundWitnessZod
   .merge(BlockBoundWitnessFieldsZod)
   // eslint-disable-next-line sonarjs/deprecation
   .merge(BlockBoundWitnessMetaZod)
-export const BlockBoundWitnessWithStorageMetaZod = UnsignedBoundWitnessWithStorageMetaZod
-  // eslint-disable-next-line sonarjs/deprecation
-  .merge(BlockBoundWitnessFieldsZod)
-  // eslint-disable-next-line sonarjs/deprecation
-  .merge(BlockBoundWitnessMetaZod)
 
 export const SignedBlockBoundWitnessZod = SignedBoundWitnessZod
   // eslint-disable-next-line sonarjs/deprecation
@@ -42,11 +34,3 @@ export const SignedBlockBoundWitnessZod = SignedBoundWitnessZod
   .merge(BlockBoundWitnessFieldsZod)
   // eslint-disable-next-line sonarjs/deprecation
   .merge(BlockBoundWitnessMetaZod)
-
-export const SignedBlockBoundWitnessWithStorageMetaZod = SignedBoundWitnessWithStorageMetaZod
-  // eslint-disable-next-line sonarjs/deprecation
-  .merge(StorageMetaZod.partial())
-  // eslint-disable-next-line sonarjs/deprecation
-  .merge(BlockBoundWitnessFieldsZod)
-  // eslint-disable-next-line sonarjs/deprecation
-  .merge(BlockBoundWitnessMetaZod)

package/src/types/schema/common/BoundWitness.ts

@@ -1,10 +1,11 @@
 import { HashZod, HexZod } from '@xylabs/hex'
 import { BoundWitnessSchema } from '@xyo-network/boundwitness-model'
-import { StorageMetaZod } from '@xyo-network/payload-model'
+import {
+  PayloadZod, SchemaZod, StorageMetaZod,
+} from '@xyo-network/payload-model'
 import * as z from 'zod'
 
 import { AddressZod } from './Address.ts'
-import { PayloadZod, SchemaZod } from './Payload.ts'
 
 const BoundWitnessRequiredFieldsZod = z.object({
   addresses: z.array(AddressZod),

package/src/types/schema/common/HydratedBlock.ts

@@ -1,10 +1,10 @@
+import { PayloadZod, WithStorageMetaZod } from '@xyo-network/payload-model'
 import * as z from 'zod'
 
 import {
-  BlockBoundWitnessWithStorageMetaZod, BlockBoundWitnessZod, SignedBlockBoundWitnessWithStorageMetaZod,
+  BlockBoundWitnessZod,
   SignedBlockBoundWitnessZod,
 } from './BlockBoundWitness.ts'
-import { PayloadWithStorageMetaZod, PayloadZod } from './Payload.ts'
 
 export const HydratedBlockZod = z.tuple([
   BlockBoundWitnessZod,
@@ -12,8 +12,8 @@ export const HydratedBlockZod = z.tuple([
 ])
 
 export const HydratedBlockWithStorageMetaZod = z.tuple([
-  BlockBoundWitnessWithStorageMetaZod,
-  z.array(PayloadWithStorageMetaZod),
+  WithStorageMetaZod(BlockBoundWitnessZod),
+  z.array(WithStorageMetaZod(PayloadZod)),
 ])
 
 export const SignedHydratedBlockZod = z.tuple([
@@ -27,6 +27,6 @@ export const SignedHydratedBlockToJsonZod = z.tuple([
 ])
 
 export const SignedHydratedBlockWithStorageMetaZod = z.tuple([
-  SignedBlockBoundWitnessWithStorageMetaZod,
-  z.array(PayloadWithStorageMetaZod),
+  WithStorageMetaZod(SignedBlockBoundWitnessZod),
+  z.array(WithStorageMetaZod(PayloadZod)),
 ])

package/src/types/schema/common/HydratedTransaction.ts

@@ -1,9 +1,8 @@
 import type { JsonObject } from '@xylabs/object'
-import { asAnyPayload } from '@xyo-network/payload-model'
+import { asAnyPayload, PayloadZod } from '@xyo-network/payload-model'
 import { asSignedHydratedTransaction } from '@xyo-network/xl1-protocol'
 import * as z from 'zod'
 
-import { PayloadZod } from './Payload.ts'
 import { SignedTransactionBoundWitnessZod, TransactionBoundWitnessZod } from './TransactionBoundWitness.ts'
 
 export const HydratedTransactionZod = z.tuple([

package/src/types/schema/common/RewardsRangeOptions.ts

@@ -1,7 +1,7 @@
+import { BlockRangeZod } from '@xyo-network/xl1-protocol'
 import { z } from 'zod'
 
 import { AddressZod } from './Address.ts'
-import { BlockRangeZod } from './BlockRange.ts'
 import { StepIdentityZod } from './StepIdentity.ts'
 
 export const RewardsRangeOptionsZod = z.object({

package/src/types/schema/common/StepIdentity.ts

@@ -1,5 +1,8 @@
 import * as z from 'zod'
 
+/**
+ * @deprecated Use StepIdentityZod from \@xyo-network/xl1-protocol
+ */
 export const StepIdentityZod = z.object({
   block: z.number(),
   step: z.number(),

package/src/types/schema/common/TransactionBoundWitness.ts

@@ -1,7 +1,7 @@
 import { StorageMetaZod } from '@xyo-network/payload-model'
+import { BlockNumberZod } from '@xyo-network/xl1-protocol'
 import * as z from 'zod'
 
-import { BlockNumberZod } from './BlockBoundWitness.ts'
 import { SignedBoundWitnessZod, UnsignedBoundWitnessZod } from './BoundWitness.ts'
 import { ChainZod } from './Chain.ts'
 import { TransactionFeesHexZod } from './TransactionFees.ts'

package/src/types/schema/common/Transfer.ts

@@ -1,5 +1,5 @@
 import { HexZod } from '@xylabs/hex'
-import { PayloadZodStrictOfSchema, StorageMetaZod } from '@xyo-network/payload-model'
+import { PayloadZodStrictOfSchema } from '@xyo-network/payload-model'
 import { TransferSchema } from '@xyo-network/xl1-protocol'
 import z from 'zod'
 
@@ -14,4 +14,3 @@ export const TransferFieldsZod = z.object({
 })
 
 export const TransferZod = PayloadZodStrictOfSchema(TransferSchema).extend(TransferFieldsZod.shape)
-export const TransferZodWithStorageMeta = TransferZod.extend(StorageMetaZod.shape)

package/src/types/schema/common/index.ts

@@ -1,13 +1,11 @@
 export * from './Address.ts'
 export * from './ArrayBuffer.ts'
 export * from './BlockBoundWitness.ts'
-export * from './BlockRange.ts'
 export * from './BoundWitness.ts'
 export * from './Chain.ts'
 export * from './HydratedBlock.ts'
 export * from './HydratedTransaction.ts'
 export * from './Json.ts'
-export * from './Payload.ts'
 export * from './Permission.ts'
 export * from './RewardsRangeOptions.ts'
 export * from './Sequence.ts'

package/src/types/schema/common/spec/Payload.spec.ts

@@ -1,13 +1,12 @@
 import { asHash } from '@xylabs/hex'
 import { PayloadBuilder } from '@xyo-network/payload-builder'
+import { PayloadZod, WithStorageMetaZod } from '@xyo-network/payload-model'
 import type { HashPayload } from '@xyo-network/xl1-protocol'
 import { HashSchema } from '@xyo-network/xl1-protocol'
 import {
   describe, expect, it,
 } from 'vitest'
 
-import { PayloadWithStorageMetaZod, PayloadZod } from '../Payload.ts'
-
 const hashPayload: HashPayload = {
   schema: HashSchema,
   hash: asHash('e70f82c755ac75847f9d1c6b45d96099b343571d724e5383569724c85cc9d303', true),
@@ -22,7 +21,7 @@ describe('Payload', () => {
     expect(result.data).toEqual(hashPayload)
   })
   it('should parse a HashPayload with storage Meta', () => {
-    const result = PayloadWithStorageMetaZod.safeParse(hashPayloadWithMeta)
+    const result = WithStorageMetaZod(PayloadZod).safeParse(hashPayloadWithMeta)
     expect(result.success).toBe(true)
     expect(result.data).toEqual(hashPayloadWithMeta)
   })

package/dist/neutral/types/schema/common/BlockRange.d.ts

@@ -1,3 +0,0 @@
-import { z } from 'zod';
-export declare const BlockRangeZod: z.ZodTuple<[z.ZodOptional<z.ZodNumber>, z.ZodOptional<z.ZodNumber>], null>;
-//# sourceMappingURL=BlockRange.d.ts.map

package/dist/neutral/types/schema/common/BlockRange.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"BlockRange.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/BlockRange.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,aAAa,4EAGxB,CAAA"}

package/dist/neutral/types/schema/common/Payload.d.ts

@@ -1,81 +0,0 @@
-import * as z from 'zod';
-export declare const SchemaZod: z.ZodString;
-export type Schema = z.infer<typeof SchemaZod>;
-export declare const PayloadZod: z.ZodObject<{
-    schema: z.ZodString;
-}, z.core.$catchall<z.ZodAny>>;
-export declare const PayloadWithStorageMetaZod: z.ZodObject<{
-    schema: z.ZodString;
-    _hash: z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown>>;
-    _dataHash: z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown>>;
-    _sequence: z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/payload-model").LocalSequence, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/payload-model").QualifiedSequence, string>>]>;
-}, z.core.$catchall<z.ZodAny>>;
-export declare const AnyPayloadZod: z.ZodObject<{
-    schema: z.ZodString;
-}, z.core.$catchall<z.ZodJSONSchema>>;
-export declare const AnyPayloadWithStorageMetaZod: z.ZodObject<{
-    schema: z.ZodString;
-    _hash: z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown>>;
-    _dataHash: z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown>>;
-    _sequence: z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/payload-model").LocalSequence, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/payload-model").QualifiedSequence, string>>]>;
-}, z.core.$catchall<z.ZodJSONSchema>>;
-export type PayloadZodType = z.infer<typeof PayloadZod>;
-export type PayloadWithStorageMetaZodType = z.infer<typeof PayloadWithStorageMetaZod>;
-export type AnyPayloadZodType = z.infer<typeof AnyPayloadZod>;
-export type AnyPayloadWithStorageMetaZodType = z.infer<typeof AnyPayloadWithStorageMetaZod>;
-export declare function WithStorageMetaZod<T extends typeof PayloadZod>(valueZod: T): z.ZodObject<{
-    _hash: z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown>>;
-    _dataHash: z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown>>;
-    _sequence: z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/payload-model").LocalSequence, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/payload-model").QualifiedSequence, string>>]>;
-    schema: z.ZodString;
-}, z.core.$strip>;
-export type WithStorageMetaZodType = z.infer<typeof WithStorageMetaZod>;
-//# sourceMappingURL=Payload.d.ts.map

package/dist/neutral/types/schema/common/Payload.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Payload.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/Payload.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAExB,eAAO,MAAM,SAAS,aAAa,CAAA;AACnC,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA;AAE9C,eAAO,MAAM,UAAU;;8BAAoD,CAAA;AAC3E,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;8BAA0C,CAAA;AAEhF,eAAO,MAAM,aAAa;;qCAAgC,CAAA;AAC1D,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;qCAA6C,CAAA;AAEtF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAA;AACvD,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAErF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA;AAC7D,MAAM,MAAM,gCAAgC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAA;AAE3F,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,OAAO,UAAU,EAAE,QAAQ,EAAE,CAAC;;;;;;;;;;;;;;;;;;;;;kBAE1E;AAED,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA"}

package/dist/node/types/schema/common/BlockRange.d.ts

@@ -1,3 +0,0 @@
-import { z } from 'zod';
-export declare const BlockRangeZod: z.ZodTuple<[z.ZodOptional<z.ZodNumber>, z.ZodOptional<z.ZodNumber>], null>;
-//# sourceMappingURL=BlockRange.d.ts.map

package/dist/node/types/schema/common/BlockRange.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"BlockRange.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/BlockRange.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,aAAa,4EAGxB,CAAA"}

package/dist/node/types/schema/common/Payload.d.ts

@@ -1,81 +0,0 @@
-import * as z from 'zod';
-export declare const SchemaZod: z.ZodString;
-export type Schema = z.infer<typeof SchemaZod>;
-export declare const PayloadZod: z.ZodObject<{
-    schema: z.ZodString;
-}, z.core.$catchall<z.ZodAny>>;
-export declare const PayloadWithStorageMetaZod: z.ZodObject<{
-    schema: z.ZodString;
-    _hash: z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown>>;
-    _dataHash: z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown>>;
-    _sequence: z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/payload-model").LocalSequence, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/payload-model").QualifiedSequence, string>>]>;
-}, z.core.$catchall<z.ZodAny>>;
-export declare const AnyPayloadZod: z.ZodObject<{
-    schema: z.ZodString;
-}, z.core.$catchall<z.ZodJSONSchema>>;
-export declare const AnyPayloadWithStorageMetaZod: z.ZodObject<{
-    schema: z.ZodString;
-    _hash: z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown>>;
-    _dataHash: z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown>>;
-    _sequence: z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/payload-model").LocalSequence, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/payload-model").QualifiedSequence, string>>]>;
-}, z.core.$catchall<z.ZodJSONSchema>>;
-export type PayloadZodType = z.infer<typeof PayloadZod>;
-export type PayloadWithStorageMetaZodType = z.infer<typeof PayloadWithStorageMetaZod>;
-export type AnyPayloadZodType = z.infer<typeof AnyPayloadZod>;
-export type AnyPayloadWithStorageMetaZodType = z.infer<typeof AnyPayloadWithStorageMetaZod>;
-export declare function WithStorageMetaZod<T extends typeof PayloadZod>(valueZod: T): z.ZodObject<{
-    _hash: z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown>>;
-    _dataHash: z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown>>;
-    _sequence: z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/payload-model").LocalSequence, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/payload-model").QualifiedSequence, string>>]>;
-    schema: z.ZodString;
-}, z.core.$strip>;
-export type WithStorageMetaZodType = z.infer<typeof WithStorageMetaZod>;
-//# sourceMappingURL=Payload.d.ts.map

package/dist/node/types/schema/common/Payload.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Payload.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/Payload.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAExB,eAAO,MAAM,SAAS,aAAa,CAAA;AACnC,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA;AAE9C,eAAO,MAAM,UAAU;;8BAAoD,CAAA;AAC3E,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;8BAA0C,CAAA;AAEhF,eAAO,MAAM,aAAa;;qCAAgC,CAAA;AAC1D,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;qCAA6C,CAAA;AAEtF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAA;AACvD,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAErF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA;AAC7D,MAAM,MAAM,gCAAgC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAA;AAE3F,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,OAAO,UAAU,EAAE,QAAQ,EAAE,CAAC;;;;;;;;;;;;;;;;;;;;;kBAE1E;AAED,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA"}

package/src/types/schema/common/BlockRange.ts

@@ -1,6 +0,0 @@
-import { z } from 'zod'
-
-export const BlockRangeZod = z.tuple([
-  z.number().optional(),
-  z.number().optional(),
-])

package/src/types/schema/common/Payload.ts

@@ -1,23 +0,0 @@
-import { StorageMetaZod } from '@xyo-network/payload-model'
-import * as z from 'zod'
-
-export const SchemaZod = z.string()
-export type Schema = z.infer<typeof SchemaZod>
-
-export const PayloadZod = z.object({ schema: SchemaZod }).catchall(z.any())
-export const PayloadWithStorageMetaZod = PayloadZod.extend(StorageMetaZod.shape)
-
-export const AnyPayloadZod = PayloadZod.catchall(z.json())
-export const AnyPayloadWithStorageMetaZod = AnyPayloadZod.extend(StorageMetaZod.shape)
-
-export type PayloadZodType = z.infer<typeof PayloadZod>
-export type PayloadWithStorageMetaZodType = z.infer<typeof PayloadWithStorageMetaZod>
-
-export type AnyPayloadZodType = z.infer<typeof AnyPayloadZod>
-export type AnyPayloadWithStorageMetaZodType = z.infer<typeof AnyPayloadWithStorageMetaZod>
-
-export function WithStorageMetaZod<T extends typeof PayloadZod>(valueZod: T) {
-  return StorageMetaZod.extend(valueZod.shape)
-}
-
-export type WithStorageMetaZodType = z.infer<typeof WithStorageMetaZod>