@xyo-network/xl1-sdk 4.0.11 → 4.0.12

package/dist/node/modules/rpc/provider/viewer/JsonRpcNetworkStakeStepRewardsTotalViewer/JsonRpcNetworkStakeStepRewardsTotalViewerMethods.d.ts

@@ -0,0 +1,185 @@
+import type { AttoXL1, NetworkStakeStepRewardsRangeOptions, NetworkStakeStepRewardsTotalViewerMethods } from '@xyo-network/xl1-protocol/protocol-lib';
+import { NetworkStakingStepRewardsTotalViewerRpcSchemas } from '../../../types/index.js';
+import { AbstractJsonRpcViewer } from '../JsonRpcViewer.js';
+/** JsonRpcNetworkStakeStepRewardsTotalViewerMethods implementation. */
+export declare class JsonRpcNetworkStakeStepRewardsTotalViewerMethods extends AbstractJsonRpcViewer<NetworkStakingStepRewardsTotalViewerRpcSchemas> implements NetworkStakeStepRewardsTotalViewerMethods {
+    moniker: "NetworkStakeStepRewardsTotalViewer";
+    bonus(options?: NetworkStakeStepRewardsRangeOptions): Promise<AttoXL1>;
+    claimed(options?: NetworkStakeStepRewardsRangeOptions): Promise<AttoXL1>;
+    earned(options?: NetworkStakeStepRewardsRangeOptions): Promise<AttoXL1>;
+    total(options?: NetworkStakeStepRewardsRangeOptions): Promise<AttoXL1>;
+    unclaimed(options?: NetworkStakeStepRewardsRangeOptions): Promise<AttoXL1>;
+    protected schemas(): {
+        networkStakingStepRewardsTotalViewer_bonus: {
+            params: {
+                to: import("zod/mini").ZodMiniTuple<readonly [import("zod/mini").ZodMiniOptional<import("zod").ZodObject<{
+                    positions: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodNumber>>;
+                    range: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodPipe<import("zod").ZodInt, import("zod").ZodTransform<import("@xyo-network/xl1-protocol/protocol-lib").BlockNumber, number>>, import("zod").ZodPipe<import("zod").ZodInt, import("zod").ZodTransform<import("@xyo-network/xl1-protocol/protocol-lib").BlockNumber, number>>], null>>;
+                    steps: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                        block: import("zod").ZodPipe<import("zod").ZodInt, import("zod").ZodTransform<import("@xyo-network/xl1-protocol/protocol-lib").XL1BlockNumber, number>>;
+                        step: import("zod").ZodNumber;
+                    }, import("zod/v4/core").$strip>>>;
+                    stakers: import("zod").ZodOptional<import("zod").ZodArray<import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
+                        readonly __hex: true;
+                    } & {
+                        readonly __address: true;
+                    }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-protocol").XyoQuantAddress, string>>]>>>;
+                }, import("zod/v4/core").$strip>>], null>;
+                from: import("zod/mini").ZodMiniTuple<readonly [import("zod/mini").ZodMiniOptional<import("zod").ZodObject<{
+                    positions: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodNumber>>;
+                    range: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodPipe<import("zod").ZodInt, import("zod").ZodTransform<import("@xyo-network/xl1-protocol/protocol-lib").BlockNumber, number>>, import("zod").ZodPipe<import("zod").ZodInt, import("zod").ZodTransform<import("@xyo-network/xl1-protocol/protocol-lib").BlockNumber, number>>], null>>;
+                    steps: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                        block: import("zod").ZodPipe<import("zod").ZodInt, import("zod").ZodTransform<import("@xyo-network/xl1-protocol/protocol-lib").XL1BlockNumber, number>>;
+                        step: import("zod").ZodNumber;
+                    }, import("zod/v4/core").$strip>>>;
+                    stakers: import("zod").ZodOptional<import("zod").ZodArray<import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
+                        readonly __hex: true;
+                    } & {
+                        readonly __address: true;
+                    }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-protocol").XyoQuantAddress, string>>]>>>;
+                }, import("zod/v4/core").$strip>>], null>;
+            };
+            result: {
+                to: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniBigInt<bigint>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHex, bigint>>;
+                from: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<bigint, string>>, import("zod/mini").ZodMiniTransform<AttoXL1, bigint>>;
+            };
+        };
+        networkStakingStepRewardsTotalViewer_claimed: {
+            params: {
+                to: import("zod/mini").ZodMiniTuple<readonly [import("zod/mini").ZodMiniOptional<import("zod").ZodObject<{
+                    positions: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodNumber>>;
+                    range: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodPipe<import("zod").ZodInt, import("zod").ZodTransform<import("@xyo-network/xl1-protocol/protocol-lib").BlockNumber, number>>, import("zod").ZodPipe<import("zod").ZodInt, import("zod").ZodTransform<import("@xyo-network/xl1-protocol/protocol-lib").BlockNumber, number>>], null>>;
+                    steps: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                        block: import("zod").ZodPipe<import("zod").ZodInt, import("zod").ZodTransform<import("@xyo-network/xl1-protocol/protocol-lib").XL1BlockNumber, number>>;
+                        step: import("zod").ZodNumber;
+                    }, import("zod/v4/core").$strip>>>;
+                    stakers: import("zod").ZodOptional<import("zod").ZodArray<import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
+                        readonly __hex: true;
+                    } & {
+                        readonly __address: true;
+                    }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-protocol").XyoQuantAddress, string>>]>>>;
+                }, import("zod/v4/core").$strip>>], null>;
+                from: import("zod/mini").ZodMiniTuple<readonly [import("zod/mini").ZodMiniOptional<import("zod").ZodObject<{
+                    positions: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodNumber>>;
+                    range: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodPipe<import("zod").ZodInt, import("zod").ZodTransform<import("@xyo-network/xl1-protocol/protocol-lib").BlockNumber, number>>, import("zod").ZodPipe<import("zod").ZodInt, import("zod").ZodTransform<import("@xyo-network/xl1-protocol/protocol-lib").BlockNumber, number>>], null>>;
+                    steps: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                        block: import("zod").ZodPipe<import("zod").ZodInt, import("zod").ZodTransform<import("@xyo-network/xl1-protocol/protocol-lib").XL1BlockNumber, number>>;
+                        step: import("zod").ZodNumber;
+                    }, import("zod/v4/core").$strip>>>;
+                    stakers: import("zod").ZodOptional<import("zod").ZodArray<import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
+                        readonly __hex: true;
+                    } & {
+                        readonly __address: true;
+                    }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-protocol").XyoQuantAddress, string>>]>>>;
+                }, import("zod/v4/core").$strip>>], null>;
+            };
+            result: {
+                to: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniBigInt<bigint>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHex, bigint>>;
+                from: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<bigint, string>>, import("zod/mini").ZodMiniTransform<AttoXL1, bigint>>;
+            };
+        };
+        networkStakingStepRewardsTotalViewer_earned: {
+            params: {
+                to: import("zod/mini").ZodMiniTuple<readonly [import("zod/mini").ZodMiniOptional<import("zod").ZodObject<{
+                    positions: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodNumber>>;
+                    range: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodPipe<import("zod").ZodInt, import("zod").ZodTransform<import("@xyo-network/xl1-protocol/protocol-lib").BlockNumber, number>>, import("zod").ZodPipe<import("zod").ZodInt, import("zod").ZodTransform<import("@xyo-network/xl1-protocol/protocol-lib").BlockNumber, number>>], null>>;
+                    steps: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                        block: import("zod").ZodPipe<import("zod").ZodInt, import("zod").ZodTransform<import("@xyo-network/xl1-protocol/protocol-lib").XL1BlockNumber, number>>;
+                        step: import("zod").ZodNumber;
+                    }, import("zod/v4/core").$strip>>>;
+                    stakers: import("zod").ZodOptional<import("zod").ZodArray<import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
+                        readonly __hex: true;
+                    } & {
+                        readonly __address: true;
+                    }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-protocol").XyoQuantAddress, string>>]>>>;
+                }, import("zod/v4/core").$strip>>], null>;
+                from: import("zod/mini").ZodMiniTuple<readonly [import("zod/mini").ZodMiniOptional<import("zod").ZodObject<{
+                    positions: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodNumber>>;
+                    range: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodPipe<import("zod").ZodInt, import("zod").ZodTransform<import("@xyo-network/xl1-protocol/protocol-lib").BlockNumber, number>>, import("zod").ZodPipe<import("zod").ZodInt, import("zod").ZodTransform<import("@xyo-network/xl1-protocol/protocol-lib").BlockNumber, number>>], null>>;
+                    steps: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                        block: import("zod").ZodPipe<import("zod").ZodInt, import("zod").ZodTransform<import("@xyo-network/xl1-protocol/protocol-lib").XL1BlockNumber, number>>;
+                        step: import("zod").ZodNumber;
+                    }, import("zod/v4/core").$strip>>>;
+                    stakers: import("zod").ZodOptional<import("zod").ZodArray<import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
+                        readonly __hex: true;
+                    } & {
+                        readonly __address: true;
+                    }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-protocol").XyoQuantAddress, string>>]>>>;
+                }, import("zod/v4/core").$strip>>], null>;
+            };
+            result: {
+                to: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniBigInt<bigint>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHex, bigint>>;
+                from: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<bigint, string>>, import("zod/mini").ZodMiniTransform<AttoXL1, bigint>>;
+            };
+        };
+        networkStakingStepRewardsTotalViewer_total: {
+            params: {
+                to: import("zod/mini").ZodMiniTuple<readonly [import("zod/mini").ZodMiniOptional<import("zod").ZodObject<{
+                    positions: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodNumber>>;
+                    range: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodPipe<import("zod").ZodInt, import("zod").ZodTransform<import("@xyo-network/xl1-protocol/protocol-lib").BlockNumber, number>>, import("zod").ZodPipe<import("zod").ZodInt, import("zod").ZodTransform<import("@xyo-network/xl1-protocol/protocol-lib").BlockNumber, number>>], null>>;
+                    steps: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                        block: import("zod").ZodPipe<import("zod").ZodInt, import("zod").ZodTransform<import("@xyo-network/xl1-protocol/protocol-lib").XL1BlockNumber, number>>;
+                        step: import("zod").ZodNumber;
+                    }, import("zod/v4/core").$strip>>>;
+                    stakers: import("zod").ZodOptional<import("zod").ZodArray<import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
+                        readonly __hex: true;
+                    } & {
+                        readonly __address: true;
+                    }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-protocol").XyoQuantAddress, string>>]>>>;
+                }, import("zod/v4/core").$strip>>], null>;
+                from: import("zod/mini").ZodMiniTuple<readonly [import("zod/mini").ZodMiniOptional<import("zod").ZodObject<{
+                    positions: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodNumber>>;
+                    range: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodPipe<import("zod").ZodInt, import("zod").ZodTransform<import("@xyo-network/xl1-protocol/protocol-lib").BlockNumber, number>>, import("zod").ZodPipe<import("zod").ZodInt, import("zod").ZodTransform<import("@xyo-network/xl1-protocol/protocol-lib").BlockNumber, number>>], null>>;
+                    steps: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                        block: import("zod").ZodPipe<import("zod").ZodInt, import("zod").ZodTransform<import("@xyo-network/xl1-protocol/protocol-lib").XL1BlockNumber, number>>;
+                        step: import("zod").ZodNumber;
+                    }, import("zod/v4/core").$strip>>>;
+                    stakers: import("zod").ZodOptional<import("zod").ZodArray<import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
+                        readonly __hex: true;
+                    } & {
+                        readonly __address: true;
+                    }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-protocol").XyoQuantAddress, string>>]>>>;
+                }, import("zod/v4/core").$strip>>], null>;
+            };
+            result: {
+                to: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniBigInt<bigint>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHex, bigint>>;
+                from: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<bigint, string>>, import("zod/mini").ZodMiniTransform<AttoXL1, bigint>>;
+            };
+        };
+        networkStakingStepRewardsTotalViewer_unclaimed: {
+            params: {
+                to: import("zod/mini").ZodMiniTuple<readonly [import("zod/mini").ZodMiniOptional<import("zod").ZodObject<{
+                    positions: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodNumber>>;
+                    range: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodPipe<import("zod").ZodInt, import("zod").ZodTransform<import("@xyo-network/xl1-protocol/protocol-lib").BlockNumber, number>>, import("zod").ZodPipe<import("zod").ZodInt, import("zod").ZodTransform<import("@xyo-network/xl1-protocol/protocol-lib").BlockNumber, number>>], null>>;
+                    steps: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                        block: import("zod").ZodPipe<import("zod").ZodInt, import("zod").ZodTransform<import("@xyo-network/xl1-protocol/protocol-lib").XL1BlockNumber, number>>;
+                        step: import("zod").ZodNumber;
+                    }, import("zod/v4/core").$strip>>>;
+                    stakers: import("zod").ZodOptional<import("zod").ZodArray<import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
+                        readonly __hex: true;
+                    } & {
+                        readonly __address: true;
+                    }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-protocol").XyoQuantAddress, string>>]>>>;
+                }, import("zod/v4/core").$strip>>], null>;
+                from: import("zod/mini").ZodMiniTuple<readonly [import("zod/mini").ZodMiniOptional<import("zod").ZodObject<{
+                    positions: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodNumber>>;
+                    range: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodPipe<import("zod").ZodInt, import("zod").ZodTransform<import("@xyo-network/xl1-protocol/protocol-lib").BlockNumber, number>>, import("zod").ZodPipe<import("zod").ZodInt, import("zod").ZodTransform<import("@xyo-network/xl1-protocol/protocol-lib").BlockNumber, number>>], null>>;
+                    steps: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                        block: import("zod").ZodPipe<import("zod").ZodInt, import("zod").ZodTransform<import("@xyo-network/xl1-protocol/protocol-lib").XL1BlockNumber, number>>;
+                        step: import("zod").ZodNumber;
+                    }, import("zod/v4/core").$strip>>>;
+                    stakers: import("zod").ZodOptional<import("zod").ZodArray<import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
+                        readonly __hex: true;
+                    } & {
+                        readonly __address: true;
+                    }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-protocol").XyoQuantAddress, string>>]>>>;
+                }, import("zod/v4/core").$strip>>], null>;
+            };
+            result: {
+                to: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniBigInt<bigint>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHex, bigint>>;
+                from: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<bigint, string>>, import("zod/mini").ZodMiniTransform<AttoXL1, bigint>>;
+            };
+        };
+    };
+}
+//# sourceMappingURL=JsonRpcNetworkStakeStepRewardsTotalViewerMethods.d.ts.map

package/dist/node/modules/rpc/provider/viewer/JsonRpcNetworkStakeStepRewardsTotalViewer/JsonRpcNetworkStakeStepRewardsTotalViewerMethods.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JsonRpcNetworkStakeStepRewardsTotalViewerMethods.d.ts","sourceRoot":"","sources":["../../../../../../../src/modules/rpc/provider/viewer/JsonRpcNetworkStakeStepRewardsTotalViewer/JsonRpcNetworkStakeStepRewardsTotalViewerMethods.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EACP,mCAAmC,EAAE,yCAAyC,EAC/E,MAAM,wCAAwC,CAAA;AAG/C,OAAO,EAAE,8CAA8C,EAAE,MAAM,yBAAyB,CAAA;AACxF,OAAO,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAA;AAE3D,uEAAuE;AACvE,qBAAa,gDAAiD,SAC5D,qBAAqB,CAAC,8CAA8C,CAAE,YAAW,yCAAyC;IAC1H,OAAO,uCAA4C;IAC7C,KAAK,CAAC,OAAO,CAAC,EAAE,mCAAmC,GAAG,OAAO,CAAC,OAAO,CAAC;IAItE,OAAO,CAAC,OAAO,CAAC,EAAE,mCAAmC,GAAG,OAAO,CAAC,OAAO,CAAC;IAIxE,MAAM,CAAC,OAAO,CAAC,EAAE,mCAAmC,GAAG,OAAO,CAAC,OAAO,CAAC;IAIvE,KAAK,CAAC,OAAO,CAAC,EAAE,mCAAmC,GAAG,OAAO,CAAC,OAAO,CAAC;IAItE,SAAS,CAAC,OAAO,CAAC,EAAE,mCAAmC,GAAG,OAAO,CAAC,OAAO,CAAC;IAIhF,SAAS,CAAC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGlB"}

package/dist/node/modules/rpc/provider/viewer/JsonRpcNetworkStakeStepRewardsTotalViewer/index.d.ts

@@ -0,0 +1,3 @@
+export * from './JsonRpcNetworkStakeStepRewardsTotalViewer.js';
+export * from './JsonRpcNetworkStakeStepRewardsTotalViewerMethods.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/node/modules/rpc/provider/viewer/JsonRpcNetworkStakeStepRewardsTotalViewer/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../src/modules/rpc/provider/viewer/JsonRpcNetworkStakeStepRewardsTotalViewer/index.ts"],"names":[],"mappings":"AAAA,cAAc,gDAAgD,CAAA;AAC9D,cAAc,uDAAuD,CAAA"}

package/dist/node/modules/rpc/provider/viewer/JsonRpcNetworkStakeStepRewardsViewer/JsonRpcNetworkStakeStepRewardsViewer.d.ts

@@ -0,0 +1,26 @@
+import { type NetworkStakeStepRewardsByPositionViewer, type NetworkStakeStepRewardsByStakerViewer, type NetworkStakeStepRewardsByStepViewer, type NetworkStakeStepRewardsTotalViewer, type NetworkStakeStepRewardsViewer } from '@xyo-network/xl1-protocol/protocol-lib';
+import type { JsonRpcNetworkStakingStepRewardsViewerMethodsParams } from './JsonRpcNetworkStakeStepRewardsViewerMethods.js';
+import { JsonRpcNetworkStakeStepRewardsViewerMethods } from './JsonRpcNetworkStakeStepRewardsViewerMethods.js';
+/** Parameters for JsonRpcNetworkStakeStepRewardsViewer. */
+export interface JsonRpcNetworkStakeStepRewardsViewerParams extends JsonRpcNetworkStakingStepRewardsViewerMethodsParams {
+    position?: NetworkStakeStepRewardsByPositionViewer;
+    staker?: NetworkStakeStepRewardsByStakerViewer;
+    step?: NetworkStakeStepRewardsByStepViewer;
+    total?: NetworkStakeStepRewardsTotalViewer;
+}
+/** JsonRpcNetworkStakeStepRewardsViewer implementation. */
+export declare class JsonRpcNetworkStakeStepRewardsViewer extends JsonRpcNetworkStakeStepRewardsViewerMethods<JsonRpcNetworkStakeStepRewardsViewerParams> implements NetworkStakeStepRewardsViewer {
+    static readonly connectionTypes: readonly ["rpc"];
+    static readonly defaultMoniker: "NetworkStakeStepRewardsViewer";
+    static readonly dependencies: never[];
+    static readonly monikers: "NetworkStakeStepRewardsViewer"[];
+    static readonly surface: "node";
+    get position(): NetworkStakeStepRewardsByPositionViewer | undefined;
+    get staker(): NetworkStakeStepRewardsByStakerViewer | undefined;
+    get step(): NetworkStakeStepRewardsByStepViewer | undefined;
+    get total(): NetworkStakeStepRewardsTotalViewer | undefined;
+}
+/** @deprecated use JsonRpcNetworkStakeStepRewardsViewer instead */
+export declare class JsonRpcNetworkStakingStepRewardsViewer extends JsonRpcNetworkStakeStepRewardsViewer {
+}
+//# sourceMappingURL=JsonRpcNetworkStakeStepRewardsViewer.d.ts.map

package/dist/node/modules/rpc/provider/viewer/JsonRpcNetworkStakeStepRewardsViewer/JsonRpcNetworkStakeStepRewardsViewer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JsonRpcNetworkStakeStepRewardsViewer.d.ts","sourceRoot":"","sources":["../../../../../../../src/modules/rpc/provider/viewer/JsonRpcNetworkStakeStepRewardsViewer/JsonRpcNetworkStakeStepRewardsViewer.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,uCAAuC,EAAE,KAAK,qCAAqC,EAAE,KAAK,mCAAmC,EAClI,KAAK,kCAAkC,EAAE,KAAK,6BAA6B,EAE5E,MAAM,wCAAwC,CAAA;AAI/C,OAAO,KAAK,EAAE,mDAAmD,EAAE,MAAM,kDAAkD,CAAA;AAC3H,OAAO,EAAE,2CAA2C,EAAE,MAAM,kDAAkD,CAAA;AAE9G,2DAA2D;AAC3D,MAAM,WAAW,0CAA2C,SAAQ,mDAAmD;IACrH,QAAQ,CAAC,EAAE,uCAAuC,CAAA;IAClD,MAAM,CAAC,EAAE,qCAAqC,CAAA;IAC9C,IAAI,CAAC,EAAE,mCAAmC,CAAA;IAC1C,KAAK,CAAC,EAAE,kCAAkC,CAAA;CAC3C;AACD,2DAA2D;AAC3D,qBACa,oCAAqC,SAChD,2CAA2C,CAAC,0CAA0C,CAAE,YAAW,6BAA6B;IAChI,MAAM,CAAC,QAAQ,CAAC,eAAe,mBAAmB;IAClD,MAAM,CAAC,QAAQ,CAAC,cAAc,kCAAuC;IACrE,MAAM,CAAC,QAAQ,CAAC,YAAY,UAAK;IACjC,MAAM,CAAC,QAAQ,CAAC,QAAQ,oCAAyC;IACjE,MAAM,CAAC,QAAQ,CAAC,OAAO,EAAG,MAAM,CAAS;IAEzC,IAAI,QAAQ,IAAI,uCAAuC,GAAG,SAAS,CAElE;IAED,IAAI,MAAM,IAAI,qCAAqC,GAAG,SAAS,CAE9D;IAED,IAAI,IAAI,IAAI,mCAAmC,GAAG,SAAS,CAE1D;IAED,IAAI,KAAK,IAAI,kCAAkC,GAAG,SAAS,CAE1D;CACF;AAED,mEAAmE;AACnE,qBAAa,sCAAuC,SAAQ,oCAAoC;CAAG"}

package/dist/node/modules/rpc/provider/viewer/JsonRpcNetworkStakeStepRewardsViewer/JsonRpcNetworkStakeStepRewardsViewerMethods.d.ts

@@ -0,0 +1,13 @@
+import { type NetworkStakeStepRewardsViewerMethods } from '@xyo-network/xl1-protocol/protocol-lib';
+import { NetworkStakingStepRewardsViewerRpcSchemas } from '../../../types/index.js';
+import type { JsonRpcViewerParams } from '../JsonRpcViewer.js';
+import { AbstractJsonRpcViewer } from '../JsonRpcViewer.js';
+/** Parameters for JsonRpcNetworkStakingStepRewardsViewerMethods. */
+export interface JsonRpcNetworkStakingStepRewardsViewerMethodsParams extends JsonRpcViewerParams<NetworkStakingStepRewardsViewerRpcSchemas> {
+}
+/** JsonRpcNetworkStakeStepRewardsViewerMethods implementation. */
+export declare class JsonRpcNetworkStakeStepRewardsViewerMethods<TParams extends JsonRpcNetworkStakingStepRewardsViewerMethodsParams = JsonRpcNetworkStakingStepRewardsViewerMethodsParams> extends AbstractJsonRpcViewer<NetworkStakingStepRewardsViewerRpcSchemas, TParams> implements NetworkStakeStepRewardsViewerMethods {
+    readonly moniker: "NetworkStakeStepRewardsViewer";
+    protected schemas(): {};
+}
+//# sourceMappingURL=JsonRpcNetworkStakeStepRewardsViewerMethods.d.ts.map

package/dist/node/modules/rpc/provider/viewer/JsonRpcNetworkStakeStepRewardsViewer/JsonRpcNetworkStakeStepRewardsViewerMethods.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JsonRpcNetworkStakeStepRewardsViewerMethods.d.ts","sourceRoot":"","sources":["../../../../../../../src/modules/rpc/provider/viewer/JsonRpcNetworkStakeStepRewardsViewer/JsonRpcNetworkStakeStepRewardsViewerMethods.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,oCAAoC,EAAwC,MAAM,wCAAwC,CAAA;AAExI,OAAO,EAAE,yCAAyC,EAAE,MAAM,yBAAyB,CAAA;AACnF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAA;AAC9D,OAAO,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAA;AAE3D,oEAAoE;AACpE,MAAM,WAAW,mDAAoD,SAAQ,mBAAmB,CAAC,yCAAyC,CAAC;CAAG;AAE9I,kEAAkE;AAClE,qBAAa,2CAA2C,CAAC,OAAO,SAChE,mDAAmD,GAAG,mDAAmD,CAAE,SACzG,qBAAqB,CAAC,yCAAyC,EAAE,OAAO,CAAE,YAAW,oCAAoC;IACzH,QAAQ,CAAC,OAAO,kCAAuC;IACvD,SAAS,CAAC,OAAO;CAGlB"}

package/dist/node/modules/rpc/provider/viewer/JsonRpcNetworkStakeStepRewardsViewer/index.d.ts

@@ -0,0 +1,3 @@
+export * from './JsonRpcNetworkStakeStepRewardsViewer.js';
+export * from './JsonRpcNetworkStakeStepRewardsViewerMethods.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/node/modules/rpc/provider/viewer/JsonRpcNetworkStakeStepRewardsViewer/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../src/modules/rpc/provider/viewer/JsonRpcNetworkStakeStepRewardsViewer/index.ts"],"names":[],"mappings":"AAAA,cAAc,2CAA2C,CAAA;AACzD,cAAc,kDAAkD,CAAA"}

package/dist/node/modules/rpc/provider/viewer/JsonRpcNetworkStakeViewer/JsonRpcNetworkStakeViewer.d.ts

@@ -0,0 +1,14 @@
+import { type NetworkStakeStepRewardsViewer, type NetworkStakeViewer } from '@xyo-network/xl1-protocol/protocol-lib';
+import { JsonRpcNetworkStakeViewerMethods } from './JsonRpcNetworkStakeViewerMethods.js';
+/** JsonRpcNetworkStakeViewer implementation. */
+export declare class JsonRpcNetworkStakeViewer extends JsonRpcNetworkStakeViewerMethods implements NetworkStakeViewer {
+    static readonly connectionTypes: readonly ["rpc"];
+    static readonly defaultMoniker: "NetworkStakeViewer";
+    static readonly dependencies: never[];
+    static readonly monikers: "NetworkStakeViewer"[];
+    static readonly surface: "node";
+    protected _stepRewards?: NetworkStakeStepRewardsViewer;
+    get stepRewards(): NetworkStakeStepRewardsViewer;
+    createHandler(): Promise<void>;
+}
+//# sourceMappingURL=JsonRpcNetworkStakeViewer.d.ts.map

package/dist/node/modules/rpc/provider/viewer/JsonRpcNetworkStakeViewer/JsonRpcNetworkStakeViewer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JsonRpcNetworkStakeViewer.d.ts","sourceRoot":"","sources":["../../../../../../../src/modules/rpc/provider/viewer/JsonRpcNetworkStakeViewer/JsonRpcNetworkStakeViewer.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,6BAA6B,EAAwC,KAAK,kBAAkB,EAClG,MAAM,wCAAwC,CAAA;AAK/C,OAAO,EAAE,gCAAgC,EAAE,MAAM,uCAAuC,CAAA;AAExF,gDAAgD;AAChD,qBACa,yBAA0B,SAAQ,gCAAiC,YAAW,kBAAkB;IAC3G,MAAM,CAAC,QAAQ,CAAC,eAAe,mBAAmB;IAClD,MAAM,CAAC,QAAQ,CAAC,cAAc,uBAA4B;IAC1D,MAAM,CAAC,QAAQ,CAAC,YAAY,UAAK;IACjC,MAAM,CAAC,QAAQ,CAAC,QAAQ,yBAA8B;IACtD,MAAM,CAAC,QAAQ,CAAC,OAAO,EAAG,MAAM,CAAS;IAEzC,SAAS,CAAC,YAAY,CAAC,EAAE,6BAA6B,CAAA;IAEtD,IAAI,WAAW,IAAI,6BAA6B,CAE/C;IAEc,aAAa;CAI7B"}

package/dist/node/modules/rpc/provider/viewer/JsonRpcNetworkStakeViewer/JsonRpcNetworkStakeViewerMethods.d.ts

@@ -0,0 +1,21 @@
+import { type NetworkStakeViewerMethods } from '@xyo-network/xl1-protocol/protocol-lib';
+import { NetworkStakeViewerRpcSchemas } from '../../../types/index.js';
+import { AbstractJsonRpcViewer } from '../JsonRpcViewer.js';
+/** JsonRpcNetworkStakeViewerMethods implementation. */
+export declare class JsonRpcNetworkStakeViewerMethods extends AbstractJsonRpcViewer<NetworkStakeViewerRpcSchemas> implements NetworkStakeViewerMethods {
+    readonly moniker: "NetworkStakeViewer";
+    active(blockNumber?: number): Promise<[bigint, number]>;
+    protected schemas(): {
+        networkStakeViewer_active: {
+            params: {
+                to: import("zod").ZodTuple<[import("zod").ZodOptional<import("zod").ZodPipe<import("zod").ZodInt, import("zod").ZodTransform<import("@xyo-network/xl1-protocol/protocol-lib").BlockNumber, number>>>], null>;
+                from: import("zod").ZodTuple<[import("zod").ZodOptional<import("zod").ZodPipe<import("zod").ZodInt, import("zod").ZodTransform<import("@xyo-network/xl1-protocol/protocol-lib").BlockNumber, number>>>], null>;
+            };
+            result: {
+                to: import("zod").ZodTuple<[import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniBigInt<bigint>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHex, bigint>>, import("zod").ZodNumber], null>;
+                from: import("zod").ZodTuple<[import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<bigint, string>>, import("zod").ZodNumber], null>;
+            };
+        };
+    };
+}
+//# sourceMappingURL=JsonRpcNetworkStakeViewerMethods.d.ts.map

package/dist/node/modules/rpc/provider/viewer/JsonRpcNetworkStakeViewer/JsonRpcNetworkStakeViewerMethods.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JsonRpcNetworkStakeViewerMethods.d.ts","sourceRoot":"","sources":["../../../../../../../src/modules/rpc/provider/viewer/JsonRpcNetworkStakeViewer/JsonRpcNetworkStakeViewerMethods.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,yBAAyB,EAA6B,MAAM,wCAAwC,CAAA;AAElH,OAAO,EAAE,4BAA4B,EAAE,MAAM,yBAAyB,CAAA;AACtE,OAAO,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAA;AAE3D,uDAAuD;AACvD,qBAAa,gCAAiC,SAAQ,qBAAqB,CAAC,4BAA4B,CAAE,YAAW,yBAAyB;IAC5I,QAAQ,CAAC,OAAO,uBAA4B;IACtC,MAAM,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAI7D,SAAS,CAAC,OAAO;;;;;;;;;;;;CAGlB"}

package/dist/node/modules/rpc/provider/viewer/JsonRpcNetworkStakeViewer/index.d.ts

@@ -0,0 +1,3 @@
+export * from './JsonRpcNetworkStakeViewer.js';
+export * from './JsonRpcNetworkStakeViewerMethods.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/node/modules/rpc/provider/viewer/JsonRpcNetworkStakeViewer/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../src/modules/rpc/provider/viewer/JsonRpcNetworkStakeViewer/index.ts"],"names":[],"mappings":"AAAA,cAAc,gCAAgC,CAAA;AAC9C,cAAc,uCAAuC,CAAA"}

package/dist/node/modules/rpc/provider/viewer/JsonRpcStakeTotalsViewer/JsonRpcStakeTotalsViewer.d.ts

@@ -0,0 +1,11 @@
+import { type StakeTotalsViewer } from '@xyo-network/xl1-protocol/protocol-lib';
+import { JsonRpcStakeTotalsViewerMethods } from './JsonRpcStakeTotalsViewerMethods.js';
+/** JsonRpcStakeTotalsViewer implementation. */
+export declare class JsonRpcStakeTotalsViewer extends JsonRpcStakeTotalsViewerMethods implements StakeTotalsViewer {
+    static readonly connectionTypes: readonly ["rpc"];
+    static readonly defaultMoniker: "StakeTotalsViewer";
+    static readonly dependencies: never[];
+    static readonly monikers: "StakeTotalsViewer"[];
+    static readonly surface: "node";
+}
+//# sourceMappingURL=JsonRpcStakeTotalsViewer.d.ts.map

package/dist/node/modules/rpc/provider/viewer/JsonRpcStakeTotalsViewer/JsonRpcStakeTotalsViewer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JsonRpcStakeTotalsViewer.d.ts","sourceRoot":"","sources":["../../../../../../../src/modules/rpc/provider/viewer/JsonRpcStakeTotalsViewer/JsonRpcStakeTotalsViewer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,iBAAiB,EAA4B,MAAM,wCAAwC,CAAA;AAIzG,OAAO,EAAE,+BAA+B,EAAE,MAAM,sCAAsC,CAAA;AAEtF,+CAA+C;AAC/C,qBACa,wBAAyB,SAAQ,+BAAgC,YAAW,iBAAiB;IACxG,MAAM,CAAC,QAAQ,CAAC,eAAe,mBAAmB;IAClD,MAAM,CAAC,QAAQ,CAAC,cAAc,sBAA2B;IACzD,MAAM,CAAC,QAAQ,CAAC,YAAY,UAAK;IACjC,MAAM,CAAC,QAAQ,CAAC,QAAQ,wBAA6B;IACrD,MAAM,CAAC,QAAQ,CAAC,OAAO,EAAG,MAAM,CAAS;CAC1C"}

package/dist/node/modules/rpc/provider/viewer/JsonRpcStakeTotalsViewer/JsonRpcStakeTotalsViewerMethods.d.ts

@@ -0,0 +1,120 @@
+import type { XyoAddress } from '@xyo-network/sdk';
+import { type StakeTotalsViewerMethods } from '@xyo-network/xl1-protocol/protocol-lib';
+import { StakeTotalsViewerRpcSchemas } from '../../../types/index.js';
+import { AbstractJsonRpcViewer } from '../JsonRpcViewer.js';
+/** JsonRpcStakeTotalsViewerMethods implementation. */
+export declare class JsonRpcStakeTotalsViewerMethods extends AbstractJsonRpcViewer<StakeTotalsViewerRpcSchemas> implements StakeTotalsViewerMethods {
+    readonly moniker: "StakeTotalsViewer";
+    active(time?: number): Promise<bigint>;
+    activeByStaked(staked: XyoAddress, time?: number): Promise<bigint>;
+    activeByStaker(address: XyoAddress, time?: number): Promise<bigint>;
+    pending(time?: number): Promise<bigint>;
+    pendingByStaker(staker: XyoAddress, time?: number): Promise<bigint>;
+    withdrawn(time?: number): Promise<bigint>;
+    withdrawnByStaker(staker: XyoAddress, time?: number): Promise<bigint>;
+    protected schemas(): {
+        stakeTotalsViewer_active: {
+            params: {
+                to: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniTuple<readonly [import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniNumber<number>>], null>>;
+                from: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniTuple<readonly [import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniNumber<number>>], null>>;
+            };
+            result: {
+                to: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniBigInt<bigint>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHex, bigint>>;
+                from: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<bigint, string>>, import("zod/mini").ZodMiniTransform<import("@xyo-network/xl1-protocol/protocol-lib").AttoXL1, bigint>>;
+            };
+        };
+        stakeTotalsViewer_activeByStaked: {
+            params: {
+                to: import("zod/mini").ZodMiniTuple<readonly [import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
+                    readonly __hex: true;
+                } & {
+                    readonly __address: true;
+                }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk").XyoQuantAddress, string>>]>, import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniNumber<number>>], null>;
+                from: import("zod/mini").ZodMiniTuple<readonly [import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
+                    readonly __hex: true;
+                } & {
+                    readonly __address: true;
+                }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk").XyoQuantAddress, string>>]>, import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniNumber<number>>], null>;
+            };
+            result: {
+                to: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniBigInt<bigint>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHex, bigint>>;
+                from: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<bigint, string>>, import("zod/mini").ZodMiniTransform<import("@xyo-network/xl1-protocol/protocol-lib").AttoXL1, bigint>>;
+            };
+        };
+        stakeTotalsViewer_activeByStaker: {
+            params: {
+                to: import("zod/mini").ZodMiniTuple<readonly [import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
+                    readonly __hex: true;
+                } & {
+                    readonly __address: true;
+                }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk").XyoQuantAddress, string>>]>, import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniNumber<number>>], null>;
+                from: import("zod/mini").ZodMiniTuple<readonly [import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
+                    readonly __hex: true;
+                } & {
+                    readonly __address: true;
+                }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk").XyoQuantAddress, string>>]>, import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniNumber<number>>], null>;
+            };
+            result: {
+                to: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniBigInt<bigint>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHex, bigint>>;
+                from: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<bigint, string>>, import("zod/mini").ZodMiniTransform<import("@xyo-network/xl1-protocol/protocol-lib").AttoXL1, bigint>>;
+            };
+        };
+        stakeTotalsViewer_pending: {
+            params: {
+                to: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniTuple<readonly [import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniNumber<number>>], null>>;
+                from: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniTuple<readonly [import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniNumber<number>>], null>>;
+            };
+            result: {
+                to: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniBigInt<bigint>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHex, bigint>>;
+                from: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<bigint, string>>, import("zod/mini").ZodMiniTransform<import("@xyo-network/xl1-protocol/protocol-lib").AttoXL1, bigint>>;
+            };
+        };
+        stakeTotalsViewer_pendingByStaker: {
+            params: {
+                to: import("zod/mini").ZodMiniTuple<readonly [import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
+                    readonly __hex: true;
+                } & {
+                    readonly __address: true;
+                }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk").XyoQuantAddress, string>>]>, import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniNumber<number>>], null>;
+                from: import("zod/mini").ZodMiniTuple<readonly [import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
+                    readonly __hex: true;
+                } & {
+                    readonly __address: true;
+                }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk").XyoQuantAddress, string>>]>, import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniNumber<number>>], null>;
+            };
+            result: {
+                to: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniBigInt<bigint>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHex, bigint>>;
+                from: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<bigint, string>>, import("zod/mini").ZodMiniTransform<import("@xyo-network/xl1-protocol/protocol-lib").AttoXL1, bigint>>;
+            };
+        };
+        stakeTotalsViewer_withdrawn: {
+            params: {
+                to: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniTuple<readonly [import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniNumber<number>>], null>>;
+                from: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniTuple<readonly [import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniNumber<number>>], null>>;
+            };
+            result: {
+                to: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniBigInt<bigint>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHex, bigint>>;
+                from: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<bigint, string>>, import("zod/mini").ZodMiniTransform<import("@xyo-network/xl1-protocol/protocol-lib").AttoXL1, bigint>>;
+            };
+        };
+        stakeTotalsViewer_withdrawnByStaker: {
+            params: {
+                to: import("zod/mini").ZodMiniTuple<readonly [import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
+                    readonly __hex: true;
+                } & {
+                    readonly __address: true;
+                }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk").XyoQuantAddress, string>>]>, import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniNumber<number>>], null>;
+                from: import("zod/mini").ZodMiniTuple<readonly [import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
+                    readonly __hex: true;
+                } & {
+                    readonly __address: true;
+                }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk").XyoQuantAddress, string>>]>, import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniNumber<number>>], null>;
+            };
+            result: {
+                to: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniBigInt<bigint>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHex, bigint>>;
+                from: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<bigint, string>>, import("zod/mini").ZodMiniTransform<import("@xyo-network/xl1-protocol/protocol-lib").AttoXL1, bigint>>;
+            };
+        };
+    };
+}
+//# sourceMappingURL=JsonRpcStakeTotalsViewerMethods.d.ts.map

package/dist/node/modules/rpc/provider/viewer/JsonRpcStakeTotalsViewer/JsonRpcStakeTotalsViewerMethods.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JsonRpcStakeTotalsViewerMethods.d.ts","sourceRoot":"","sources":["../../../../../../../src/modules/rpc/provider/viewer/JsonRpcStakeTotalsViewer/JsonRpcStakeTotalsViewerMethods.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAClD,OAAO,EAAE,KAAK,wBAAwB,EAA4B,MAAM,wCAAwC,CAAA;AAEhH,OAAO,EAAE,2BAA2B,EAAE,MAAM,yBAAyB,CAAA;AACrE,OAAO,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAA;AAE3D,sDAAsD;AACtD,qBAAa,+BAAgC,SAAQ,qBAAqB,CAAC,2BAA2B,CAAE,YAAW,wBAAwB;IACzI,QAAQ,CAAC,OAAO,sBAA2B;IAErC,MAAM,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAItC,cAAc,CAAC,MAAM,EAAE,UAAU,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAIlE,cAAc,CAAC,OAAO,EAAE,UAAU,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAInE,OAAO,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAIvC,eAAe,CAAC,MAAM,EAAE,UAAU,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAInE,SAAS,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAIzC,iBAAiB,CAAC,MAAM,EAAE,UAAU,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAI3E,SAAS,CAAC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGlB"}

package/dist/node/modules/rpc/provider/viewer/JsonRpcStakeTotalsViewer/index.d.ts

@@ -0,0 +1,3 @@
+export * from './JsonRpcStakeTotalsViewer.js';
+export * from './JsonRpcStakeTotalsViewerMethods.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/node/modules/rpc/provider/viewer/JsonRpcStakeTotalsViewer/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../src/modules/rpc/provider/viewer/JsonRpcStakeTotalsViewer/index.ts"],"names":[],"mappings":"AAAA,cAAc,+BAA+B,CAAA;AAC7C,cAAc,sCAAsC,CAAA"}

package/dist/node/modules/rpc/provider/viewer/JsonRpcStakeViewer/JsonRpcStakeViewer.d.ts

@@ -0,0 +1,18 @@
+import type { Promisable } from '@ariestools/sdk';
+import type { Position, StakeEventsViewer, StakeViewer } from '@xyo-network/xl1-protocol/protocol-lib';
+import { JsonRpcStakeViewerMethods } from './JsonRpcStakeViewerMethods.js';
+/** JsonRpcStakeViewer implementation. */
+export declare class JsonRpcStakeViewer extends JsonRpcStakeViewerMethods implements StakeViewer {
+    static readonly connectionTypes: readonly ["rpc"];
+    static readonly defaultMoniker: "StakeViewer";
+    static readonly dependencies: never[];
+    static readonly monikers: "StakeViewer"[];
+    static readonly surface: "node";
+    protected _stakeEvents: StakeEventsViewer;
+    get stakeEvents(): StakeEventsViewer;
+    activeStakes(): Promisable<Position[]>;
+    createHandler(): Promise<void>;
+    removedStakes(): Promisable<Position[]>;
+    withdrawnStakes(): Promisable<Position[]>;
+}
+//# sourceMappingURL=JsonRpcStakeViewer.d.ts.map

package/dist/node/modules/rpc/provider/viewer/JsonRpcStakeViewer/JsonRpcStakeViewer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JsonRpcStakeViewer.d.ts","sourceRoot":"","sources":["../../../../../../../src/modules/rpc/provider/viewer/JsonRpcStakeViewer/JsonRpcStakeViewer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AACjD,OAAO,KAAK,EACV,QAAQ,EACR,iBAAiB,EACjB,WAAW,EACZ,MAAM,wCAAwC,CAAA;AAQ/C,OAAO,EAAE,yBAAyB,EAAE,MAAM,gCAAgC,CAAA;AAE1E,yCAAyC;AACzC,qBACa,kBAAmB,SAAQ,yBAA0B,YAAW,WAAW;IACtF,MAAM,CAAC,QAAQ,CAAC,eAAe,mBAAmB;IAClD,MAAM,CAAC,QAAQ,CAAC,cAAc,gBAAqB;IACnD,MAAM,CAAC,QAAQ,CAAC,YAAY,UAAK;IACjC,MAAM,CAAC,QAAQ,CAAC,QAAQ,kBAAuB;IAC/C,MAAM,CAAC,QAAQ,CAAC,OAAO,EAAG,MAAM,CAAS;IAEzC,SAAS,CAAC,YAAY,EAAG,iBAAiB,CAAA;IAE1C,IAAI,WAAW,sBAEd;IAED,YAAY,IAAI,UAAU,CAAC,QAAQ,EAAE,CAAC;IAIvB,aAAa;IAK5B,aAAa,IAAI,UAAU,CAAC,QAAQ,EAAE,CAAC;IAIvC,eAAe,IAAI,UAAU,CAAC,QAAQ,EAAE,CAAC;CAG1C"}