@xyo-network/xl1-rpc 1.15.26 → 1.15.28

package/src/index-node.ts

@@ -1,5 +1,5 @@
-// eslint-disable-next-line import-x/no-internal-modules
-export * from './engine/index-node.ts'
+export * from './engine/index.ts'
+export * from './engine-node/index.ts'
 export * from './provider/index.ts'
 export * from './transport/index.ts'
 export * from './types/index.ts'

package/src/provider/client/spec/MemoryXyoClient.spec.ts

@@ -35,7 +35,6 @@ describe('Client', () => {
     permissions = new MemoryXyoPermissions(store)
     connection = new HttpRpcXyoConnection({
       endpoint,
-      account,
       // storage: dataLakeEndpoint,
     })
     gateway = new MemoryXyoGateway(signer, connection)

package/src/provider/connection/HttpRpcXyoConnection.ts

@@ -1,39 +1,33 @@
-import { isDefined, isString } from '@xylabs/typeof'
-import type { AccountInstance } from '@xyo-network/account-model'
+import { isString } from '@xylabs/typeof'
 import type { XyoDataLake } from '@xyo-network/xl1-protocol'
 import { isDataLakeProvider } from '@xyo-network/xl1-protocol'
 
 import { HttpRpcTransport } from '../../transport/index.ts'
-import { XyoRunnerRpcSchemas, XyoViewerRpcSchemas } from '../../types/index.ts'
+import {
+  NetworkStakeViewerRpcSchemas, XyoRunnerRpcSchemas, XyoViewerRpcSchemas,
+} from '../../types/index.ts'
 import { HttpXyoDataLake } from '../datalake/index.ts'
 import { JsonRpcXyoRunner } from '../runner/index.ts'
-import { MemoryXyoSigner } from '../signer/index.ts'
-import { JsonRpcXyoViewer } from '../viewer/index.ts'
+import { JsonRpcNetworkStakeViewer, JsonRpcXyoViewer } from '../viewer/index.ts'
 import { XyoBaseConnection } from './XyoBaseConnection.ts'
 
 export interface RpcXyoProviderParams {
-  account?: AccountInstance
   endpoint: string
   storage?: string | XyoDataLake
 }
 
 export class HttpRpcXyoConnection extends XyoBaseConnection {
   constructor(params: RpcXyoProviderParams) {
-    const {
-      account, endpoint, storage: storageParam,
-    } = params
-    const signer = isDefined(account) ? new MemoryXyoSigner(account) : undefined
-    const transport = new HttpRpcTransport(endpoint, { ...XyoRunnerRpcSchemas, ...XyoViewerRpcSchemas })
+    const { endpoint, storage: storageParam } = params
+    const transport = new HttpRpcTransport(endpoint, {
+      ...XyoRunnerRpcSchemas, ...XyoViewerRpcSchemas, ...NetworkStakeViewerRpcSchemas,
+    })
     const runner = new JsonRpcXyoRunner(transport)
-    const viewer = new JsonRpcXyoViewer(transport)
+    const networkStakeViewer = new JsonRpcNetworkStakeViewer(transport)
+    const viewer = new JsonRpcXyoViewer(transport, networkStakeViewer)
     const storage = isDataLakeProvider(storageParam) ? storageParam : isString(storageParam) ? new HttpXyoDataLake(storageParam) : undefined
     super({
-      signer, runner, viewer, storage,
+      runner, viewer, storage,
     })
   }
 }
-
-/**
- * @deprecated Use `HttpRpcXyoConnection` instead.
- */
-export class RpcXyoConnection extends HttpRpcXyoConnection {}

package/src/provider/connection/XyoBaseConnection.ts

@@ -1,34 +1,21 @@
-import { assertEx } from '@xylabs/assert'
-import type { Address, Hex } from '@xylabs/hex'
-import type { Signed } from '@xyo-network/boundwitness-model'
-import { PayloadBuilder } from '@xyo-network/payload-builder'
-import { isAnyPayload, type Payload } from '@xyo-network/payload-model'
 import type {
-  AllowedBlockPayload,
-  SignedHydratedTransactionWithStorageMeta,
-  TransactionBoundWitness, TransactionFeesBigInt,
-  TransactionOptions, XyoConnection, XyoDataLake, XyoDataLakeViewer, XyoNetwork, XyoRunner, XyoSigner, XyoViewer,
+  XyoConnection, XyoDataLake, XyoDataLakeViewer, XyoNetwork, XyoRunner, XyoViewer,
 } from '@xyo-network/xl1-protocol'
-import { defaultTransactionFees, isDataLakeProvider } from '@xyo-network/xl1-protocol'
-import { HydratedTransactionWrapper } from '@xyo-network/xl1-wrappers'
 
 export class XyoBaseConnection implements XyoConnection {
   private readonly _network?: XyoNetwork
   private readonly _runner?: XyoRunner
-  private readonly _signer?: XyoSigner
   private readonly _storage?: XyoDataLake | XyoDataLakeViewer
   private readonly _viewer?: XyoViewer
 
   constructor(params?: {
     network?: XyoNetwork
     runner?: XyoRunner
-    signer?: XyoSigner
     storage?: XyoDataLake | XyoDataLakeViewer
     viewer?: XyoViewer
   }) {
     this._network = params?.network
     this._runner = params?.runner
-    this._signer = params?.signer
     this._storage = params?.storage
     this._viewer = params?.viewer
   }
@@ -41,11 +28,6 @@ export class XyoBaseConnection implements XyoConnection {
     return this._runner
   }
 
-  /** @deprecated use signer from gateway instead */
-  get signer(): XyoSigner | undefined {
-    return this._signer
-  }
-
   get storage(): XyoDataLake | XyoDataLakeViewer | undefined {
     return this._storage
   }
@@ -53,64 +35,4 @@ export class XyoBaseConnection implements XyoConnection {
   get viewer(): XyoViewer | undefined {
     return this._viewer
   }
-
-  /** @deprecated use submitTransaction instead */
-  async send(
-    elevatedPayloads: AllowedBlockPayload[],
-    additionalPayloads: Payload[],
-    chain?: Hex,
-    nbf?: number,
-    exp?: number,
-    from?: Address,
-    fees?: TransactionFeesBigInt,
-  ): Promise<Signed<TransactionBoundWitness>> {
-    // eslint-disable-next-line sonarjs/deprecation
-    return (await this.submitTransaction(elevatedPayloads, additionalPayloads, {
-      chain, nbf, exp, from, fees,
-    }))[0]
-  }
-
-  /** @deprecated use addPayloadsToChain from gateway instead */
-  async submitTransaction(
-    elevatedPayloads: AllowedBlockPayload[],
-    additionalPayloads: Payload[],
-    {
-      chain, exp, fees, from, nbf,
-    }: TransactionOptions = {},
-  ): Promise<SignedHydratedTransactionWithStorageMeta> {
-    const viewer = assertEx(this.viewer, () => 'No viewer available')
-    // eslint-disable-next-line sonarjs/deprecation
-    const signer = assertEx(this.signer, () => 'No signer available')
-    const runner = assertEx(this.runner, () => 'No runner available')
-    const storage = this.storage
-    const chainResolved = chain ?? await viewer.chainId()
-    if (chainResolved === undefined) throw new Error('Failed to determine chain')
-    const nbfResolved = Math.max(await viewer.currentBlockNumber() ?? 0, nbf ?? 0)
-    const expResolved = exp ?? (nbfResolved + 1000)
-    const feesResolved = fees ?? defaultTransactionFees
-    const fromResolved = from ?? await signer.address()
-    if (fromResolved === undefined) throw new Error('Failed to determine from address')
-    // eslint-disable-next-line sonarjs/deprecation
-    const signedTransaction = assertEx(await signer.createSignedTransaction(
-      chainResolved,
-      elevatedPayloads,
-      additionalPayloads,
-      nbfResolved,
-      expResolved,
-      feesResolved,
-      fromResolved,
-    ), () => 'Failed to create transaction')
-    const hydratedTransaction: SignedHydratedTransactionWithStorageMeta = [await PayloadBuilder.addStorageMeta(signedTransaction),
-      await PayloadBuilder.addStorageMeta(elevatedPayloads)]
-
-    // if storage configured, add the external payloads to it
-    if (isDataLakeProvider(storage)) {
-      const wrapper = await HydratedTransactionWrapper.parse(hydratedTransaction)
-      await storage.add(Object.values(wrapper.externalPayloads).filter(isAnyPayload))
-    }
-
-    assertEx(await runner.broadcastTransaction(hydratedTransaction), () => 'Failed to broadcast transaction')
-
-    return hydratedTransaction
-  }
 }

package/src/provider/connection/spec/XyoConnection.spec.ts

@@ -0,0 +1,30 @@
+import type { XyoConnection } from '@xyo-network/xl1-protocol'
+import {
+  beforeAll, describe, expect, it,
+} from 'vitest'
+
+import { rpcEngineFromConnection } from '../../../engine-node/index.ts'
+import { MemoryRpcTransport } from '../../../transport/index.ts'
+import { AllRpcSchemas } from '../../../types/index.ts'
+import { MemoryXyoRunner } from '../../runner/index.ts'
+import { JsonRpcNetworkStakeViewer, JsonRpcXyoViewer } from '../../viewer/index.ts'
+import { XyoBaseConnection } from '../XyoBaseConnection.ts'
+
+describe('RpcEngine - XyoProvider', () => {
+  let sut: XyoConnection
+  beforeAll(() => {
+    const runner = new MemoryXyoRunner()
+    const connection = new XyoBaseConnection({ runner })
+    const engine = rpcEngineFromConnection(connection)
+    const transport = new MemoryRpcTransport(engine, AllRpcSchemas)
+    const networkStakeViewer = new JsonRpcNetworkStakeViewer(transport)
+    const viewer = new JsonRpcXyoViewer(transport, networkStakeViewer)
+    sut = new XyoBaseConnection({ runner, viewer })
+  })
+  it('should expose a runner', () => {
+    expect(sut.runner).toBeDefined()
+  })
+  it('should expose a viewer', () => {
+    expect(sut.viewer).toBeDefined()
+  })
+})

package/src/provider/gateway/Abstract.ts

@@ -31,10 +31,7 @@ export abstract class AbstractXyoGateway implements XyoGatewayProvider {
     const tx = await buildUnsignedTransaction(resolvedChainId, onChain, offChain, resolvedNbf, resolvedExp, await signer.address(), fees)
     const runner = assertEx(connection.runner, () => 'No runner available on connection')
     const signedTx = await signer.signTransaction(tx)
-    const hash = await runner.broadcastTransaction(
-      [await PayloadBuilder.addStorageMeta(signedTx[0]),
-        await PayloadBuilder.addStorageMeta(signedTx[1])],
-    )
+    const hash = await runner.broadcastTransaction(signedTx)
     return [hash, signedTx]
   }
 
@@ -49,16 +46,6 @@ export abstract class AbstractXyoGateway implements XyoGatewayProvider {
     )
   }
 
-  /** @deprecated use addPayloadsToChain instead */
-  async submitTransaction(elevatedPayloads: AllowedBlockPayload[], additionalPayloads: Payload[]): Promise<SignedHydratedTransaction> {
-    const connection = await this.connection()
-    // eslint-disable-next-line sonarjs/deprecation
-    assertEx(connection.submitTransaction, () => 'Active connection does not support transaction submission')
-    // eslint-disable-next-line sonarjs/deprecation
-    const tx = await connection.submitTransaction?.(elevatedPayloads, additionalPayloads)
-    return assertEx(tx, () => 'Transaction submission failed')
-  }
-
   abstract connection(): Promisable<XyoConnection>
   abstract signer(): Promisable<XyoSigner>
 }

package/src/provider/gateway/spec/MemoryXyoGateway.spec.ts

@@ -1,11 +1,10 @@
-import { isAddress, isHash } from '@xylabs/hex'
+import type { Hash } from '@xylabs/hex'
+import { isHash } from '@xylabs/hex'
 import { Account } from '@xyo-network/account'
 import type { AccountInstance } from '@xyo-network/account-model'
 import { PayloadBuilder } from '@xyo-network/payload-builder'
-import type { Payload } from '@xyo-network/payload-model'
-import type {
-  AllowedBlockPayload, ChainId, SignedHydratedTransaction,
-} from '@xyo-network/xl1-protocol'
+import type { AnyPayload, Payload } from '@xyo-network/payload-model'
+import type { AllowedBlockPayload, SignedHydratedTransaction } from '@xyo-network/xl1-protocol'
 import { buildUnsignedTransaction } from '@xyo-network/xl1-protocol-sdk'
 import {
   beforeEach, describe, expect, it,
@@ -30,7 +29,6 @@ describe('MemoryXyoGateway', () => {
 
     connection = new HttpRpcXyoConnection({
       endpoint,
-      account,
       // storage: dataLakeEndpoint,
     })
     sut = new MemoryXyoGateway(signer, connection)
@@ -69,8 +67,13 @@ describe('MemoryXyoGateway', () => {
       })
       const chainId = (await Account.random()).address
       const mockSigner = vi.spyOn(signer, 'signTransaction')
-      const elevatedPayloads: AllowedBlockPayload[] = []
-      const additionalPayloads: Payload[] = []
+      const elevatedPayloads: AllowedBlockPayload[] = [
+        { schema: 'network.xyo.hash', hash: '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef' as Hash },
+      ]
+      const additionalPayloads: AnyPayload[] = [{
+        schema: 'network.xyo.data',
+        data: 'foo',
+      }]
       const result = await sut.addPayloadsToChain(elevatedPayloads, additionalPayloads, {
         nbf: 0,
         exp: 1000,
@@ -82,6 +85,7 @@ describe('MemoryXyoGateway', () => {
       expect(mockSigner).toHaveBeenCalled()
 
       // Verify result
+      expect(result[0]).toEqual(await PayloadBuilder.hash(result[1][0]))
       expect(result).toBeDefined()
       expect(result.length).toBe(2)
       expect(isHash(result[0])).toBe(true)

package/src/provider/signer/JsonRpcXyoSigner.ts

@@ -1,12 +1,6 @@
 import type { Address } from '@xylabs/hex'
-import type { Signed } from '@xyo-network/boundwitness-model'
-import type { Payload } from '@xyo-network/payload-model'
 import type {
-  AllowedBlockPayload,
-  ChainId,
   SignedHydratedTransaction,
-  TransactionBoundWitness,
-  TransactionFeesBigInt,
   UnsignedHydratedTransaction,
   XyoSigner,
 } from '@xyo-network/xl1-protocol'
@@ -25,35 +19,8 @@ export class RpcXyoSigner implements XyoSigner {
     return await this.transport.sendRequest('xyoSigner_address')
   }
 
-  /** @deprecated - use signTransaction instead */
-  async createSignedTransaction(
-    chain: ChainId,
-    elevatedPayloads: AllowedBlockPayload[],
-    additionalPayloads: Payload[],
-    nbf: number,
-    exp: number,
-    fees: TransactionFeesBigInt,
-    from?: Address,
-  ): Promise<Signed<TransactionBoundWitness>> {
-    const ret = await this.transport.sendRequest('xyoSigner_createSignedTransaction', [
-      chain,
-      elevatedPayloads,
-      additionalPayloads,
-      nbf,
-      exp,
-      fees,
-      from,
-    ])
-    return ret
-  }
-
   async signTransaction(tx: UnsignedHydratedTransaction): Promise<SignedHydratedTransaction> {
     const ret = await this.transport.sendRequest('xyoSigner_signTransaction', [tx])
     return ret
   }
 }
-
-/**
- * @deprecated Use `RpcXyoSigner` instead.
- */
-export class JsonRpcXyoSigner extends RpcXyoSigner {}

package/src/provider/signer/spec/RpcEngineXyoSigner.spec.ts

@@ -1,16 +1,19 @@
+import { createAsyncMiddleware, JsonRpcEngine } from '@metamask/json-rpc-engine'
+import type { Json } from '@metamask/utils'
 import { asAddress, toAddress } from '@xylabs/hex'
 import { Account } from '@xyo-network/account'
 import type { ChainId, XyoSigner } from '@xyo-network/xl1-protocol'
 import { defaultTransactionFees } from '@xyo-network/xl1-protocol'
+import { buildUnsignedTransaction } from '@xyo-network/xl1-protocol-sdk'
 import {
   beforeAll, describe, expect, it,
 } from 'vitest'
 
-// eslint-disable-next-line import-x/no-internal-modules
-import { rpcEngineFromConnection } from '../../../engine/index-node.ts'
-import { XyoSignerRpcSchemas } from '../../../index-node.ts'
+import { requestSchemas, rpcMethodHandlersFromSigner } from '../../../engine/index.ts'
 import { MemoryRpcTransport } from '../../../transport/index.ts'
-import { XyoBaseConnection } from '../../connection/index.ts'
+import {
+  createRequestSchema, JsonRpcErrorCodes, XyoSignerRpcSchemas,
+} from '../../../types/index.ts'
 import { RpcXyoSigner } from '../JsonRpcXyoSigner.ts'
 import { MemoryXyoSigner } from '../MemoryXyoSigner.ts'
 
@@ -20,8 +23,50 @@ describe('RpcEngine - XyoSigner', () => {
   beforeAll(async () => {
     const account = await Account.random()
     const signer = new MemoryXyoSigner(account)
-    const connection = new XyoBaseConnection({ signer })
-    const engine = rpcEngineFromConnection(connection)
+    const handlers = rpcMethodHandlersFromSigner(signer)
+    const engine = new JsonRpcEngine()
+    engine.push(
+      createAsyncMiddleware(async (req, res) => {
+      // Get method name
+        const method = req.method as keyof typeof handlers & keyof typeof requestSchemas
+        // Get schema for method
+        const handler = handlers[method]
+        // Get handler for method
+        const schema = XyoSignerRpcSchemas[method]
+
+        // If no schema or handler exists
+        if (schema === undefined || handler === undefined) {
+        // return method not found error
+          res.error = JsonRpcErrorCodes.MethodNotFound
+          return
+        }
+
+        // Validate request according to schema
+        let requestSchema = requestSchemas[method]
+        if (requestSchema == undefined) {
+          requestSchema = createRequestSchema(method, schema.params.from)
+          requestSchemas[method] = requestSchema
+        }
+
+        const parsed = requestSchema.safeParse(req)
+        // If validation fails
+        if (!parsed.success) {
+          res.error = {
+          // Return invalid params error
+            ...JsonRpcErrorCodes.InvalidParams,
+            // with the specific validation error message
+            message: parsed.error.message,
+          }
+          return
+        }
+
+        // Call handler with validated params
+        const { params } = parsed.data
+        const result = await handler(params as never)
+        // Parse handler result according to schema
+        res.result = schema.result.to.parse(result) as Json
+      }),
+    )
     const transport = new MemoryRpcTransport(engine, XyoSignerRpcSchemas)
     sut = new RpcXyoSigner(transport)
   })
@@ -31,17 +76,11 @@ describe('RpcEngine - XyoSigner', () => {
       expect(asAddress(address)).toBeDefined()
     })
   })
-  describe('createSignedTransaction', () => {
+  describe('signTransaction', () => {
     it('should return signed transaction', async () => {
-      // eslint-disable-next-line sonarjs/deprecation
-      const signedTransaction = await sut.createSignedTransaction(
-        chain,
-        [],
-        [],
-        0,
-        1000,
-        defaultTransactionFees,
-      )
+      const address = await sut.address()
+      const unsignedTransaction = await buildUnsignedTransaction(chain, [], [], 0, 1000, address, defaultTransactionFees)
+      const signedTransaction = await sut.signTransaction(unsignedTransaction)
       expect(signedTransaction).toBeDefined()
     })
   })

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

@@ -0,0 +1,19 @@
+import type { NetworkStakeViewer, StepRewardsViewer } from '@xyo-network/xl1-protocol'
+
+import type { RpcTransport } from '../../../transport/index.ts'
+import type { NetworkStakeViewerRpcSchemas } from '../../../types/index.ts'
+import { JsonRpcNetworkStakingStepRewardsViewer } from '../JsonRpcNetworkStakingStepRewardsViewer/index.ts'
+import { JsonRpcNetworkStakeViewerMethods } from './JsonRpcNetworkStakeViewerMethods.ts'
+
+export class JsonRpcNetworkStakeViewer extends JsonRpcNetworkStakeViewerMethods implements NetworkStakeViewer {
+  protected _stepRewards: StepRewardsViewer
+
+  constructor(transport: RpcTransport<typeof NetworkStakeViewerRpcSchemas>) {
+    super(transport)
+    this._stepRewards = new JsonRpcNetworkStakingStepRewardsViewer(transport)
+  }
+
+  get stepRewards(): StepRewardsViewer {
+    return this._stepRewards
+  }
+}

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

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

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

@@ -0,0 +1,2 @@
+export * from './JsonRpcNetworkStakeViewer.ts'
+export * from './JsonRpcNetworkStakeViewerMethods.ts'

package/src/provider/viewer/JsonRpcNetworkStakingStepRewardsByPositionViewer/JsonRpcNetworkStakingStepRewardsByPositionViewer.ts

@@ -0,0 +1,6 @@
+import type { RewardsByPositionViewer } from '@xyo-network/xl1-protocol'
+
+import { JsonRpcNetworkStakingStepRewardsByPositionViewerMethods } from './JsonRpcNetworkStakingStepRewardsByPositionViewerMethods.ts'
+
+export class JsonRpcNetworkStakingStepRewardsByPositionViewer extends JsonRpcNetworkStakingStepRewardsByPositionViewerMethods
+  implements RewardsByPositionViewer {}

package/src/provider/viewer/JsonRpcNetworkStakingStepRewardsByPositionViewer/JsonRpcNetworkStakingStepRewardsByPositionViewerMethods.ts

@@ -0,0 +1,28 @@
+import type {
+  AttoXL1, RewardsByPositionViewerMethods, RewardsByPositionViewerOptions,
+} from '@xyo-network/xl1-protocol'
+
+import type { NetworkStakingStepRewardsByPositionViewerRpcSchemas } from '../../../types/index.ts'
+import { JsonRpcViewer } from '../JsonRpcViewer.ts'
+export class JsonRpcNetworkStakingStepRewardsByPositionViewerMethods extends
+  JsonRpcViewer<typeof NetworkStakingStepRewardsByPositionViewerRpcSchemas> implements RewardsByPositionViewerMethods {
+  async bonus(options?: RewardsByPositionViewerOptions | undefined): Promise<Record<number, AttoXL1>> {
+    return (await this.transport.sendRequest('networkStakingStepRewardsByPositionViewer_bonus', [options]))
+  }
+
+  async claimed(options?: RewardsByPositionViewerOptions | undefined): Promise<Record<number, AttoXL1>> {
+    return (await this.transport.sendRequest('networkStakingStepRewardsByPositionViewer_claimed', [options]))
+  }
+
+  async earned(options?: RewardsByPositionViewerOptions | undefined): Promise<Record<number, AttoXL1>> {
+    return (await this.transport.sendRequest('networkStakingStepRewardsByPositionViewer_earned', [options]))
+  }
+
+  async total(options?: RewardsByPositionViewerOptions | undefined): Promise<Record<number, AttoXL1>> {
+    return (await this.transport.sendRequest('networkStakingStepRewardsByPositionViewer_total', [options]))
+  }
+
+  async unclaimed(options?: RewardsByPositionViewerOptions | undefined): Promise<Record<number, AttoXL1>> {
+    return (await this.transport.sendRequest('networkStakingStepRewardsByPositionViewer_unclaimed', [options]))
+  }
+}

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

@@ -0,0 +1,2 @@
+export * from './JsonRpcNetworkStakingStepRewardsByPositionViewer.ts'
+export * from './JsonRpcNetworkStakingStepRewardsByPositionViewerMethods.ts'

package/src/provider/viewer/JsonRpcNetworkStakingStepRewardsByStakerViewer/JsonRpcNetworkStakingStepRewardsByStakerViewer.ts

@@ -0,0 +1,5 @@
+import type { RewardsByStakerViewer } from '@xyo-network/xl1-protocol'
+
+import { JsonRpcNetworkStakingStepRewardsByStakerViewerMethods } from './JsonRpcNetworkStakingStepRewardsByStakerViewerMethods.ts'
+
+export class JsonRpcNetworkStakingStepRewardsViewer extends JsonRpcNetworkStakingStepRewardsByStakerViewerMethods implements RewardsByStakerViewer {}

package/src/provider/viewer/JsonRpcNetworkStakingStepRewardsByStakerViewer/JsonRpcNetworkStakingStepRewardsByStakerViewerMethods.ts

@@ -0,0 +1,28 @@
+import type {
+  AttoXL1, RewardsByPositionViewerMethods, RewardsByPositionViewerOptions,
+} from '@xyo-network/xl1-protocol'
+
+import type { NetworkStakingStepRewardsByStakerViewerRpcSchemas } from '../../../types/index.ts'
+import { JsonRpcViewer } from '../JsonRpcViewer.ts'
+export class JsonRpcNetworkStakingStepRewardsByStakerViewerMethods extends
+  JsonRpcViewer<typeof NetworkStakingStepRewardsByStakerViewerRpcSchemas> implements RewardsByPositionViewerMethods {
+  async bonus(options?: RewardsByPositionViewerOptions | undefined): Promise<Record<number, AttoXL1>> {
+    return (await this.transport.sendRequest('networkStakingStepRewardsByStakerViewer_bonus', [options]))
+  }
+
+  async claimed(options?: RewardsByPositionViewerOptions | undefined): Promise<Record<number, AttoXL1>> {
+    return (await this.transport.sendRequest('networkStakingStepRewardsByStakerViewer_claimed', [options]))
+  }
+
+  async earned(options?: RewardsByPositionViewerOptions | undefined): Promise<Record<number, AttoXL1>> {
+    return (await this.transport.sendRequest('networkStakingStepRewardsByStakerViewer_earned', [options]))
+  }
+
+  async total(options?: RewardsByPositionViewerOptions | undefined): Promise<Record<number, AttoXL1>> {
+    return (await this.transport.sendRequest('networkStakingStepRewardsByStakerViewer_total', [options]))
+  }
+
+  async unclaimed(options?: RewardsByPositionViewerOptions | undefined): Promise<Record<number, AttoXL1>> {
+    return (await this.transport.sendRequest('networkStakingStepRewardsByStakerViewer_unclaimed', [options]))
+  }
+}

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

@@ -0,0 +1,2 @@
+export * from './JsonRpcNetworkStakingStepRewardsByStakerViewer.ts'
+export * from './JsonRpcNetworkStakingStepRewardsByStakerViewerMethods.ts'

package/src/provider/viewer/JsonRpcNetworkStakingStepRewardsByStepViewer/JsonRpcNetworkStakingStepRewardsByStepViewer.ts

@@ -0,0 +1,5 @@
+import type { RewardsByStepViewer } from '@xyo-network/xl1-protocol'
+
+import { JsonRpcNetworkStakingStepRewardsByStepViewerMethods } from './JsonRpcNetworkStakingStepRewardsByStepViewerMethods.ts'
+
+export class JsonRpcNetworkStakingStepRewardsByStepViewer extends JsonRpcNetworkStakingStepRewardsByStepViewerMethods implements RewardsByStepViewer {}

package/src/provider/viewer/JsonRpcNetworkStakingStepRewardsByStepViewer/JsonRpcNetworkStakingStepRewardsByStepViewerMethods.ts

@@ -0,0 +1,28 @@
+import type {
+  AttoXL1, RewardsByStepViewerMethods, RewardsByStepViewerOptions,
+} from '@xyo-network/xl1-protocol'
+
+import type { NetworkStakingStepRewardsByStepViewerRpcSchemas } from '../../../types/index.ts'
+import { JsonRpcViewer } from '../JsonRpcViewer.ts'
+export class JsonRpcNetworkStakingStepRewardsByStepViewerMethods extends
+  JsonRpcViewer<typeof NetworkStakingStepRewardsByStepViewerRpcSchemas> implements RewardsByStepViewerMethods {
+  async bonus(options?: RewardsByStepViewerOptions | undefined): Promise<Record<number, AttoXL1>> {
+    return (await this.transport.sendRequest('networkStakingStepRewardsByStepViewer_bonus', [options]))
+  }
+
+  async claimed(options?: RewardsByStepViewerOptions | undefined): Promise<Record<number, AttoXL1>> {
+    return (await this.transport.sendRequest('networkStakingStepRewardsByStepViewer_claimed', [options]))
+  }
+
+  async earned(options?: RewardsByStepViewerOptions | undefined): Promise<Record<number, AttoXL1>> {
+    return (await this.transport.sendRequest('networkStakingStepRewardsByStepViewer_earned', [options]))
+  }
+
+  async total(options?: RewardsByStepViewerOptions | undefined): Promise<Record<number, AttoXL1>> {
+    return (await this.transport.sendRequest('networkStakingStepRewardsByStepViewer_total', [options]))
+  }
+
+  async unclaimed(options?: RewardsByStepViewerOptions | undefined): Promise<Record<number, AttoXL1>> {
+    return (await this.transport.sendRequest('networkStakingStepRewardsByStepViewer_unclaimed', [options]))
+  }
+}

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

@@ -0,0 +1,2 @@
+export * from './JsonRpcNetworkStakingStepRewardsByStepViewer.ts'
+export * from './JsonRpcNetworkStakingStepRewardsByStepViewerMethods.ts'

package/src/provider/viewer/JsonRpcNetworkStakingStepRewardsTotalViewer/JsonRpcNetworkStakingStepRewardsTotalViewer.ts

@@ -0,0 +1,5 @@
+import type { RewardsTotalViewer } from '@xyo-network/xl1-protocol'
+
+import { JsonRpcNetworkStakingStepRewardsTotalViewerMethods } from './JsonRpcNetworkStakingStepRewardsTotalViewerMethods.ts'
+
+export class JsonRpcNetworkStakingStepRewardsTotalViewer extends JsonRpcNetworkStakingStepRewardsTotalViewerMethods implements RewardsTotalViewer {}

package/src/provider/viewer/JsonRpcNetworkStakingStepRewardsTotalViewer/JsonRpcNetworkStakingStepRewardsTotalViewerMethods.ts

@@ -0,0 +1,30 @@
+import type {
+  AttoXL1,
+  RewardsRangeOptions,
+  RewardsTotalViewerMethods,
+} from '@xyo-network/xl1-protocol'
+
+import type { NetworkStakingStepRewardsTotalViewerRpcSchemas } from '../../../types/index.ts'
+import { JsonRpcViewer } from '../JsonRpcViewer.ts'
+export class JsonRpcNetworkStakingStepRewardsTotalViewerMethods extends
+  JsonRpcViewer<typeof NetworkStakingStepRewardsTotalViewerRpcSchemas> implements RewardsTotalViewerMethods {
+  async bonus(options?: RewardsRangeOptions | undefined): Promise<AttoXL1> {
+    return (await this.transport.sendRequest('networkStakingStepRewardsTotalViewer_bonus', [options]))
+  }
+
+  async claimed(options?: RewardsRangeOptions | undefined): Promise<AttoXL1> {
+    return (await this.transport.sendRequest('networkStakingStepRewardsTotalViewer_claimed', [options]))
+  }
+
+  async earned(options?: RewardsRangeOptions | undefined): Promise<AttoXL1> {
+    return (await this.transport.sendRequest('networkStakingStepRewardsTotalViewer_earned', [options]))
+  }
+
+  async total(options?: RewardsRangeOptions | undefined): Promise<AttoXL1> {
+    return (await this.transport.sendRequest('networkStakingStepRewardsTotalViewer_total', [options]))
+  }
+
+  async unclaimed(options?: RewardsRangeOptions | undefined): Promise<AttoXL1> {
+    return (await this.transport.sendRequest('networkStakingStepRewardsTotalViewer_unclaimed', [options]))
+  }
+}

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

@@ -0,0 +1,2 @@
+export * from './JsonRpcNetworkStakingStepRewardsTotalViewer.ts'
+export * from './JsonRpcNetworkStakingStepRewardsTotalViewerMethods.ts'