@xyo-network/xl1-rpc 1.18.0-rc.1 → 1.18.1

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

@@ -1 +1 @@
-{"version":3,"file":"XyoViewerRpcSchemas.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/XyoViewerRpcSchemas.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAKxB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiUgB,CAAA;AAEhD,MAAM,MAAM,mBAAmB,GAAG,OAAO,mBAAmB,CAAA"}
+{"version":3,"file":"XyoViewerRpcSchemas.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/XyoViewerRpcSchemas.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiUgB,CAAA;AAEhD,MAAM,MAAM,mBAAmB,GAAG,OAAO,mBAAmB,CAAA"}

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

@@ -1,5 +1,5 @@
 import type { ZodUndefined } from 'zod';
-import * as z from 'zod';
+import { z } from 'zod';
 export declare const createRequestSchema: <TParams extends z.ZodTypeAny, TMethodName extends string = string>(methodName: TMethodName, paramsSchema?: TParams | ZodUndefined) => z.ZodObject<{
     id: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
     jsonrpc: z.ZodLiteral<"2.0">;

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

@@ -1 +1 @@
-{"version":3,"file":"createRequestSchema.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/createRequestSchema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,KAAK,CAAA;AACvC,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAIxB,eAAO,MAAM,mBAAmB,GAAI,OAAO,SAAS,CAAC,CAAC,UAAU,EAAE,WAAW,SAAS,MAAM,GAAG,MAAM,EACnG,YAAY,WAAW,EACvB,eAAc,OAAO,GAAG,YAA4B;;;;;iBAOlD,CAAA"}
+{"version":3,"file":"createRequestSchema.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/createRequestSchema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,KAAK,CAAA;AACvC,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,mBAAmB,GAAI,OAAO,SAAS,CAAC,CAAC,UAAU,EAAE,WAAW,SAAS,MAAM,GAAG,MAAM,EACnG,YAAY,WAAW,EACvB,eAAc,OAAO,GAAG,YAA4B;;;;;iBAOlD,CAAA"}

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

@@ -1,5 +1,5 @@
 import type { ZodUndefined } from 'zod';
-import * as z from 'zod';
+import { z } from 'zod';
 export declare const createResponseSchema: <TParams extends z.ZodTypeAny>(resultSchema?: TParams | ZodUndefined) => z.ZodObject<{
     id: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
     jsonrpc: z.ZodLiteral<"2.0">;

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

@@ -1 +1 @@
-{"version":3,"file":"createResponseSchema.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/createResponseSchema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,KAAK,CAAA;AACvC,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAIxB,eAAO,MAAM,oBAAoB,GAAI,OAAO,SAAS,CAAC,CAAC,UAAU,EAC/D,eAAc,OAAO,GAAG,YAA4B;;;;iBAMlD,CAAA"}
+{"version":3,"file":"createResponseSchema.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/createResponseSchema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,KAAK,CAAA;AACvC,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,oBAAoB,GAAI,OAAO,SAAS,CAAC,CAAC,UAAU,EAC/D,eAAc,OAAO,GAAG,YAA4B;;;;iBAMlD,CAAA"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "http://json.schemastore.org/package.json",
   "name": "@xyo-network/xl1-rpc",
-  "version": "1.18.0-rc.1",
+  "version": "1.18.1",
   "description": "XYO Layer One API",
   "homepage": "https://xylabs.com",
   "bugs": {
@@ -59,33 +59,35 @@
   },
   "dependencies": {
     "@metamask/json-rpc-engine": "~10.2.0",
-    "@xylabs/axios": "~5.0.51",
-    "@xylabs/sdk-js": "~5.0.51",
-    "@xyo-network/archivist-model": "~5.2.17",
-    "@xyo-network/module-model": "~5.2.17",
-    "@xyo-network/node-model": "~5.2.17",
-    "@xyo-network/payload-model": "~5.2.17",
-    "@xyo-network/xl1-protocol": "~1.14.17",
-    "@xyo-network/xl1-protocol-sdk": "~1.18.0-rc.1",
+    "@xylabs/axios": "~5.0.61",
+    "@xylabs/sdk-js": "~5.0.61",
+    "@xyo-network/archivist-model": "~5.2.19",
+    "@xyo-network/module-model": "~5.2.19",
+    "@xyo-network/node-model": "~5.2.19",
+    "@xyo-network/payload-model": "~5.2.19",
+    "@xyo-network/xl1-protocol": "~1.18.1",
+    "@xyo-network/xl1-protocol-sdk": "~1.18.1",
     "axios": "~1.13.2",
     "uuid": "~13.0.0",
-    "zod": "~4.1.13"
+    "zod": "~4.2.1"
   },
   "devDependencies": {
-    "@metamask/utils": "~11.8.1",
-    "@types/node": "~25.0.2",
-    "@xylabs/sdk-js": "~5.0.51",
+    "@metamask/utils": "~11.9.0",
+    "@types/node": "~25.0.3",
+    "@xylabs/sdk-js": "~5.0.61",
     "@xylabs/ts-scripts-yarn3": "~7.2.32",
     "@xylabs/tsconfig": "~7.2.32",
-    "@xylabs/vitest-extended": "~5.0.51",
-    "@xyo-network/account": "~5.2.17",
-    "@xyo-network/account-model": "~5.2.17",
-    "@xyo-network/payload-builder": "~5.2.17",
-    "@xyo-network/wallet": "~5.2.17",
+    "@xylabs/vitest-extended": "~5.0.61",
+    "@xyo-network/account": "~5.2.19",
+    "@xyo-network/account-model": "~5.2.19",
+    "@xyo-network/boundwitness-model": "~5.2.19",
+    "@xyo-network/payload-builder": "~5.2.19",
+    "@xyo-network/wallet": "~5.2.19",
     "dotenv": "~17.2.3",
     "eslint": "^9.39.2",
+    "tslib": "^2.8.1",
     "typescript": "~5.9.3",
-    "vitest": "~4.0.15"
+    "vitest": "~4.0.16"
   },
   "packageManager": "yarn@4.6.0",
   "engines": {
@@ -98,6 +100,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "src": "./src/index.ts",
-  "stableVersion": "1.17.7"
+  "src": "./src/index.ts"
 }

package/src/provider/datalake/JsonRpcDataLakeViewer.ts

@@ -1,5 +1,8 @@
-import type { DataLakeViewer } from '@xyo-network/xl1-protocol-sdk'
+import { creatableProvider, type DataLakeViewer } from '@xyo-network/xl1-protocol-sdk'
 
 import { JsonRpcDataLakeViewerMethods } from './JsonRpcDataLakeViewerMethods.ts'
 
-export class JsonRpcDataLakeViewer extends JsonRpcDataLakeViewerMethods implements DataLakeViewer {}
+@creatableProvider()
+export class JsonRpcDataLakeViewer extends JsonRpcDataLakeViewerMethods implements DataLakeViewer {
+  static readonly dependencies = []
+}

package/src/provider/runner/JsonRpcMempoolRunner/JsonRpcMempoolRunner.ts

@@ -7,6 +7,6 @@ import { JsonRpcMempoolRunnerMethods } from './JsonRpcMempoolRunnerMethods.ts'
 @creatableProvider()
 export class JsonRpcMempoolRunner extends JsonRpcMempoolRunnerMethods implements MempoolRunner {
   static readonly defaultMoniker = MempoolRunnerMoniker
+  static readonly dependencies = []
   static readonly monikers = [MempoolRunnerMoniker]
-  moniker = JsonRpcMempoolRunner.defaultMoniker
 }

package/src/provider/runner/JsonRpcMempoolRunner/JsonRpcMempoolRunnerMethods.ts

@@ -1,11 +1,13 @@
 import type { Hash } from '@xylabs/sdk-js'
 import type { SignedHydratedBlock, SignedHydratedTransaction } from '@xyo-network/xl1-protocol'
 import type { MempoolRunnerMethods } from '@xyo-network/xl1-protocol-sdk'
+import { MempoolRunnerMoniker } from '@xyo-network/xl1-protocol-sdk'
 
 import { MempoolRunnerRpcSchemas } from '../../../types/index.ts'
 import { AbstractJsonRpcRunner } from '../JsonRpcRunner.ts'
 
 export class JsonRpcMempoolRunnerMethods extends AbstractJsonRpcRunner<typeof MempoolRunnerRpcSchemas> implements MempoolRunnerMethods {
+  readonly moniker = MempoolRunnerMoniker
   async submitBlocks(blocks: SignedHydratedBlock[]): Promise<Hash[]> {
     const result = await this.transport.sendRequest(
       'mempoolRunner_submitBlocks',

package/src/provider/runner/JsonRpcXyoRunner.ts

@@ -1,12 +1,15 @@
 import { type Hash } from '@xylabs/sdk-js'
 import type { SignedHydratedTransaction } from '@xyo-network/xl1-protocol'
 import type { MempoolRunner, XyoRunner } from '@xyo-network/xl1-protocol-sdk'
-import { XyoRunnerMoniker } from '@xyo-network/xl1-protocol-sdk'
+import { creatableProvider, XyoRunnerMoniker } from '@xyo-network/xl1-protocol-sdk'
 
 import { XyoRunnerRpcSchemas } from '../../types/index.ts'
 import { AbstractJsonRpcRunner } from './JsonRpcRunner.ts'
+
+@creatableProvider()
 export class JsonRpcXyoRunner extends AbstractJsonRpcRunner<XyoRunnerRpcSchemas> implements XyoRunner {
   static readonly defaultMoniker = XyoRunnerMoniker
+  static readonly dependencies = []
   static readonly monikers = [XyoRunnerMoniker]
   moniker = JsonRpcXyoRunner.defaultMoniker
 

package/src/provider/runner/NodeXyoRunner.ts

@@ -21,6 +21,7 @@ export interface NodeXyoRunnerParams extends CreatableProviderParams {
 @creatableProvider()
 export class NodeXyoRunner extends AbstractCreatableProvider<NodeXyoRunnerParams> implements XyoRunner {
   static readonly defaultMoniker = XyoRunnerMoniker
+  static readonly dependencies = []
   static readonly monikers = [XyoRunnerMoniker]
   moniker = NodeXyoRunner.defaultMoniker
 

package/src/provider/viewer/JsonRpcAccountBalanceViewer/JsonRpcAccountBalanceViewer.ts

@@ -1,32 +1,35 @@
-import type { Address, Hash } from '@xylabs/sdk-js'
-import { type AttoXL1, type XL1BlockRange } from '@xyo-network/xl1-protocol'
-import type { AccountBalanceHistoryItem, AccountBalanceViewer } from '@xyo-network/xl1-protocol-sdk'
-import { AccountBalanceViewerMoniker } from '@xyo-network/xl1-protocol-sdk'
+import type { Address } from '@xylabs/sdk-js'
+import { type AttoXL1 } from '@xyo-network/xl1-protocol'
+import type {
+  AccountBalanceHistoryItem, AccountBalanceViewer, ChainQualifiedConfig,
+} from '@xyo-network/xl1-protocol-sdk'
+import { AccountBalanceViewerMoniker, creatableProvider } from '@xyo-network/xl1-protocol-sdk'
 
 import { JsonRpcAccountBalanceViewerMethods } from './JsonRpcAccountBalanceViewerMethods.ts'
 
+@creatableProvider()
 export class JsonRpcAccountBalanceViewer extends JsonRpcAccountBalanceViewerMethods implements AccountBalanceViewer {
   static readonly defaultMoniker = AccountBalanceViewerMoniker
+  static readonly dependencies = []
   static readonly monikers = [AccountBalanceViewerMoniker]
-  moniker = JsonRpcAccountBalanceViewer.defaultMoniker
 
-  async accountBalance(address: Address, headOrRange?: Hash | XL1BlockRange): Promise<AttoXL1> {
-    const result = await this.accountBalances([address], headOrRange)
+  async accountBalance(address: Address, config: ChainQualifiedConfig = {}): Promise<AttoXL1> {
+    const result = await this.accountBalances([address], config)
     return result[address]
   }
 
-  async accountBalanceHistories(address: Address[], headOrRange?: Hash | XL1BlockRange): Promise<Record<Address, AccountBalanceHistoryItem[]>> {
-    const [result] = await this.qualifiedAccountBalanceHistories(address, headOrRange)
+  async accountBalanceHistories(address: Address[], config: ChainQualifiedConfig = {}): Promise<Record<Address, AccountBalanceHistoryItem[]>> {
+    const [result] = await this.qualifiedAccountBalanceHistories(address, config)
     return result
   }
 
-  async accountBalanceHistory(address: Address, headOrRange?: Hash | XL1BlockRange): Promise<AccountBalanceHistoryItem[]> {
-    const result = await this.accountBalanceHistories([address], headOrRange)
+  async accountBalanceHistory(address: Address, config: ChainQualifiedConfig = {}): Promise<AccountBalanceHistoryItem[]> {
+    const result = await this.accountBalanceHistories([address], config)
     return result[address]
   }
 
-  async accountBalances(address: Address[], headOrRange?: Hash | XL1BlockRange): Promise<Record<Address, AttoXL1>> {
-    const [result] = await this.qualifiedAccountBalances(address, headOrRange)
+  async accountBalances(address: Address[], config: ChainQualifiedConfig = {}): Promise<Record<Address, AttoXL1>> {
+    const [result] = await this.qualifiedAccountBalances(address, config)
     return result
   }
 }

package/src/provider/viewer/JsonRpcAccountBalanceViewer/JsonRpcAccountBalanceViewerMethods.ts

@@ -1,34 +1,33 @@
-import type { Address, Hash } from '@xylabs/sdk-js'
+import type { Address } from '@xylabs/sdk-js'
+import { type AttoXL1 } from '@xyo-network/xl1-protocol'
 import {
-  type AttoXL1,
-  type XL1BlockRange,
-} from '@xyo-network/xl1-protocol'
-import type {
-  AccountBalanceHistoryItem, AccountBalanceViewerMethods, Qualified,
+  type AccountBalanceHistoryItem, type AccountBalanceViewerMethods, AccountBalanceViewerMoniker,
+  type ChainQualified, type ChainQualifiedConfig,
 } from '@xyo-network/xl1-protocol-sdk'
 
 import { AccountBalanceViewerRpcSchemas } from '../../../types/index.ts'
 import { AbstractJsonRpcViewer } from '../JsonRpcViewer.ts'
 
 export class JsonRpcAccountBalanceViewerMethods extends AbstractJsonRpcViewer<AccountBalanceViewerRpcSchemas> implements AccountBalanceViewerMethods {
+  moniker = AccountBalanceViewerMoniker
   async qualifiedAccountBalanceHistories(
     addresses: Address[],
-    headOrRange?: Hash | XL1BlockRange,
-  ): Promise<Qualified<Record<Address, AccountBalanceHistoryItem[]>>> {
+    config: ChainQualifiedConfig,
+  ): Promise<ChainQualified<Record<Address, AccountBalanceHistoryItem[]>>> {
     return (await this.transport.sendRequest(
       'accountBalanceViewer_qualifiedAccountBalanceHistories',
-      headOrRange ? [addresses, headOrRange] : [addresses],
-    )) as Qualified<Record<Address, AccountBalanceHistoryItem[]>>
+      [addresses, config],
+    )) as ChainQualified<Record<Address, AccountBalanceHistoryItem[]>>
   }
 
   async qualifiedAccountBalances(
     addresses: Address[],
-    headOrRange?: Hash | XL1BlockRange,
+    config: ChainQualifiedConfig,
   ) {
     return await this.transport.sendRequest(
       'accountBalanceViewer_qualifiedAccountBalances',
-      headOrRange ? [addresses, headOrRange] : [addresses],
-    ) as Qualified<Record<Address, AttoXL1>>
+      [addresses, config],
+    ) as ChainQualified<Record<Address, AttoXL1>>
   }
 
   protected schemas() {

package/src/provider/viewer/JsonRpcBlockViewer/JsonRpcBlockViewer.ts

@@ -3,14 +3,17 @@ import type { Payload, WithHashMeta } from '@xyo-network/payload-model'
 import type {
   ChainId, SignedHydratedBlockWithHashMeta, XL1BlockNumber,
 } from '@xyo-network/xl1-protocol'
-import { type BlockViewer, BlockViewerMoniker } from '@xyo-network/xl1-protocol-sdk'
+import {
+  type BlockViewer, BlockViewerMoniker, creatableProvider,
+} from '@xyo-network/xl1-protocol-sdk'
 
 import { JsonRpcBlockViewerMethods } from './JsonRpcBlockViewerMethods.ts'
 
+@creatableProvider()
 export class JsonRpcBlockViewer extends JsonRpcBlockViewerMethods implements BlockViewer {
   static readonly defaultMoniker = BlockViewerMoniker
+  static readonly dependencies = []
   static readonly monikers = [BlockViewerMoniker]
-  moniker = JsonRpcBlockViewer.defaultMoniker
 
   async blockByHash(hash: Hash): Promise<SignedHydratedBlockWithHashMeta | null> {
     return (await this.blocksByHash(hash, 1))[0]

package/src/provider/viewer/JsonRpcBlockViewer/JsonRpcBlockViewerMethods.ts

@@ -4,12 +4,13 @@ import {
   asHashMeta, type Payload, type WithHashMeta,
 } from '@xyo-network/payload-model'
 import type { SignedHydratedBlockWithHashMeta, XL1BlockNumber } from '@xyo-network/xl1-protocol'
-import type { BlockViewerMethods } from '@xyo-network/xl1-protocol-sdk'
+import { type BlockViewerMethods, BlockViewerMoniker } from '@xyo-network/xl1-protocol-sdk'
 
 import { BlockViewerRpcSchemas } from '../../../types/index.ts'
 import { AbstractJsonRpcViewer } from '../JsonRpcViewer.ts'
 
 export class JsonRpcBlockViewerMethods extends AbstractJsonRpcViewer<BlockViewerRpcSchemas> implements BlockViewerMethods {
+  readonly moniker = BlockViewerMoniker
   async blocksByHash(hash: Hash, limit?: number): Promise<SignedHydratedBlockWithHashMeta[]> {
     const result = await this.transport.sendRequest(
       'blockViewer_blocksByHash',

package/src/provider/viewer/JsonRpcMempoolViewer/JsonRpcMempoolViewer.ts

@@ -1,9 +1,12 @@
-import { type MempoolViewer, MempoolViewerMoniker } from '@xyo-network/xl1-protocol-sdk'
+import {
+  creatableProvider, type MempoolViewer, MempoolViewerMoniker,
+} from '@xyo-network/xl1-protocol-sdk'
 
 import { JsonRpcMempoolViewerMethods } from './JsonRpcMempoolViewerMethods.ts'
 
+@creatableProvider()
 export class JsonRpcMempoolViewer extends JsonRpcMempoolViewerMethods implements MempoolViewer {
   static readonly defaultMoniker = MempoolViewerMoniker
+  static readonly dependencies = []
   static readonly monikers = [MempoolViewerMoniker]
-  moniker = JsonRpcMempoolViewer.defaultMoniker
 }

package/src/provider/viewer/JsonRpcMempoolViewer/JsonRpcMempoolViewerMethods.ts

@@ -1,12 +1,14 @@
 import type { SignedHydratedBlockWithHashMeta, SignedHydratedTransactionWithHashMeta } from '@xyo-network/xl1-protocol'
-import type {
-  MempoolViewerMethods, PendingBlocksOptions, PendingTransactionsOptions,
+import {
+  type MempoolViewerMethods, MempoolViewerMoniker,
+  type PendingBlocksOptions, type PendingTransactionsOptions,
 } from '@xyo-network/xl1-protocol-sdk'
 
 import { MempoolViewerRpcSchemas } from '../../../types/index.ts'
 import { AbstractJsonRpcViewer } from '../JsonRpcViewer.ts'
 
 export class JsonRpcMempoolViewerMethods extends AbstractJsonRpcViewer<MempoolViewerRpcSchemas> implements MempoolViewerMethods {
+  readonly moniker = MempoolViewerMoniker
   async pendingBlocks(options?: PendingBlocksOptions): Promise<SignedHydratedBlockWithHashMeta[]> {
     const result = await this.transport.sendRequest(
       'mempoolViewer_pendingBlocks',

package/src/provider/viewer/{JsonRpcNetworkStakingStepRewardsByPositionViewer/JsonRpcNetworkStakingStepRewardsByPositionViewer.ts → JsonRpcNetworkStakeStepRewardsByPositionViewer/JsonRpcNetworkStakeStepRewardsByPositionViewer.ts}

@@ -1,10 +1,9 @@
 import { type NetworkStakeStepRewardsByPositionViewer, NetworkStakeStepRewardsByPositionViewerMoniker } from '@xyo-network/xl1-protocol-sdk'
 
-import { JsonRpcNetworkStakingStepRewardsByPositionViewerMethods } from './JsonRpcNetworkStakingStepRewardsByPositionViewerMethods.ts'
+import { JsonRpcNetworkStakeStepRewardsByPositionViewerMethods } from './JsonRpcNetworkStakeStepRewardsByPositionViewerMethods.ts'
 
-export class JsonRpcNetworkStakingStepRewardsByPositionViewer extends JsonRpcNetworkStakingStepRewardsByPositionViewerMethods
+export class JsonRpcNetworkStakeStepRewardsByPositionViewer extends JsonRpcNetworkStakeStepRewardsByPositionViewerMethods
   implements NetworkStakeStepRewardsByPositionViewer {
   static readonly defaultMoniker = NetworkStakeStepRewardsByPositionViewerMoniker
   static readonly monikers = [NetworkStakeStepRewardsByPositionViewerMoniker] as const
-  moniker = JsonRpcNetworkStakingStepRewardsByPositionViewer.defaultMoniker
 }

package/src/provider/viewer/{JsonRpcNetworkStakingStepRewardsByPositionViewer/JsonRpcNetworkStakingStepRewardsByPositionViewerMethods.ts → JsonRpcNetworkStakeStepRewardsByPositionViewer/JsonRpcNetworkStakeStepRewardsByPositionViewerMethods.ts}

@@ -1,10 +1,14 @@
 import type { AttoXL1 } from '@xyo-network/xl1-protocol'
-import type { NetworkStakeStepRewardsByPositionViewerMethods, NetworkStakeStepRewardsByPositionViewerOptions } from '@xyo-network/xl1-protocol-sdk'
+import {
+  type NetworkStakeStepRewardsByPositionViewerMethods, NetworkStakeStepRewardsByPositionViewerMoniker, type NetworkStakeStepRewardsByPositionViewerOptions,
+} from '@xyo-network/xl1-protocol-sdk'
 
 import { NetworkStakingStepRewardsByPositionViewerRpcSchemas } from '../../../types/index.ts'
 import { AbstractJsonRpcViewer } from '../JsonRpcViewer.ts'
-export class JsonRpcNetworkStakingStepRewardsByPositionViewerMethods extends
+
+export class JsonRpcNetworkStakeStepRewardsByPositionViewerMethods extends
   AbstractJsonRpcViewer<NetworkStakingStepRewardsByPositionViewerRpcSchemas> implements NetworkStakeStepRewardsByPositionViewerMethods {
+  readonly moniker = NetworkStakeStepRewardsByPositionViewerMoniker
   async bonus(options?: NetworkStakeStepRewardsByPositionViewerOptions | undefined): Promise<Record<number, AttoXL1>> {
     return (await this.transport.sendRequest('networkStakingStepRewardsByPositionViewer_bonus', [options]))
   }

package/src/provider/viewer/JsonRpcNetworkStakeStepRewardsByPositionViewer/index.ts

@@ -0,0 +1,2 @@
+export * from './JsonRpcNetworkStakeStepRewardsByPositionViewer.ts'
+export * from './JsonRpcNetworkStakeStepRewardsByPositionViewerMethods.ts'

package/src/provider/viewer/JsonRpcNetworkStakeStepRewardsByStakerViewer/JsonRpcNetworkStakeStepRewardsByStakerViewer.ts

@@ -0,0 +1,9 @@
+import { type NetworkStakeStepRewardsByStakerViewer, NetworkStakeStepRewardsByStakerViewerMoniker } from '@xyo-network/xl1-protocol-sdk'
+
+import { JsonRpcNetworkStakeStepRewardsByStakerViewerMethods } from './JsonRpcNetworkStakeStepRewardsByStakerViewerMethods.ts'
+
+export class JsonRpcNetworkStakeStepRewardsByStakerViewer extends
+  JsonRpcNetworkStakeStepRewardsByStakerViewerMethods implements NetworkStakeStepRewardsByStakerViewer {
+  static readonly defaultMoniker = NetworkStakeStepRewardsByStakerViewerMoniker
+  static readonly monikers = [NetworkStakeStepRewardsByStakerViewerMoniker] as const
+}

package/src/provider/viewer/{JsonRpcNetworkStakingStepRewardsByStakerViewer/JsonRpcNetworkStakingStepRewardsByStakerViewerMethods.ts → JsonRpcNetworkStakeStepRewardsByStakerViewer/JsonRpcNetworkStakeStepRewardsByStakerViewerMethods.ts}

@@ -1,10 +1,15 @@
 import type { AttoXL1 } from '@xyo-network/xl1-protocol'
-import type { NetworkStakeStepRewardsByPositionViewerMethods, NetworkStakeStepRewardsByPositionViewerOptions } from '@xyo-network/xl1-protocol-sdk'
+import {
+  type NetworkStakeStepRewardsByPositionViewerMethods, type NetworkStakeStepRewardsByPositionViewerOptions, NetworkStakeStepRewardsByStakerViewerMoniker,
+} from '@xyo-network/xl1-protocol-sdk'
 
 import { NetworkStakingStepRewardsByStakerViewerRpcSchemas } from '../../../types/index.ts'
 import { AbstractJsonRpcViewer } from '../JsonRpcViewer.ts'
-export class JsonRpcNetworkStakingStepRewardsByStakerViewerMethods extends
+
+export class JsonRpcNetworkStakeStepRewardsByStakerViewerMethods extends
   AbstractJsonRpcViewer<NetworkStakingStepRewardsByStakerViewerRpcSchemas> implements NetworkStakeStepRewardsByPositionViewerMethods {
+  moniker = NetworkStakeStepRewardsByStakerViewerMoniker
+
   async bonus(options?: NetworkStakeStepRewardsByPositionViewerOptions | undefined): Promise<Record<number, AttoXL1>> {
     return (await this.transport.sendRequest('networkStakingStepRewardsByStakerViewer_bonus', [options]))
   }

package/src/provider/viewer/JsonRpcNetworkStakeStepRewardsByStakerViewer/index.ts

@@ -0,0 +1,2 @@
+export * from './JsonRpcNetworkStakeStepRewardsByStakerViewer.ts'
+export * from './JsonRpcNetworkStakeStepRewardsByStakerViewerMethods.ts'

package/src/provider/viewer/JsonRpcNetworkStakeStepRewardsByStepViewer/JsonRpcNetworkStakeStepRewardsByStepViewer.ts

@@ -0,0 +1,9 @@
+import { type NetworkStakeStepRewardsByStepViewer, NetworkStakeStepRewardsByStepViewerMoniker } from '@xyo-network/xl1-protocol-sdk'
+
+import { JsonRpcNetworkStakeStepRewardsByStepViewerMethods } from './JsonRpcNetworkStakeStepRewardsByStepViewerMethods.ts'
+
+export class JsonRpcNetworkStakeStepRewardsByStepViewer extends
+  JsonRpcNetworkStakeStepRewardsByStepViewerMethods implements NetworkStakeStepRewardsByStepViewer {
+  static readonly defaultMoniker = NetworkStakeStepRewardsByStepViewerMoniker
+  static readonly monikers = [NetworkStakeStepRewardsByStepViewerMoniker] as const
+}

package/src/provider/viewer/{JsonRpcNetworkStakingStepRewardsByStepViewer/JsonRpcNetworkStakingStepRewardsByStepViewerMethods.ts → JsonRpcNetworkStakeStepRewardsByStepViewer/JsonRpcNetworkStakeStepRewardsByStepViewerMethods.ts}

@@ -1,10 +1,15 @@
 import type { AttoXL1 } from '@xyo-network/xl1-protocol'
-import type { NetworkStakeStepRewardsByStepViewerMethods, NetworkStakeStepRewardsByStepViewerOptions } from '@xyo-network/xl1-protocol-sdk'
+import {
+  type NetworkStakeStepRewardsByStepViewerMethods, NetworkStakeStepRewardsByStepViewerMoniker, type NetworkStakeStepRewardsByStepViewerOptions,
+} from '@xyo-network/xl1-protocol-sdk'
 
 import { NetworkStakingStepRewardsByStepViewerRpcSchemas } from '../../../types/index.ts'
 import { AbstractJsonRpcViewer } from '../JsonRpcViewer.ts'
-export class JsonRpcNetworkStakingStepRewardsByStepViewerMethods extends
+
+export class JsonRpcNetworkStakeStepRewardsByStepViewerMethods extends
   AbstractJsonRpcViewer<NetworkStakingStepRewardsByStepViewerRpcSchemas> implements NetworkStakeStepRewardsByStepViewerMethods {
+  readonly moniker = NetworkStakeStepRewardsByStepViewerMoniker
+
   async bonus(options?: NetworkStakeStepRewardsByStepViewerOptions | undefined): Promise<Record<number, AttoXL1>> {
     return (await this.transport.sendRequest('networkStakingStepRewardsByStepViewer_bonus', [options]))
   }

package/src/provider/viewer/JsonRpcNetworkStakeStepRewardsByStepViewer/index.ts

@@ -0,0 +1,2 @@
+export * from './JsonRpcNetworkStakeStepRewardsByStepViewer.ts'
+export * from './JsonRpcNetworkStakeStepRewardsByStepViewerMethods.ts'

package/src/provider/viewer/JsonRpcNetworkStakeStepRewardsTotalViewer/JsonRpcNetworkStakeStepRewardsTotalViewer.ts

@@ -0,0 +1,9 @@
+import { type NetworkStakeStepRewardsTotalViewer, NetworkStakeStepRewardsTotalViewerMoniker } from '@xyo-network/xl1-protocol-sdk'
+
+import { JsonRpcNetworkStakeStepRewardsTotalViewerMethods } from './JsonRpcNetworkStakeStepRewardsTotalViewerMethods.ts'
+
+export class JsonRpcNetworkStakeStepRewardsTotalViewer extends
+  JsonRpcNetworkStakeStepRewardsTotalViewerMethods implements NetworkStakeStepRewardsTotalViewer {
+  static readonly defaultMoniker = NetworkStakeStepRewardsTotalViewerMoniker
+  static readonly monikers = [NetworkStakeStepRewardsTotalViewerMoniker] as const
+}

package/src/provider/viewer/{JsonRpcNetworkStakingStepRewardsTotalViewer/JsonRpcNetworkStakingStepRewardsTotalViewerMethods.ts → JsonRpcNetworkStakeStepRewardsTotalViewer/JsonRpcNetworkStakeStepRewardsTotalViewerMethods.ts}

@@ -1,10 +1,14 @@
 import type { AttoXL1 } from '@xyo-network/xl1-protocol'
-import type { NetworkStakeStepRewardsRangeOptions, NetworkStakeStepRewardsTotalViewerMethods } from '@xyo-network/xl1-protocol-sdk'
+import {
+  type NetworkStakeStepRewardsRangeOptions, type NetworkStakeStepRewardsTotalViewerMethods, NetworkStakeStepRewardsTotalViewerMoniker,
+} from '@xyo-network/xl1-protocol-sdk'
 
 import { NetworkStakingStepRewardsTotalViewerRpcSchemas } from '../../../types/index.ts'
 import { AbstractJsonRpcViewer } from '../JsonRpcViewer.ts'
-export class JsonRpcNetworkStakingStepRewardsTotalViewerMethods extends
+
+export class JsonRpcNetworkStakeStepRewardsTotalViewerMethods extends
   AbstractJsonRpcViewer<NetworkStakingStepRewardsTotalViewerRpcSchemas> implements NetworkStakeStepRewardsTotalViewerMethods {
+  moniker = NetworkStakeStepRewardsTotalViewerMoniker
   async bonus(options?: NetworkStakeStepRewardsRangeOptions | undefined): Promise<AttoXL1> {
     return (await this.transport.sendRequest('networkStakingStepRewardsTotalViewer_bonus', [options]))
   }

package/src/provider/viewer/JsonRpcNetworkStakeStepRewardsTotalViewer/index.ts

@@ -0,0 +1,2 @@
+export * from './JsonRpcNetworkStakeStepRewardsTotalViewer.ts'
+export * from './JsonRpcNetworkStakeStepRewardsTotalViewerMethods.ts'

package/src/provider/viewer/{JsonRpcNetworkStakingStepRewardsViewer/JsonRpcNetworkStakingStepRewardsViewer.ts → JsonRpcNetworkStakeStepRewardsViewer/JsonRpcNetworkStakeStepRewardsViewer.ts}

@@ -1,24 +1,25 @@
 import {
+  creatableProvider,
   type NetworkStakeStepRewardsByPositionViewer, type NetworkStakeStepRewardsByStakerViewer, type NetworkStakeStepRewardsByStepViewer,
   type NetworkStakeStepRewardsTotalViewer, type NetworkStakeStepRewardsViewer,
   NetworkStakeStepRewardsViewerMoniker,
 } from '@xyo-network/xl1-protocol-sdk'
 
-import type { JsonRpcNetworkStakingStepRewardsViewerMethodsParams } from './JsonRpcNetworkStakingStepRewardsViewerMethods.ts'
-import { JsonRpcNetworkStakingStepRewardsViewerMethods } from './JsonRpcNetworkStakingStepRewardsViewerMethods.ts'
+import type { JsonRpcNetworkStakingStepRewardsViewerMethodsParams } from './JsonRpcNetworkStakeStepRewardsViewerMethods.ts'
+import { JsonRpcNetworkStakeStepRewardsViewerMethods } from './JsonRpcNetworkStakeStepRewardsViewerMethods.ts'
 
-export interface JsonRpcNetworkStakingStepRewardsViewerParams extends JsonRpcNetworkStakingStepRewardsViewerMethodsParams {
+export interface JsonRpcNetworkStakeStepRewardsViewerParams extends JsonRpcNetworkStakingStepRewardsViewerMethodsParams {
   position?: NetworkStakeStepRewardsByPositionViewer
   staker?: NetworkStakeStepRewardsByStakerViewer
   step?: NetworkStakeStepRewardsByStepViewer
   total?: NetworkStakeStepRewardsTotalViewer
 }
-
+@creatableProvider()
 export class JsonRpcNetworkStakingStepRewardsViewer extends
-  JsonRpcNetworkStakingStepRewardsViewerMethods<JsonRpcNetworkStakingStepRewardsViewerParams> implements NetworkStakeStepRewardsViewer {
+  JsonRpcNetworkStakeStepRewardsViewerMethods<JsonRpcNetworkStakeStepRewardsViewerParams> implements NetworkStakeStepRewardsViewer {
   static readonly defaultMoniker = NetworkStakeStepRewardsViewerMoniker
+  static readonly dependencies = []
   static readonly monikers = [NetworkStakeStepRewardsViewerMoniker]
-  moniker = JsonRpcNetworkStakingStepRewardsViewer.defaultMoniker
 
   get position(): NetworkStakeStepRewardsByPositionViewer | undefined {
     return this.params.position

package/src/provider/viewer/{JsonRpcNetworkStakingStepRewardsViewer/JsonRpcNetworkStakingStepRewardsViewerMethods.ts → JsonRpcNetworkStakeStepRewardsViewer/JsonRpcNetworkStakeStepRewardsViewerMethods.ts}

@@ -1,4 +1,4 @@
-import { type NetworkStakeStepRewardsViewerMethods } from '@xyo-network/xl1-protocol-sdk'
+import { type NetworkStakeStepRewardsViewerMethods, NetworkStakeStepRewardsViewerMoniker } from '@xyo-network/xl1-protocol-sdk'
 
 import { NetworkStakingStepRewardsViewerRpcSchemas } from '../../../types/index.ts'
 import type { JsonRpcViewerParams } from '../JsonRpcViewer.ts'
@@ -6,9 +6,10 @@ import { AbstractJsonRpcViewer } from '../JsonRpcViewer.ts'
 
 export interface JsonRpcNetworkStakingStepRewardsViewerMethodsParams extends JsonRpcViewerParams<NetworkStakingStepRewardsViewerRpcSchemas> {}
 
-export class JsonRpcNetworkStakingStepRewardsViewerMethods<TParams extends
+export class JsonRpcNetworkStakeStepRewardsViewerMethods<TParams extends
 JsonRpcNetworkStakingStepRewardsViewerMethodsParams = JsonRpcNetworkStakingStepRewardsViewerMethodsParams> extends
   AbstractJsonRpcViewer<NetworkStakingStepRewardsViewerRpcSchemas, TParams> implements NetworkStakeStepRewardsViewerMethods {
+  readonly moniker = NetworkStakeStepRewardsViewerMoniker
   protected schemas() {
     return NetworkStakingStepRewardsViewerRpcSchemas
   }

package/src/provider/viewer/JsonRpcNetworkStakeStepRewardsViewer/index.ts

@@ -0,0 +1,2 @@
+export * from './JsonRpcNetworkStakeStepRewardsViewer.ts'
+export * from './JsonRpcNetworkStakeStepRewardsViewerMethods.ts'

package/src/provider/viewer/JsonRpcNetworkStakeViewer/JsonRpcNetworkStakeViewer.ts

@@ -1,14 +1,16 @@
 import {
-  type NetworkStakeStepRewardsViewer, type NetworkStakeViewer, NetworkStakeViewerMoniker,
+  creatableProvider,
+  type NetworkStakeStepRewardsViewer, NetworkStakeStepRewardsViewerMoniker, type NetworkStakeViewer, NetworkStakeViewerMoniker,
 } from '@xyo-network/xl1-protocol-sdk'
 
-import { JsonRpcNetworkStakingStepRewardsViewer } from '../JsonRpcNetworkStakingStepRewardsViewer/index.ts'
+import type { JsonRpcNetworkStakingStepRewardsViewer } from '../JsonRpcNetworkStakeStepRewardsViewer/index.ts'
 import { JsonRpcNetworkStakeViewerMethods } from './JsonRpcNetworkStakeViewerMethods.ts'
 
+@creatableProvider()
 export class JsonRpcNetworkStakeViewer extends JsonRpcNetworkStakeViewerMethods implements NetworkStakeViewer {
   static readonly defaultMoniker = NetworkStakeViewerMoniker
+  static readonly dependencies = []
   static readonly monikers = [NetworkStakeViewerMoniker]
-  moniker = JsonRpcNetworkStakeViewer.defaultMoniker
 
   protected _stepRewards?: NetworkStakeStepRewardsViewer
 
@@ -18,6 +20,6 @@ export class JsonRpcNetworkStakeViewer extends JsonRpcNetworkStakeViewerMethods
 
   override async createHandler() {
     await super.createHandler()
-    this._stepRewards = await JsonRpcNetworkStakingStepRewardsViewer.create({ transport: this.transport })
+    this._stepRewards = await this.locator.getInstance<JsonRpcNetworkStakingStepRewardsViewer>(NetworkStakeStepRewardsViewerMoniker)
   }
 }

package/src/provider/viewer/JsonRpcNetworkStakeViewer/JsonRpcNetworkStakeViewerMethods.ts

@@ -1,8 +1,10 @@
-import type { NetworkStakeViewerMethods } from '@xyo-network/xl1-protocol-sdk'
+import { type NetworkStakeViewerMethods, NetworkStakeViewerMoniker } from '@xyo-network/xl1-protocol-sdk'
 
 import { NetworkStakeViewerRpcSchemas } from '../../../types/index.ts'
 import { AbstractJsonRpcViewer } from '../JsonRpcViewer.ts'
+
 export class JsonRpcNetworkStakeViewerMethods extends AbstractJsonRpcViewer<NetworkStakeViewerRpcSchemas> implements NetworkStakeViewerMethods {
+  readonly moniker = NetworkStakeViewerMoniker
   async active(blockNumber?: number): Promise<[bigint, number]> {
     return (await this.transport.sendRequest('networkStakeViewer_active', [blockNumber]))
   }

package/src/provider/viewer/JsonRpcStakeTotalsViewer/JsonRpcStakeTotalsViewer.ts

@@ -1,9 +1,12 @@
-import { type StakeTotalsViewer, StakeTotalsViewerMoniker } from '@xyo-network/xl1-protocol-sdk'
+import {
+  creatableProvider, type StakeTotalsViewer, StakeTotalsViewerMoniker,
+} from '@xyo-network/xl1-protocol-sdk'
 
 import { JsonRpcStakeTotalsViewerMethods } from './JsonRpcStakeTotalsViewerMethods.ts'
 
+@creatableProvider()
 export class JsonRpcStakeTotalsViewer extends JsonRpcStakeTotalsViewerMethods implements StakeTotalsViewer {
   static readonly defaultMoniker = StakeTotalsViewerMoniker
+  static readonly dependencies = []
   static readonly monikers = [StakeTotalsViewerMoniker]
-  moniker = JsonRpcStakeTotalsViewer.defaultMoniker
 }

package/src/provider/viewer/JsonRpcStakeTotalsViewer/JsonRpcStakeTotalsViewerMethods.ts

@@ -1,10 +1,12 @@
 import type { Address } from '@xylabs/sdk-js'
-import type { StakeTotalsViewerMethods } from '@xyo-network/xl1-protocol-sdk'
+import { type StakeTotalsViewerMethods, StakeTotalsViewerMoniker } from '@xyo-network/xl1-protocol-sdk'
 
 import { StakeTotalsViewerRpcSchemas } from '../../../types/index.ts'
 import { AbstractJsonRpcViewer } from '../JsonRpcViewer.ts'
 
 export class JsonRpcStakeTotalsViewerMethods extends AbstractJsonRpcViewer<StakeTotalsViewerRpcSchemas> implements StakeTotalsViewerMethods {
+  readonly moniker = StakeTotalsViewerMoniker
+
   async active(): Promise<bigint> {
     return await this.transport.sendRequest('stakeTotalsViewer_active', [])
   }