@xyo-network/xl1-rpc 1.30.3 → 2.0.0

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

@@ -1,29 +1,29 @@
-import { z } from 'zod';
+import { z } from 'zod/mini';
 /** NetworkStakingStepRewardsByStakerViewerRpcSchemas constant. */
 export declare const NetworkStakingStepRewardsByStakerViewerRpcSchemas: {
     networkStakingStepRewardsByStakerViewer_bonus: {
         params: {
-            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-lib").BlockNumber, number>>, z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").BlockNumber, number>>], null>>;
-                steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                    block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").XL1BlockNumber, number>>;
-                    step: z.ZodNumber;
+            to: z.ZodMiniTuple<readonly [z.ZodMiniOptional<import("zod").ZodObject<{
+                positions: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodNumber>>;
+                range: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").BlockNumber, number>>, import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").BlockNumber, number>>], null>>;
+                steps: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                    block: import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").XL1BlockNumber, number>>;
+                    step: import("zod").ZodNumber;
                 }, z.core.$strip>>>;
-                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+                stakers: import("zod").ZodOptional<import("zod").ZodArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
                     readonly __hex: true;
                 } & {
                     readonly __address: true;
                 }, string>>>>;
             }, z.core.$strip>>], null>;
-            from: 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-lib").BlockNumber, number>>, z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").BlockNumber, number>>], null>>;
-                steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                    block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").XL1BlockNumber, number>>;
-                    step: z.ZodNumber;
+            from: z.ZodMiniTuple<readonly [z.ZodMiniOptional<import("zod").ZodObject<{
+                positions: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodNumber>>;
+                range: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").BlockNumber, number>>, import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").BlockNumber, number>>], null>>;
+                steps: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                    block: import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").XL1BlockNumber, number>>;
+                    step: import("zod").ZodNumber;
                 }, z.core.$strip>>>;
-                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+                stakers: import("zod").ZodOptional<import("zod").ZodArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
                     readonly __hex: true;
                 } & {
                     readonly __address: true;
@@ -31,41 +31,41 @@ export declare const NetworkStakingStepRewardsByStakerViewerRpcSchemas: {
             }, z.core.$strip>>], null>;
         };
         result: {
-            to: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+            to: z.ZodMiniRecord<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<Lowercase<string> & {
                 readonly __hex: true;
             } & {
                 readonly __address: true;
-            }, string>>, z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, bigint>>>;
-            from: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+            }, string>>, z.ZodMiniPipe<z.ZodMiniBigInt<bigint>, z.ZodMiniTransform<import("@xylabs/sdk-js").BrandedHex, bigint>>>;
+            from: z.ZodMiniRecord<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<Lowercase<string> & {
                 readonly __hex: true;
             } & {
                 readonly __address: true;
-            }, string>>, z.ZodPipe<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>, z.ZodTransform<bigint, import("@xylabs/sdk-js").BrandedHex>>, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").AttoXL1, bigint>>>;
+            }, string>>, z.ZodMiniPipe<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<bigint, string>>, z.ZodMiniTransform<import("@xyo-network/xl1-protocol-lib").AttoXL1, bigint>>>;
         };
     };
     networkStakingStepRewardsByStakerViewer_claimed: {
         params: {
-            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-lib").BlockNumber, number>>, z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").BlockNumber, number>>], null>>;
-                steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                    block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").XL1BlockNumber, number>>;
-                    step: z.ZodNumber;
+            to: z.ZodMiniTuple<readonly [z.ZodMiniOptional<import("zod").ZodObject<{
+                positions: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodNumber>>;
+                range: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").BlockNumber, number>>, import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").BlockNumber, number>>], null>>;
+                steps: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                    block: import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").XL1BlockNumber, number>>;
+                    step: import("zod").ZodNumber;
                 }, z.core.$strip>>>;
-                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+                stakers: import("zod").ZodOptional<import("zod").ZodArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
                     readonly __hex: true;
                 } & {
                     readonly __address: true;
                 }, string>>>>;
             }, z.core.$strip>>], null>;
-            from: 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-lib").BlockNumber, number>>, z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").BlockNumber, number>>], null>>;
-                steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                    block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").XL1BlockNumber, number>>;
-                    step: z.ZodNumber;
+            from: z.ZodMiniTuple<readonly [z.ZodMiniOptional<import("zod").ZodObject<{
+                positions: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodNumber>>;
+                range: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").BlockNumber, number>>, import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").BlockNumber, number>>], null>>;
+                steps: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                    block: import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").XL1BlockNumber, number>>;
+                    step: import("zod").ZodNumber;
                 }, z.core.$strip>>>;
-                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+                stakers: import("zod").ZodOptional<import("zod").ZodArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
                     readonly __hex: true;
                 } & {
                     readonly __address: true;
@@ -73,41 +73,41 @@ export declare const NetworkStakingStepRewardsByStakerViewerRpcSchemas: {
             }, z.core.$strip>>], null>;
         };
         result: {
-            to: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+            to: z.ZodMiniRecord<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<Lowercase<string> & {
                 readonly __hex: true;
             } & {
                 readonly __address: true;
-            }, string>>, z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, bigint>>>;
-            from: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+            }, string>>, z.ZodMiniPipe<z.ZodMiniBigInt<bigint>, z.ZodMiniTransform<import("@xylabs/sdk-js").BrandedHex, bigint>>>;
+            from: z.ZodMiniRecord<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<Lowercase<string> & {
                 readonly __hex: true;
             } & {
                 readonly __address: true;
-            }, string>>, z.ZodPipe<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>, z.ZodTransform<bigint, import("@xylabs/sdk-js").BrandedHex>>, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").AttoXL1, bigint>>>;
+            }, string>>, z.ZodMiniPipe<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<bigint, string>>, z.ZodMiniTransform<import("@xyo-network/xl1-protocol-lib").AttoXL1, bigint>>>;
         };
     };
     networkStakingStepRewardsByStakerViewer_earned: {
         params: {
-            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-lib").BlockNumber, number>>, z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").BlockNumber, number>>], null>>;
-                steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                    block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").XL1BlockNumber, number>>;
-                    step: z.ZodNumber;
+            to: z.ZodMiniTuple<readonly [z.ZodMiniOptional<import("zod").ZodObject<{
+                positions: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodNumber>>;
+                range: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").BlockNumber, number>>, import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").BlockNumber, number>>], null>>;
+                steps: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                    block: import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").XL1BlockNumber, number>>;
+                    step: import("zod").ZodNumber;
                 }, z.core.$strip>>>;
-                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+                stakers: import("zod").ZodOptional<import("zod").ZodArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
                     readonly __hex: true;
                 } & {
                     readonly __address: true;
                 }, string>>>>;
             }, z.core.$strip>>], null>;
-            from: 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-lib").BlockNumber, number>>, z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").BlockNumber, number>>], null>>;
-                steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                    block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").XL1BlockNumber, number>>;
-                    step: z.ZodNumber;
+            from: z.ZodMiniTuple<readonly [z.ZodMiniOptional<import("zod").ZodObject<{
+                positions: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodNumber>>;
+                range: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").BlockNumber, number>>, import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").BlockNumber, number>>], null>>;
+                steps: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                    block: import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").XL1BlockNumber, number>>;
+                    step: import("zod").ZodNumber;
                 }, z.core.$strip>>>;
-                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+                stakers: import("zod").ZodOptional<import("zod").ZodArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
                     readonly __hex: true;
                 } & {
                     readonly __address: true;
@@ -115,41 +115,41 @@ export declare const NetworkStakingStepRewardsByStakerViewerRpcSchemas: {
             }, z.core.$strip>>], null>;
         };
         result: {
-            to: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+            to: z.ZodMiniRecord<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<Lowercase<string> & {
                 readonly __hex: true;
             } & {
                 readonly __address: true;
-            }, string>>, z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, bigint>>>;
-            from: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+            }, string>>, z.ZodMiniPipe<z.ZodMiniBigInt<bigint>, z.ZodMiniTransform<import("@xylabs/sdk-js").BrandedHex, bigint>>>;
+            from: z.ZodMiniRecord<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<Lowercase<string> & {
                 readonly __hex: true;
             } & {
                 readonly __address: true;
-            }, string>>, z.ZodPipe<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>, z.ZodTransform<bigint, import("@xylabs/sdk-js").BrandedHex>>, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").AttoXL1, bigint>>>;
+            }, string>>, z.ZodMiniPipe<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<bigint, string>>, z.ZodMiniTransform<import("@xyo-network/xl1-protocol-lib").AttoXL1, bigint>>>;
         };
     };
     networkStakingStepRewardsByStakerViewer_total: {
         params: {
-            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-lib").BlockNumber, number>>, z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").BlockNumber, number>>], null>>;
-                steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                    block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").XL1BlockNumber, number>>;
-                    step: z.ZodNumber;
+            to: z.ZodMiniTuple<readonly [z.ZodMiniOptional<import("zod").ZodObject<{
+                positions: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodNumber>>;
+                range: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").BlockNumber, number>>, import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").BlockNumber, number>>], null>>;
+                steps: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                    block: import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").XL1BlockNumber, number>>;
+                    step: import("zod").ZodNumber;
                 }, z.core.$strip>>>;
-                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+                stakers: import("zod").ZodOptional<import("zod").ZodArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
                     readonly __hex: true;
                 } & {
                     readonly __address: true;
                 }, string>>>>;
             }, z.core.$strip>>], null>;
-            from: 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-lib").BlockNumber, number>>, z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").BlockNumber, number>>], null>>;
-                steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                    block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").XL1BlockNumber, number>>;
-                    step: z.ZodNumber;
+            from: z.ZodMiniTuple<readonly [z.ZodMiniOptional<import("zod").ZodObject<{
+                positions: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodNumber>>;
+                range: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").BlockNumber, number>>, import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").BlockNumber, number>>], null>>;
+                steps: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                    block: import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").XL1BlockNumber, number>>;
+                    step: import("zod").ZodNumber;
                 }, z.core.$strip>>>;
-                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+                stakers: import("zod").ZodOptional<import("zod").ZodArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
                     readonly __hex: true;
                 } & {
                     readonly __address: true;
@@ -157,41 +157,41 @@ export declare const NetworkStakingStepRewardsByStakerViewerRpcSchemas: {
             }, z.core.$strip>>], null>;
         };
         result: {
-            to: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+            to: z.ZodMiniRecord<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<Lowercase<string> & {
                 readonly __hex: true;
             } & {
                 readonly __address: true;
-            }, string>>, z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, bigint>>>;
-            from: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+            }, string>>, z.ZodMiniPipe<z.ZodMiniBigInt<bigint>, z.ZodMiniTransform<import("@xylabs/sdk-js").BrandedHex, bigint>>>;
+            from: z.ZodMiniRecord<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<Lowercase<string> & {
                 readonly __hex: true;
             } & {
                 readonly __address: true;
-            }, string>>, z.ZodPipe<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>, z.ZodTransform<bigint, import("@xylabs/sdk-js").BrandedHex>>, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").AttoXL1, bigint>>>;
+            }, string>>, z.ZodMiniPipe<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<bigint, string>>, z.ZodMiniTransform<import("@xyo-network/xl1-protocol-lib").AttoXL1, bigint>>>;
         };
     };
     networkStakingStepRewardsByStakerViewer_unclaimed: {
         params: {
-            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-lib").BlockNumber, number>>, z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").BlockNumber, number>>], null>>;
-                steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                    block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").XL1BlockNumber, number>>;
-                    step: z.ZodNumber;
+            to: z.ZodMiniTuple<readonly [z.ZodMiniOptional<import("zod").ZodObject<{
+                positions: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodNumber>>;
+                range: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").BlockNumber, number>>, import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").BlockNumber, number>>], null>>;
+                steps: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                    block: import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").XL1BlockNumber, number>>;
+                    step: import("zod").ZodNumber;
                 }, z.core.$strip>>>;
-                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+                stakers: import("zod").ZodOptional<import("zod").ZodArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
                     readonly __hex: true;
                 } & {
                     readonly __address: true;
                 }, string>>>>;
             }, z.core.$strip>>], null>;
-            from: 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-lib").BlockNumber, number>>, z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").BlockNumber, number>>], null>>;
-                steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                    block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").XL1BlockNumber, number>>;
-                    step: z.ZodNumber;
+            from: z.ZodMiniTuple<readonly [z.ZodMiniOptional<import("zod").ZodObject<{
+                positions: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodNumber>>;
+                range: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").BlockNumber, number>>, import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").BlockNumber, number>>], null>>;
+                steps: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                    block: import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").XL1BlockNumber, number>>;
+                    step: import("zod").ZodNumber;
                 }, z.core.$strip>>>;
-                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+                stakers: import("zod").ZodOptional<import("zod").ZodArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
                     readonly __hex: true;
                 } & {
                     readonly __address: true;
@@ -199,16 +199,16 @@ export declare const NetworkStakingStepRewardsByStakerViewerRpcSchemas: {
             }, z.core.$strip>>], null>;
         };
         result: {
-            to: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+            to: z.ZodMiniRecord<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<Lowercase<string> & {
                 readonly __hex: true;
             } & {
                 readonly __address: true;
-            }, string>>, z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, bigint>>>;
-            from: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+            }, string>>, z.ZodMiniPipe<z.ZodMiniBigInt<bigint>, z.ZodMiniTransform<import("@xylabs/sdk-js").BrandedHex, bigint>>>;
+            from: z.ZodMiniRecord<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<Lowercase<string> & {
                 readonly __hex: true;
             } & {
                 readonly __address: true;
-            }, string>>, z.ZodPipe<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>, z.ZodTransform<bigint, import("@xylabs/sdk-js").BrandedHex>>, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").AttoXL1, bigint>>>;
+            }, string>>, z.ZodMiniPipe<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<bigint, string>>, z.ZodMiniTransform<import("@xyo-network/xl1-protocol-lib").AttoXL1, bigint>>>;
         };
     };
 };

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

@@ -1 +1 @@
-{"version":3,"file":"RewardsByStakerViewerRpcSchemas.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/RewardsByStakerViewerRpcSchemas.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB,kEAAkE;AAClE,eAAO,MAAM,iDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmDgB,CAAA;AAE9E,8DAA8D;AAC9D,MAAM,MAAM,iDAAiD,GAAG,OAAO,iDAAiD,CAAA"}
+{"version":3,"file":"RewardsByStakerViewerRpcSchemas.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/RewardsByStakerViewerRpcSchemas.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,UAAU,CAAA;AAK5B,kEAAkE;AAClE,eAAO,MAAM,iDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmDgB,CAAA;AAE9E,8DAA8D;AAC9D,MAAM,MAAM,iDAAiD,GAAG,OAAO,iDAAiD,CAAA"}