@xyo-network/xl1-rpc 1.11.0 → 1.12.0

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

@@ -1,214 +0,0 @@
-import { z } from 'zod';
-export declare const HydratedTransactionSchema: z.ZodTuple<[z.ZodObject<{} & {
-    schema: z.ZodLiteral<"network.xyo.boundwitness">;
-} & {
-    addresses: z.ZodArray<z.ZodString, "many">;
-    payload_hashes: z.ZodArray<z.ZodString, "many">;
-    payload_schemas: z.ZodArray<z.ZodString, "many">;
-    previous_hashes: z.ZodArray<z.ZodNullable<z.ZodString>, "many">;
-} & {
-    $destination: z.ZodOptional<z.ZodString>;
-    $sourceQuery: z.ZodOptional<z.ZodString>;
-} & {
-    nbf: z.ZodNumber;
-    exp: z.ZodNumber;
-} & {
-    fees: z.ZodObject<{
-        base: z.ZodString;
-        gasLimit: z.ZodString;
-        gasPrice: z.ZodString;
-        priority: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        base: string;
-        gasLimit: string;
-        gasPrice: string;
-        priority: string;
-    }, {
-        base: string;
-        gasLimit: string;
-        gasPrice: string;
-        priority: string;
-    }>;
-} & {
-    chain: z.ZodString;
-}, "passthrough", z.ZodTypeAny, z.objectOutputType<{} & {
-    schema: z.ZodLiteral<"network.xyo.boundwitness">;
-} & {
-    addresses: z.ZodArray<z.ZodString, "many">;
-    payload_hashes: z.ZodArray<z.ZodString, "many">;
-    payload_schemas: z.ZodArray<z.ZodString, "many">;
-    previous_hashes: z.ZodArray<z.ZodNullable<z.ZodString>, "many">;
-} & {
-    $destination: z.ZodOptional<z.ZodString>;
-    $sourceQuery: z.ZodOptional<z.ZodString>;
-} & {
-    nbf: z.ZodNumber;
-    exp: z.ZodNumber;
-} & {
-    fees: z.ZodObject<{
-        base: z.ZodString;
-        gasLimit: z.ZodString;
-        gasPrice: z.ZodString;
-        priority: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        base: string;
-        gasLimit: string;
-        gasPrice: string;
-        priority: string;
-    }, {
-        base: string;
-        gasLimit: string;
-        gasPrice: string;
-        priority: string;
-    }>;
-} & {
-    chain: z.ZodString;
-}, z.ZodTypeAny, "passthrough">, z.objectInputType<{} & {
-    schema: z.ZodLiteral<"network.xyo.boundwitness">;
-} & {
-    addresses: z.ZodArray<z.ZodString, "many">;
-    payload_hashes: z.ZodArray<z.ZodString, "many">;
-    payload_schemas: z.ZodArray<z.ZodString, "many">;
-    previous_hashes: z.ZodArray<z.ZodNullable<z.ZodString>, "many">;
-} & {
-    $destination: z.ZodOptional<z.ZodString>;
-    $sourceQuery: z.ZodOptional<z.ZodString>;
-} & {
-    nbf: z.ZodNumber;
-    exp: z.ZodNumber;
-} & {
-    fees: z.ZodObject<{
-        base: z.ZodString;
-        gasLimit: z.ZodString;
-        gasPrice: z.ZodString;
-        priority: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        base: string;
-        gasLimit: string;
-        gasPrice: string;
-        priority: string;
-    }, {
-        base: string;
-        gasLimit: string;
-        gasPrice: string;
-        priority: string;
-    }>;
-} & {
-    chain: z.ZodString;
-}, z.ZodTypeAny, "passthrough">>, z.ZodArray<z.ZodObject<{
-    schema: z.ZodString;
-}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-    schema: z.ZodString;
-}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-    schema: z.ZodString;
-}, z.ZodTypeAny, "passthrough">>, "many">], null>;
-export declare const SignedHydratedTransactionSchema: z.ZodTuple<[z.ZodObject<{} & {
-    schema: z.ZodLiteral<"network.xyo.boundwitness">;
-} & {
-    addresses: z.ZodArray<z.ZodString, "many">;
-    payload_hashes: z.ZodArray<z.ZodString, "many">;
-    payload_schemas: z.ZodArray<z.ZodString, "many">;
-    previous_hashes: z.ZodArray<z.ZodNullable<z.ZodString>, "many">;
-} & {
-    $destination: z.ZodOptional<z.ZodString>;
-    $sourceQuery: z.ZodOptional<z.ZodString>;
-} & {
-    $signatures: z.ZodArray<z.ZodString, "many">;
-} & {
-    nbf: z.ZodNumber;
-    exp: z.ZodNumber;
-} & {
-    fees: z.ZodObject<{
-        base: z.ZodString;
-        gasLimit: z.ZodString;
-        gasPrice: z.ZodString;
-        priority: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        base: string;
-        gasLimit: string;
-        gasPrice: string;
-        priority: string;
-    }, {
-        base: string;
-        gasLimit: string;
-        gasPrice: string;
-        priority: string;
-    }>;
-} & {
-    chain: z.ZodString;
-}, "passthrough", z.ZodTypeAny, z.objectOutputType<{} & {
-    schema: z.ZodLiteral<"network.xyo.boundwitness">;
-} & {
-    addresses: z.ZodArray<z.ZodString, "many">;
-    payload_hashes: z.ZodArray<z.ZodString, "many">;
-    payload_schemas: z.ZodArray<z.ZodString, "many">;
-    previous_hashes: z.ZodArray<z.ZodNullable<z.ZodString>, "many">;
-} & {
-    $destination: z.ZodOptional<z.ZodString>;
-    $sourceQuery: z.ZodOptional<z.ZodString>;
-} & {
-    $signatures: z.ZodArray<z.ZodString, "many">;
-} & {
-    nbf: z.ZodNumber;
-    exp: z.ZodNumber;
-} & {
-    fees: z.ZodObject<{
-        base: z.ZodString;
-        gasLimit: z.ZodString;
-        gasPrice: z.ZodString;
-        priority: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        base: string;
-        gasLimit: string;
-        gasPrice: string;
-        priority: string;
-    }, {
-        base: string;
-        gasLimit: string;
-        gasPrice: string;
-        priority: string;
-    }>;
-} & {
-    chain: z.ZodString;
-}, z.ZodTypeAny, "passthrough">, z.objectInputType<{} & {
-    schema: z.ZodLiteral<"network.xyo.boundwitness">;
-} & {
-    addresses: z.ZodArray<z.ZodString, "many">;
-    payload_hashes: z.ZodArray<z.ZodString, "many">;
-    payload_schemas: z.ZodArray<z.ZodString, "many">;
-    previous_hashes: z.ZodArray<z.ZodNullable<z.ZodString>, "many">;
-} & {
-    $destination: z.ZodOptional<z.ZodString>;
-    $sourceQuery: z.ZodOptional<z.ZodString>;
-} & {
-    $signatures: z.ZodArray<z.ZodString, "many">;
-} & {
-    nbf: z.ZodNumber;
-    exp: z.ZodNumber;
-} & {
-    fees: z.ZodObject<{
-        base: z.ZodString;
-        gasLimit: z.ZodString;
-        gasPrice: z.ZodString;
-        priority: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        base: string;
-        gasLimit: string;
-        gasPrice: string;
-        priority: string;
-    }, {
-        base: string;
-        gasLimit: string;
-        gasPrice: string;
-        priority: string;
-    }>;
-} & {
-    chain: z.ZodString;
-}, z.ZodTypeAny, "passthrough">>, z.ZodArray<z.ZodObject<{
-    schema: z.ZodString;
-}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-    schema: z.ZodString;
-}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-    schema: z.ZodString;
-}, z.ZodTypeAny, "passthrough">>, "many">], null>;
-//# sourceMappingURL=HydratedTransactionSchema.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"HydratedTransactionSchema.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/HydratedTransactionSchema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iDAGpC,CAAA;AAEF,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iDAG1C,CAAA"}

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

@@ -1,7 +0,0 @@
-import { z } from 'zod';
-declare const JsonValueSchema: z.ZodType<unknown>;
-export declare const JsonObjectSchema: z.ZodRecord<z.ZodString, z.ZodType<unknown, z.ZodTypeDef, unknown>>;
-export type JsonValue = z.infer<typeof JsonValueSchema>;
-export type JsonObject = z.infer<typeof JsonObjectSchema>;
-export {};
-//# sourceMappingURL=JsonSchema.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"JsonSchema.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/JsonSchema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,QAAA,MAAM,eAAe,EAAE,CAAC,CAAC,OAAO,CAAC,OAAO,CAQnC,CAAA;AAGL,eAAO,MAAM,gBAAgB,qEAA4B,CAAA;AAGzD,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AACvD,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA"}

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

@@ -1,28 +0,0 @@
-import { z } from 'zod';
-export declare const PayloadSchema: z.ZodObject<{
-    schema: z.ZodString;
-}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-    schema: z.ZodString;
-}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-    schema: z.ZodString;
-}, z.ZodTypeAny, "passthrough">>;
-export declare const PayloadWithStorageMetaSchema: z.ZodObject<{
-    schema: z.ZodString;
-} & {
-    _hash: z.ZodString;
-    _dataHash: z.ZodString;
-    _sequence: z.ZodUnion<[z.ZodString, z.ZodString]>;
-}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-    schema: z.ZodString;
-} & {
-    _hash: z.ZodString;
-    _dataHash: z.ZodString;
-    _sequence: z.ZodUnion<[z.ZodString, z.ZodString]>;
-}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-    schema: z.ZodString;
-} & {
-    _hash: z.ZodString;
-    _dataHash: z.ZodString;
-    _sequence: z.ZodUnion<[z.ZodString, z.ZodString]>;
-}, z.ZodTypeAny, "passthrough">>;
-//# sourceMappingURL=PayloadSchema.d.ts.map

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

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

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

@@ -1,9 +0,0 @@
-import type { LocalSequence, QualifiedSequence } from '@xyo-network/payload-model';
-import { z } from 'zod';
-export declare const LocalSequenceToStringSchema: z.ZodString;
-export declare const LocalSequenceFromStringSchema: z.ZodEffects<z.ZodString, LocalSequence, string>;
-export declare const QualifiedSequenceToStringSchema: z.ZodString;
-export declare const QualifiedSequenceFromStringSchema: z.ZodEffects<z.ZodString, QualifiedSequence, string>;
-export declare const SequenceToStringSchema: z.ZodUnion<[z.ZodString, z.ZodString]>;
-export declare const SequenceFromStringSchema: z.ZodUnion<[z.ZodEffects<z.ZodString, LocalSequence, string>, z.ZodEffects<z.ZodString, QualifiedSequence, string>]>;
-//# sourceMappingURL=SequenceSchema.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"SequenceSchema.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/SequenceSchema.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,aAAa,EACb,iBAAiB,EAClB,MAAM,4BAA4B,CAAA;AAGnC,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,eAAO,MAAM,2BAA2B,aAAuC,CAAA;AAC/E,eAAO,MAAM,6BAA6B,kDAAgG,CAAA;AAG1I,eAAO,MAAM,+BAA+B,aAA2C,CAAA;AACvF,eAAO,MAAM,iCAAiC,sDAA4G,CAAA;AAE1J,eAAO,MAAM,sBAAsB,wCAA0E,CAAA;AAC7G,eAAO,MAAM,wBAAwB,sHAA8E,CAAA"}

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

@@ -1,46 +0,0 @@
-import { z } from 'zod';
-export declare const StorageMetaSchema: z.ZodObject<{
-    _hash: z.ZodString;
-    _dataHash: z.ZodString;
-    _sequence: z.ZodUnion<[z.ZodString, z.ZodString]>;
-}, "strip", z.ZodTypeAny, {
-    _hash: string;
-    _dataHash: string;
-    _sequence: string;
-}, {
-    _hash: string;
-    _dataHash: string;
-    _sequence: string;
-}>;
-export declare function WithStorageMetaSchema<T extends z.ZodTypeAny>(valueSchema: T): z.ZodObject<{
-    _hash: z.ZodString;
-    _dataHash: z.ZodString;
-    _sequence: z.ZodUnion<[z.ZodString, z.ZodString]>;
-} & {
-    value: T;
-}, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
-    _hash: z.ZodString;
-    _dataHash: z.ZodString;
-    _sequence: z.ZodUnion<[z.ZodString, z.ZodString]>;
-} & {
-    value: T;
-}>, any> extends infer T_1 ? { [k in keyof T_1]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
-    _hash: z.ZodString;
-    _dataHash: z.ZodString;
-    _sequence: z.ZodUnion<[z.ZodString, z.ZodString]>;
-} & {
-    value: T;
-}>, any>[k]; } : never, z.baseObjectInputType<{
-    _hash: z.ZodString;
-    _dataHash: z.ZodString;
-    _sequence: z.ZodUnion<[z.ZodString, z.ZodString]>;
-} & {
-    value: T;
-}> extends infer T_2 ? { [k_1 in keyof T_2]: z.baseObjectInputType<{
-    _hash: z.ZodString;
-    _dataHash: z.ZodString;
-    _sequence: z.ZodUnion<[z.ZodString, z.ZodString]>;
-} & {
-    value: T;
-}>[k_1]; } : never>;
-//# sourceMappingURL=StorageMetaSchema.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"StorageMetaSchema.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/StorageMetaSchema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB,eAAO,MAAM,iBAAiB;;;;;;;;;;;;EAI5B,CAAA;AAEF,wBAAgB,qBAAqB,CAAC,CAAC,SAAS,CAAC,CAAC,UAAU,EAAE,WAAW,EAAE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAE3E"}

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

@@ -1,258 +0,0 @@
-import z from 'zod';
-export declare const BlockStartSchema: z.ZodObject<{
-    nbf: z.ZodNumber;
-}, "strip", z.ZodTypeAny, {
-    nbf: number;
-}, {
-    nbf: number;
-}>;
-export declare const BlockEndSchema: z.ZodObject<{
-    exp: z.ZodNumber;
-}, "strip", z.ZodTypeAny, {
-    exp: number;
-}, {
-    exp: number;
-}>;
-export declare const BlockDurationSchema: z.ZodObject<{
-    nbf: z.ZodNumber;
-    exp: z.ZodNumber;
-}, "strip", z.ZodTypeAny, {
-    nbf: number;
-    exp: number;
-}, {
-    nbf: number;
-    exp: number;
-}>;
-export declare const TransactionFeesSchema: z.ZodObject<{
-    fees: z.ZodObject<{
-        base: z.ZodString;
-        gasLimit: z.ZodString;
-        gasPrice: z.ZodString;
-        priority: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        base: string;
-        gasLimit: string;
-        gasPrice: string;
-        priority: string;
-    }, {
-        base: string;
-        gasLimit: string;
-        gasPrice: string;
-        priority: string;
-    }>;
-}, "strip", z.ZodTypeAny, {
-    fees: {
-        base: string;
-        gasLimit: string;
-        gasPrice: string;
-        priority: string;
-    };
-}, {
-    fees: {
-        base: string;
-        gasLimit: string;
-        gasPrice: string;
-        priority: string;
-    };
-}>;
-export declare const TransactionBoundWitnessSchema: z.ZodObject<{} & {
-    schema: z.ZodLiteral<"network.xyo.boundwitness">;
-} & {
-    addresses: z.ZodArray<z.ZodString, "many">;
-    payload_hashes: z.ZodArray<z.ZodString, "many">;
-    payload_schemas: z.ZodArray<z.ZodString, "many">;
-    previous_hashes: z.ZodArray<z.ZodNullable<z.ZodString>, "many">;
-} & {
-    $destination: z.ZodOptional<z.ZodString>;
-    $sourceQuery: z.ZodOptional<z.ZodString>;
-} & {
-    nbf: z.ZodNumber;
-    exp: z.ZodNumber;
-} & {
-    fees: z.ZodObject<{
-        base: z.ZodString;
-        gasLimit: z.ZodString;
-        gasPrice: z.ZodString;
-        priority: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        base: string;
-        gasLimit: string;
-        gasPrice: string;
-        priority: string;
-    }, {
-        base: string;
-        gasLimit: string;
-        gasPrice: string;
-        priority: string;
-    }>;
-} & {
-    chain: z.ZodString;
-}, "passthrough", z.ZodTypeAny, z.objectOutputType<{} & {
-    schema: z.ZodLiteral<"network.xyo.boundwitness">;
-} & {
-    addresses: z.ZodArray<z.ZodString, "many">;
-    payload_hashes: z.ZodArray<z.ZodString, "many">;
-    payload_schemas: z.ZodArray<z.ZodString, "many">;
-    previous_hashes: z.ZodArray<z.ZodNullable<z.ZodString>, "many">;
-} & {
-    $destination: z.ZodOptional<z.ZodString>;
-    $sourceQuery: z.ZodOptional<z.ZodString>;
-} & {
-    nbf: z.ZodNumber;
-    exp: z.ZodNumber;
-} & {
-    fees: z.ZodObject<{
-        base: z.ZodString;
-        gasLimit: z.ZodString;
-        gasPrice: z.ZodString;
-        priority: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        base: string;
-        gasLimit: string;
-        gasPrice: string;
-        priority: string;
-    }, {
-        base: string;
-        gasLimit: string;
-        gasPrice: string;
-        priority: string;
-    }>;
-} & {
-    chain: z.ZodString;
-}, z.ZodTypeAny, "passthrough">, z.objectInputType<{} & {
-    schema: z.ZodLiteral<"network.xyo.boundwitness">;
-} & {
-    addresses: z.ZodArray<z.ZodString, "many">;
-    payload_hashes: z.ZodArray<z.ZodString, "many">;
-    payload_schemas: z.ZodArray<z.ZodString, "many">;
-    previous_hashes: z.ZodArray<z.ZodNullable<z.ZodString>, "many">;
-} & {
-    $destination: z.ZodOptional<z.ZodString>;
-    $sourceQuery: z.ZodOptional<z.ZodString>;
-} & {
-    nbf: z.ZodNumber;
-    exp: z.ZodNumber;
-} & {
-    fees: z.ZodObject<{
-        base: z.ZodString;
-        gasLimit: z.ZodString;
-        gasPrice: z.ZodString;
-        priority: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        base: string;
-        gasLimit: string;
-        gasPrice: string;
-        priority: string;
-    }, {
-        base: string;
-        gasLimit: string;
-        gasPrice: string;
-        priority: string;
-    }>;
-} & {
-    chain: z.ZodString;
-}, z.ZodTypeAny, "passthrough">>;
-export declare const SignedTransactionBoundWitnessSchema: z.ZodObject<{} & {
-    schema: z.ZodLiteral<"network.xyo.boundwitness">;
-} & {
-    addresses: z.ZodArray<z.ZodString, "many">;
-    payload_hashes: z.ZodArray<z.ZodString, "many">;
-    payload_schemas: z.ZodArray<z.ZodString, "many">;
-    previous_hashes: z.ZodArray<z.ZodNullable<z.ZodString>, "many">;
-} & {
-    $destination: z.ZodOptional<z.ZodString>;
-    $sourceQuery: z.ZodOptional<z.ZodString>;
-} & {
-    $signatures: z.ZodArray<z.ZodString, "many">;
-} & {
-    nbf: z.ZodNumber;
-    exp: z.ZodNumber;
-} & {
-    fees: z.ZodObject<{
-        base: z.ZodString;
-        gasLimit: z.ZodString;
-        gasPrice: z.ZodString;
-        priority: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        base: string;
-        gasLimit: string;
-        gasPrice: string;
-        priority: string;
-    }, {
-        base: string;
-        gasLimit: string;
-        gasPrice: string;
-        priority: string;
-    }>;
-} & {
-    chain: z.ZodString;
-}, "passthrough", z.ZodTypeAny, z.objectOutputType<{} & {
-    schema: z.ZodLiteral<"network.xyo.boundwitness">;
-} & {
-    addresses: z.ZodArray<z.ZodString, "many">;
-    payload_hashes: z.ZodArray<z.ZodString, "many">;
-    payload_schemas: z.ZodArray<z.ZodString, "many">;
-    previous_hashes: z.ZodArray<z.ZodNullable<z.ZodString>, "many">;
-} & {
-    $destination: z.ZodOptional<z.ZodString>;
-    $sourceQuery: z.ZodOptional<z.ZodString>;
-} & {
-    $signatures: z.ZodArray<z.ZodString, "many">;
-} & {
-    nbf: z.ZodNumber;
-    exp: z.ZodNumber;
-} & {
-    fees: z.ZodObject<{
-        base: z.ZodString;
-        gasLimit: z.ZodString;
-        gasPrice: z.ZodString;
-        priority: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        base: string;
-        gasLimit: string;
-        gasPrice: string;
-        priority: string;
-    }, {
-        base: string;
-        gasLimit: string;
-        gasPrice: string;
-        priority: string;
-    }>;
-} & {
-    chain: z.ZodString;
-}, z.ZodTypeAny, "passthrough">, z.objectInputType<{} & {
-    schema: z.ZodLiteral<"network.xyo.boundwitness">;
-} & {
-    addresses: z.ZodArray<z.ZodString, "many">;
-    payload_hashes: z.ZodArray<z.ZodString, "many">;
-    payload_schemas: z.ZodArray<z.ZodString, "many">;
-    previous_hashes: z.ZodArray<z.ZodNullable<z.ZodString>, "many">;
-} & {
-    $destination: z.ZodOptional<z.ZodString>;
-    $sourceQuery: z.ZodOptional<z.ZodString>;
-} & {
-    $signatures: z.ZodArray<z.ZodString, "many">;
-} & {
-    nbf: z.ZodNumber;
-    exp: z.ZodNumber;
-} & {
-    fees: z.ZodObject<{
-        base: z.ZodString;
-        gasLimit: z.ZodString;
-        gasPrice: z.ZodString;
-        priority: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        base: string;
-        gasLimit: string;
-        gasPrice: string;
-        priority: string;
-    }, {
-        base: string;
-        gasLimit: string;
-        gasPrice: string;
-        priority: string;
-    }>;
-} & {
-    chain: z.ZodString;
-}, z.ZodTypeAny, "passthrough">>;
-//# sourceMappingURL=TransactionBoundWitnessSchema.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"TransactionBoundWitnessSchema.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/TransactionBoundWitnessSchema.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAA;AAOnB,eAAO,MAAM,gBAAgB;;;;;;EAAuC,CAAA;AACpE,eAAO,MAAM,cAAc;;;;;;EAAuC,CAAA;AAClE,eAAO,MAAM,mBAAmB;;;;;;;;;EAA+D,CAAA;AAE/F,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAOhC,CAAA;AAIF,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAI1B,CAAA;AAEhB,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAIhC,CAAA"}

package/dist/node/types/schema/common/spec/BigIntSchema.spec.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=BigIntSchema.spec.d.ts.map

package/dist/node/types/schema/common/spec/BigIntSchema.spec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"BigIntSchema.spec.d.ts","sourceRoot":"","sources":["../../../../../../src/types/schema/common/spec/BigIntSchema.spec.ts"],"names":[],"mappings":""}

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

@@ -1,10 +0,0 @@
-import {
-  asHex, hexToBigInt, toHex,
-} from '@xylabs/hex'
-import { HexRegEx } from '@xyo-network/payload-wrapper'
-import { z } from 'zod'
-
-const CompiledHexRegEx = new RegExp(HexRegEx)
-
-export const BigIntToStringSchema = z.bigint().nonnegative().transform(x => asHex(toHex(x)))
-export const BigIntFromStringSchema = z.string().regex(CompiledHexRegEx).transform(x => hexToBigInt(asHex(toHex(x), true)))

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

@@ -1,30 +0,0 @@
-import { z } from 'zod'
-
-import {
-  SignedBoundWitnessSchema, SignedBoundWitnessWithStorageMetaSchema, UnsignedBoundWitnessSchema, UnsignedBoundWitnessWithStorageMetaSchema,
-} from './BoundWitnessSchema.ts'
-import { HexToStringSchema } from './HexSchema.ts'
-
-export const BlockNumberSchema = z.number().int().nonnegative()
-
-const BlockBoundWitnessFieldsSchema = z.object({
-  block: BlockNumberSchema,
-  chain: HexToStringSchema,
-  previous: HexToStringSchema.nullable(),
-  protocol: z.number().optional(),
-  step_hashes: z.array(HexToStringSchema).optional(),
-})
-
-export const BlockBoundWitnessSchema = UnsignedBoundWitnessSchema
-  .merge(BlockBoundWitnessFieldsSchema)
-  .passthrough()
-export const BlockBoundWitnessWithStorageMetaSchema = UnsignedBoundWitnessWithStorageMetaSchema
-  .merge(BlockBoundWitnessFieldsSchema)
-  .passthrough()
-
-export const SignedBlockBoundWitnessSchema = SignedBoundWitnessSchema
-  .merge(BlockBoundWitnessFieldsSchema)
-  .passthrough()
-export const SignedBlockBoundWitnessWithStorageMetaSchema = SignedBoundWitnessWithStorageMetaSchema
-  .merge(BlockBoundWitnessFieldsSchema)
-  .passthrough()

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

@@ -1,45 +0,0 @@
-import { BoundWitnessSchema } from '@xyo-network/boundwitness-model'
-import { z } from 'zod'
-
-import { AddressToStringSchema } from './AddressSchema.ts'
-import { HashToStringSchema } from './HashSchema.ts'
-import { HexToStringSchema } from './HexSchema.ts'
-import { PayloadSchema, PayloadWithStorageMetaSchema } from './PayloadSchema.ts'
-
-export const SchemaIdSchema = z.string()
-
-const BoundWitnessRequiredFieldsSchema = z.object({
-  addresses: z.array(AddressToStringSchema),
-  payload_hashes: z.array(HashToStringSchema),
-  payload_schemas: z.array(SchemaIdSchema),
-  previous_hashes: z.array(HashToStringSchema.nullable()),
-})
-
-const BoundWitnessMetaSchema = z.object({
-  $destination: AddressToStringSchema.optional(),
-  $sourceQuery: HashToStringSchema.optional(),
-})
-
-export const UnsignedBoundWitnessSchema = PayloadSchema
-  .extend({ schema: z.literal(BoundWitnessSchema) })
-  .merge(BoundWitnessRequiredFieldsSchema)
-  .merge(BoundWitnessMetaSchema)
-  .passthrough()
-
-export const UnsignedBoundWitnessWithStorageMetaSchema = PayloadWithStorageMetaSchema
-  .extend({ schema: z.literal(BoundWitnessSchema) })
-  .merge(BoundWitnessRequiredFieldsSchema)
-  .merge(BoundWitnessMetaSchema)
-  .passthrough()
-
-export const SignedBoundWitnessSchema = UnsignedBoundWitnessSchema
-  .extend(
-    { $signatures: z.array(HexToStringSchema) },
-  )
-  .passthrough()
-
-export const SignedBoundWitnessWithStorageMetaSchema = UnsignedBoundWitnessWithStorageMetaSchema
-  .extend(
-    { $signatures: z.array(HexToStringSchema) },
-  )
-  .passthrough()