@xyo-network/xl1-rpc 1.16.9 → 1.16.10

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

@@ -1 +1 @@
-{"version":3,"file":"AllRpcSchemas.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/AllRpcSchemas.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAMF,CAAA"}
+{"version":3,"file":"AllRpcSchemas.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/AllRpcSchemas.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAMF,CAAA"}

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

@@ -6,23 +6,19 @@ export declare const NetworkStakingStepRewardsByPositionViewerRpcSchemas: {
                 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.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.z.core.$strip>>], null>;
             to: z.ZodTuple<[z.ZodOptional<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.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.z.core.$strip>>], null>;
         };
         result: {
@@ -36,23 +32,19 @@ export declare const NetworkStakingStepRewardsByPositionViewerRpcSchemas: {
                 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.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.z.core.$strip>>], null>;
             to: z.ZodTuple<[z.ZodOptional<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.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.z.core.$strip>>], null>;
         };
         result: {
@@ -66,23 +58,19 @@ export declare const NetworkStakingStepRewardsByPositionViewerRpcSchemas: {
                 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.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.z.core.$strip>>], null>;
             to: z.ZodTuple<[z.ZodOptional<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.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.z.core.$strip>>], null>;
         };
         result: {
@@ -96,23 +84,19 @@ export declare const NetworkStakingStepRewardsByPositionViewerRpcSchemas: {
                 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.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.z.core.$strip>>], null>;
             to: z.ZodTuple<[z.ZodOptional<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.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.z.core.$strip>>], null>;
         };
         result: {
@@ -126,23 +110,19 @@ export declare const NetworkStakingStepRewardsByPositionViewerRpcSchemas: {
                 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.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.z.core.$strip>>], null>;
             to: z.ZodTuple<[z.ZodOptional<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.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.z.core.$strip>>], null>;
         };
         result: {

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

@@ -1 +1 @@
-{"version":3,"file":"RewardsByPositionViewerRpcSchemas.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/RewardsByPositionViewerRpcSchemas.ts"],"names":[],"mappings":"AAEA,OAAO,CAAC,MAAM,KAAK,CAAA;AAMnB,eAAO,MAAM,mDAAmD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmDgB,CAAA"}
+{"version":3,"file":"RewardsByPositionViewerRpcSchemas.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/RewardsByPositionViewerRpcSchemas.ts"],"names":[],"mappings":"AAEA,OAAO,CAAC,MAAM,KAAK,CAAA;AAMnB,eAAO,MAAM,mDAAmD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmDgB,CAAA"}

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

@@ -6,32 +6,24 @@ export declare const NetworkStakingStepRewardsByStakerViewerRpcSchemas: {
                 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.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.z.core.$strip>>], null>;
             to: z.ZodTuple<[z.ZodOptional<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.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.z.core.$strip>>], null>;
         };
         result: {
-            from: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-                readonly __address: true;
-            }>, string>>, z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/hex").Hex, bigint>>>;
-            to: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-                readonly __address: true;
-            }>, string>>, z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>, z.ZodTransform<bigint, import("@xylabs/hex").Hex>>>;
+            from: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>, z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/hex").Hex, bigint>>>;
+            to: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>, z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>, z.ZodTransform<bigint, import("@xylabs/hex").Hex>>>;
         };
     };
     networkStakingStepRewardsByStakerViewer_claimed: {
@@ -40,32 +32,24 @@ export declare const NetworkStakingStepRewardsByStakerViewerRpcSchemas: {
                 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.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.z.core.$strip>>], null>;
             to: z.ZodTuple<[z.ZodOptional<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.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.z.core.$strip>>], null>;
         };
         result: {
-            from: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-                readonly __address: true;
-            }>, string>>, z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/hex").Hex, bigint>>>;
-            to: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-                readonly __address: true;
-            }>, string>>, z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>, z.ZodTransform<bigint, import("@xylabs/hex").Hex>>>;
+            from: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>, z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/hex").Hex, bigint>>>;
+            to: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>, z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>, z.ZodTransform<bigint, import("@xylabs/hex").Hex>>>;
         };
     };
     networkStakingStepRewardsByStakerViewer_earned: {
@@ -74,32 +58,24 @@ export declare const NetworkStakingStepRewardsByStakerViewerRpcSchemas: {
                 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.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.z.core.$strip>>], null>;
             to: z.ZodTuple<[z.ZodOptional<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.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.z.core.$strip>>], null>;
         };
         result: {
-            from: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-                readonly __address: true;
-            }>, string>>, z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/hex").Hex, bigint>>>;
-            to: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-                readonly __address: true;
-            }>, string>>, z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>, z.ZodTransform<bigint, import("@xylabs/hex").Hex>>>;
+            from: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>, z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/hex").Hex, bigint>>>;
+            to: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>, z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>, z.ZodTransform<bigint, import("@xylabs/hex").Hex>>>;
         };
     };
     networkStakingStepRewardsByStakerViewer_total: {
@@ -108,32 +84,24 @@ export declare const NetworkStakingStepRewardsByStakerViewerRpcSchemas: {
                 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.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.z.core.$strip>>], null>;
             to: z.ZodTuple<[z.ZodOptional<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.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.z.core.$strip>>], null>;
         };
         result: {
-            from: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-                readonly __address: true;
-            }>, string>>, z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/hex").Hex, bigint>>>;
-            to: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-                readonly __address: true;
-            }>, string>>, z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>, z.ZodTransform<bigint, import("@xylabs/hex").Hex>>>;
+            from: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>, z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/hex").Hex, bigint>>>;
+            to: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>, z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>, z.ZodTransform<bigint, import("@xylabs/hex").Hex>>>;
         };
     };
     networkStakingStepRewardsByStakerViewer_unclaimed: {
@@ -142,32 +110,24 @@ export declare const NetworkStakingStepRewardsByStakerViewerRpcSchemas: {
                 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.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.z.core.$strip>>], null>;
             to: z.ZodTuple<[z.ZodOptional<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.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.z.core.$strip>>], null>;
         };
         result: {
-            from: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-                readonly __address: true;
-            }>, string>>, z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/hex").Hex, bigint>>>;
-            to: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-                readonly __address: true;
-            }>, string>>, z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>, z.ZodTransform<bigint, import("@xylabs/hex").Hex>>>;
+            from: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>, z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/hex").Hex, bigint>>>;
+            to: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>, z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>, z.ZodTransform<bigint, import("@xylabs/hex").Hex>>>;
         };
     };
 };

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

@@ -1 +1 @@
-{"version":3,"file":"RewardsByStakerViewerRpcSchemas.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/RewardsByStakerViewerRpcSchemas.ts"],"names":[],"mappings":"AACA,OAAO,CAAC,MAAM,KAAK,CAAA;AAMnB,eAAO,MAAM,iDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmDgB,CAAA"}
+{"version":3,"file":"RewardsByStakerViewerRpcSchemas.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/RewardsByStakerViewerRpcSchemas.ts"],"names":[],"mappings":"AAGA,OAAO,CAAC,MAAM,KAAK,CAAA;AAMnB,eAAO,MAAM,iDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmDgB,CAAA"}

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

@@ -6,32 +6,24 @@ export declare const NetworkStakingStepRewardsByStepViewerRpcSchemas: {
                 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.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.z.core.$strip>>], null>;
             to: z.ZodTuple<[z.ZodOptional<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.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.z.core.$strip>>], null>;
         };
         result: {
-            from: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-                readonly __address: true;
-            }>, string>>, z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/hex").Hex, bigint>>>;
-            to: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-                readonly __address: true;
-            }>, string>>, z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>, z.ZodTransform<bigint, import("@xylabs/hex").Hex>>>;
+            from: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>, z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/hex").Hex, bigint>>>;
+            to: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>, z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>, z.ZodTransform<bigint, import("@xylabs/hex").Hex>>>;
         };
     };
     networkStakingStepRewardsByStepViewer_claimed: {
@@ -40,32 +32,24 @@ export declare const NetworkStakingStepRewardsByStepViewerRpcSchemas: {
                 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.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.z.core.$strip>>], null>;
             to: z.ZodTuple<[z.ZodOptional<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.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.z.core.$strip>>], null>;
         };
         result: {
-            from: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-                readonly __address: true;
-            }>, string>>, z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/hex").Hex, bigint>>>;
-            to: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-                readonly __address: true;
-            }>, string>>, z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>, z.ZodTransform<bigint, import("@xylabs/hex").Hex>>>;
+            from: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>, z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/hex").Hex, bigint>>>;
+            to: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>, z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>, z.ZodTransform<bigint, import("@xylabs/hex").Hex>>>;
         };
     };
     networkStakingStepRewardsByStepViewer_earned: {
@@ -74,32 +58,24 @@ export declare const NetworkStakingStepRewardsByStepViewerRpcSchemas: {
                 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.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.z.core.$strip>>], null>;
             to: z.ZodTuple<[z.ZodOptional<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.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.z.core.$strip>>], null>;
         };
         result: {
-            from: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-                readonly __address: true;
-            }>, string>>, z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/hex").Hex, bigint>>>;
-            to: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-                readonly __address: true;
-            }>, string>>, z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>, z.ZodTransform<bigint, import("@xylabs/hex").Hex>>>;
+            from: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>, z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/hex").Hex, bigint>>>;
+            to: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>, z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>, z.ZodTransform<bigint, import("@xylabs/hex").Hex>>>;
         };
     };
     networkStakingStepRewardsByStepViewer_total: {
@@ -108,32 +84,24 @@ export declare const NetworkStakingStepRewardsByStepViewerRpcSchemas: {
                 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.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.z.core.$strip>>], null>;
             to: z.ZodTuple<[z.ZodOptional<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.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.z.core.$strip>>], null>;
         };
         result: {
-            from: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-                readonly __address: true;
-            }>, string>>, z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/hex").Hex, bigint>>>;
-            to: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-                readonly __address: true;
-            }>, string>>, z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>, z.ZodTransform<bigint, import("@xylabs/hex").Hex>>>;
+            from: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>, z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/hex").Hex, bigint>>>;
+            to: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>, z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>, z.ZodTransform<bigint, import("@xylabs/hex").Hex>>>;
         };
     };
     networkStakingStepRewardsByStepViewer_unclaimed: {
@@ -142,32 +110,24 @@ export declare const NetworkStakingStepRewardsByStepViewerRpcSchemas: {
                 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.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.z.core.$strip>>], null>;
             to: z.ZodTuple<[z.ZodOptional<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.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.z.core.$strip>>], null>;
         };
         result: {
-            from: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-                readonly __address: true;
-            }>, string>>, z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/hex").Hex, bigint>>>;
-            to: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-                readonly __address: true;
-            }>, string>>, z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>, z.ZodTransform<bigint, import("@xylabs/hex").Hex>>>;
+            from: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>, z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/hex").Hex, bigint>>>;
+            to: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>, z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>, z.ZodTransform<bigint, import("@xylabs/hex").Hex>>>;
         };
     };
 };

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

@@ -1 +1 @@
-{"version":3,"file":"RewardsByStepViewerRpcSchemas.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/RewardsByStepViewerRpcSchemas.ts"],"names":[],"mappings":"AACA,OAAO,CAAC,MAAM,KAAK,CAAA;AAMnB,eAAO,MAAM,+CAA+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmDgB,CAAA"}
+{"version":3,"file":"RewardsByStepViewerRpcSchemas.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/RewardsByStepViewerRpcSchemas.ts"],"names":[],"mappings":"AAGA,OAAO,CAAC,MAAM,KAAK,CAAA;AAMnB,eAAO,MAAM,+CAA+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmDgB,CAAA"}