@xyo-network/xl1-rpc 1.16.8 → 1.16.10

package/dist/neutral/types/schema/XyoViewerRpcSchemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"XyoViewerRpcSchemas.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/XyoViewerRpcSchemas.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAgBxB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2ZgB,CAAA"}
+{"version":3,"file":"XyoViewerRpcSchemas.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/XyoViewerRpcSchemas.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAcxB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiZgB,CAAA"}

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

@@ -1,17 +1,13 @@
 import * as z from 'zod';
 export declare const BlockBoundWitnessZod: z.ZodObject<{
     schema: z.ZodLiteral<"network.xyo.boundwitness">;
-    addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>, string>>>;
+    addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>>;
     payload_hashes: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
     payload_schemas: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<string & {
         __schema: true;
     }, string>>]>>;
     previous_hashes: z.ZodArray<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>>;
-    $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>, string>>>;
+    $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, 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.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
@@ -26,17 +22,13 @@ export declare const BlockBoundWitnessZod: z.ZodObject<{
 }, z.core.$strip>;
 export declare const SignedBlockBoundWitnessZod: z.ZodObject<{
     schema: z.ZodLiteral<"network.xyo.boundwitness">;
-    addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>, string>>>;
+    addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>>;
     payload_hashes: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
     payload_schemas: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<string & {
         __schema: true;
     }, string>>]>>;
     previous_hashes: z.ZodArray<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>>;
-    $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>, string>>>;
+    $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, 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.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;

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

@@ -1 +1 @@
-{"version":3,"file":"BlockBoundWitness.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/BlockBoundWitness.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAkBxB,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;iBAMC,CAAA;AAElC,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;iBAML,CAAA"}
+{"version":3,"file":"BlockBoundWitness.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/BlockBoundWitness.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAkBxB,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;iBAMC,CAAA;AAElC,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;iBAML,CAAA"}

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

@@ -1,85 +1,65 @@
 import * as z from 'zod';
 export declare const BoundWitnessZod: z.ZodObject<{
     schema: z.ZodLiteral<"network.xyo.boundwitness">;
-    addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>, string>>>;
+    addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>>;
     payload_hashes: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
     payload_schemas: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<string & {
         __schema: true;
     }, string>>]>>;
     previous_hashes: z.ZodArray<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>>;
-    $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>, string>>>;
+    $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, 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]>>;
 }, z.core.$strip>;
 export type BoundWitness = z.infer<typeof BoundWitnessZod>;
 export declare const AnyBoundWitnessZod: z.ZodObject<{
     schema: z.ZodLiteral<"network.xyo.boundwitness">;
-    addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>, string>>>;
+    addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>>;
     payload_hashes: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
     payload_schemas: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<string & {
         __schema: true;
     }, string>>]>>;
     previous_hashes: z.ZodArray<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>>;
-    $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>, string>>>;
+    $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, 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]>>;
 }, z.core.$catchall<z.ZodAny>>;
 export type AnyBoundWitness = z.infer<typeof AnyBoundWitnessZod>;
 export declare const UnsignedBoundWitnessZod: z.ZodObject<{
     schema: z.ZodLiteral<"network.xyo.boundwitness">;
-    addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>, string>>>;
+    addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>>;
     payload_hashes: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
     payload_schemas: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<string & {
         __schema: true;
     }, string>>]>>;
     previous_hashes: z.ZodArray<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>>;
-    $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>, string>>>;
+    $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, 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]>>;
 }, z.core.$strip>;
 export type UnsignedBoundWitness = z.infer<typeof UnsignedBoundWitnessZod>;
 export declare const AnyUnsignedBoundWitnessZod: z.ZodObject<{
     schema: z.ZodLiteral<"network.xyo.boundwitness">;
-    addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>, string>>>;
+    addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>>;
     payload_hashes: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
     payload_schemas: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<string & {
         __schema: true;
     }, string>>]>>;
     previous_hashes: z.ZodArray<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>>;
-    $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>, string>>>;
+    $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, 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]>>;
 }, z.core.$catchall<z.ZodAny>>;
 export type AnyUnsignedBoundWitness = z.infer<typeof AnyUnsignedBoundWitnessZod>;
 export declare const UnsignedBoundWitnessWithStorageMetaZod: z.ZodObject<{
     schema: z.ZodLiteral<"network.xyo.boundwitness">;
-    addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>, string>>>;
+    addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>>;
     payload_hashes: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
     payload_schemas: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<string & {
         __schema: true;
     }, string>>]>>;
     previous_hashes: z.ZodArray<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>>;
-    $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>, string>>>;
+    $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, 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.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>;
@@ -88,33 +68,25 @@ export declare const UnsignedBoundWitnessWithStorageMetaZod: z.ZodObject<{
 }, z.core.$strip>;
 export declare const SignedBoundWitnessZod: z.ZodObject<{
     schema: z.ZodLiteral<"network.xyo.boundwitness">;
-    addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>, string>>>;
+    addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>>;
     payload_hashes: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
     payload_schemas: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<string & {
         __schema: true;
     }, string>>]>>;
     previous_hashes: z.ZodArray<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>>;
-    $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>, string>>>;
+    $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, 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]>>;
 }, z.core.$strip>;
 export declare const SignedBoundWitnessWithStorageMetaZod: z.ZodObject<{
     schema: z.ZodLiteral<"network.xyo.boundwitness">;
-    addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>, string>>>;
+    addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>>;
     payload_hashes: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
     payload_schemas: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<string & {
         __schema: true;
     }, string>>]>>;
     previous_hashes: z.ZodArray<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>>;
-    $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>, string>>>;
+    $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, 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.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>;
@@ -123,33 +95,25 @@ export declare const SignedBoundWitnessWithStorageMetaZod: z.ZodObject<{
 }, z.core.$strip>;
 export declare const AnySignedBoundWitnessZod: z.ZodObject<{
     schema: z.ZodLiteral<"network.xyo.boundwitness">;
-    addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>, string>>>;
+    addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>>;
     payload_hashes: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
     payload_schemas: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<string & {
         __schema: true;
     }, string>>]>>;
     previous_hashes: z.ZodArray<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>>;
-    $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>, string>>>;
+    $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, 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]>>;
 }, z.core.$catchall<z.ZodAny>>;
 export declare const AnySignedBoundWitnessWithStorageMetaZod: z.ZodObject<{
     schema: z.ZodLiteral<"network.xyo.boundwitness">;
-    addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>, string>>>;
+    addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>>;
     payload_hashes: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
     payload_schemas: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<string & {
         __schema: true;
     }, string>>]>>;
     previous_hashes: z.ZodArray<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>>;
-    $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>, string>>>;
+    $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, 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.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>;

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

@@ -1 +1 @@
-{"version":3,"file":"BoundWitness.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/BoundWitness.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAiBxB,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;iBAIuG,CAAA;AAEnI,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AAE1D,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;8BACX,CAAA;AAEpB,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAEhE,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;iBAA+G,CAAA;AAEnJ,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAE1E,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;8BACnB,CAAA;AAEpB,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAEhF,eAAO,MAAM,sCAAsC;;;;;;;;;;;;;;;;;;iBAGhB,CAAA;AAEnC,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;iBAAoH,CAAA;AAEtJ,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;iBAAyC,CAAA;AAE1F,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;8BAA4C,CAAA;AAEjF,eAAO,MAAM,uCAAuC;;;;;;;;;;;;;;;;;;8BAA2D,CAAA"}
+{"version":3,"file":"BoundWitness.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/BoundWitness.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAexB,eAAO,MAAM,eAAe;;;;;;;;;;;iBAIuG,CAAA;AAEnI,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AAE1D,eAAO,MAAM,kBAAkB;;;;;;;;;;;8BACX,CAAA;AAEpB,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAEhE,eAAO,MAAM,uBAAuB;;;;;;;;;;;iBAA+G,CAAA;AAEnJ,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAE1E,eAAO,MAAM,0BAA0B;;;;;;;;;;;8BACnB,CAAA;AAEpB,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAEhF,eAAO,MAAM,sCAAsC;;;;;;;;;;;;;;iBAGhB,CAAA;AAEnC,eAAO,MAAM,qBAAqB;;;;;;;;;;;iBAAoH,CAAA;AAEtJ,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;iBAAyC,CAAA;AAE1F,eAAO,MAAM,wBAAwB;;;;;;;;;;;8BAA4C,CAAA;AAEjF,eAAO,MAAM,uCAAuC;;;;;;;;;;;;;;8BAA2D,CAAA"}

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

@@ -1,17 +1,13 @@
 import * as z from 'zod';
 export declare const HydratedBlockZod: z.ZodTuple<[z.ZodObject<{
     schema: z.ZodLiteral<"network.xyo.boundwitness">;
-    addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>, string>>>;
+    addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>>;
     payload_hashes: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
     payload_schemas: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<string & {
         __schema: true;
     }, string>>]>>;
     previous_hashes: z.ZodArray<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>>;
-    $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>, string>>>;
+    $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, 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.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
@@ -30,17 +26,13 @@ export declare const HydratedBlockZod: z.ZodTuple<[z.ZodObject<{
 }, z.core.$strict>>], null>;
 export declare const HydratedBlockWithStorageMetaZod: z.ZodTuple<[z.ZodObject<{
     schema: z.ZodLiteral<"network.xyo.boundwitness">;
-    addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>, string>>>;
+    addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>>;
     payload_hashes: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
     payload_schemas: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<string & {
         __schema: true;
     }, string>>]>>;
     previous_hashes: z.ZodArray<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>>;
-    $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>, string>>>;
+    $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, 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]>>;
     block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>;
@@ -62,17 +54,13 @@ export declare const HydratedBlockWithStorageMetaZod: z.ZodTuple<[z.ZodObject<{
 }, z.core.$strip>>], null>;
 export declare const SignedHydratedBlockZod: z.ZodTuple<[z.ZodObject<{
     schema: z.ZodLiteral<"network.xyo.boundwitness">;
-    addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>, string>>>;
+    addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>>;
     payload_hashes: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
     payload_schemas: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<string & {
         __schema: true;
     }, string>>]>>;
     previous_hashes: z.ZodArray<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>>;
-    $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>, string>>>;
+    $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, 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.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
@@ -91,17 +79,13 @@ export declare const SignedHydratedBlockZod: z.ZodTuple<[z.ZodObject<{
 }, z.core.$strict>>], null>;
 export declare const SignedHydratedBlockToJsonZod: z.ZodTuple<[z.ZodObject<{
     schema: z.ZodLiteral<"network.xyo.boundwitness">;
-    addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>, string>>>;
+    addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>>;
     payload_hashes: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
     payload_schemas: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<string & {
         __schema: true;
     }, string>>]>>;
     previous_hashes: z.ZodArray<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>>;
-    $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>, string>>>;
+    $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, 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.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
@@ -120,17 +104,13 @@ export declare const SignedHydratedBlockToJsonZod: z.ZodTuple<[z.ZodObject<{
 }, z.core.$strict>>], null>;
 export declare const SignedHydratedBlockWithStorageMetaZod: z.ZodTuple<[z.ZodObject<{
     schema: z.ZodLiteral<"network.xyo.boundwitness">;
-    addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>, string>>>;
+    addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>>;
     payload_hashes: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
     payload_schemas: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<string & {
         __schema: true;
     }, string>>]>>;
     previous_hashes: z.ZodArray<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>>;
-    $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>, string>>>;
+    $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, 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]>>;
     block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>;

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

@@ -1 +1 @@
-{"version":3,"file":"HydratedBlock.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/HydratedBlock.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAOxB,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAG3B,CAAA;AAEF,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAG1C,CAAA;AAEF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAGjC,CAAA;AAEF,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAGvC,CAAA;AAEF,eAAO,MAAM,qCAAqC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAGhD,CAAA"}
+{"version":3,"file":"HydratedBlock.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/HydratedBlock.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAOxB,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;2BAG3B,CAAA;AAEF,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAG1C,CAAA;AAEF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;2BAGjC,CAAA;AAEF,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;2BAGvC,CAAA;AAEF,eAAO,MAAM,qCAAqC;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAGhD,CAAA"}

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

@@ -1,17 +1,13 @@
 import * as z from 'zod';
 export declare const HydratedTransactionZod: z.ZodTuple<[z.ZodObject<{
     schema: z.ZodLiteral<"network.xyo.boundwitness">;
-    addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>, string>>>;
+    addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>>;
     payload_hashes: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
     payload_schemas: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<string & {
         __schema: true;
     }, string>>]>>;
     previous_hashes: z.ZodArray<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>>;
-    $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>, string>>>;
+    $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, 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.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
@@ -35,17 +31,13 @@ export declare const HydratedTransactionZod: z.ZodTuple<[z.ZodObject<{
 }, z.core.$strict>>], null>;
 export declare const UnsignedHydratedTransactionZod: z.ZodTuple<[z.ZodObject<{
     schema: z.ZodLiteral<"network.xyo.boundwitness">;
-    addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>, string>>>;
+    addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>>;
     payload_hashes: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
     payload_schemas: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<string & {
         __schema: true;
     }, string>>]>>;
     previous_hashes: z.ZodArray<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>>;
-    $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>, string>>>;
+    $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, 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.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
@@ -69,17 +61,13 @@ export declare const UnsignedHydratedTransactionZod: z.ZodTuple<[z.ZodObject<{
 }, z.core.$strict>>], null>;
 export declare const SignedHydratedTransactionZod: z.ZodTuple<[z.ZodObject<{
     schema: z.ZodLiteral<"network.xyo.boundwitness">;
-    addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>, string>>>;
+    addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>>;
     payload_hashes: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
     payload_schemas: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<string & {
         __schema: true;
     }, string>>]>>;
     previous_hashes: z.ZodArray<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>>;
-    $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>, string>>>;
+    $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, 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.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
@@ -103,17 +91,13 @@ export declare const SignedHydratedTransactionZod: z.ZodTuple<[z.ZodObject<{
 }, z.core.$strict>>], null>;
 export declare const SignedHydratedTransactionToJsonZod: z.ZodPipe<z.ZodTuple<[z.ZodObject<{
     schema: z.ZodLiteral<"network.xyo.boundwitness">;
-    addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>, string>>>;
+    addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>>;
     payload_hashes: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
     payload_schemas: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<string & {
         __schema: true;
     }, string>>]>>;
     previous_hashes: z.ZodArray<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>>;
-    $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>, string>>>;
+    $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, 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.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
@@ -136,9 +120,7 @@ export declare const SignedHydratedTransactionToJsonZod: z.ZodPipe<z.ZodTuple<[z
     }, string>>]>;
 }, z.core.$strict>>], null>, z.ZodTransform<import("@xyo-network/xl1-protocol").SignedHydratedTransaction<import("@xyo-network/xl1-protocol").TransactionBoundWitness, import("@xyo-network/payload-model").Payload> | undefined, [{
     schema: "network.xyo.boundwitness";
-    addresses: import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>[];
+    addresses: import("@xylabs/hex").Address[];
     payload_hashes: import("@xylabs/hex").Hash[];
     payload_schemas: (string | (string & {
         __schema: true;
@@ -155,9 +137,7 @@ export declare const SignedHydratedTransactionToJsonZod: z.ZodPipe<z.ZodTuple<[z
     };
     chain: import("@xyo-network/xl1-protocol").ChainId;
     from: import("@xyo-network/xl1-protocol").ChainId;
-    $destination?: import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }> | undefined;
+    $destination?: import("@xylabs/hex").Address | undefined;
     $sourceQuery?: import("@xylabs/hex").Hash | undefined;
     _hash?: import("@xylabs/hex").Hash | undefined;
     _dataHash?: import("@xylabs/hex").Hash | undefined;
@@ -170,17 +150,13 @@ export declare const SignedHydratedTransactionToJsonZod: z.ZodPipe<z.ZodTuple<[z
 }[]]>>;
 export declare const JsonToSignedHydratedTransactionZod: z.ZodPipe<z.ZodTuple<[z.ZodObject<{
     schema: z.ZodLiteral<"network.xyo.boundwitness">;
-    addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>, string>>>;
+    addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>>;
     payload_hashes: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
     payload_schemas: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<string & {
         __schema: true;
     }, string>>]>>;
     previous_hashes: z.ZodArray<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>>;
-    $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>, string>>>;
+    $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, 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.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
@@ -203,9 +179,7 @@ export declare const JsonToSignedHydratedTransactionZod: z.ZodPipe<z.ZodTuple<[z
     }, string>>]>;
 }, z.core.$strict>>], null>, z.ZodTransform<(import("@xyo-network/xl1-protocol").SignedHydratedTransaction<import("@xyo-network/xl1-protocol").TransactionBoundWitness, import("@xyo-network/payload-model").Payload> | (import("@xyo-network/payload-model").Payload | undefined)[] | undefined)[], [{
     schema: "network.xyo.boundwitness";
-    addresses: import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>[];
+    addresses: import("@xylabs/hex").Address[];
     payload_hashes: import("@xylabs/hex").Hash[];
     payload_schemas: (string | (string & {
         __schema: true;
@@ -222,9 +196,7 @@ export declare const JsonToSignedHydratedTransactionZod: z.ZodPipe<z.ZodTuple<[z
     };
     chain: import("@xyo-network/xl1-protocol").ChainId;
     from: import("@xyo-network/xl1-protocol").ChainId;
-    $destination?: import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }> | undefined;
+    $destination?: import("@xylabs/hex").Address | undefined;
     $sourceQuery?: import("@xylabs/hex").Hash | undefined;
     _hash?: import("@xylabs/hex").Hash | undefined;
     _dataHash?: import("@xylabs/hex").Hash | undefined;

package/dist/neutral/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;AAIxB,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAGjC,CAAA;AAEF,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAGzC,CAAA;AAEF,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAGvC,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;AAIxB,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAGjC,CAAA;AAEF,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAGzC,CAAA;AAEF,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAGvC,CAAA;AAEF,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAM5C,CAAA;AAEH,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAM5C,CAAA"}

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

@@ -3,11 +3,9 @@ export declare const RewardsRangeOptionsZod: z.ZodObject<{
     positions: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
     range: z.ZodOptional<z.ZodTuple<[z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").BlockNumber, number>>, z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").BlockNumber, number>>], null>>;
     steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        block: z.ZodNumber;
+        block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>;
         step: z.ZodNumber;
     }, z.core.$strip>>>;
-    stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>, string>>>>;
+    stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>>>;
 }, z.core.$strip>;
 //# sourceMappingURL=RewardsRangeOptions.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"RewardsRangeOptions.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/RewardsRangeOptions.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB,eAAO,MAAM,sBAAsB;;;;;;;;;;iBAKjC,CAAA"}
+{"version":3,"file":"RewardsRangeOptions.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/RewardsRangeOptions.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,sBAAsB;;;;;;;;iBAKjC,CAAA"}