@xyo-network/xl1-rpc 4.0.11 → 4.0.12

package/dist/neutral/provider/viewer/JsonRpcStakeViewer/JsonRpcStakeViewerMethods.d.ts

@@ -1,584 +0,0 @@
-import type { XyoAddress } from '@xyo-network/sdk';
-import type { StakeViewerMethods } from '@xyo-network/xl1-protocol-lib';
-import { StakeViewerRpcSchemas } from '../../../types/index.ts';
-import { AbstractJsonRpcViewer } from '../JsonRpcViewer.ts';
-/** JsonRpcStakeViewerMethods implementation. */
-export declare class JsonRpcStakeViewerMethods extends AbstractJsonRpcViewer<StakeViewerRpcSchemas> implements StakeViewerMethods {
-    readonly moniker: "StakeViewer";
-    minWithdrawalBlocks(): Promise<number>;
-    rewardsContract(): Promise<(Lowercase<string> & {
-        readonly __hex: true;
-    } & {
-        readonly __address: true;
-    }) | import("@xyo-network/sdk").XyoQuantAddress>;
-    stakeById(id: number): Promise<{
-        addBlock: number;
-        amount: import("@xyo-network/xl1-protocol-lib").AttoXL1;
-        id: import("@xyo-network/xl1-protocol-lib").PositionId;
-        removeBlock: number;
-        staked: (Lowercase<string> & {
-            readonly __hex: true;
-        } & {
-            readonly __address: true;
-        }) | import("@xyo-network/sdk").XyoQuantAddress;
-        staker: (Lowercase<string> & {
-            readonly __hex: true;
-        } & {
-            readonly __address: true;
-        }) | import("@xyo-network/sdk").XyoQuantAddress;
-        withdrawBlock: number;
-    }>;
-    stakeByStaker(staker: XyoAddress, slot: number): Promise<{
-        addBlock: number;
-        amount: import("@xyo-network/xl1-protocol-lib").AttoXL1;
-        id: import("@xyo-network/xl1-protocol-lib").PositionId;
-        removeBlock: number;
-        staked: (Lowercase<string> & {
-            readonly __hex: true;
-        } & {
-            readonly __address: true;
-        }) | import("@xyo-network/sdk").XyoQuantAddress;
-        staker: (Lowercase<string> & {
-            readonly __hex: true;
-        } & {
-            readonly __address: true;
-        }) | import("@xyo-network/sdk").XyoQuantAddress;
-        withdrawBlock: number;
-    }>;
-    stakesByStaked(staked: XyoAddress): Promise<{
-        addBlock: number;
-        amount: import("@xyo-network/xl1-protocol-lib").AttoXL1;
-        id: import("@xyo-network/xl1-protocol-lib").PositionId;
-        removeBlock: number;
-        staked: (Lowercase<string> & {
-            readonly __hex: true;
-        } & {
-            readonly __address: true;
-        }) | import("@xyo-network/sdk").XyoQuantAddress;
-        staker: (Lowercase<string> & {
-            readonly __hex: true;
-        } & {
-            readonly __address: true;
-        }) | import("@xyo-network/sdk").XyoQuantAddress;
-        withdrawBlock: number;
-    }[]>;
-    stakesByStaker(staker: XyoAddress): Promise<{
-        addBlock: number;
-        amount: import("@xyo-network/xl1-protocol-lib").AttoXL1;
-        id: import("@xyo-network/xl1-protocol-lib").PositionId;
-        removeBlock: number;
-        staked: (Lowercase<string> & {
-            readonly __hex: true;
-        } & {
-            readonly __address: true;
-        }) | import("@xyo-network/sdk").XyoQuantAddress;
-        staker: (Lowercase<string> & {
-            readonly __hex: true;
-        } & {
-            readonly __address: true;
-        }) | import("@xyo-network/sdk").XyoQuantAddress;
-        withdrawBlock: number;
-    }[]>;
-    stakingTokenAddress(): Promise<(Lowercase<string> & {
-        readonly __hex: true;
-    } & {
-        readonly __address: true;
-    }) | import("@xyo-network/sdk").XyoQuantAddress>;
-    protected schemas(): {
-        stakeViewer_minWithdrawalBlocks: {
-            params: {
-                to: import("zod").ZodDefault<import("zod").ZodTuple<[], null>>;
-                from: import("zod").ZodDefault<import("zod").ZodTuple<[], null>>;
-            };
-            result: {
-                to: import("zod").ZodNumber;
-                from: import("zod").ZodNumber;
-            };
-        };
-        stakeViewer_rewardsContract: {
-            params: {
-                to: import("zod").ZodDefault<import("zod").ZodTuple<[], null>>;
-                from: import("zod").ZodDefault<import("zod").ZodTuple<[], null>>;
-            };
-            result: {
-                to: 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>>]>;
-                from: 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>>]>;
-            };
-        };
-        stakeViewer_stakeById: {
-            params: {
-                to: import("zod").ZodTuple<[import("zod").ZodNumber], null>;
-                from: import("zod").ZodTuple<[import("zod").ZodNumber], null>;
-            };
-            result: {
-                to: import("zod").ZodPipe<import("zod").ZodObject<{
-                    amount: import("zod/mini").ZodMiniBigInt<bigint>;
-                    addBlock: import("zod").ZodNumber;
-                    id: import("zod").ZodNumber;
-                    removeBlock: import("zod").ZodNumber;
-                    staked: 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>>]>;
-                    staker: 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>>]>;
-                    withdrawBlock: import("zod").ZodNumber;
-                }, import("zod/v4/core").$strip>, import("zod").ZodTransform<{
-                    addBlock: number;
-                    amount: import("@ariestools/sdk").BrandedHex;
-                    id: number;
-                    removeBlock: number;
-                    staked: (Lowercase<string> & {
-                        readonly __hex: true;
-                    } & {
-                        readonly __address: true;
-                    }) | import("@xyo-network/sdk").XyoQuantAddress;
-                    staker: (Lowercase<string> & {
-                        readonly __hex: true;
-                    } & {
-                        readonly __address: true;
-                    }) | import("@xyo-network/sdk").XyoQuantAddress;
-                    withdrawBlock: number;
-                }, {
-                    amount: bigint;
-                    addBlock: number;
-                    id: number;
-                    removeBlock: number;
-                    staked: (Lowercase<string> & {
-                        readonly __hex: true;
-                    } & {
-                        readonly __address: true;
-                    }) | import("@xyo-network/sdk").XyoQuantAddress;
-                    staker: (Lowercase<string> & {
-                        readonly __hex: true;
-                    } & {
-                        readonly __address: true;
-                    }) | import("@xyo-network/sdk").XyoQuantAddress;
-                    withdrawBlock: number;
-                }>>;
-                from: import("zod").ZodPipe<import("zod").ZodObject<{
-                    addBlock: import("zod").ZodNumber;
-                    id: import("zod").ZodNumber;
-                    removeBlock: import("zod").ZodNumber;
-                    staked: 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>>]>;
-                    staker: 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>>]>;
-                    withdrawBlock: import("zod").ZodNumber;
-                    amount: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>;
-                }, import("zod/v4/core").$strip>, import("zod").ZodTransform<{
-                    addBlock: number;
-                    amount: import("@xyo-network/xl1-protocol-lib").AttoXL1;
-                    id: import("@xyo-network/xl1-protocol-lib").PositionId;
-                    removeBlock: number;
-                    staked: (Lowercase<string> & {
-                        readonly __hex: true;
-                    } & {
-                        readonly __address: true;
-                    }) | import("@xyo-network/sdk").XyoQuantAddress;
-                    staker: (Lowercase<string> & {
-                        readonly __hex: true;
-                    } & {
-                        readonly __address: true;
-                    }) | import("@xyo-network/sdk").XyoQuantAddress;
-                    withdrawBlock: number;
-                }, {
-                    addBlock: number;
-                    id: number;
-                    removeBlock: number;
-                    staked: (Lowercase<string> & {
-                        readonly __hex: true;
-                    } & {
-                        readonly __address: true;
-                    }) | import("@xyo-network/sdk").XyoQuantAddress;
-                    staker: (Lowercase<string> & {
-                        readonly __hex: true;
-                    } & {
-                        readonly __address: true;
-                    }) | import("@xyo-network/sdk").XyoQuantAddress;
-                    withdrawBlock: number;
-                    amount: import("@ariestools/sdk").BrandedHex;
-                }>>;
-            };
-        };
-        stakeViewer_stakeByStaker: {
-            params: {
-                to: import("zod").ZodTuple<[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").ZodNumber], null>;
-                from: import("zod").ZodTuple<[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").ZodNumber], null>;
-            };
-            result: {
-                to: import("zod").ZodPipe<import("zod").ZodObject<{
-                    amount: import("zod/mini").ZodMiniBigInt<bigint>;
-                    addBlock: import("zod").ZodNumber;
-                    id: import("zod").ZodNumber;
-                    removeBlock: import("zod").ZodNumber;
-                    staked: 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>>]>;
-                    staker: 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>>]>;
-                    withdrawBlock: import("zod").ZodNumber;
-                }, import("zod/v4/core").$strip>, import("zod").ZodTransform<{
-                    addBlock: number;
-                    amount: import("@ariestools/sdk").BrandedHex;
-                    id: number;
-                    removeBlock: number;
-                    staked: (Lowercase<string> & {
-                        readonly __hex: true;
-                    } & {
-                        readonly __address: true;
-                    }) | import("@xyo-network/sdk").XyoQuantAddress;
-                    staker: (Lowercase<string> & {
-                        readonly __hex: true;
-                    } & {
-                        readonly __address: true;
-                    }) | import("@xyo-network/sdk").XyoQuantAddress;
-                    withdrawBlock: number;
-                }, {
-                    amount: bigint;
-                    addBlock: number;
-                    id: number;
-                    removeBlock: number;
-                    staked: (Lowercase<string> & {
-                        readonly __hex: true;
-                    } & {
-                        readonly __address: true;
-                    }) | import("@xyo-network/sdk").XyoQuantAddress;
-                    staker: (Lowercase<string> & {
-                        readonly __hex: true;
-                    } & {
-                        readonly __address: true;
-                    }) | import("@xyo-network/sdk").XyoQuantAddress;
-                    withdrawBlock: number;
-                }>>;
-                from: import("zod").ZodPipe<import("zod").ZodObject<{
-                    addBlock: import("zod").ZodNumber;
-                    id: import("zod").ZodNumber;
-                    removeBlock: import("zod").ZodNumber;
-                    staked: 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>>]>;
-                    staker: 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>>]>;
-                    withdrawBlock: import("zod").ZodNumber;
-                    amount: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>;
-                }, import("zod/v4/core").$strip>, import("zod").ZodTransform<{
-                    addBlock: number;
-                    amount: import("@xyo-network/xl1-protocol-lib").AttoXL1;
-                    id: import("@xyo-network/xl1-protocol-lib").PositionId;
-                    removeBlock: number;
-                    staked: (Lowercase<string> & {
-                        readonly __hex: true;
-                    } & {
-                        readonly __address: true;
-                    }) | import("@xyo-network/sdk").XyoQuantAddress;
-                    staker: (Lowercase<string> & {
-                        readonly __hex: true;
-                    } & {
-                        readonly __address: true;
-                    }) | import("@xyo-network/sdk").XyoQuantAddress;
-                    withdrawBlock: number;
-                }, {
-                    addBlock: number;
-                    id: number;
-                    removeBlock: number;
-                    staked: (Lowercase<string> & {
-                        readonly __hex: true;
-                    } & {
-                        readonly __address: true;
-                    }) | import("@xyo-network/sdk").XyoQuantAddress;
-                    staker: (Lowercase<string> & {
-                        readonly __hex: true;
-                    } & {
-                        readonly __address: true;
-                    }) | import("@xyo-network/sdk").XyoQuantAddress;
-                    withdrawBlock: number;
-                    amount: import("@ariestools/sdk").BrandedHex;
-                }>>;
-            };
-        };
-        stakeViewer_stakesByStaker: {
-            params: {
-                to: import("zod").ZodTuple<[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>>]>], null>;
-                from: import("zod").ZodTuple<[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>>]>], null>;
-            };
-            result: {
-                to: import("zod").ZodArray<import("zod").ZodPipe<import("zod").ZodObject<{
-                    amount: import("zod/mini").ZodMiniBigInt<bigint>;
-                    addBlock: import("zod").ZodNumber;
-                    id: import("zod").ZodNumber;
-                    removeBlock: import("zod").ZodNumber;
-                    staked: 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>>]>;
-                    staker: 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>>]>;
-                    withdrawBlock: import("zod").ZodNumber;
-                }, import("zod/v4/core").$strip>, import("zod").ZodTransform<{
-                    addBlock: number;
-                    amount: import("@ariestools/sdk").BrandedHex;
-                    id: number;
-                    removeBlock: number;
-                    staked: (Lowercase<string> & {
-                        readonly __hex: true;
-                    } & {
-                        readonly __address: true;
-                    }) | import("@xyo-network/sdk").XyoQuantAddress;
-                    staker: (Lowercase<string> & {
-                        readonly __hex: true;
-                    } & {
-                        readonly __address: true;
-                    }) | import("@xyo-network/sdk").XyoQuantAddress;
-                    withdrawBlock: number;
-                }, {
-                    amount: bigint;
-                    addBlock: number;
-                    id: number;
-                    removeBlock: number;
-                    staked: (Lowercase<string> & {
-                        readonly __hex: true;
-                    } & {
-                        readonly __address: true;
-                    }) | import("@xyo-network/sdk").XyoQuantAddress;
-                    staker: (Lowercase<string> & {
-                        readonly __hex: true;
-                    } & {
-                        readonly __address: true;
-                    }) | import("@xyo-network/sdk").XyoQuantAddress;
-                    withdrawBlock: number;
-                }>>>;
-                from: import("zod").ZodArray<import("zod").ZodPipe<import("zod").ZodObject<{
-                    addBlock: import("zod").ZodNumber;
-                    id: import("zod").ZodNumber;
-                    removeBlock: import("zod").ZodNumber;
-                    staked: 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>>]>;
-                    staker: 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>>]>;
-                    withdrawBlock: import("zod").ZodNumber;
-                    amount: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>;
-                }, import("zod/v4/core").$strip>, import("zod").ZodTransform<{
-                    addBlock: number;
-                    amount: import("@xyo-network/xl1-protocol-lib").AttoXL1;
-                    id: import("@xyo-network/xl1-protocol-lib").PositionId;
-                    removeBlock: number;
-                    staked: (Lowercase<string> & {
-                        readonly __hex: true;
-                    } & {
-                        readonly __address: true;
-                    }) | import("@xyo-network/sdk").XyoQuantAddress;
-                    staker: (Lowercase<string> & {
-                        readonly __hex: true;
-                    } & {
-                        readonly __address: true;
-                    }) | import("@xyo-network/sdk").XyoQuantAddress;
-                    withdrawBlock: number;
-                }, {
-                    addBlock: number;
-                    id: number;
-                    removeBlock: number;
-                    staked: (Lowercase<string> & {
-                        readonly __hex: true;
-                    } & {
-                        readonly __address: true;
-                    }) | import("@xyo-network/sdk").XyoQuantAddress;
-                    staker: (Lowercase<string> & {
-                        readonly __hex: true;
-                    } & {
-                        readonly __address: true;
-                    }) | import("@xyo-network/sdk").XyoQuantAddress;
-                    withdrawBlock: number;
-                    amount: import("@ariestools/sdk").BrandedHex;
-                }>>>;
-            };
-        };
-        stakeViewer_stakesByStaked: {
-            params: {
-                to: import("zod").ZodTuple<[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>>]>], null>;
-                from: import("zod").ZodTuple<[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>>]>], null>;
-            };
-            result: {
-                to: import("zod").ZodArray<import("zod").ZodPipe<import("zod").ZodObject<{
-                    amount: import("zod/mini").ZodMiniBigInt<bigint>;
-                    addBlock: import("zod").ZodNumber;
-                    id: import("zod").ZodNumber;
-                    removeBlock: import("zod").ZodNumber;
-                    staked: 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>>]>;
-                    staker: 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>>]>;
-                    withdrawBlock: import("zod").ZodNumber;
-                }, import("zod/v4/core").$strip>, import("zod").ZodTransform<{
-                    addBlock: number;
-                    amount: import("@ariestools/sdk").BrandedHex;
-                    id: number;
-                    removeBlock: number;
-                    staked: (Lowercase<string> & {
-                        readonly __hex: true;
-                    } & {
-                        readonly __address: true;
-                    }) | import("@xyo-network/sdk").XyoQuantAddress;
-                    staker: (Lowercase<string> & {
-                        readonly __hex: true;
-                    } & {
-                        readonly __address: true;
-                    }) | import("@xyo-network/sdk").XyoQuantAddress;
-                    withdrawBlock: number;
-                }, {
-                    amount: bigint;
-                    addBlock: number;
-                    id: number;
-                    removeBlock: number;
-                    staked: (Lowercase<string> & {
-                        readonly __hex: true;
-                    } & {
-                        readonly __address: true;
-                    }) | import("@xyo-network/sdk").XyoQuantAddress;
-                    staker: (Lowercase<string> & {
-                        readonly __hex: true;
-                    } & {
-                        readonly __address: true;
-                    }) | import("@xyo-network/sdk").XyoQuantAddress;
-                    withdrawBlock: number;
-                }>>>;
-                from: import("zod").ZodArray<import("zod").ZodPipe<import("zod").ZodObject<{
-                    addBlock: import("zod").ZodNumber;
-                    id: import("zod").ZodNumber;
-                    removeBlock: import("zod").ZodNumber;
-                    staked: 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>>]>;
-                    staker: 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>>]>;
-                    withdrawBlock: import("zod").ZodNumber;
-                    amount: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>;
-                }, import("zod/v4/core").$strip>, import("zod").ZodTransform<{
-                    addBlock: number;
-                    amount: import("@xyo-network/xl1-protocol-lib").AttoXL1;
-                    id: import("@xyo-network/xl1-protocol-lib").PositionId;
-                    removeBlock: number;
-                    staked: (Lowercase<string> & {
-                        readonly __hex: true;
-                    } & {
-                        readonly __address: true;
-                    }) | import("@xyo-network/sdk").XyoQuantAddress;
-                    staker: (Lowercase<string> & {
-                        readonly __hex: true;
-                    } & {
-                        readonly __address: true;
-                    }) | import("@xyo-network/sdk").XyoQuantAddress;
-                    withdrawBlock: number;
-                }, {
-                    addBlock: number;
-                    id: number;
-                    removeBlock: number;
-                    staked: (Lowercase<string> & {
-                        readonly __hex: true;
-                    } & {
-                        readonly __address: true;
-                    }) | import("@xyo-network/sdk").XyoQuantAddress;
-                    staker: (Lowercase<string> & {
-                        readonly __hex: true;
-                    } & {
-                        readonly __address: true;
-                    }) | import("@xyo-network/sdk").XyoQuantAddress;
-                    withdrawBlock: number;
-                    amount: import("@ariestools/sdk").BrandedHex;
-                }>>>;
-            };
-        };
-        stakeViewer_stakingTokenAddress: {
-            params: {
-                to: import("zod").ZodDefault<import("zod").ZodTuple<[], null>>;
-                from: import("zod").ZodDefault<import("zod").ZodTuple<[], null>>;
-            };
-            result: {
-                to: 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>>]>;
-                from: 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>>]>;
-            };
-        };
-    };
-}
-//# sourceMappingURL=JsonRpcStakeViewerMethods.d.ts.map

package/dist/neutral/provider/viewer/JsonRpcStakeViewer/JsonRpcStakeViewerMethods.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"JsonRpcStakeViewerMethods.d.ts","sourceRoot":"","sources":["../../../../../src/provider/viewer/JsonRpcStakeViewer/JsonRpcStakeViewerMethods.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAClD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAA;AAGvE,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAA;AAC/D,OAAO,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAA;AAE3D,gDAAgD;AAChD,qBAAa,yBAA0B,SAAQ,qBAAqB,CAAC,qBAAqB,CAAE,YAAW,kBAAkB;IACvH,QAAQ,CAAC,OAAO,gBAAqB;IAE/B,mBAAmB;IAInB,eAAe;;;;;IAIf,SAAS,CAAC,EAAE,EAAE,MAAM;;;;;;;;;;;;;;;;;IAIpB,aAAa,CAAC,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM;;;;;;;;;;;;;;;;;IAI9C,cAAc,CAAC,MAAM,EAAE,UAAU;;;;;;;;;;;;;;;;;IAIjC,cAAc,CAAC,MAAM,EAAE,UAAU;;;;;;;;;;;;;;;;;IAIjC,mBAAmB;;;;;IAIzB,SAAS,CAAC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGlB"}

package/dist/neutral/provider/viewer/JsonRpcStakeViewer/index.d.ts

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

package/dist/neutral/provider/viewer/JsonRpcStakeViewer/index.d.ts.map

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

package/dist/neutral/provider/viewer/JsonRpcTimeSyncViewer/JsonRpcTimeSyncViewer.d.ts

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

package/dist/neutral/provider/viewer/JsonRpcTimeSyncViewer/JsonRpcTimeSyncViewer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"JsonRpcTimeSyncViewer.d.ts","sourceRoot":"","sources":["../../../../../src/provider/viewer/JsonRpcTimeSyncViewer/JsonRpcTimeSyncViewer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAyB,MAAM,+BAA+B,CAAA;AAG1F,OAAO,EAAE,4BAA4B,EAAE,MAAM,mCAAmC,CAAA;AAEhF,4CAA4C;AAC5C,qBACa,qBAAsB,SAAQ,4BAA6B,YAAW,cAAc;IAC/F,MAAM,CAAC,QAAQ,CAAC,eAAe,mBAAmB;IAClD,MAAM,CAAC,QAAQ,CAAC,cAAc,mBAAwB;IACtD,MAAM,CAAC,QAAQ,CAAC,YAAY,UAAK;IACjC,MAAM,CAAC,QAAQ,CAAC,QAAQ,qBAA0B;IAClD,MAAM,CAAC,QAAQ,CAAC,OAAO,EAAG,MAAM,CAAS;CAC1C"}