@xyo-network/xl1-rpc 1.16.2 → 1.16.4

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

@@ -12,9 +12,25 @@ export declare const HydratedTransactionZod: z.ZodTuple<[z.ZodObject<{
     }>, string>>>;
     $sourceQuery: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
     $signatures: z.ZodArray<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>, z.ZodNull]>>;
-    _hash: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>, z.ZodTransform<string, import("@xylabs/hex").Hash>>>;
-    _dataHash: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>, z.ZodTransform<string, import("@xylabs/hex").Hash>>>;
-    _sequence: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
+    _hash: 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>>>;
+    _dataHash: 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>>>;
+    _sequence: z.ZodOptional<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>>]>>;
     nbf: z.ZodNumber;
     exp: z.ZodNumber;
     fees: z.ZodObject<{
@@ -42,9 +58,25 @@ export declare const UnsignedHydratedTransactionZod: z.ZodTuple<[z.ZodObject<{
     }>, string>>>;
     $sourceQuery: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
     $signatures: z.ZodArray<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>, z.ZodNull]>>;
-    _hash: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>, z.ZodTransform<string, import("@xylabs/hex").Hash>>>;
-    _dataHash: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>, z.ZodTransform<string, import("@xylabs/hex").Hash>>>;
-    _sequence: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
+    _hash: 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>>>;
+    _dataHash: 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>>>;
+    _sequence: z.ZodOptional<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>>]>>;
     nbf: z.ZodNumber;
     exp: z.ZodNumber;
     fees: z.ZodObject<{
@@ -72,9 +104,25 @@ export declare const SignedHydratedTransactionZod: z.ZodTuple<[z.ZodObject<{
     }>, string>>>;
     $sourceQuery: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
     $signatures: z.ZodArray<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>, z.ZodNull]>>;
-    _hash: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>, z.ZodTransform<string, import("@xylabs/hex").Hash>>>;
-    _dataHash: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>, z.ZodTransform<string, import("@xylabs/hex").Hash>>>;
-    _sequence: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
+    _hash: 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>>>;
+    _dataHash: 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>>>;
+    _sequence: z.ZodOptional<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>>]>>;
     nbf: z.ZodNumber;
     exp: z.ZodNumber;
     fees: z.ZodObject<{
@@ -102,9 +150,25 @@ export declare const SignedHydratedTransactionToJsonZod: z.ZodPipe<z.ZodTuple<[z
     }>, string>>>;
     $sourceQuery: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
     $signatures: z.ZodArray<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>, z.ZodNull]>>;
-    _hash: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>, z.ZodTransform<string, import("@xylabs/hex").Hash>>>;
-    _dataHash: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>, z.ZodTransform<string, import("@xylabs/hex").Hash>>>;
-    _sequence: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
+    _hash: 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>>>;
+    _dataHash: 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>>>;
+    _sequence: z.ZodOptional<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>>]>>;
     nbf: z.ZodNumber;
     exp: z.ZodNumber;
     fees: z.ZodObject<{
@@ -141,9 +205,17 @@ export declare const SignedHydratedTransactionToJsonZod: z.ZodPipe<z.ZodTuple<[z
         readonly __address: true;
     }> | undefined;
     $sourceQuery?: import("@xylabs/hex").Hash | undefined;
-    _hash?: string | undefined;
-    _dataHash?: string | undefined;
-    _sequence?: string | undefined;
+    _hash?: import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, {
+        readonly __hash: true;
+    }> | undefined;
+    _dataHash?: import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, {
+        readonly __hash: true;
+    }> | undefined;
+    _sequence?: import("@xyo-network/payload-model").LocalSequence | import("@xyo-network/payload-model").QualifiedSequence | undefined;
     script?: string[] | undefined;
 }, {
     [x: string]: any;
@@ -162,9 +234,25 @@ export declare const JsonToSignedHydratedTransactionZod: z.ZodPipe<z.ZodTuple<[z
     }>, string>>>;
     $sourceQuery: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
     $signatures: z.ZodArray<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>, z.ZodNull]>>;
-    _hash: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>, z.ZodTransform<string, import("@xylabs/hex").Hash>>>;
-    _dataHash: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>, z.ZodTransform<string, import("@xylabs/hex").Hash>>>;
-    _sequence: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
+    _hash: 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>>>;
+    _dataHash: 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>>>;
+    _sequence: z.ZodOptional<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>>]>>;
     nbf: z.ZodNumber;
     exp: z.ZodNumber;
     fees: z.ZodObject<{
@@ -201,9 +289,17 @@ export declare const JsonToSignedHydratedTransactionZod: z.ZodPipe<z.ZodTuple<[z
         readonly __address: true;
     }> | undefined;
     $sourceQuery?: import("@xylabs/hex").Hash | undefined;
-    _hash?: string | undefined;
-    _dataHash?: string | undefined;
-    _sequence?: string | undefined;
+    _hash?: import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, {
+        readonly __hash: true;
+    }> | undefined;
+    _dataHash?: import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, {
+        readonly __hash: true;
+    }> | undefined;
+    _sequence?: import("@xyo-network/payload-model").LocalSequence | import("@xyo-network/payload-model").QualifiedSequence | undefined;
     script?: string[] | undefined;
 }, {
     [x: string]: any;

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

@@ -1 +1 @@
-{"version":3,"file":"HydratedTransaction.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/HydratedTransaction.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAKxB,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uCAGjC,CAAA;AAEF,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uCAGzC,CAAA;AAEF,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uCAGvC,CAAA;AAEF,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAM5C,CAAA;AAEH,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAM5C,CAAA"}
+{"version":3,"file":"HydratedTransaction.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/HydratedTransaction.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAKxB,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uCAGjC,CAAA;AAEF,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uCAGzC,CAAA;AAEF,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uCAGvC,CAAA;AAEF,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAM5C,CAAA;AAEH,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAM5C,CAAA"}

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

@@ -1,9 +1,4 @@
 import * as z from 'zod';
-export declare const StorageMetaZod: z.ZodObject<{
-    _hash: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>, z.ZodTransform<string, import("@xylabs/hex").Hash>>;
-    _dataHash: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>, z.ZodTransform<string, import("@xylabs/hex").Hash>>;
-    _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<{
@@ -11,27 +6,75 @@ export declare const PayloadZod: z.ZodObject<{
 }, z.core.$catchall<z.ZodAny>>;
 export declare const PayloadWithStorageMetaZod: z.ZodObject<{
     schema: z.ZodString;
-    _hash: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>, z.ZodTransform<string, import("@xylabs/hex").Hash>>;
-    _dataHash: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>, z.ZodTransform<string, import("@xylabs/hex").Hash>>;
-    _sequence: z.ZodUnion<readonly [z.ZodString, 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.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>, z.ZodTransform<string, import("@xylabs/hex").Hash>>;
-    _dataHash: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>, z.ZodTransform<string, import("@xylabs/hex").Hash>>;
-    _sequence: z.ZodUnion<readonly [z.ZodString, 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.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>, z.ZodTransform<string, import("@xylabs/hex").Hash>>;
-    _dataHash: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>, z.ZodTransform<string, import("@xylabs/hex").Hash>>;
-    _sequence: z.ZodUnion<readonly [z.ZodString, 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>>]>;
     schema: z.ZodString;
 }, z.core.$strip>;
 export type WithStorageMetaZodType = z.infer<typeof WithStorageMetaZod>;

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

@@ -1 +1 @@
-{"version":3,"file":"Payload.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/Payload.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAIxB,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"}
+{"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/Sequence.d.ts.map

@@ -1 +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;AAEnC,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAGxB,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"}
+{"version":3,"file":"Sequence.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/Sequence.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAA;AAElF,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAGxB,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/node/types/schema/common/TransactionBoundWitness.d.ts

@@ -33,9 +33,25 @@ export declare const TransactionBoundWitnessZod: z.ZodObject<{
     }>, string>>>;
     $sourceQuery: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
     $signatures: z.ZodArray<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>, z.ZodNull]>>;
-    _hash: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>, z.ZodTransform<string, import("@xylabs/hex").Hash>>>;
-    _dataHash: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>, z.ZodTransform<string, import("@xylabs/hex").Hash>>>;
-    _sequence: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
+    _hash: 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>>>;
+    _dataHash: 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>>>;
+    _sequence: z.ZodOptional<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>>]>>;
     nbf: z.ZodNumber;
     exp: z.ZodNumber;
     fees: z.ZodObject<{
@@ -61,9 +77,25 @@ export declare const SignedTransactionBoundWitnessZod: z.ZodObject<{
     }>, string>>>;
     $sourceQuery: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
     $signatures: z.ZodArray<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>, z.ZodNull]>>;
-    _hash: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>, z.ZodTransform<string, import("@xylabs/hex").Hash>>>;
-    _dataHash: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>, z.ZodTransform<string, import("@xylabs/hex").Hash>>>;
-    _sequence: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
+    _hash: 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>>>;
+    _dataHash: 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>>>;
+    _sequence: z.ZodOptional<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>>]>>;
     nbf: z.ZodNumber;
     exp: z.ZodNumber;
     fees: z.ZodObject<{

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

@@ -1 +1 @@
-{"version":3,"file":"TransactionBoundWitness.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/TransactionBoundWitness.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAQxB,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"}
+{"version":3,"file":"TransactionBoundWitness.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/TransactionBoundWitness.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAOxB,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/node/types/schema/common/Transfer.d.ts

@@ -1,7 +1,7 @@
 import z from 'zod';
 export declare const TransferFieldsZod: z.ZodObject<{
     $opCodes: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    context: z.ZodOptional<z.ZodObject<{}, z.z.core.$strip>>;
+    context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
     epoch: z.ZodNumber;
     from: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
         readonly __address: true;
@@ -13,7 +13,7 @@ export declare const TransferFieldsZod: z.ZodObject<{
 export declare const TransferZod: z.ZodObject<{
     schema: z.ZodLiteral<"network.xyo.transfer">;
     $opCodes: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    context: z.ZodOptional<z.ZodObject<{}, z.z.core.$strip>>;
+    context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
     epoch: z.ZodNumber;
     from: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
         readonly __address: true;
@@ -25,7 +25,7 @@ export declare const TransferZod: z.ZodObject<{
 export declare const TransferZodWithStorageMeta: z.ZodObject<{
     schema: z.ZodLiteral<"network.xyo.transfer">;
     $opCodes: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    context: z.ZodOptional<z.ZodObject<{}, z.z.core.$strip>>;
+    context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
     epoch: z.ZodNumber;
     from: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
         readonly __address: true;
@@ -33,7 +33,7 @@ export declare const TransferZodWithStorageMeta: z.ZodObject<{
     transfers: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
         readonly __address: true;
     }>, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>>;
-    _hash: z.ZodPipe<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+    _hash: z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
         readonly __hex: true;
     }>, {
         readonly __hash: true;
@@ -41,12 +41,8 @@ export declare const TransferZodWithStorageMeta: z.ZodObject<{
         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>, {
+    }>, unknown>>;
+    _dataHash: z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
         readonly __hex: true;
     }>, {
         readonly __hash: true;
@@ -54,11 +50,7 @@ export declare const TransferZodWithStorageMeta: z.ZodObject<{
         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]>;
+    }>, 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.z.core.$strict>;
 //# sourceMappingURL=Transfer.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"Transfer.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/Transfer.ts"],"names":[],"mappings":"AAGA,OAAO,CAAC,MAAM,KAAK,CAAA;AAInB,eAAO,MAAM,iBAAiB;;;;;;;;;;mBAM5B,CAAA;AAEF,eAAO,MAAM,WAAW;;;;;;;;;;;oBAA2E,CAAA;AACnG,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAA2C,CAAA"}
+{"version":3,"file":"Transfer.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/Transfer.ts"],"names":[],"mappings":"AAGA,OAAO,CAAC,MAAM,KAAK,CAAA;AAInB,eAAO,MAAM,iBAAiB;;;;;;;;;;mBAM5B,CAAA;AAEF,eAAO,MAAM,WAAW;;;;;;;;;;;oBAA2E,CAAA;AACnG,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAA2C,CAAA"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "http://json.schemastore.org/package.json",
   "name": "@xyo-network/xl1-rpc",
-  "version": "1.16.2",
+  "version": "1.16.4",
   "description": "XYO Layer One API",
   "homepage": "https://xylabs.com",
   "bugs": {
@@ -59,18 +59,15 @@
     "@xylabs/assert": "~5.0.22",
     "@xylabs/axios": "~5.0.22",
     "@xylabs/hex": "~5.0.22",
-    "@xylabs/promise": "~5.0.22",
     "@xylabs/typeof": "~5.0.22",
-    "@xyo-network/account-model": "~5.1.18",
-    "@xyo-network/archivist-memory": "~5.1.18",
-    "@xyo-network/archivist-model": "~5.1.18",
-    "@xyo-network/boundwitness-model": "~5.1.18",
-    "@xyo-network/module-model": "~5.1.18",
-    "@xyo-network/node-model": "~5.1.18",
-    "@xyo-network/payload-builder": "~5.1.18",
-    "@xyo-network/payload-model": "~5.1.18",
+    "@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.2",
+    "@xyo-network/xl1-protocol-sdk": "~1.16.4",
     "axios": "~1.13.2",
     "uuid": "~13.0.0",
     "zod": "~4.1.12"
@@ -83,9 +80,10 @@
     "@xylabs/ts-scripts-yarn3": "~7.2.8",
     "@xylabs/tsconfig": "~7.2.8",
     "@xylabs/vitest-extended": "~5.0.22",
-    "@xyo-network/account": "~5.1.18",
-    "@xyo-network/chain-protocol": "~1.16.2",
-    "@xyo-network/wallet": "~5.1.18",
+    "@xyo-network/account": "~5.1.19",
+    "@xyo-network/account-model": "~5.1.19",
+    "@xyo-network/chain-protocol": "~1.16.4",
+    "@xyo-network/wallet": "~5.1.19",
     "dotenv": "~17.2.3",
     "eslint": "^9.39.1",
     "typescript": "~5.9.3",

package/src/spec/MemoryXyoClient.spec.ts

@@ -58,7 +58,7 @@ describe('Client', () => {
         expect(gateway).toBeDefined()
       })
       it('should allow retrieving the chain ID', async () => {
-        const chainId = await (await client.gateways['localhost' as GatewayName]?.connection)?.viewer?.chainId()
+        const chainId = await (await client.gateways['localhost' as GatewayName]?.connection())?.viewer?.chainId()
         expect(chainId).toBeDefined()
       })
     })

package/src/spec/MemoryXyoGateway.spec.ts

@@ -52,7 +52,7 @@ describe('MemoryXyoGateway', () => {
       const additionalPayloads: Payload[] = []
       const chainId = await connection.viewer?.chainId()
       const nbf = await connection.viewer?.currentBlockNumber() ?? 0
-      const signer = sut.signer
+      const signer = await sut.signer()
       const signerAddress = await signer.address()
       expect(chainId).toBeDefined()
       if (chainId) {

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

@@ -1,4 +1,5 @@
 import { HashZod } from '@xylabs/hex'
+import { StorageMetaZod } from '@xyo-network/payload-model'
 import { asXL1BlockNumber } from '@xyo-network/xl1-protocol'
 import * as z from 'zod'
 
@@ -7,7 +8,6 @@ import {
   UnsignedBoundWitnessZod,
 } from './BoundWitness.ts'
 import { ChainZod } from './Chain.ts'
-import { StorageMetaZod } from './Payload.ts'
 
 export const BlockNumberZod = z.number().int().nonnegative()
 export const XL1BlockNumberZod = BlockNumberZod.transform(asXL1BlockNumber)
@@ -42,6 +42,7 @@ 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())

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

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

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

@@ -1,14 +1,6 @@
-import { HashToJsonZod } from '@xylabs/hex'
+import { StorageMetaZod } from '@xyo-network/payload-model'
 import * as z from 'zod'
 
-import { SequenceToStringZod } from './Sequence.ts'
-
-export const StorageMetaZod = z.object({
-  _hash: HashToJsonZod,
-  _dataHash: HashToJsonZod,
-  _sequence: SequenceToStringZod,
-})
-
 export const SchemaZod = z.string()
 export type Schema = z.infer<typeof SchemaZod>
 

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

@@ -1,8 +1,5 @@
 import { HexRegExMinMax, toHex } from '@xylabs/hex'
-import type {
-  LocalSequence,
-  QualifiedSequence,
-} from '@xyo-network/payload-model'
+import type { LocalSequence, QualifiedSequence } from '@xyo-network/payload-model'
 import { SequenceConstants } from '@xyo-network/payload-model'
 import * as z from 'zod'
 

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

@@ -1,9 +1,9 @@
+import { StorageMetaZod } from '@xyo-network/payload-model'
 import * as z from 'zod'
 
 import { BlockNumberZod } from './BlockBoundWitness.ts'
 import { SignedBoundWitnessZod, UnsignedBoundWitnessZod } from './BoundWitness.ts'
 import { ChainZod } from './Chain.ts'
-import { StorageMetaZod } from './Payload.ts'
 import { TransactionFeesHexZod } from './TransactionFees.ts'
 
 export const BlockStartZod = z.object({ nbf: BlockNumberZod })

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

@@ -7,7 +7,7 @@ import { AddressZod } from './Address.ts'
 
 export const TransferFieldsZod = z.object({
   $opCodes: z.array(z.string()).optional(),
-  context: z.object().optional(),
+  context: z.record(z.string(), z.json()).optional(),
   epoch: z.number(),
   from: AddressZod,
   transfers: z.record(AddressZod, HexZod),