@xyo-network/xl1-rpc 1.16.0 → 1.16.2

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

@@ -1,27 +1,27 @@
 import type { AttoXL1 } from '@xyo-network/xl1-protocol'
-import type { RewardsByPositionViewerMethods, RewardsByPositionViewerOptions } from '@xyo-network/xl1-protocol-sdk'
+import type { NetworkStakeStepRewardsByPositionViewerMethods, NetworkStakeStepRewardsByPositionViewerOptions } from '@xyo-network/xl1-protocol-sdk'
 
 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>> {
+  JsonRpcViewer<typeof NetworkStakingStepRewardsByStakerViewerRpcSchemas> implements NetworkStakeStepRewardsByPositionViewerMethods {
+  async bonus(options?: NetworkStakeStepRewardsByPositionViewerOptions | undefined): Promise<Record<number, AttoXL1>> {
     return (await this.transport.sendRequest('networkStakingStepRewardsByStakerViewer_bonus', [options]))
   }
 
-  async claimed(options?: RewardsByPositionViewerOptions | undefined): Promise<Record<number, AttoXL1>> {
+  async claimed(options?: NetworkStakeStepRewardsByPositionViewerOptions | undefined): Promise<Record<number, AttoXL1>> {
     return (await this.transport.sendRequest('networkStakingStepRewardsByStakerViewer_claimed', [options]))
   }
 
-  async earned(options?: RewardsByPositionViewerOptions | undefined): Promise<Record<number, AttoXL1>> {
+  async earned(options?: NetworkStakeStepRewardsByPositionViewerOptions | undefined): Promise<Record<number, AttoXL1>> {
     return (await this.transport.sendRequest('networkStakingStepRewardsByStakerViewer_earned', [options]))
   }
 
-  async total(options?: RewardsByPositionViewerOptions | undefined): Promise<Record<number, AttoXL1>> {
+  async total(options?: NetworkStakeStepRewardsByPositionViewerOptions | undefined): Promise<Record<number, AttoXL1>> {
     return (await this.transport.sendRequest('networkStakingStepRewardsByStakerViewer_total', [options]))
   }
 
-  async unclaimed(options?: RewardsByPositionViewerOptions | undefined): Promise<Record<number, AttoXL1>> {
+  async unclaimed(options?: NetworkStakeStepRewardsByPositionViewerOptions | undefined): Promise<Record<number, AttoXL1>> {
     return (await this.transport.sendRequest('networkStakingStepRewardsByStakerViewer_unclaimed', [options]))
   }
 }

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

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

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

@@ -1,27 +1,27 @@
 import type { AttoXL1 } from '@xyo-network/xl1-protocol'
-import type { RewardsByStepViewerMethods, RewardsByStepViewerOptions } from '@xyo-network/xl1-protocol-sdk'
+import type { NetworkStakeStepRewardsByStepViewerMethods, NetworkStakeStepRewardsByStepViewerOptions } from '@xyo-network/xl1-protocol-sdk'
 
 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>> {
+  JsonRpcViewer<typeof NetworkStakingStepRewardsByStepViewerRpcSchemas> implements NetworkStakeStepRewardsByStepViewerMethods {
+  async bonus(options?: NetworkStakeStepRewardsByStepViewerOptions | undefined): Promise<Record<number, AttoXL1>> {
     return (await this.transport.sendRequest('networkStakingStepRewardsByStepViewer_bonus', [options]))
   }
 
-  async claimed(options?: RewardsByStepViewerOptions | undefined): Promise<Record<number, AttoXL1>> {
+  async claimed(options?: NetworkStakeStepRewardsByStepViewerOptions | undefined): Promise<Record<number, AttoXL1>> {
     return (await this.transport.sendRequest('networkStakingStepRewardsByStepViewer_claimed', [options]))
   }
 
-  async earned(options?: RewardsByStepViewerOptions | undefined): Promise<Record<number, AttoXL1>> {
+  async earned(options?: NetworkStakeStepRewardsByStepViewerOptions | undefined): Promise<Record<number, AttoXL1>> {
     return (await this.transport.sendRequest('networkStakingStepRewardsByStepViewer_earned', [options]))
   }
 
-  async total(options?: RewardsByStepViewerOptions | undefined): Promise<Record<number, AttoXL1>> {
+  async total(options?: NetworkStakeStepRewardsByStepViewerOptions | undefined): Promise<Record<number, AttoXL1>> {
     return (await this.transport.sendRequest('networkStakingStepRewardsByStepViewer_total', [options]))
   }
 
-  async unclaimed(options?: RewardsByStepViewerOptions | undefined): Promise<Record<number, AttoXL1>> {
+  async unclaimed(options?: NetworkStakeStepRewardsByStepViewerOptions | undefined): Promise<Record<number, AttoXL1>> {
     return (await this.transport.sendRequest('networkStakingStepRewardsByStepViewer_unclaimed', [options]))
   }
 }

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

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

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

@@ -1,27 +1,27 @@
 import type { AttoXL1 } from '@xyo-network/xl1-protocol'
-import type { RewardsRangeOptions, RewardsTotalViewerMethods } from '@xyo-network/xl1-protocol-sdk'
+import type { NetworkStakeStepRewardsRangeOptions, NetworkStakeStepRewardsTotalViewerMethods } from '@xyo-network/xl1-protocol-sdk'
 
 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> {
+  JsonRpcViewer<typeof NetworkStakingStepRewardsTotalViewerRpcSchemas> implements NetworkStakeStepRewardsTotalViewerMethods {
+  async bonus(options?: NetworkStakeStepRewardsRangeOptions | undefined): Promise<AttoXL1> {
     return (await this.transport.sendRequest('networkStakingStepRewardsTotalViewer_bonus', [options]))
   }
 
-  async claimed(options?: RewardsRangeOptions | undefined): Promise<AttoXL1> {
+  async claimed(options?: NetworkStakeStepRewardsRangeOptions | undefined): Promise<AttoXL1> {
     return (await this.transport.sendRequest('networkStakingStepRewardsTotalViewer_claimed', [options]))
   }
 
-  async earned(options?: RewardsRangeOptions | undefined): Promise<AttoXL1> {
+  async earned(options?: NetworkStakeStepRewardsRangeOptions | undefined): Promise<AttoXL1> {
     return (await this.transport.sendRequest('networkStakingStepRewardsTotalViewer_earned', [options]))
   }
 
-  async total(options?: RewardsRangeOptions | undefined): Promise<AttoXL1> {
+  async total(options?: NetworkStakeStepRewardsRangeOptions | undefined): Promise<AttoXL1> {
     return (await this.transport.sendRequest('networkStakingStepRewardsTotalViewer_total', [options]))
   }
 
-  async unclaimed(options?: RewardsRangeOptions | undefined): Promise<AttoXL1> {
+  async unclaimed(options?: NetworkStakeStepRewardsRangeOptions | undefined): Promise<AttoXL1> {
     return (await this.transport.sendRequest('networkStakingStepRewardsTotalViewer_unclaimed', [options]))
   }
 }

package/src/provider/viewer/JsonRpcNetworkStakingStepRewardsViewer/JsonRpcNetworkStakingStepRewardsViewer.ts

@@ -1,42 +1,40 @@
 import type {
-  RewardsByPositionViewer, RewardsByStakerViewer, RewardsByStepViewer, RewardsTotalViewer, StepRewardsViewerMethods,
+  NetworkStakeStepRewardsByPositionViewer, NetworkStakeStepRewardsByStakerViewer, NetworkStakeStepRewardsByStepViewer,
+  NetworkStakeStepRewardsTotalViewer, NetworkStakeStepRewardsViewerMethods,
 } from '@xyo-network/xl1-protocol-sdk'
 
 import type { RpcTransport } from '../../../transport/index.ts'
 import type { NetworkStakingStepRewardsViewerRpcSchemas } from '../../../types/index.ts'
-import { JsonRpcNetworkStakingStepRewardsByPositionViewer } from '../JsonRpcNetworkStakingStepRewardsByPositionViewer/index.ts'
-import { JsonRpcNetworkStakingStepRewardsByStakerViewerMethods } from '../JsonRpcNetworkStakingStepRewardsByStakerViewer/index.ts'
-import { JsonRpcNetworkStakingStepRewardsByStepViewer } from '../JsonRpcNetworkStakingStepRewardsByStepViewer/index.ts'
-import { JsonRpcNetworkStakingStepRewardsTotalViewer } from '../JsonRpcNetworkStakingStepRewardsTotalViewer/index.ts'
 import { JsonRpcNetworkStakingStepRewardsViewerMethods } from './JsonRpcNetworkStakingStepRewardsViewerMethods.ts'
 
-export class JsonRpcNetworkStakingStepRewardsViewer extends JsonRpcNetworkStakingStepRewardsViewerMethods implements StepRewardsViewerMethods {
-  protected _position: RewardsByPositionViewer
-  protected _staker: RewardsByStakerViewer
-  protected _step: RewardsByStepViewer
-  protected _total: RewardsTotalViewer
+export interface JsonRpcNetworkStakingStepRewardsViewerProviders {
+  position?: NetworkStakeStepRewardsByPositionViewer
+  staker?: NetworkStakeStepRewardsByStakerViewer
+  step?: NetworkStakeStepRewardsByStepViewer
+  total?: NetworkStakeStepRewardsTotalViewer
+}
+
+export class JsonRpcNetworkStakingStepRewardsViewer extends JsonRpcNetworkStakingStepRewardsViewerMethods implements NetworkStakeStepRewardsViewerMethods {
+  protected providers: JsonRpcNetworkStakingStepRewardsViewerProviders
 
-  constructor(transport: RpcTransport<typeof NetworkStakingStepRewardsViewerRpcSchemas>) {
+  constructor(transport: RpcTransport<typeof NetworkStakingStepRewardsViewerRpcSchemas>, providers?: JsonRpcNetworkStakingStepRewardsViewerProviders) {
     super(transport)
-    this._position = new JsonRpcNetworkStakingStepRewardsByPositionViewer(transport)
-    this._staker = new JsonRpcNetworkStakingStepRewardsByStakerViewerMethods(transport)
-    this._step = new JsonRpcNetworkStakingStepRewardsByStepViewer(transport)
-    this._total = new JsonRpcNetworkStakingStepRewardsTotalViewer(transport)
+    this.providers = providers ?? {}
   }
 
-  get position(): RewardsByPositionViewer {
-    return this._position
+  get position(): NetworkStakeStepRewardsByPositionViewer | undefined {
+    return this.providers.position
   }
 
-  get staker(): RewardsByStakerViewer {
-    return this._staker
+  get staker(): NetworkStakeStepRewardsByStakerViewer | undefined {
+    return this.providers.staker
   }
 
-  get step(): RewardsByStepViewer {
-    return this._step
+  get step(): NetworkStakeStepRewardsByStepViewer | undefined {
+    return this.providers.step
   }
 
-  get total(): RewardsTotalViewer {
-    return this._total
+  get total(): NetworkStakeStepRewardsTotalViewer | undefined {
+    return this.providers.total
   }
 }

package/src/provider/viewer/JsonRpcNetworkStakingStepRewardsViewer/JsonRpcNetworkStakingStepRewardsViewerMethods.ts

@@ -1,6 +1,6 @@
-import type { StepRewardsViewerMethods } from '@xyo-network/xl1-protocol-sdk'
+import type { NetworkStakeStepRewardsViewerMethods } from '@xyo-network/xl1-protocol-sdk'
 
 import type { NetworkStakingStepRewardsViewerRpcSchemas } from '../../../types/index.ts'
 import { JsonRpcViewer } from '../JsonRpcViewer.ts'
 export class JsonRpcNetworkStakingStepRewardsViewerMethods extends
-  JsonRpcViewer<typeof NetworkStakingStepRewardsViewerRpcSchemas> implements StepRewardsViewerMethods {}
+  JsonRpcViewer<typeof NetworkStakingStepRewardsViewerRpcSchemas> implements NetworkStakeStepRewardsViewerMethods {}

package/src/provider/viewer/JsonRpcXyoViewer.ts

@@ -18,17 +18,22 @@ import type {
 
 import type { RpcTransport } from '../../transport/index.ts'
 import type { XyoViewerRpcSchemas } from '../../types/index.ts'
+
+export interface JsonRpcXyoViewerProviders {
+  networkStakeViewer?: NetworkStakeViewer
+}
+
 export class JsonRpcXyoViewer implements XyoViewer {
-  protected readonly _networkStakeViewer: NetworkStakeViewer
+  protected readonly providers?: JsonRpcXyoViewerProviders
   protected readonly transport: RpcTransport<typeof XyoViewerRpcSchemas>
 
-  constructor(transport: RpcTransport<typeof XyoViewerRpcSchemas>, networkStakeViewer: NetworkStakeViewer) {
+  constructor(transport: RpcTransport<typeof XyoViewerRpcSchemas>, providers?: JsonRpcXyoViewerProviders) {
     this.transport = transport
-    this._networkStakeViewer = networkStakeViewer
+    this.providers = providers
   }
 
-  get networkStakeViewer(): NetworkStakeViewer {
-    return this._networkStakeViewer
+  get networkStakeViewer() {
+    return this.providers?.networkStakeViewer
   }
 
   async accountBalance(address: Address): Promise<AttoXL1> {
@@ -183,7 +188,7 @@ export class JsonRpcXyoViewer implements XyoViewer {
     return asAttoXL1(await this.transport.sendRequest('xyoViewer_transferBalance', [address]))
   }
 
-  transferBalanceHistory(address: Address, range?: XL1BlockRange): Promise<TransferBalanceHistoryItem[]> {
+  transferBalanceHistory(_address: Address, _range?: XL1BlockRange): Promise<TransferBalanceHistoryItem[]> {
     throw new Error('Method not implemented.')
   }
 
@@ -191,7 +196,7 @@ export class JsonRpcXyoViewer implements XyoViewer {
     return asAttoXL1(await this.transport.sendRequest('xyoViewer_transferPairBalance', [pair]))
   }
 
-  transferPairBalanceHistory(pair: TransferPair): Promise<TransferBalanceHistoryItem[]> {
+  transferPairBalanceHistory(_pair: TransferPair): Promise<TransferBalanceHistoryItem[]> {
     throw new Error('Method not implemented.')
   }
 }

package/src/provider/viewer/index.ts

@@ -1,3 +1,4 @@
 export * from './JsonRpcNetworkStakeViewer/index.ts'
 export * from './JsonRpcNetworkStakingStepRewardsViewer/index.ts'
+export * from './JsonRpcViewer.ts'
 export * from './JsonRpcXyoViewer.ts'

package/src/provider/viewer/spec/JsonRpcXyoViewer.spec.ts

@@ -19,7 +19,7 @@ import { JsonRpcXyoViewer } from '../JsonRpcXyoViewer.ts'
 
 describe.skip('RpcXyoViewer - live integration tests', () => {
   const transport = new HttpRpcTransport('http://localhost:8080/rpc', { ...XyoViewerRpcSchemas, ...NetworkStakeViewerRpcSchemas })
-  const sut = new JsonRpcXyoViewer(transport, new JsonRpcNetworkStakeViewer(transport))
+  const sut = new JsonRpcXyoViewer(transport, { networkStakeViewer: new JsonRpcNetworkStakeViewer(transport) })
 
   describe('accountBalance', () => {
     const TEST_ADDRESS = '796c74fb1c23dc2dcc4e40b8c4284f05da51210f' as Address

package/src/{provider/client/spec → spec}/MemoryXyoClient.spec.ts

@@ -1,43 +1,47 @@
 import type { AccountInstance } from '@xyo-network/account-model'
 import { HDWallet } from '@xyo-network/wallet'
 import type { GatewayName } from '@xyo-network/xl1-protocol'
-import type { XyoClient, XyoConnection } from '@xyo-network/xl1-protocol-sdk'
-import { ADDRESS_INDEX, generateXyoBaseWalletFromPhrase } from '@xyo-network/xl1-protocol-sdk'
+import type {
+  XyoClient, XyoConnection,
+  XyoGateway,
+  XyoPermissions,
+} from '@xyo-network/xl1-protocol-sdk'
+import {
+  ADDRESS_INDEX, generateXyoBaseWalletFromPhrase, MemoryPermissionsStore, SimpleXyoClient, SimpleXyoGateway,
+  SimpleXyoPermissions,
+  SimpleXyoSigner,
+} from '@xyo-network/xl1-protocol-sdk'
 import {
   beforeEach, describe, expect, it,
 } from 'vitest'
 
-import { HttpRpcXyoConnection } from '../../connection/index.ts'
-import { MemoryXyoGateway } from '../../gateway/index.ts'
-import { MemoryPermissionsStore, MemoryXyoPermissions } from '../../permissions/index.ts'
-import { MemoryXyoSigner } from '../../signer/index.ts'
-import { MemoryXyoClient } from '../MemoryXyoClient.ts'
+import { HttpRpcXyoConnection } from '../provider/connection/index.ts'
 
 describe('Client', () => {
   const endpoint = 'http://localhost:8080/rpc'
   const invoker = 'http://localhost:3000'
   // const dataLakeEndpoint = 'http://localhost:8080/chain/archivist'
   let account: AccountInstance
-  let signer: MemoryXyoSigner
+  let signer: SimpleXyoSigner
   let store
-  let permissions: MemoryXyoPermissions
+  let permissions: XyoPermissions
   let connection: XyoConnection
-  let gateway: MemoryXyoGateway
+  let gateway: XyoGateway
   let client: XyoClient
 
   beforeEach(async () => {
     const mnemonic = process.env.XL1_PRODUCER__MNEMONIC ?? HDWallet.generateMnemonic()
     const wallet = await generateXyoBaseWalletFromPhrase(mnemonic)
     account = await wallet.derivePath(ADDRESS_INDEX.XYO)
-    signer = new MemoryXyoSigner(account)
+    signer = new SimpleXyoSigner(account)
     store = new MemoryPermissionsStore(invoker)
-    permissions = new MemoryXyoPermissions(store)
+    permissions = new SimpleXyoPermissions(store)
     connection = new HttpRpcXyoConnection({
       endpoint,
       // storage: dataLakeEndpoint,
     })
-    gateway = new MemoryXyoGateway(signer, connection)
-    client = new MemoryXyoClient({ localhost: gateway }, permissions)
+    gateway = new SimpleXyoGateway(signer, connection)
+    client = new SimpleXyoClient({ localhost: gateway }, permissions)
   })
 
   describe('permissions', () => {
@@ -50,11 +54,11 @@ describe('Client', () => {
   describe('gateways', () => {
     describe('connection', () => {
       it('should be defined', () => {
-        const gateway = client.gateways['localhost' as GatewayName].connection()
+        const gateway = client.gateways['localhost' as GatewayName].connection
         expect(gateway).toBeDefined()
       })
       it('should allow retrieving the chain ID', async () => {
-        const chainId = await (await client.gateways['localhost' as GatewayName]?.connection())?.viewer?.chainId()
+        const chainId = await (await client.gateways['localhost' as GatewayName]?.connection)?.viewer?.chainId()
         expect(chainId).toBeDefined()
       })
     })

package/src/{provider/gateway/spec → spec}/MemoryXyoGateway.spec.ts

@@ -5,43 +5,45 @@ import type { AccountInstance } from '@xyo-network/account-model'
 import { PayloadBuilder } from '@xyo-network/payload-builder'
 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 type { XyoGatewayRunner } from '@xyo-network/xl1-protocol-sdk'
+import {
+  buildUnsignedTransaction, SimpleXyoGateway, SimpleXyoGatewayRunner,
+  SimpleXyoSigner,
+} from '@xyo-network/xl1-protocol-sdk'
 import {
   beforeEach, describe, expect, it,
   vi,
 } from 'vitest'
 
-import { HttpRpcXyoConnection } from '../../connection/index.ts'
-import { MemoryXyoSigner } from '../../signer/index.ts'
-import { MemoryXyoGateway } from '../MemoryXyoGateway.ts'
+import { HttpRpcXyoConnection } from '../provider/connection/index.ts'
 
 describe('MemoryXyoGateway', () => {
   const endpoint = 'http://localhost:8080/rpc'
   // const dataLakeEndpoint = 'http://localhost:8080/chain/archivist'
   let account: AccountInstance
-  let signer: MemoryXyoSigner
+  let signer: SimpleXyoSigner
   let connection: HttpRpcXyoConnection
-  let sut: MemoryXyoGateway
+  let sut: XyoGatewayRunner
 
   beforeEach(async () => {
     account = await Account.random()
-    signer = new MemoryXyoSigner(account)
+    signer = new SimpleXyoSigner(account)
 
     connection = new HttpRpcXyoConnection({
       endpoint,
       // storage: dataLakeEndpoint,
     })
-    sut = new MemoryXyoGateway(signer, connection)
+    sut = new SimpleXyoGatewayRunner(new SimpleXyoGateway(signer, connection))
   })
 
   describe('connection', () => {
     it('should return the connection', () => {
-      expect(sut.connection()).toBeDefined()
+      expect(sut.connection).toBeDefined()
     })
   })
   describe('signer', () => {
     it('should return the signer', () => {
-      expect(sut.signer()).toBeDefined()
+      expect(sut.signer).toBeDefined()
     })
   })
   describe('submitTransaction', () => {
@@ -50,7 +52,7 @@ describe('MemoryXyoGateway', () => {
       const additionalPayloads: Payload[] = []
       const chainId = await connection.viewer?.chainId()
       const nbf = await connection.viewer?.currentBlockNumber() ?? 0
-      const signer = sut.signer()
+      const signer = sut.signer
       const signerAddress = await signer.address()
       expect(chainId).toBeDefined()
       if (chainId) {

package/src/types/NetworkStakingStepRewardsByPositionViewerRpc.ts

@@ -1,16 +1,16 @@
-import type { RewardsByPositionViewerMethods } from '@xyo-network/xl1-protocol-sdk'
+import type { NetworkStakeStepRewardsByPositionViewerMethods } from '@xyo-network/xl1-protocol-sdk'
 
 import type { MethodName, RpcMethodName } from './RpcMethodName.ts'
 
 export const NetworkStakingStepRewardsByPositionViewerRpcNamespace = 'networkStakingStepRewardsByPositionViewer' as const
 export type NetworkStakingStepRewardsByPositionViewerRpcNamespace = typeof NetworkStakingStepRewardsByPositionViewerRpcNamespace
 
-export type NetworkStakingStepRewardsByPositionViewerMethodName = MethodName<RewardsByPositionViewerMethods>
+export type NetworkStakingStepRewardsByPositionViewerMethodName = MethodName<NetworkStakeStepRewardsByPositionViewerMethods>
 export type NetworkStakingStepRewardsByPositionViewerRpcMethodName = RpcMethodName<NetworkStakingStepRewardsByPositionViewerRpcNamespace,
   NetworkStakingStepRewardsByPositionViewerMethodName>
 
 export type NetworkStakingStepRewardsByPositionViewerRpcMethodHandlers = {
   [K in NetworkStakingStepRewardsByPositionViewerMethodName as NetworkStakingStepRewardsByPositionViewerRpcMethodName]: (
-    params: Parameters<RewardsByPositionViewerMethods[K]>,
-  ) => ReturnType<RewardsByPositionViewerMethods[K]>
+    params: Parameters<NetworkStakeStepRewardsByPositionViewerMethods[K]>,
+  ) => ReturnType<NetworkStakeStepRewardsByPositionViewerMethods[K]>
 }

package/src/types/NetworkStakingStepRewardsByStakerViewerRpc.ts

@@ -1,15 +1,15 @@
-import type { RewardsByStakerViewerMethods } from '@xyo-network/xl1-protocol-sdk'
+import type { NetworkStakeStepRewardsByStakerViewerMethods } from '@xyo-network/xl1-protocol-sdk'
 
 import type { MethodName, RpcMethodName } from './RpcMethodName.ts'
 
 export const NetworkStakingStepRewardsByStakerViewerRpcNamespace = 'networkStakingStepRewardsByStakerViewer' as const
 export type NetworkStakingStepRewardsByStakerViewerRpcNamespace = typeof NetworkStakingStepRewardsByStakerViewerRpcNamespace
 
-export type NetworkStakingStepRewardsByStakerViewerMethodName = MethodName<RewardsByStakerViewerMethods>
+export type NetworkStakingStepRewardsByStakerViewerMethodName = MethodName<NetworkStakeStepRewardsByStakerViewerMethods>
 export type NetworkStakingStepRewardsByStakerViewerRpcMethodName = RpcMethodName<NetworkStakingStepRewardsByStakerViewerRpcNamespace,
   NetworkStakingStepRewardsByStakerViewerMethodName>
 export type NetworkStakingStepRewardsByStakerViewerRpcMethodHandlers = {
   [K in NetworkStakingStepRewardsByStakerViewerMethodName as NetworkStakingStepRewardsByStakerViewerRpcMethodName]: (
-    params: Parameters<RewardsByStakerViewerMethods[K]>,
-  ) => ReturnType<RewardsByStakerViewerMethods[K]>
+    params: Parameters<NetworkStakeStepRewardsByStakerViewerMethods[K]>,
+  ) => ReturnType<NetworkStakeStepRewardsByStakerViewerMethods[K]>
 }

package/src/types/NetworkStakingStepRewardsByStepViewerRpc.ts

@@ -1,15 +1,15 @@
-import type { RewardsByStepViewerMethods } from '@xyo-network/xl1-protocol-sdk'
+import type { NetworkStakeStepRewardsByStepViewerMethods } from '@xyo-network/xl1-protocol-sdk'
 
 import type { MethodName, RpcMethodName } from './RpcMethodName.ts'
 
 export const NetworkStakingStepRewardsByStepViewerRpcNamespace = 'networkStakingStepRewardsByStepViewer' as const
 export type NetworkStakingStepRewardsByStepViewerRpcNamespace = typeof NetworkStakingStepRewardsByStepViewerRpcNamespace
 
-export type NetworkStakingStepRewardsByStepViewerMethodName = MethodName<RewardsByStepViewerMethods>
+export type NetworkStakingStepRewardsByStepViewerMethodName = MethodName<NetworkStakeStepRewardsByStepViewerMethods>
 export type NetworkStakingStepRewardsByStepViewerRpcMethodName = RpcMethodName<NetworkStakingStepRewardsByStepViewerRpcNamespace,
   NetworkStakingStepRewardsByStepViewerMethodName>
 export type NetworkStakingStepRewardsByStepViewerRpcMethodHandlers = {
   [K in NetworkStakingStepRewardsByStepViewerMethodName as NetworkStakingStepRewardsByStepViewerRpcMethodName]: (
-    params: Parameters<RewardsByStepViewerMethods[K]>,
-  ) => ReturnType<RewardsByStepViewerMethods[K]>
+    params: Parameters<NetworkStakeStepRewardsByStepViewerMethods[K]>,
+  ) => ReturnType<NetworkStakeStepRewardsByStepViewerMethods[K]>
 }

package/src/types/NetworkStakingStepRewardsTotalViewerRpc.ts

@@ -1,15 +1,15 @@
-import type { RewardsTotalViewerMethods } from '@xyo-network/xl1-protocol-sdk'
+import type { NetworkStakeStepRewardsTotalViewerMethods } from '@xyo-network/xl1-protocol-sdk'
 
 import type { MethodName, RpcMethodName } from './RpcMethodName.ts'
 
 export const NetworkStakingStepRewardsTotalViewerRpcNamespace = 'networkStakingStepRewardsTotalViewer' as const
 export type NetworkStakingStepRewardsTotalViewerRpcNamespace = typeof NetworkStakingStepRewardsTotalViewerRpcNamespace
 
-export type NetworkStakingStepRewardsTotalViewerMethodName = MethodName<RewardsTotalViewerMethods>
+export type NetworkStakingStepRewardsTotalViewerMethodName = MethodName<NetworkStakeStepRewardsTotalViewerMethods>
 export type NetworkStakingStepRewardsTotalViewerRpcMethodName = RpcMethodName<NetworkStakingStepRewardsTotalViewerRpcNamespace,
   NetworkStakingStepRewardsTotalViewerMethodName>
 export type NetworkStakingStepRewardsTotalViewerRpcMethodHandlers = {
   [K in NetworkStakingStepRewardsTotalViewerMethodName as NetworkStakingStepRewardsTotalViewerRpcMethodName]: (
-    params: Parameters<RewardsTotalViewerMethods[K]>,
-  ) => ReturnType<RewardsTotalViewerMethods[K]>
+    params: Parameters<NetworkStakeStepRewardsTotalViewerMethods[K]>,
+  ) => ReturnType<NetworkStakeStepRewardsTotalViewerMethods[K]>
 }

package/src/types/NetworkStakingStepRewardsViewerRpc.ts

@@ -1,15 +1,15 @@
-import type { StepRewardsViewerMethods } from '@xyo-network/xl1-protocol-sdk'
+import type { NetworkStakeStepRewardsViewerMethods } from '@xyo-network/xl1-protocol-sdk'
 
 import type { MethodName, RpcMethodName } from './RpcMethodName.ts'
 
 export const NetworkStakingStepRewardsViewerRpcNamespace = 'networkStakingStepRewardsViewer' as const
 export type NetworkStakingStepRewardsViewerRpcNamespace = typeof NetworkStakingStepRewardsViewerRpcNamespace
 
-export type NetworkStakingStepRewardsViewerMethodName = MethodName<StepRewardsViewerMethods>
+export type NetworkStakingStepRewardsViewerMethodName = MethodName<NetworkStakeStepRewardsViewerMethods>
 export type NetworkStakingStepRewardsViewerRpcMethodName = RpcMethodName<NetworkStakingStepRewardsViewerRpcNamespace, NetworkStakingStepRewardsViewerMethodName>
 
 export type NetworkStakingStepRewardsViewerRpcMethodHandlers = {
   [K in NetworkStakingStepRewardsViewerMethodName]: (
-    params: Parameters<StepRewardsViewerMethods[K]>,
-  ) => ReturnType<StepRewardsViewerMethods[K]>
+    params: Parameters<NetworkStakeStepRewardsViewerMethods[K]>,
+  ) => ReturnType<NetworkStakeStepRewardsViewerMethods[K]>
 }

package/src/types/XyoDataLakeViewerRpc.ts

@@ -0,0 +1,16 @@
+import type { DataLakeViewerMethods } from '@xyo-network/xl1-protocol-sdk'
+
+import type { MethodName, RpcMethodName } from './RpcMethodName.ts'
+
+export const DataLakeViewerRpcNamespace = 'dataLakeViewer' as const
+export type DataLakeViewerRpcNamespace = typeof DataLakeViewerRpcNamespace
+
+export type DataLakeViewerMethodName = MethodName<DataLakeViewerMethods>
+export type DataLakeViewerRpcMethodName = RpcMethodName<DataLakeViewerRpcNamespace,
+  DataLakeViewerMethodName>
+
+export type DataLakeViewerRpcMethodHandlers = {
+  [K in DataLakeViewerMethodName as DataLakeViewerRpcMethodName]: (
+    params: Parameters<DataLakeViewerMethods[K]>,
+  ) => ReturnType<DataLakeViewerMethods[K]>
+}

package/src/types/schema/DataLakeViewerRpcSchema.ts

@@ -0,0 +1,40 @@
+import { HashZod } from '@xylabs/hex'
+import { PayloadZod } from '@xyo-network/payload-model'
+import * as z from 'zod'
+
+import type { DataLakeViewerRpcMethodName } from '../XyoDataLakeViewerRpc.ts'
+import { ArrayBufferToJsonZod, JsonToArrayBufferZod } from './common/index.ts'
+import type { RpcSchemaMap } from './RpcSchemaMap.ts'
+
+export const DataLakeViewerRpcSchemas = {
+  dataLakeViewer_get: {
+    params: {
+      to: z.tuple([HashZod]),
+      from: z.tuple([HashZod]),
+    },
+    result: {
+      to: z.union([PayloadZod, ArrayBufferToJsonZod]).optional(),
+      from: z.union([PayloadZod, JsonToArrayBufferZod]).optional(),
+    },
+  },
+  dataLakeViewer_getMany: {
+    params: {
+      to: z.tuple([z.array(HashZod)]),
+      from: z.tuple([z.array(HashZod)]),
+    },
+    result: {
+      to: z.array(z.union([PayloadZod, ArrayBufferToJsonZod])),
+      from: z.array(z.union([PayloadZod, JsonToArrayBufferZod])),
+    },
+  },
+  dataLakeViewer_has: {
+    params: {
+      to: z.tuple([HashZod]),
+      from: z.tuple([HashZod]),
+    },
+    result: {
+      to: z.boolean(),
+      from: z.boolean(),
+    },
+  },
+} satisfies RpcSchemaMap<DataLakeViewerRpcMethodName>

package/src/types/schema/common/ArrayBuffer.ts

@@ -0,0 +1,42 @@
+import * as z from 'zod'
+
+function base64Encode(u8: Uint8Array): string {
+  // Node
+  if (typeof Buffer !== 'undefined' && typeof Buffer.from === 'function') {
+    return Buffer.from(u8).toString('base64')
+  }
+
+  // Browser
+  let binary = ''
+  const chunk = 0x80_00
+  for (let i = 0; i < u8.length; i += chunk) {
+    // eslint-disable-next-line unicorn/prefer-code-point
+    binary += String.fromCharCode(...u8.subarray(i, i + chunk))
+  }
+  return btoa(binary)
+}
+
+/** Base64 decode that works in Node and browsers -> Uint8Array */
+function base64Decode(b64: string): Uint8Array {
+  // Node
+  if (typeof Buffer !== 'undefined' && typeof Buffer.from === 'function') {
+    return new Uint8Array(Buffer.from(b64, 'base64'))
+  }
+
+  // Browser
+  const binary = atob(b64)
+  const u8 = new Uint8Array(binary.length)
+  // eslint-disable-next-line unicorn/prefer-code-point
+  for (let i = 0; i < binary.length; i++) u8[i] = binary.charCodeAt(i)
+  return u8
+}
+
+export const ArrayBufferToJsonZod = z.instanceof(ArrayBuffer).transform((x) => {
+  const u8 = new Uint8Array(x)
+  return base64Encode(u8)
+})
+
+export const JsonToArrayBufferZod = z.string().transform((x) => {
+  const u8 = base64Decode(x)
+  return u8.buffer
+})

package/src/types/schema/common/BlockBoundWitness.ts

@@ -1,4 +1,4 @@
-import type { Hash } from '@xylabs/hex'
+import { HashZod } from '@xylabs/hex'
 import { asXL1BlockNumber } from '@xyo-network/xl1-protocol'
 import * as z from 'zod'
 
@@ -11,8 +11,6 @@ import { StorageMetaZod } from './Payload.ts'
 
 export const BlockNumberZod = z.number().int().nonnegative()
 export const XL1BlockNumberZod = BlockNumberZod.transform(asXL1BlockNumber)
-export const HexZod = z.string().regex(/^[0-9a-f]+$/)
-export const HashZod = HexZod.transform(v => v as Hash)
 
 const BlockBoundWitnessFieldsZod = z.object({
   block: XL1BlockNumberZod,