@xyo-network/xl1-rpc 1.10.2 → 1.12.0

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

@@ -0,0 +1,134 @@
+import { z } from 'zod';
+export declare const StorageMetaZod: z.ZodObject<{
+    _hash: z.ZodPipe<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>>, z.ZodTransform<string, import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, {
+        readonly __hash: true;
+    }>>>;
+    _dataHash: z.ZodPipe<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>>, z.ZodTransform<string, import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, {
+        readonly __hash: true;
+    }>>>;
+    _sequence: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+}, z.core.$strip>;
+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.ZodPipe<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>>, z.ZodTransform<string, import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, {
+        readonly __hash: true;
+    }>>>;
+    _dataHash: z.ZodPipe<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>>, z.ZodTransform<string, import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, {
+        readonly __hash: true;
+    }>>>;
+    _sequence: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+}, 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.ZodPipe<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>>, z.ZodTransform<string, import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, {
+        readonly __hash: true;
+    }>>>;
+    _dataHash: z.ZodPipe<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>>, z.ZodTransform<string, import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, {
+        readonly __hash: true;
+    }>>>;
+    _sequence: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+}, 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.ZodPipe<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>>, z.ZodTransform<string, import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, {
+        readonly __hash: true;
+    }>>>;
+    _dataHash: z.ZodPipe<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>>, z.ZodTransform<string, import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, {
+        readonly __hash: true;
+    }>>>;
+    _sequence: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+    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

@@ -0,0 +1 @@
+{"version":3,"file":"Payload.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/Payload.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAIzB,CAAA;AAEF,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/neutral/types/schema/common/Sequence.d.ts

@@ -0,0 +1,9 @@
+import type { LocalSequence, QualifiedSequence } from '@xyo-network/payload-model';
+import { z } from 'zod';
+export declare const LocalSequenceToStringZod: z.ZodString;
+export declare const LocalSequenceFromStringZod: z.ZodPipe<z.ZodString, z.ZodTransform<LocalSequence, string>>;
+export declare const QualifiedSequenceToStringZod: z.ZodString;
+export declare const QualifiedSequenceFromStringZod: z.ZodPipe<z.ZodString, z.ZodTransform<QualifiedSequence, string>>;
+export declare const SequenceToStringZod: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+export declare const SequenceFromStringZod: z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<LocalSequence, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<QualifiedSequence, string>>]>;
+//# sourceMappingURL=Sequence.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Sequence.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/Sequence.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,wBAAwB,aAAuC,CAAA;AAC5E,eAAO,MAAM,0BAA0B,+DAAgG,CAAA;AAGvI,eAAO,MAAM,4BAA4B,aAA2C,CAAA;AACpF,eAAO,MAAM,8BAA8B,mEAA4G,CAAA;AAEvJ,eAAO,MAAM,mBAAmB,iDAAoE,CAAA;AACpG,eAAO,MAAM,qBAAqB,yJAAwE,CAAA"}

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

@@ -0,0 +1,239 @@
+import { z } from 'zod';
+export declare const BlockStartZod: z.ZodObject<{
+    nbf: z.ZodNumber;
+}, z.core.$strip>;
+export declare const BlockEndZod: z.ZodObject<{
+    exp: z.ZodNumber;
+}, z.core.$strip>;
+export declare const BlockDurationZod: z.ZodObject<{
+    nbf: z.ZodNumber;
+    exp: z.ZodNumber;
+}, z.core.$strip>;
+export declare const BlockScriptsZod: z.ZodObject<{
+    script: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const WithTransactionFeesZod: z.ZodObject<{
+    fees: z.ZodObject<{
+        base: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
+            readonly __hex: true;
+        }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
+            readonly __hex: true;
+        }>, unknown>>;
+        gasLimit: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
+            readonly __hex: true;
+        }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
+            readonly __hex: true;
+        }>, unknown>>;
+        gasPrice: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
+            readonly __hex: true;
+        }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
+            readonly __hex: true;
+        }>, unknown>>;
+        priority: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
+            readonly __hex: true;
+        }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
+            readonly __hex: true;
+        }>, unknown>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const TransactionBoundWitnessZod: z.ZodObject<{
+    schema: z.ZodLiteral<"network.xyo.boundwitness">;
+    addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, {
+        readonly __address: true;
+    }>, string>>>;
+    payload_hashes: z.ZodArray<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>>>;
+    payload_schemas: z.ZodArray<z.ZodString>;
+    previous_hashes: z.ZodArray<z.ZodNullable<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>>>>;
+    $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, {
+        readonly __address: true;
+    }>, string>>>;
+    $sourceQuery: z.ZodOptional<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>>>;
+    $signatures: z.ZodArray<z.ZodUnion<readonly [z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, unknown>>, z.ZodNull]>>;
+    _hash: z.ZodOptional<z.ZodPipe<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>>, z.ZodTransform<string, import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, {
+        readonly __hash: true;
+    }>>>>;
+    _dataHash: z.ZodOptional<z.ZodPipe<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>>, z.ZodTransform<string, import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, {
+        readonly __hash: true;
+    }>>>>;
+    _sequence: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
+    nbf: z.ZodNumber;
+    exp: z.ZodNumber;
+    fees: z.ZodObject<{
+        base: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
+            readonly __hex: true;
+        }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
+            readonly __hex: true;
+        }>, unknown>>;
+        gasLimit: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
+            readonly __hex: true;
+        }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
+            readonly __hex: true;
+        }>, unknown>>;
+        gasPrice: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
+            readonly __hex: true;
+        }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
+            readonly __hex: true;
+        }>, unknown>>;
+        priority: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
+            readonly __hex: true;
+        }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
+            readonly __hex: true;
+        }>, unknown>>;
+    }, z.core.$strip>;
+    chain: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/xl1-protocol").Chain, string>>;
+    from: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/xl1-protocol").Chain, string>>;
+    script: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const SignedTransactionBoundWitnessZod: z.ZodObject<{
+    schema: z.ZodLiteral<"network.xyo.boundwitness">;
+    addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, {
+        readonly __address: true;
+    }>, string>>>;
+    payload_hashes: z.ZodArray<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>>>;
+    payload_schemas: z.ZodArray<z.ZodString>;
+    previous_hashes: z.ZodArray<z.ZodNullable<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>>>>;
+    $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, {
+        readonly __address: true;
+    }>, string>>>;
+    $sourceQuery: z.ZodOptional<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>>>;
+    $signatures: z.ZodArray<z.ZodUnion<readonly [z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, unknown>>, z.ZodNull]>>;
+    _hash: z.ZodOptional<z.ZodPipe<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>>, z.ZodTransform<string, import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, {
+        readonly __hash: true;
+    }>>>>;
+    _dataHash: z.ZodOptional<z.ZodPipe<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>>, z.ZodTransform<string, import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, {
+        readonly __hash: true;
+    }>>>>;
+    _sequence: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
+    nbf: z.ZodNumber;
+    exp: z.ZodNumber;
+    fees: z.ZodObject<{
+        base: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
+            readonly __hex: true;
+        }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
+            readonly __hex: true;
+        }>, unknown>>;
+        gasLimit: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
+            readonly __hex: true;
+        }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
+            readonly __hex: true;
+        }>, unknown>>;
+        gasPrice: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
+            readonly __hex: true;
+        }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
+            readonly __hex: true;
+        }>, unknown>>;
+        priority: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
+            readonly __hex: true;
+        }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
+            readonly __hex: true;
+        }>, unknown>>;
+    }, z.core.$strip>;
+    chain: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/xl1-protocol").Chain, string>>;
+    from: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/xl1-protocol").Chain, string>>;
+    script: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+}, z.core.$strip>;
+//# sourceMappingURL=TransactionBoundWitness.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TransactionBoundWitness.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/TransactionBoundWitness.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAQvB,eAAO,MAAM,aAAa;;iBAAoC,CAAA;AAC9D,eAAO,MAAM,WAAW;;iBAAoC,CAAA;AAC5D,eAAO,MAAM,gBAAgB;;;iBAAyD,CAAA;AACtF,eAAO,MAAM,eAAe;;iBAAuD,CAAA;AAEnF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;iBAA4C,CAAA;AAM/E,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAUd,CAAA;AAEzB,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAUV,CAAA"}

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

@@ -1,34 +1,103 @@
 import { z } from 'zod';
-export declare const TransactionFeesToStingSchema: z.ZodObject<{
-    base: z.ZodEffects<z.ZodBigInt, import("@xylabs/hex").Hex | undefined, bigint>;
-    gasLimit: z.ZodEffects<z.ZodBigInt, import("@xylabs/hex").Hex | undefined, bigint>;
-    gasPrice: z.ZodEffects<z.ZodBigInt, import("@xylabs/hex").Hex | undefined, bigint>;
-    priority: z.ZodEffects<z.ZodBigInt, import("@xylabs/hex").Hex | undefined, bigint>;
-}, "strip", z.ZodTypeAny, {
-    base?: import("@xylabs/hex").Hex | undefined;
-    gasLimit?: import("@xylabs/hex").Hex | undefined;
-    gasPrice?: import("@xylabs/hex").Hex | undefined;
-    priority?: import("@xylabs/hex").Hex | undefined;
-}, {
+export declare const AttoFromStringZod: z.ZodPipe<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<Lowercase<string>, {
+    readonly __hex: true;
+}>, string>>, z.ZodTransform<bigint, import("@xylabs/typeof").Brand<Lowercase<string>, {
+    readonly __hex: true;
+}>>>, z.ZodTransform<import("@xyo-network/xl1-protocol").AttoXL1, bigint>>;
+export declare const TransactionFeesHexZod: z.ZodObject<{
+    base: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, unknown>>;
+    gasLimit: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, unknown>>;
+    gasPrice: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, unknown>>;
+    priority: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, unknown>>;
+}, z.core.$strip>;
+export type TransactionFeesHexZodType = z.infer<typeof TransactionFeesHexZod>;
+export declare const TransactionFeesBigIntZod: z.ZodObject<{
+    base: z.ZodBigInt;
+    gasLimit: z.ZodBigInt;
+    gasPrice: z.ZodBigInt;
+    priority: z.ZodBigInt;
+}, z.core.$strip>;
+export type TransactionFeesBigIntZodType = z.infer<typeof TransactionFeesBigIntZod>;
+export declare const TransactionFeesJsonToBigIntZod: z.ZodPipe<z.ZodObject<{
+    base: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, unknown>>;
+    gasLimit: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, unknown>>;
+    gasPrice: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, unknown>>;
+    priority: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, unknown>>;
+}, z.core.$strip>, z.ZodTransform<{
     base: bigint;
     gasLimit: bigint;
     gasPrice: bigint;
     priority: bigint;
-}>;
-export declare const TransactionFeesFromStingSchema: z.ZodObject<{
-    base: z.ZodEffects<z.ZodString, bigint, string>;
-    gasLimit: z.ZodEffects<z.ZodString, bigint, string>;
-    gasPrice: z.ZodEffects<z.ZodString, bigint, string>;
-    priority: z.ZodEffects<z.ZodString, bigint, string>;
-}, "strip", z.ZodTypeAny, {
+}, {
+    base: import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>;
+    gasLimit: import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>;
+    gasPrice: import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>;
+    priority: import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>;
+}>>;
+export declare const TransactionFeesBigIntToJsonZod: z.ZodPipe<z.ZodObject<{
+    base: z.ZodBigInt;
+    gasLimit: z.ZodBigInt;
+    gasPrice: z.ZodBigInt;
+    priority: z.ZodBigInt;
+}, z.core.$strip>, z.ZodTransform<{
+    base: import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>;
+    gasLimit: import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>;
+    gasPrice: import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>;
+    priority: import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>;
+}, {
     base: bigint;
     gasLimit: bigint;
     gasPrice: bigint;
     priority: bigint;
-}, {
-    base: string;
-    gasLimit: string;
-    gasPrice: string;
-    priority: string;
-}>;
+}>>;
+export type TransactionFeesJsonToBigIntZodType = z.infer<typeof TransactionFeesJsonToBigIntZod>;
+export type TransactionFeesBigIntToJsonZodType = z.infer<typeof TransactionFeesBigIntToJsonZod>;
 //# sourceMappingURL=TransactionFees.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"TransactionFees.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/TransactionFees.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;EAKvC,CAAA;AAEF,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;EAKzC,CAAA"}
+{"version":3,"file":"TransactionFees.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/TransactionFees.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,eAAO,MAAM,iBAAiB;;;;0EAA+C,CAAA;AAE7E,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;iBAKhC,CAAA;AAEF,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAE7E,eAAO,MAAM,wBAAwB;;;;;iBAKnC,CAAA;AAEF,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAEnF,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAKxC,CAAA;AAEH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;GAKxC,CAAA;AAEH,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAA;AAC/F,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAA"}

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

@@ -1,15 +1,13 @@
-export * from './AddressSchema.ts';
-export * from './BigIntSchema.ts';
-export * from './BlockBoundWitnessSchema.ts';
-export * from './BoundWitnessSchema.ts';
-export * from './HashSchema.ts';
-export * from './HexSchema.ts';
-export * from './HydratedBlockSchema.ts';
-export * from './HydratedTransactionSchema.ts';
-export * from './JsonSchema.ts';
-export * from './PayloadSchema.ts';
-export * from './SequenceSchema.ts';
-export * from './StorageMetaSchema.ts';
-export * from './TransactionBoundWitnessSchema.ts';
+export * from './Address.ts';
+export * from './AllowedBlockPayload.ts';
+export * from './BlockBoundWitness.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 './Sequence.ts';
+export * from './TransactionBoundWitness.ts';
 export * from './TransactionFees.ts';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAA;AAClC,cAAc,mBAAmB,CAAA;AACjC,cAAc,8BAA8B,CAAA;AAC5C,cAAc,yBAAyB,CAAA;AACvC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,0BAA0B,CAAA;AACxC,cAAc,gCAAgC,CAAA;AAC9C,cAAc,iBAAiB,CAAA;AAC/B,cAAc,oBAAoB,CAAA;AAClC,cAAc,qBAAqB,CAAA;AACnC,cAAc,wBAAwB,CAAA;AACtC,cAAc,oCAAoC,CAAA;AAClD,cAAc,sBAAsB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAA;AAC5B,cAAc,0BAA0B,CAAA;AACxC,cAAc,wBAAwB,CAAA;AACtC,cAAc,mBAAmB,CAAA;AACjC,cAAc,YAAY,CAAA;AAC1B,cAAc,oBAAoB,CAAA;AAClC,cAAc,0BAA0B,CAAA;AACxC,cAAc,WAAW,CAAA;AACzB,cAAc,cAAc,CAAA;AAC5B,cAAc,eAAe,CAAA;AAC7B,cAAc,8BAA8B,CAAA;AAC5C,cAAc,sBAAsB,CAAA"}

package/dist/neutral/types/schema/common/spec/BigIntZod.spec.d.ts

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

package/dist/neutral/types/schema/common/spec/BigIntZod.spec.d.ts.map

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

package/dist/neutral/types/schema/common/spec/HydratedTransaction.spec.d.ts

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

package/dist/neutral/types/schema/common/spec/HydratedTransaction.spec.d.ts.map

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

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

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

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

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

package/dist/neutral/types/schema/common/spec/TransactionBoundWitnessZod.spec.d.ts

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

package/dist/neutral/types/schema/common/spec/TransactionBoundWitnessZod.spec.d.ts.map

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

package/dist/neutral/types/schema/common/spec/UnsignedHydratedTransactionSchema.spec copy.d.ts

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

package/dist/neutral/types/schema/common/spec/UnsignedHydratedTransactionSchema.spec copy.d.ts.map

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

package/dist/neutral/types/schema/createRequestSchema.d.ts

@@ -1,29 +1,9 @@
 import type { ZodUndefined } from 'zod';
 import { z } from 'zod';
 export declare const createRequestSchema: <TParams extends z.ZodTypeAny, TMethodName extends string = string>(methodName: TMethodName, paramsSchema?: TParams | ZodUndefined) => z.ZodObject<{
-    id: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+    id: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
     jsonrpc: z.ZodLiteral<"2.0">;
     method: z.ZodLiteral<TMethodName>;
     params: TParams | ZodUndefined;
-}, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
-    id: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
-    jsonrpc: z.ZodLiteral<"2.0">;
-    method: z.ZodLiteral<TMethodName>;
-    params: TParams | ZodUndefined;
-}>, any> extends infer T ? { [k in keyof T]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
-    id: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
-    jsonrpc: z.ZodLiteral<"2.0">;
-    method: z.ZodLiteral<TMethodName>;
-    params: TParams | ZodUndefined;
-}>, any>[k]; } : never, z.baseObjectInputType<{
-    id: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
-    jsonrpc: z.ZodLiteral<"2.0">;
-    method: z.ZodLiteral<TMethodName>;
-    params: TParams | ZodUndefined;
-}> extends infer T_1 ? { [k_1 in keyof T_1]: z.baseObjectInputType<{
-    id: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
-    jsonrpc: z.ZodLiteral<"2.0">;
-    method: z.ZodLiteral<TMethodName>;
-    params: TParams | ZodUndefined;
-}>[k_1]; } : never>;
+}, z.core.$strip>;
 //# sourceMappingURL=createRequestSchema.d.ts.map