@xyo-network/xl1-rpc 1.16.0 → 1.16.2

package/dist/node/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/node/types/schema/DataLakeViewerRpcSchema.d.ts

@@ -0,0 +1,50 @@
+import * as z from 'zod';
+export declare const DataLakeViewerRpcSchemas: {
+    dataLakeViewer_get: {
+        params: {
+            to: z.ZodTuple<[z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>], null>;
+            from: z.ZodTuple<[z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>], null>;
+        };
+        result: {
+            to: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                schema: z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<string & {
+                    __schema: true;
+                }, string>>]>;
+            }, z.core.$strip>, z.ZodPipe<z.ZodCustom<ArrayBuffer, ArrayBuffer>, z.ZodTransform<string, ArrayBuffer>>]>>;
+            from: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                schema: z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<string & {
+                    __schema: true;
+                }, string>>]>;
+            }, z.core.$strip>, z.ZodPipe<z.ZodString, z.ZodTransform<ArrayBuffer | SharedArrayBuffer, string>>]>>;
+        };
+    };
+    dataLakeViewer_getMany: {
+        params: {
+            to: z.ZodTuple<[z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>], null>;
+            from: z.ZodTuple<[z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>], null>;
+        };
+        result: {
+            to: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                schema: z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<string & {
+                    __schema: true;
+                }, string>>]>;
+            }, z.core.$strip>, z.ZodPipe<z.ZodCustom<ArrayBuffer, ArrayBuffer>, z.ZodTransform<string, ArrayBuffer>>]>>;
+            from: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                schema: z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<string & {
+                    __schema: true;
+                }, string>>]>;
+            }, z.core.$strip>, z.ZodPipe<z.ZodString, z.ZodTransform<ArrayBuffer | SharedArrayBuffer, string>>]>>;
+        };
+    };
+    dataLakeViewer_has: {
+        params: {
+            to: z.ZodTuple<[z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>], null>;
+            from: z.ZodTuple<[z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>], null>;
+        };
+        result: {
+            to: z.ZodBoolean;
+            from: z.ZodBoolean;
+        };
+    };
+};
+//# sourceMappingURL=DataLakeViewerRpcSchema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DataLakeViewerRpcSchema.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/DataLakeViewerRpcSchema.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAMxB,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BgB,CAAA"}

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

@@ -6,14 +6,8 @@ export declare const NetworkStakeViewerRpcSchemas: {
             to: z.ZodTuple<[z.ZodOptional<z.ZodNumber>], null>;
         };
         result: {
-            from: z.ZodTuple<[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.ZodNumber], null>;
-            to: z.ZodTuple<[z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                readonly __hex: true;
-            }>, bigint>>, z.ZodNumber], null>;
+            from: z.ZodTuple<[z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>, z.ZodTransform<bigint, import("@xylabs/hex").Hex>>, z.ZodNumber], null>;
+            to: z.ZodTuple<[z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/hex").Hex, bigint>>, z.ZodNumber], null>;
         };
     };
 };

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

@@ -1 +1 @@
-{"version":3,"file":"NetworkStakeViewerRpcSchemas.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/NetworkStakeViewerRpcSchemas.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAMxB,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;CAWgB,CAAA"}
+{"version":3,"file":"NetworkStakeViewerRpcSchemas.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/NetworkStakeViewerRpcSchemas.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAMxB,eAAO,MAAM,4BAA4B;;;;;;;;;;;CAWgB,CAAA"}

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

@@ -9,9 +9,7 @@ export declare const NetworkStakingStepRewardsByPositionViewerRpcSchemas: {
                     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,22 +20,14 @@ export declare const NetworkStakingStepRewardsByPositionViewerRpcSchemas: {
                     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.ZodNumber, 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.ZodRecord<z.ZodNumber, z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                readonly __hex: true;
-            }>, bigint>>>;
+            from: z.ZodRecord<z.ZodNumber, 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.ZodRecord<z.ZodNumber, z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/hex").Hex, bigint>>>;
         };
     };
     networkStakingStepRewardsByPositionViewer_claimed: {
@@ -49,9 +39,7 @@ export declare const NetworkStakingStepRewardsByPositionViewerRpcSchemas: {
                     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>;
@@ -62,24 +50,14 @@ export declare const NetworkStakingStepRewardsByPositionViewerRpcSchemas: {
                     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.ZodNumber, z.ZodPipe<z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                readonly __hex: true;
-            }>, bigint>>, z.ZodTransform<import("@xyo-network/xl1-protocol").AttoXL1, import("@xylabs/typeof").Brand<Lowercase<string>, {
-                readonly __hex: true;
-            }>>>>;
-            to: z.ZodRecord<z.ZodNumber, 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.ZodRecord<z.ZodNumber, z.ZodPipe<z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/hex").Hex, bigint>>, z.ZodTransform<import("@xyo-network/xl1-protocol").AttoXL1, import("@xylabs/hex").Hex>>>;
+            to: z.ZodRecord<z.ZodNumber, z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>, z.ZodTransform<bigint, import("@xylabs/hex").Hex>>>;
         };
     };
     networkStakingStepRewardsByPositionViewer_earned: {
@@ -91,9 +69,7 @@ export declare const NetworkStakingStepRewardsByPositionViewerRpcSchemas: {
                     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>;
@@ -104,24 +80,14 @@ export declare const NetworkStakingStepRewardsByPositionViewerRpcSchemas: {
                     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.ZodNumber, z.ZodPipe<z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                readonly __hex: true;
-            }>, bigint>>, z.ZodTransform<import("@xyo-network/xl1-protocol").AttoXL1, import("@xylabs/typeof").Brand<Lowercase<string>, {
-                readonly __hex: true;
-            }>>>>;
-            to: z.ZodRecord<z.ZodNumber, 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.ZodRecord<z.ZodNumber, z.ZodPipe<z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/hex").Hex, bigint>>, z.ZodTransform<import("@xyo-network/xl1-protocol").AttoXL1, import("@xylabs/hex").Hex>>>;
+            to: z.ZodRecord<z.ZodNumber, z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>, z.ZodTransform<bigint, import("@xylabs/hex").Hex>>>;
         };
     };
     networkStakingStepRewardsByPositionViewer_total: {
@@ -133,9 +99,7 @@ export declare const NetworkStakingStepRewardsByPositionViewerRpcSchemas: {
                     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>;
@@ -146,24 +110,14 @@ export declare const NetworkStakingStepRewardsByPositionViewerRpcSchemas: {
                     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.ZodNumber, z.ZodPipe<z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                readonly __hex: true;
-            }>, bigint>>, z.ZodTransform<import("@xyo-network/xl1-protocol").AttoXL1, import("@xylabs/typeof").Brand<Lowercase<string>, {
-                readonly __hex: true;
-            }>>>>;
-            to: z.ZodRecord<z.ZodNumber, 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.ZodRecord<z.ZodNumber, z.ZodPipe<z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/hex").Hex, bigint>>, z.ZodTransform<import("@xyo-network/xl1-protocol").AttoXL1, import("@xylabs/hex").Hex>>>;
+            to: z.ZodRecord<z.ZodNumber, z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>, z.ZodTransform<bigint, import("@xylabs/hex").Hex>>>;
         };
     };
     networkStakingStepRewardsByPositionViewer_unclaimed: {
@@ -175,9 +129,7 @@ export declare const NetworkStakingStepRewardsByPositionViewerRpcSchemas: {
                     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>;
@@ -188,24 +140,14 @@ export declare const NetworkStakingStepRewardsByPositionViewerRpcSchemas: {
                     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.ZodNumber, z.ZodPipe<z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                readonly __hex: true;
-            }>, bigint>>, z.ZodTransform<import("@xyo-network/xl1-protocol").AttoXL1, import("@xylabs/typeof").Brand<Lowercase<string>, {
-                readonly __hex: true;
-            }>>>>;
-            to: z.ZodRecord<z.ZodNumber, 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.ZodRecord<z.ZodNumber, z.ZodPipe<z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/hex").Hex, bigint>>, z.ZodTransform<import("@xyo-network/xl1-protocol").AttoXL1, import("@xylabs/hex").Hex>>>;
+            to: z.ZodRecord<z.ZodNumber, z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>, z.ZodTransform<bigint, import("@xylabs/hex").Hex>>>;
         };
     };
 };

package/dist/node/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/node/types/schema/RewardsByStakerViewerRpcSchemas.d.ts

@@ -9,9 +9,7 @@ export declare const NetworkStakingStepRewardsByStakerViewerRpcSchemas: {
                     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 NetworkStakingStepRewardsByStakerViewerRpcSchemas: {
                     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>>>;
         };
     };
     networkStakingStepRewardsByStakerViewer_claimed: {
@@ -57,9 +43,7 @@ export declare const NetworkStakingStepRewardsByStakerViewerRpcSchemas: {
                     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 NetworkStakingStepRewardsByStakerViewerRpcSchemas: {
                     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>>>;
         };
     };
     networkStakingStepRewardsByStakerViewer_earned: {
@@ -105,9 +77,7 @@ export declare const NetworkStakingStepRewardsByStakerViewerRpcSchemas: {
                     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 NetworkStakingStepRewardsByStakerViewerRpcSchemas: {
                     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>>>;
         };
     };
     networkStakingStepRewardsByStakerViewer_total: {
@@ -153,9 +111,7 @@ export declare const NetworkStakingStepRewardsByStakerViewerRpcSchemas: {
                     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 NetworkStakingStepRewardsByStakerViewerRpcSchemas: {
                     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>>>;
         };
     };
     networkStakingStepRewardsByStakerViewer_unclaimed: {
@@ -201,9 +145,7 @@ export declare const NetworkStakingStepRewardsByStakerViewerRpcSchemas: {
                     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 NetworkStakingStepRewardsByStakerViewerRpcSchemas: {
                     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/node/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":"AACA,OAAO,CAAC,MAAM,KAAK,CAAA;AAMnB,eAAO,MAAM,iDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmDgB,CAAA"}