npm - @xyo-network/xl1-rpc - Versions diffs - 1.15.27 → 1.15.28 - Mend

@xyo-network/xl1-rpc 1.15.27 → 1.15.28

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (338) hide show

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

@@ -0,0 +1,244 @@
+import z from 'zod';
+export declare const NetworkStakingStepRewardsByStepViewerRpcSchemas: {
+    networkStakingStepRewardsByStepViewer_bonus: {
+        params: {
+            from: z.ZodTuple<[z.ZodOptional<z.ZodObject<{
+                positions: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+                range: z.ZodOptional<z.ZodTuple<[z.ZodOptional<z.ZodNumber>, z.ZodOptional<z.ZodNumber>], null>>;
+                steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    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;
+                }>, {
+                    readonly __address: true;
+                }>, string>>>>;
+            }, z.z.core.$strip>>], null>;
+            to: z.ZodTuple<[z.ZodOptional<z.ZodObject<{
+                positions: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+                range: z.ZodOptional<z.ZodTuple<[z.ZodOptional<z.ZodNumber>, z.ZodOptional<z.ZodNumber>], null>>;
+                steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    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;
+                }>, {
+                    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;
+            }>, {
+                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;
+            }>, {
+                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;
+            }>>>>;
+        };
+    };
+    networkStakingStepRewardsByStepViewer_claimed: {
+        params: {
+            from: z.ZodTuple<[z.ZodOptional<z.ZodObject<{
+                positions: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+                range: z.ZodOptional<z.ZodTuple<[z.ZodOptional<z.ZodNumber>, z.ZodOptional<z.ZodNumber>], null>>;
+                steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    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;
+                }>, {
+                    readonly __address: true;
+                }>, string>>>>;
+            }, z.z.core.$strip>>], null>;
+            to: z.ZodTuple<[z.ZodOptional<z.ZodObject<{
+                positions: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+                range: z.ZodOptional<z.ZodTuple<[z.ZodOptional<z.ZodNumber>, z.ZodOptional<z.ZodNumber>], null>>;
+                steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    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;
+                }>, {
+                    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;
+            }>, {
+                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;
+            }>, {
+                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;
+            }>>>>;
+        };
+    };
+    networkStakingStepRewardsByStepViewer_earned: {
+        params: {
+            from: z.ZodTuple<[z.ZodOptional<z.ZodObject<{
+                positions: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+                range: z.ZodOptional<z.ZodTuple<[z.ZodOptional<z.ZodNumber>, z.ZodOptional<z.ZodNumber>], null>>;
+                steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    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;
+                }>, {
+                    readonly __address: true;
+                }>, string>>>>;
+            }, z.z.core.$strip>>], null>;
+            to: z.ZodTuple<[z.ZodOptional<z.ZodObject<{
+                positions: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+                range: z.ZodOptional<z.ZodTuple<[z.ZodOptional<z.ZodNumber>, z.ZodOptional<z.ZodNumber>], null>>;
+                steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    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;
+                }>, {
+                    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;
+            }>, {
+                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;
+            }>, {
+                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;
+            }>>>>;
+        };
+    };
+    networkStakingStepRewardsByStepViewer_total: {
+        params: {
+            from: z.ZodTuple<[z.ZodOptional<z.ZodObject<{
+                positions: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+                range: z.ZodOptional<z.ZodTuple<[z.ZodOptional<z.ZodNumber>, z.ZodOptional<z.ZodNumber>], null>>;
+                steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    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;
+                }>, {
+                    readonly __address: true;
+                }>, string>>>>;
+            }, z.z.core.$strip>>], null>;
+            to: z.ZodTuple<[z.ZodOptional<z.ZodObject<{
+                positions: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+                range: z.ZodOptional<z.ZodTuple<[z.ZodOptional<z.ZodNumber>, z.ZodOptional<z.ZodNumber>], null>>;
+                steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    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;
+                }>, {
+                    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;
+            }>, {
+                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;
+            }>, {
+                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;
+            }>>>>;
+        };
+    };
+    networkStakingStepRewardsByStepViewer_unclaimed: {
+        params: {
+            from: z.ZodTuple<[z.ZodOptional<z.ZodObject<{
+                positions: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+                range: z.ZodOptional<z.ZodTuple<[z.ZodOptional<z.ZodNumber>, z.ZodOptional<z.ZodNumber>], null>>;
+                steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    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;
+                }>, {
+                    readonly __address: true;
+                }>, string>>>>;
+            }, z.z.core.$strip>>], null>;
+            to: z.ZodTuple<[z.ZodOptional<z.ZodObject<{
+                positions: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+                range: z.ZodOptional<z.ZodTuple<[z.ZodOptional<z.ZodNumber>, z.ZodOptional<z.ZodNumber>], null>>;
+                steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    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;
+                }>, {
+                    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;
+            }>, {
+                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;
+            }>, {
+                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;
+            }>>>>;
+        };
+    };
+};
+//# sourceMappingURL=RewardsByStepViewerRpcSchemas.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,204 @@
+import * as z from 'zod';
+export declare const NetworkStakingStepRewardsTotalViewerRpcSchemas: {
+    networkStakingStepRewardsTotalViewer_bonus: {
+        params: {
+            from: z.ZodTuple<[z.ZodOptional<z.ZodObject<{
+                positions: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+                range: z.ZodOptional<z.ZodTuple<[z.ZodOptional<z.ZodNumber>, z.ZodOptional<z.ZodNumber>], null>>;
+                steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    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;
+                }>, {
+                    readonly __address: true;
+                }>, string>>>>;
+            }, z.core.$strip>>], null>;
+            to: z.ZodTuple<[z.ZodOptional<z.ZodObject<{
+                positions: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+                range: z.ZodOptional<z.ZodTuple<[z.ZodOptional<z.ZodNumber>, z.ZodOptional<z.ZodNumber>], null>>;
+                steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    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;
+                }>, {
+                    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>>;
+        };
+    };
+    networkStakingStepRewardsTotalViewer_claimed: {
+        params: {
+            from: z.ZodTuple<[z.ZodOptional<z.ZodObject<{
+                positions: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+                range: z.ZodOptional<z.ZodTuple<[z.ZodOptional<z.ZodNumber>, z.ZodOptional<z.ZodNumber>], null>>;
+                steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    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;
+                }>, {
+                    readonly __address: true;
+                }>, string>>>>;
+            }, z.core.$strip>>], null>;
+            to: z.ZodTuple<[z.ZodOptional<z.ZodObject<{
+                positions: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+                range: z.ZodOptional<z.ZodTuple<[z.ZodOptional<z.ZodNumber>, z.ZodOptional<z.ZodNumber>], null>>;
+                steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    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;
+                }>, {
+                    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>>;
+        };
+    };
+    networkStakingStepRewardsTotalViewer_earned: {
+        params: {
+            from: z.ZodTuple<[z.ZodOptional<z.ZodObject<{
+                positions: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+                range: z.ZodOptional<z.ZodTuple<[z.ZodOptional<z.ZodNumber>, z.ZodOptional<z.ZodNumber>], null>>;
+                steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    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;
+                }>, {
+                    readonly __address: true;
+                }>, string>>>>;
+            }, z.core.$strip>>], null>;
+            to: z.ZodTuple<[z.ZodOptional<z.ZodObject<{
+                positions: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+                range: z.ZodOptional<z.ZodTuple<[z.ZodOptional<z.ZodNumber>, z.ZodOptional<z.ZodNumber>], null>>;
+                steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    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;
+                }>, {
+                    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>>;
+        };
+    };
+    networkStakingStepRewardsTotalViewer_total: {
+        params: {
+            from: z.ZodTuple<[z.ZodOptional<z.ZodObject<{
+                positions: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+                range: z.ZodOptional<z.ZodTuple<[z.ZodOptional<z.ZodNumber>, z.ZodOptional<z.ZodNumber>], null>>;
+                steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    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;
+                }>, {
+                    readonly __address: true;
+                }>, string>>>>;
+            }, z.core.$strip>>], null>;
+            to: z.ZodTuple<[z.ZodOptional<z.ZodObject<{
+                positions: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+                range: z.ZodOptional<z.ZodTuple<[z.ZodOptional<z.ZodNumber>, z.ZodOptional<z.ZodNumber>], null>>;
+                steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    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;
+                }>, {
+                    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>>;
+        };
+    };
+    networkStakingStepRewardsTotalViewer_unclaimed: {
+        params: {
+            from: z.ZodTuple<[z.ZodOptional<z.ZodObject<{
+                positions: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+                range: z.ZodOptional<z.ZodTuple<[z.ZodOptional<z.ZodNumber>, z.ZodOptional<z.ZodNumber>], null>>;
+                steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    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;
+                }>, {
+                    readonly __address: true;
+                }>, string>>>>;
+            }, z.core.$strip>>], null>;
+            to: z.ZodTuple<[z.ZodOptional<z.ZodObject<{
+                positions: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+                range: z.ZodOptional<z.ZodTuple<[z.ZodOptional<z.ZodNumber>, z.ZodOptional<z.ZodNumber>], null>>;
+                steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    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;
+                }>, {
+                    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>>;
+        };
+    };
+};
+//# sourceMappingURL=RewardsTotalViewerRpcSchemas.d.ts.map

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

@@ -0,0 +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"}

package/dist/neutral/types/schema/StepRewardsViewerRpcSchemas.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ export declare const NetworkStakingStepRewardsViewerRpcSchemas: {};
2	+ //# sourceMappingURL=StepRewardsViewerRpcSchemas.d.ts.map

package/dist/neutral/types/schema/StepRewardsViewerRpcSchemas.d.ts.map ADDED Viewed

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"StepRewardsViewerRpcSchemas.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/StepRewardsViewerRpcSchemas.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,yCAAyC,IAA0E,CAAA"}