@xyo-network/xl1-rpc 1.16.1 → 1.16.2

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

@@ -9,9 +9,7 @@ export declare const NetworkStakingStepRewardsByStepViewerRpcSchemas: {
                     block: z.ZodNumber;
                     step: z.ZodNumber;
                 }, z.z.core.$strip>>>;
-                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
+                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
                     readonly __address: true;
                 }>, string>>>>;
             }, z.z.core.$strip>>], null>;
@@ -22,30 +20,18 @@ export declare const NetworkStakingStepRewardsByStepViewerRpcSchemas: {
                     block: z.ZodNumber;
                     step: z.ZodNumber;
                 }, z.z.core.$strip>>>;
-                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
+                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
                     readonly __address: true;
                 }>, string>>>>;
             }, z.z.core.$strip>>], null>;
         };
         result: {
-            from: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                readonly __hex: true;
-            }>, {
+            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/typeof").Brand<Lowercase<string>, {
-                readonly __hex: true;
-            }>, bigint>>>;
-            to: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                readonly __hex: 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/typeof").Brand<Lowercase<string>, {
-                readonly __hex: true;
-            }>, string>>, z.ZodTransform<bigint, import("@xylabs/typeof").Brand<Lowercase<string>, {
-                readonly __hex: true;
-            }>>>>;
+            }>, string>>, z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>, z.ZodTransform<bigint, import("@xylabs/hex").Hex>>>;
         };
     };
     networkStakingStepRewardsByStepViewer_claimed: {
@@ -57,9 +43,7 @@ export declare const NetworkStakingStepRewardsByStepViewerRpcSchemas: {
                     block: z.ZodNumber;
                     step: z.ZodNumber;
                 }, z.z.core.$strip>>>;
-                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
+                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
                     readonly __address: true;
                 }>, string>>>>;
             }, z.z.core.$strip>>], null>;
@@ -70,30 +54,18 @@ export declare const NetworkStakingStepRewardsByStepViewerRpcSchemas: {
                     block: z.ZodNumber;
                     step: z.ZodNumber;
                 }, z.z.core.$strip>>>;
-                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
+                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
                     readonly __address: true;
                 }>, string>>>>;
             }, z.z.core.$strip>>], null>;
         };
         result: {
-            from: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                readonly __hex: true;
-            }>, {
+            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/typeof").Brand<Lowercase<string>, {
-                readonly __hex: true;
-            }>, bigint>>>;
-            to: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                readonly __hex: 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/typeof").Brand<Lowercase<string>, {
-                readonly __hex: true;
-            }>, string>>, z.ZodTransform<bigint, import("@xylabs/typeof").Brand<Lowercase<string>, {
-                readonly __hex: true;
-            }>>>>;
+            }>, string>>, z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>, z.ZodTransform<bigint, import("@xylabs/hex").Hex>>>;
         };
     };
     networkStakingStepRewardsByStepViewer_earned: {
@@ -105,9 +77,7 @@ export declare const NetworkStakingStepRewardsByStepViewerRpcSchemas: {
                     block: z.ZodNumber;
                     step: z.ZodNumber;
                 }, z.z.core.$strip>>>;
-                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
+                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
                     readonly __address: true;
                 }>, string>>>>;
             }, z.z.core.$strip>>], null>;
@@ -118,30 +88,18 @@ export declare const NetworkStakingStepRewardsByStepViewerRpcSchemas: {
                     block: z.ZodNumber;
                     step: z.ZodNumber;
                 }, z.z.core.$strip>>>;
-                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
+                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
                     readonly __address: true;
                 }>, string>>>>;
             }, z.z.core.$strip>>], null>;
         };
         result: {
-            from: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                readonly __hex: true;
-            }>, {
+            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/typeof").Brand<Lowercase<string>, {
-                readonly __hex: true;
-            }>, bigint>>>;
-            to: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                readonly __hex: 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/typeof").Brand<Lowercase<string>, {
-                readonly __hex: true;
-            }>, string>>, z.ZodTransform<bigint, import("@xylabs/typeof").Brand<Lowercase<string>, {
-                readonly __hex: true;
-            }>>>>;
+            }>, string>>, z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>, z.ZodTransform<bigint, import("@xylabs/hex").Hex>>>;
         };
     };
     networkStakingStepRewardsByStepViewer_total: {
@@ -153,9 +111,7 @@ export declare const NetworkStakingStepRewardsByStepViewerRpcSchemas: {
                     block: z.ZodNumber;
                     step: z.ZodNumber;
                 }, z.z.core.$strip>>>;
-                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
+                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
                     readonly __address: true;
                 }>, string>>>>;
             }, z.z.core.$strip>>], null>;
@@ -166,30 +122,18 @@ export declare const NetworkStakingStepRewardsByStepViewerRpcSchemas: {
                     block: z.ZodNumber;
                     step: z.ZodNumber;
                 }, z.z.core.$strip>>>;
-                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
+                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
                     readonly __address: true;
                 }>, string>>>>;
             }, z.z.core.$strip>>], null>;
         };
         result: {
-            from: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                readonly __hex: true;
-            }>, {
+            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/typeof").Brand<Lowercase<string>, {
-                readonly __hex: true;
-            }>, bigint>>>;
-            to: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                readonly __hex: 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/typeof").Brand<Lowercase<string>, {
-                readonly __hex: true;
-            }>, string>>, z.ZodTransform<bigint, import("@xylabs/typeof").Brand<Lowercase<string>, {
-                readonly __hex: true;
-            }>>>>;
+            }>, string>>, z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>, z.ZodTransform<bigint, import("@xylabs/hex").Hex>>>;
         };
     };
     networkStakingStepRewardsByStepViewer_unclaimed: {
@@ -201,9 +145,7 @@ export declare const NetworkStakingStepRewardsByStepViewerRpcSchemas: {
                     block: z.ZodNumber;
                     step: z.ZodNumber;
                 }, z.z.core.$strip>>>;
-                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
+                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
                     readonly __address: true;
                 }>, string>>>>;
             }, z.z.core.$strip>>], null>;
@@ -214,30 +156,18 @@ export declare const NetworkStakingStepRewardsByStepViewerRpcSchemas: {
                     block: z.ZodNumber;
                     step: z.ZodNumber;
                 }, z.z.core.$strip>>>;
-                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
+                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
                     readonly __address: true;
                 }>, string>>>>;
             }, z.z.core.$strip>>], null>;
         };
         result: {
-            from: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                readonly __hex: true;
-            }>, {
+            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/typeof").Brand<Lowercase<string>, {
-                readonly __hex: true;
-            }>, bigint>>>;
-            to: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                readonly __hex: 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/typeof").Brand<Lowercase<string>, {
-                readonly __hex: true;
-            }>, string>>, z.ZodTransform<bigint, import("@xylabs/typeof").Brand<Lowercase<string>, {
-                readonly __hex: true;
-            }>>>>;
+            }>, 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":"AACA,OAAO,CAAC,MAAM,KAAK,CAAA;AAMnB,eAAO,MAAM,+CAA+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmDgB,CAAA"}

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

@@ -9,9 +9,7 @@ export declare const NetworkStakingStepRewardsTotalViewerRpcSchemas: {
                     block: z.ZodNumber;
                     step: z.ZodNumber;
                 }, z.core.$strip>>>;
-                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
+                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
                     readonly __address: true;
                 }>, string>>>>;
             }, z.core.$strip>>], null>;
@@ -22,22 +20,14 @@ export declare const NetworkStakingStepRewardsTotalViewerRpcSchemas: {
                     block: z.ZodNumber;
                     step: z.ZodNumber;
                 }, z.core.$strip>>>;
-                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
+                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
                     readonly __address: true;
                 }>, string>>>>;
             }, z.core.$strip>>], null>;
         };
         result: {
-            from: z.ZodPipe<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                readonly __hex: true;
-            }>, string>>, z.ZodTransform<bigint, import("@xylabs/typeof").Brand<Lowercase<string>, {
-                readonly __hex: true;
-            }>>>, z.ZodTransform<import("@xyo-network/xl1-protocol").AttoXL1, bigint>>;
-            to: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                readonly __hex: true;
-            }>, bigint>>;
+            from: z.ZodPipe<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>, z.ZodTransform<bigint, import("@xylabs/hex").Hex>>, z.ZodTransform<import("@xyo-network/xl1-protocol").AttoXL1, bigint>>;
+            to: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/hex").Hex, bigint>>;
         };
     };
     networkStakingStepRewardsTotalViewer_claimed: {
@@ -49,9 +39,7 @@ export declare const NetworkStakingStepRewardsTotalViewerRpcSchemas: {
                     block: z.ZodNumber;
                     step: z.ZodNumber;
                 }, z.core.$strip>>>;
-                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
+                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
                     readonly __address: true;
                 }>, string>>>>;
             }, z.core.$strip>>], null>;
@@ -62,22 +50,14 @@ export declare const NetworkStakingStepRewardsTotalViewerRpcSchemas: {
                     block: z.ZodNumber;
                     step: z.ZodNumber;
                 }, z.core.$strip>>>;
-                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
+                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
                     readonly __address: true;
                 }>, string>>>>;
             }, z.core.$strip>>], null>;
         };
         result: {
-            from: z.ZodPipe<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                readonly __hex: true;
-            }>, string>>, z.ZodTransform<bigint, import("@xylabs/typeof").Brand<Lowercase<string>, {
-                readonly __hex: true;
-            }>>>, z.ZodTransform<import("@xyo-network/xl1-protocol").AttoXL1, bigint>>;
-            to: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                readonly __hex: true;
-            }>, bigint>>;
+            from: z.ZodPipe<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>, z.ZodTransform<bigint, import("@xylabs/hex").Hex>>, z.ZodTransform<import("@xyo-network/xl1-protocol").AttoXL1, bigint>>;
+            to: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/hex").Hex, bigint>>;
         };
     };
     networkStakingStepRewardsTotalViewer_earned: {
@@ -89,9 +69,7 @@ export declare const NetworkStakingStepRewardsTotalViewerRpcSchemas: {
                     block: z.ZodNumber;
                     step: z.ZodNumber;
                 }, z.core.$strip>>>;
-                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
+                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
                     readonly __address: true;
                 }>, string>>>>;
             }, z.core.$strip>>], null>;
@@ -102,22 +80,14 @@ export declare const NetworkStakingStepRewardsTotalViewerRpcSchemas: {
                     block: z.ZodNumber;
                     step: z.ZodNumber;
                 }, z.core.$strip>>>;
-                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
+                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
                     readonly __address: true;
                 }>, string>>>>;
             }, z.core.$strip>>], null>;
         };
         result: {
-            from: z.ZodPipe<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                readonly __hex: true;
-            }>, string>>, z.ZodTransform<bigint, import("@xylabs/typeof").Brand<Lowercase<string>, {
-                readonly __hex: true;
-            }>>>, z.ZodTransform<import("@xyo-network/xl1-protocol").AttoXL1, bigint>>;
-            to: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                readonly __hex: true;
-            }>, bigint>>;
+            from: z.ZodPipe<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>, z.ZodTransform<bigint, import("@xylabs/hex").Hex>>, z.ZodTransform<import("@xyo-network/xl1-protocol").AttoXL1, bigint>>;
+            to: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/hex").Hex, bigint>>;
         };
     };
     networkStakingStepRewardsTotalViewer_total: {
@@ -129,9 +99,7 @@ export declare const NetworkStakingStepRewardsTotalViewerRpcSchemas: {
                     block: z.ZodNumber;
                     step: z.ZodNumber;
                 }, z.core.$strip>>>;
-                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
+                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
                     readonly __address: true;
                 }>, string>>>>;
             }, z.core.$strip>>], null>;
@@ -142,22 +110,14 @@ export declare const NetworkStakingStepRewardsTotalViewerRpcSchemas: {
                     block: z.ZodNumber;
                     step: z.ZodNumber;
                 }, z.core.$strip>>>;
-                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
+                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
                     readonly __address: true;
                 }>, string>>>>;
             }, z.core.$strip>>], null>;
         };
         result: {
-            from: z.ZodPipe<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                readonly __hex: true;
-            }>, string>>, z.ZodTransform<bigint, import("@xylabs/typeof").Brand<Lowercase<string>, {
-                readonly __hex: true;
-            }>>>, z.ZodTransform<import("@xyo-network/xl1-protocol").AttoXL1, bigint>>;
-            to: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                readonly __hex: true;
-            }>, bigint>>;
+            from: z.ZodPipe<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>, z.ZodTransform<bigint, import("@xylabs/hex").Hex>>, z.ZodTransform<import("@xyo-network/xl1-protocol").AttoXL1, bigint>>;
+            to: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/hex").Hex, bigint>>;
         };
     };
     networkStakingStepRewardsTotalViewer_unclaimed: {
@@ -169,9 +129,7 @@ export declare const NetworkStakingStepRewardsTotalViewerRpcSchemas: {
                     block: z.ZodNumber;
                     step: z.ZodNumber;
                 }, z.core.$strip>>>;
-                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
+                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
                     readonly __address: true;
                 }>, string>>>>;
             }, z.core.$strip>>], null>;
@@ -182,22 +140,14 @@ export declare const NetworkStakingStepRewardsTotalViewerRpcSchemas: {
                     block: z.ZodNumber;
                     step: z.ZodNumber;
                 }, z.core.$strip>>>;
-                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
+                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
                     readonly __address: true;
                 }>, string>>>>;
             }, z.core.$strip>>], null>;
         };
         result: {
-            from: z.ZodPipe<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                readonly __hex: true;
-            }>, string>>, z.ZodTransform<bigint, import("@xylabs/typeof").Brand<Lowercase<string>, {
-                readonly __hex: true;
-            }>>>, z.ZodTransform<import("@xyo-network/xl1-protocol").AttoXL1, bigint>>;
-            to: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                readonly __hex: true;
-            }>, bigint>>;
+            from: z.ZodPipe<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>, z.ZodTransform<bigint, import("@xylabs/hex").Hex>>, z.ZodTransform<import("@xyo-network/xl1-protocol").AttoXL1, bigint>>;
+            to: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/hex").Hex, bigint>>;
         };
     };
 };

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

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

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

@@ -12,14 +12,8 @@ export declare const StepViewerRpcSchemas: {
             }, z.z.core.$strip>], null>;
         };
         result: {
-            from: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                readonly __hex: true;
-            }>, bigint>>;
-            to: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                readonly __hex: true;
-            }>, string>>, z.ZodTransform<bigint, import("@xylabs/typeof").Brand<Lowercase<string>, {
-                readonly __hex: true;
-            }>>>;
+            from: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/hex").Hex, bigint>>;
+            to: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>, z.ZodTransform<bigint, import("@xylabs/hex").Hex>>;
         };
     };
     stake: {
@@ -34,14 +28,8 @@ export declare const StepViewerRpcSchemas: {
             }, z.z.core.$strip>], null>;
         };
         result: {
-            from: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                readonly __hex: true;
-            }>, bigint>>;
-            to: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                readonly __hex: true;
-            }>, string>>, z.ZodTransform<bigint, import("@xylabs/typeof").Brand<Lowercase<string>, {
-                readonly __hex: true;
-            }>>>;
+            from: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/hex").Hex, bigint>>;
+            to: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>, z.ZodTransform<bigint, import("@xylabs/hex").Hex>>;
         };
     };
     stakers: {
@@ -56,22 +44,14 @@ export declare const StepViewerRpcSchemas: {
             }, z.z.core.$strip>], null>;
         };
         result: {
-            from: z.ZodArray<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                readonly __hex: true;
-            }>, {
+            from: z.ZodArray<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
                 readonly __address: true;
-            }>, unknown, z.z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                readonly __hex: true;
-            }>, {
+            }>, unknown, z.z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
                 readonly __address: true;
             }>, unknown>>>;
-            to: z.ZodArray<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                readonly __hex: true;
-            }>, {
+            to: z.ZodArray<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
                 readonly __address: true;
-            }>, unknown, z.z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                readonly __hex: true;
-            }>, {
+            }>, unknown, z.z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
                 readonly __address: true;
             }>, unknown>>>;
         };
@@ -88,14 +68,8 @@ export declare const StepViewerRpcSchemas: {
             }, z.z.core.$strip>], null>;
         };
         result: {
-            from: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                readonly __hex: true;
-            }>, bigint>>;
-            to: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                readonly __hex: true;
-            }>, string>>, z.ZodTransform<bigint, import("@xylabs/typeof").Brand<Lowercase<string>, {
-                readonly __hex: true;
-            }>>>;
+            from: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/hex").Hex, bigint>>;
+            to: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>, z.ZodTransform<bigint, import("@xylabs/hex").Hex>>;
         };
     };
     positionCount: {
@@ -131,32 +105,22 @@ export declare const StepViewerRpcSchemas: {
                 addBlock: z.ZodNumber;
                 id: z.ZodNumber;
                 removeBlock: z.ZodNumber;
-                staked: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
+                staked: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
                     readonly __address: true;
                 }>, string>>;
-                staker: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
+                staker: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
                     readonly __address: true;
                 }>, string>>;
                 withdrawBlock: z.ZodNumber;
             }, z.z.core.$strip>, z.ZodTransform<{
                 addBlock: number;
-                amount: import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>;
+                amount: import("@xylabs/hex").Hex;
                 id: number;
                 removeBlock: number;
-                staked: import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
+                staked: import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
                     readonly __address: true;
                 }>;
-                staker: import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
+                staker: import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
                     readonly __address: true;
                 }>;
                 withdrawBlock: number;
@@ -165,14 +129,10 @@ export declare const StepViewerRpcSchemas: {
                 addBlock: number;
                 id: number;
                 removeBlock: number;
-                staked: import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
+                staked: import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
                     readonly __address: true;
                 }>;
-                staker: import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
+                staker: import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
                     readonly __address: true;
                 }>;
                 withdrawBlock: number;
@@ -181,35 +141,23 @@ export declare const StepViewerRpcSchemas: {
                 addBlock: z.ZodNumber;
                 id: z.ZodNumber;
                 removeBlock: z.ZodNumber;
-                staked: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
+                staked: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
                     readonly __address: true;
                 }>, string>>;
-                staker: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
+                staker: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
                     readonly __address: true;
                 }>, string>>;
                 withdrawBlock: z.ZodNumber;
-                amount: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, unknown, z.z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, unknown>>;
+                amount: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>;
             }, z.z.core.$strip>, z.ZodTransform<{
                 addBlock: number;
                 amount: import("@xyo-network/xl1-protocol").AttoXL1;
                 id: import("@xyo-network/xl1-protocol").PositionId;
                 removeBlock: number;
-                staked: import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
+                staked: import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
                     readonly __address: true;
                 }>;
-                staker: import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
+                staker: import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
                     readonly __address: true;
                 }>;
                 withdrawBlock: number;
@@ -217,20 +165,14 @@ export declare const StepViewerRpcSchemas: {
                 addBlock: number;
                 id: number;
                 removeBlock: number;
-                staked: import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
+                staked: import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
                     readonly __address: true;
                 }>;
-                staker: import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
+                staker: import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
                     readonly __address: true;
                 }>;
                 withdrawBlock: number;
-                amount: import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>;
+                amount: import("@xylabs/hex").Hex;
             }>>>;
         };
     };