@xyo-network/xl1-rpc 1.16.23 → 1.16.25

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqagB,CAAA"}
+{"version":3,"file":"XyoViewerRpcSchemas.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/XyoViewerRpcSchemas.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAKxB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqagB,CAAA"}

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

@@ -1,7 +1,9 @@
+export * from './AccountBalanceViewerRpcSchemas.ts';
 export * from './AllRpcSchemas.ts';
 export * from './createRequestSchema.ts';
 export * from './createResponseSchema.ts';
 export * from './DataLakeViewerRpcSchema.ts';
+export * from './MempoolViewerRpcSchemas.ts';
 export * from './NetworkStakeViewerRpcSchemas.ts';
 export * from './RewardsByPositionViewerRpcSchemas.ts';
 export * from './RewardsByStakerViewerRpcSchemas.ts';

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAA;AAClC,cAAc,0BAA0B,CAAA;AACxC,cAAc,2BAA2B,CAAA;AACzC,cAAc,8BAA8B,CAAA;AAC5C,cAAc,mCAAmC,CAAA;AACjD,cAAc,wCAAwC,CAAA;AACtD,cAAc,sCAAsC,CAAA;AACpD,cAAc,oCAAoC,CAAA;AAClD,cAAc,mCAAmC,CAAA;AACjD,cAAc,mBAAmB,CAAA;AACjC,cAAc,kCAAkC,CAAA;AAChD,cAAc,8BAA8B,CAAA;AAC5C,cAAc,+BAA+B,CAAA;AAC7C,cAAc,0BAA0B,CAAA;AACxC,cAAc,0BAA0B,CAAA;AACxC,cAAc,0BAA0B,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/index.ts"],"names":[],"mappings":"AAAA,cAAc,qCAAqC,CAAA;AACnD,cAAc,oBAAoB,CAAA;AAClC,cAAc,0BAA0B,CAAA;AACxC,cAAc,2BAA2B,CAAA;AACzC,cAAc,8BAA8B,CAAA;AAC5C,cAAc,8BAA8B,CAAA;AAC5C,cAAc,mCAAmC,CAAA;AACjD,cAAc,wCAAwC,CAAA;AACtD,cAAc,sCAAsC,CAAA;AACpD,cAAc,oCAAoC,CAAA;AAClD,cAAc,mCAAmC,CAAA;AACjD,cAAc,mBAAmB,CAAA;AACjC,cAAc,kCAAkC,CAAA;AAChD,cAAc,8BAA8B,CAAA;AAC5C,cAAc,+BAA+B,CAAA;AAC7C,cAAc,0BAA0B,CAAA;AACxC,cAAc,0BAA0B,CAAA;AACxC,cAAc,0BAA0B,CAAA"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "http://json.schemastore.org/package.json",
   "name": "@xyo-network/xl1-rpc",
-  "version": "1.16.23",
+  "version": "1.16.25",
   "description": "XYO Layer One API",
   "homepage": "https://xylabs.com",
   "bugs": {
@@ -58,17 +58,16 @@
     "types": "tsc --noEmit -p tsconfig.test.json"
   },
   "dependencies": {
-    "@metamask/json-rpc-engine": "~10.1.1",
-    "@xylabs/axios": "~5.0.39",
-    "@xylabs/sdk-js": "~5.0.39",
-    "@xyo-network/archivist-model": "~5.1.24",
-    "@xyo-network/boundwitness-model": "~5.1.24",
-    "@xyo-network/module-model": "~5.1.24",
-    "@xyo-network/node-model": "~5.1.24",
-    "@xyo-network/payload-builder": "~5.1.24",
-    "@xyo-network/payload-model": "~5.1.24",
-    "@xyo-network/xl1-protocol": "~1.13.13",
-    "@xyo-network/xl1-protocol-sdk": "~1.16.23",
+    "@metamask/json-rpc-engine": "~10.2.0",
+    "@xylabs/axios": "~5.0.42",
+    "@xylabs/sdk-js": "~5.0.42",
+    "@xyo-network/archivist-model": "~5.2.10",
+    "@xyo-network/module-model": "~5.2.10",
+    "@xyo-network/node-model": "~5.2.10",
+    "@xyo-network/payload-builder": "~5.2.10",
+    "@xyo-network/payload-model": "~5.2.10",
+    "@xyo-network/xl1-protocol": "~1.14.13",
+    "@xyo-network/xl1-protocol-sdk": "~1.16.25",
     "axios": "~1.13.2",
     "uuid": "~13.0.0",
     "zod": "~4.1.12"
@@ -76,18 +75,18 @@
   "devDependencies": {
     "@metamask/utils": "~11.8.1",
     "@types/node": "~24.10.1",
-    "@xylabs/sdk-js": "~5.0.39",
+    "@xylabs/sdk-js": "~5.0.42",
     "@xylabs/ts-scripts-yarn3": "~7.2.8",
     "@xylabs/tsconfig": "~7.2.8",
-    "@xylabs/vitest-extended": "~5.0.39",
-    "@xyo-network/account": "~5.1.24",
-    "@xyo-network/account-model": "~5.1.24",
-    "@xyo-network/chain-protocol": "~1.16.23",
-    "@xyo-network/wallet": "~5.1.24",
+    "@xylabs/vitest-extended": "~5.0.42",
+    "@xyo-network/account": "~5.2.10",
+    "@xyo-network/account-model": "~5.2.10",
+    "@xyo-network/chain-protocol": "~1.16.25",
+    "@xyo-network/wallet": "~5.2.10",
     "dotenv": "~17.2.3",
     "eslint": "^9.39.1",
     "typescript": "~5.9.3",
-    "vitest": "~4.0.10"
+    "vitest": "~4.0.13"
   },
   "packageManager": "yarn@4.6.0",
   "engines": {

package/src/engine/rpcMethodHandlersFromAccountBalanceViewer.ts

@@ -0,0 +1,10 @@
+import type { AccountBalanceViewerMethods } from '@xyo-network/xl1-protocol-sdk'
+
+import type { AccountBalanceViewerRpcMethodHandlers } from '../types/index.ts'
+
+export const rpcMethodHandlersFromAccountBalanceViewer = (viewer: AccountBalanceViewerMethods): AccountBalanceViewerRpcMethodHandlers => {
+  return {
+    accountBalanceViewer_accountsBalances: params => viewer.accountsBalances(params[0], params[1]),
+    accountBalanceViewer_accountsBalancesHistory: params => viewer.accountsBalancesHistory(params[0], params[1]),
+  }
+}

package/src/engine/rpcMethodHandlersFromConnection.ts

@@ -1,6 +1,7 @@
 import type { NetworkStakeViewer, XyoConnection } from '@xyo-network/xl1-protocol-sdk'
 
 import type { XyoProviderRpcMethodHandlers } from '../types/index.ts'
+import { rpcMethodHandlersFromAccountBalanceViewer } from './rpcMethodHandlersFromAccountBalanceViewer.ts'
 import { rpcMethodHandlersFromNetworkStakingStepRewardsByPositionViewer } from './rpcMethodHandlersFromNetworkStakingStepRewardsByPositionViewer.ts'
 import { rpcMethodHandlersFromRunner } from './rpcMethodHandlersFromRunner.ts'
 import { rpcMethodHandlersFromViewer } from './rpcMethodHandlersFromViewer.ts'
@@ -17,5 +18,12 @@ export const rpcMethodHandlersFromConnection = (connection: XyoConnection, netwo
       ...rpcMethodHandlersFromNetworkStakingStepRewardsByPositionViewer(networkStakeViewer.stepRewards.position),
     }
   }
+  const accountBalanceViewer = viewer?.account?.balance
+  if (accountBalanceViewer) {
+    result = {
+      ...result,
+      ...rpcMethodHandlersFromAccountBalanceViewer(accountBalanceViewer),
+    }
+  }
   return result
 }

package/src/engine/rpcMethodHandlersFromNetworkStakeStepRewardsByPositionViewer.ts

@@ -0,0 +1,14 @@
+import type { NetworkStakeStepRewardsByPositionViewerMethods } from '@xyo-network/xl1-protocol-sdk'
+
+import type { NetworkStakingStepRewardsByPositionViewerRpcMethodHandlers } from '../types/index.ts'
+
+export const rpcMethodHandlersFromNetworkStakeStepRewardsByPositionViewer
+  = (viewer: NetworkStakeStepRewardsByPositionViewerMethods): NetworkStakingStepRewardsByPositionViewerRpcMethodHandlers => {
+    return {
+      networkStakingStepRewardsByPositionViewer_bonus: params => viewer.bonus(...(params ?? [])),
+      networkStakingStepRewardsByPositionViewer_claimed: params => viewer.claimed(...(params ?? [])),
+      networkStakingStepRewardsByPositionViewer_earned: params => viewer.earned(...(params ?? [])),
+      networkStakingStepRewardsByPositionViewer_total: params => viewer.total(...(params ?? [])),
+      networkStakingStepRewardsByPositionViewer_unclaimed: params => viewer.unclaimed(...(params ?? [])),
+    }
+  }

package/src/provider/signer/JsonRpcXyoSigner.ts

@@ -20,7 +20,6 @@ export class RpcXyoSigner implements XyoSigner {
   }
 
   async signTransaction(tx: UnsignedHydratedTransaction): Promise<SignedHydratedTransactionWithHashMeta> {
-    const ret = await this.transport.sendRequest('xyoSigner_signTransaction', [tx])
-    return ret
+    return await this.transport.sendRequest('xyoSigner_signTransaction', [tx])
   }
 }

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

@@ -0,0 +1,23 @@
+import type { Address, Hash } from '@xylabs/sdk-js'
+import {
+  asAttoXL1, type AttoXL1, type XL1BlockRange,
+} from '@xyo-network/xl1-protocol'
+import type { AccountBalanceHistoryItem, AccountBalanceViewer } from '@xyo-network/xl1-protocol-sdk'
+
+import type { RpcTransport } from '../../../transport/index.ts'
+import type { AccountBalanceViewerRpcSchemas } from '../../../types/index.ts'
+import { JsonRpcAccountBalanceViewerMethods } from './JsonRpcAccountBalanceViewerMethods.ts'
+
+export class JsonRpcAccountBalanceViewer extends JsonRpcAccountBalanceViewerMethods implements AccountBalanceViewer {
+  constructor(transport: RpcTransport<typeof AccountBalanceViewerRpcSchemas>) {
+    super(transport)
+  }
+
+  async accountBalance(address: Address, headOrRange?: Hash | XL1BlockRange): Promise<AttoXL1> {
+    return (await this.accountsBalances([address], headOrRange))[address] ?? asAttoXL1(0)
+  }
+
+  async accountBalanceHistory(address: Address, headOrRange?: Hash | XL1BlockRange): Promise<AccountBalanceHistoryItem[]> {
+    return (await this.accountsBalancesHistory([address], headOrRange))[address] ?? []
+  }
+}

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

@@ -0,0 +1,31 @@
+import type { Address, Hash } from '@xylabs/sdk-js'
+import {
+  type AttoXL1,
+  type XL1BlockRange,
+} from '@xyo-network/xl1-protocol'
+import type { AccountBalanceHistoryItem, AccountBalanceViewerMethods } from '@xyo-network/xl1-protocol-sdk'
+
+import type { RpcTransport } from '../../../transport/index.ts'
+import type { AccountBalanceViewerRpcSchemas } from '../../../types/index.ts'
+
+export class JsonRpcAccountBalanceViewerMethods implements AccountBalanceViewerMethods {
+  protected readonly transport: RpcTransport<typeof AccountBalanceViewerRpcSchemas>
+
+  constructor(transport: RpcTransport<typeof AccountBalanceViewerRpcSchemas>) {
+    this.transport = transport
+  }
+
+  async accountsBalances(address: Address[], headOrRange?: Hash | XL1BlockRange): Promise<Partial<Record<Address, AttoXL1>>> {
+    return await this.transport.sendRequest(
+      'accountBalanceViewer_accountsBalances',
+      headOrRange ? [address, headOrRange] : [address],
+    ) as Partial<Record<Address, AttoXL1>>
+  }
+
+  async accountsBalancesHistory(address: Address[], headOrRange?: Hash | XL1BlockRange): Promise<Partial<Record<Address, AccountBalanceHistoryItem[]>>> {
+    return (await this.transport.sendRequest(
+      'accountBalanceViewer_accountsBalancesHistory',
+      headOrRange ? [address, headOrRange] : [address],
+    )) as Partial<Record<Address, AccountBalanceHistoryItem[]>>
+  }
+}

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

@@ -0,0 +1,2 @@
+export * from './JsonRpcAccountBalanceViewer.ts'
+export * from './JsonRpcAccountBalanceViewerMethods.ts'

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

@@ -0,0 +1,11 @@
+import type { MempoolViewer } from '@xyo-network/xl1-protocol-sdk'
+
+import type { RpcTransport } from '../../../transport/index.ts'
+import type { MempoolViewerRpcSchemas } from '../../../types/index.ts'
+import { JsonRpcMempoolViewerMethods } from './JsonRpcMempoolViewerMethods.ts'
+
+export class JsonRpcMempoolViewer extends JsonRpcMempoolViewerMethods implements MempoolViewer {
+  constructor(transport: RpcTransport<typeof MempoolViewerRpcSchemas>) {
+    super(transport)
+  }
+}

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

@@ -0,0 +1,21 @@
+import type { SignedHydratedTransactionWithHashMeta } from '@xyo-network/xl1-protocol'
+import type { MempoolViewerMethods, PendingTransactionsOptions } from '@xyo-network/xl1-protocol-sdk'
+
+import type { RpcTransport } from '../../../transport/index.ts'
+import type { MempoolViewerRpcSchemas } from '../../../types/index.ts'
+
+export class JsonRpcMempoolViewerMethods implements MempoolViewerMethods {
+  protected readonly transport: RpcTransport<typeof MempoolViewerRpcSchemas>
+
+  constructor(transport: RpcTransport<typeof MempoolViewerRpcSchemas>) {
+    this.transport = transport
+  }
+
+  async pendingTransactions(options?: PendingTransactionsOptions): Promise<SignedHydratedTransactionWithHashMeta[]> {
+    const result = await this.transport.sendRequest(
+      'mempoolViewer_pendingTransactions',
+      options ? [options] : [],
+    )
+    return result
+  }
+}

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

@@ -0,0 +1,2 @@
+export * from './JsonRpcMempoolViewer.ts'
+export * from './JsonRpcMempoolViewerMethods.ts'

package/src/provider/viewer/JsonRpcXyoViewer.ts

@@ -4,14 +4,14 @@ import type {
   AttoXL1,
   BlockRange,
   ChainId,
-  HydratedBlock,
+  SignedHydratedBlockWithHashMeta,
   SignedHydratedTransaction,
   StepIdentity,
   StepIdentityString,
   XL1BlockNumber,
   XL1BlockRange,
 } from '@xyo-network/xl1-protocol'
-import { asAttoXL1, asHydratedBlock } from '@xyo-network/xl1-protocol'
+import { asAttoXL1, asSignedHydratedBlockWithHashMeta } from '@xyo-network/xl1-protocol'
 import type {
   AccountBalanceHistoryItem, ForkHistory, NetworkStakeViewer, Position, TransferBalanceHistoryItem, TransferPair, XyoViewer,
 } from '@xyo-network/xl1-protocol-sdk'
@@ -76,16 +76,16 @@ export class JsonRpcXyoViewer implements XyoViewer {
     throw new Error('Method not implemented.')
   }
 
-  async blockByHash(hash: Hash): Promise<HydratedBlock | null> {
-    return asHydratedBlock(await this.transport.sendRequest('xyoViewer_blockByHash', [hash])) ?? null
+  async blockByHash(hash: Hash): Promise<SignedHydratedBlockWithHashMeta | null> {
+    return asSignedHydratedBlockWithHashMeta(await this.transport.sendRequest('xyoViewer_blockByHash', [hash])) ?? null
   }
 
-  async blockByNumber(blockNumber: number): Promise<HydratedBlock | null> {
-    return asHydratedBlock(await this.transport.sendRequest('xyoViewer_blockByNumber', [blockNumber])) ?? null
+  async blockByNumber(blockNumber: number): Promise<SignedHydratedBlockWithHashMeta | null> {
+    return asSignedHydratedBlockWithHashMeta(await this.transport.sendRequest('xyoViewer_blockByNumber', [blockNumber])) ?? null
   }
 
-  async blocksByHash(hash: Hash, limit?: number): Promise<HydratedBlock[]> {
-    return (await this.transport.sendRequest('xyoViewer_blocksByHash', [hash, limit])).map(b => asHydratedBlock(b, { required: true }))
+  async blocksByHash(hash: Hash, limit?: number): Promise<SignedHydratedBlockWithHashMeta[]> {
+    return (await this.transport.sendRequest('xyoViewer_blocksByHash', [hash, limit])).map(b => asSignedHydratedBlockWithHashMeta(b, true))
   }
 
   async chainId(): Promise<Address> {
@@ -96,8 +96,8 @@ export class JsonRpcXyoViewer implements XyoViewer {
     return (await this.transport.sendRequest('xyoViewer_chainIdAtBlock', [blockNumber]))
   }
 
-  async currentBlock(): Promise<HydratedBlock> {
-    return asHydratedBlock(await this.transport.sendRequest('xyoViewer_currentBlock'), { required: true })
+  async currentBlock(): Promise<SignedHydratedBlockWithHashMeta> {
+    return asSignedHydratedBlockWithHashMeta(await this.transport.sendRequest('xyoViewer_currentBlock'), true)
   }
 
   async currentBlockHash(): Promise<Hash> {

package/src/provider/viewer/index.ts

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

package/src/transport/HttpRpcTransport.ts

@@ -2,22 +2,26 @@ import type {
   JsonRpcFailure, JsonRpcRequest, JsonRpcSuccess,
 } from '@metamask/utils'
 import { axiosJsonConfig } from '@xylabs/axios'
-import { isError, isUndefinedOrNull } from '@xylabs/sdk-js'
+import {
+  isDefined, isError, isUndefinedOrNull,
+} from '@xylabs/sdk-js'
 import { Axios, isAxiosError } from 'axios'
 import { v4 } from 'uuid'
-import type * as z from 'zod'
+import * as z from 'zod'
 
 import type { RpcSchemaMap } from '../types/index.ts'
 import { jsonrpc } from '../types/index.ts'
 import type { RpcTransport } from './RpcTransport.ts'
 
 export class HttpRpcTransport<T extends RpcSchemaMap = RpcSchemaMap> implements RpcTransport<T> {
+  protected readonly _passThrough: boolean
   protected readonly _rpcUrl: string
   protected readonly _schemas: T
 
-  constructor(rpcUrl: string, schemas: T) {
+  constructor(rpcUrl: string, schemas: T, passThrough = false) {
     this._rpcUrl = rpcUrl
     this._schemas = schemas
+    this._passThrough = passThrough
   }
 
   async sendRequest<
@@ -46,8 +50,15 @@ export class HttpRpcTransport<T extends RpcSchemaMap = RpcSchemaMap> implements
         method: method as string,
       }
 
+      const schema = schemas[method]
+
       if (params) {
-        body.params = schemas[method].params.to.parse(params) as JsonRpcRequest
+        body.params = isDefined(schema)
+          ? schema.params.to.parse(params) as JsonRpcRequest
+          : this._passThrough ? z.json().parse(params) as JsonRpcRequest : undefined
+        if (!isDefined(body.params)) {
+          throw new Error(`RPC method ${String(method)} missing schema`)
+        }
       }
 
       const res = await new Axios(axiosJsonConfig()).post(url, body)

package/src/types/AccountBalanceViewerRpc.ts

@@ -0,0 +1,16 @@
+import type { AccountBalanceViewerMethods } from '@xyo-network/xl1-protocol-sdk'
+
+import type { MethodName, RpcMethodName } from './RpcMethodName.ts'
+
+export const AccountBalanceViewerRpcNamespace = 'accountBalanceViewer' as const
+export type AccountBalanceViewerRpcNamespace = typeof AccountBalanceViewerRpcNamespace
+
+export type AccountBalanceViewerMethodName = MethodName<AccountBalanceViewerMethods>
+export type AccountBalanceViewerRpcMethodName = RpcMethodName<AccountBalanceViewerRpcNamespace,
+  AccountBalanceViewerMethodName>
+
+export type AccountBalanceViewerRpcMethodHandlers = {
+  [K in AccountBalanceViewerMethodName as AccountBalanceViewerRpcMethodName]: (
+    params: Parameters<AccountBalanceViewerMethods[K]>,
+  ) => ReturnType<AccountBalanceViewerMethods[K]>
+}

package/src/types/MempoolViewerRpc.ts

@@ -0,0 +1,16 @@
+import type { MempoolViewerMethods } from '@xyo-network/xl1-protocol-sdk'
+
+import type { MethodName, RpcMethodName } from './RpcMethodName.ts'
+
+export const MempoolViewerRpcNamespace = 'mempoolViewer' as const
+export type MempoolViewerRpcNamespace = typeof MempoolViewerRpcNamespace
+
+export type MempoolViewerMethodName = MethodName<MempoolViewerMethods>
+export type MempoolViewerRpcMethodName = RpcMethodName<MempoolViewerRpcNamespace,
+  MempoolViewerMethodName>
+
+export type MempoolViewerRpcMethodHandlers = {
+  [K in MempoolViewerMethodName as MempoolViewerRpcMethodName]: (
+    params: Parameters<MempoolViewerMethods[K]>,
+  ) => ReturnType<MempoolViewerMethods[K]>
+}

package/src/types/index.ts

@@ -1,3 +1,4 @@
+export * from './AccountBalanceViewerRpc.ts'
 export * from './DataLakeViewerRpc.ts'
 export * from './ErrorCodes.ts'
 export * from './JsonRpc.ts'

package/src/types/schema/AccountBalanceViewerRpcSchemas.ts

@@ -0,0 +1,33 @@
+import {
+  AddressZod,
+  BigIntToJsonZod, HashZod, JsonToBigIntZod,
+} from '@xylabs/sdk-js'
+import { XL1BlockRangeZod } from '@xyo-network/xl1-protocol'
+import { AccountBalanceHistoryItemZod } from '@xyo-network/xl1-protocol-sdk'
+import * as z from 'zod'
+
+import type { AccountBalanceViewerRpcMethodName } from '../AccountBalanceViewerRpc.ts'
+import type { RpcSchemaMap } from './RpcSchemaMap.ts'
+
+export const AccountBalanceViewerRpcSchemas = {
+  accountBalanceViewer_accountsBalances: {
+    params: {
+      to: z.union([z.tuple([z.array(AddressZod)]), z.tuple([z.array(AddressZod), z.union([XL1BlockRangeZod, HashZod])])]),
+      from: z.union([z.tuple([z.array(AddressZod)]), z.tuple([z.array(AddressZod), z.union([XL1BlockRangeZod, HashZod])])]),
+    },
+    result: {
+      to: z.record(AddressZod, BigIntToJsonZod),
+      from: z.record(AddressZod, JsonToBigIntZod),
+    },
+  },
+  accountBalanceViewer_accountsBalancesHistory: {
+    params: {
+      to: z.union([z.tuple([z.array(AddressZod)]), z.tuple([z.array(AddressZod), z.union([XL1BlockRangeZod, HashZod])])]),
+      from: z.union([z.tuple([z.array(AddressZod)]), z.tuple([z.array(AddressZod), z.union([XL1BlockRangeZod, HashZod])])]),
+    },
+    result: {
+      to: z.record(AddressZod, z.array(AccountBalanceHistoryItemZod)),
+      from: z.record(AddressZod, z.array(AccountBalanceHistoryItemZod)),
+    },
+  },
+} satisfies RpcSchemaMap<AccountBalanceViewerRpcMethodName>

package/src/types/schema/AllRpcSchemas.ts

@@ -1,3 +1,4 @@
+import { AccountBalanceViewerRpcSchemas } from './AccountBalanceViewerRpcSchemas.ts'
 import { NetworkStakeViewerRpcSchemas } from './NetworkStakeViewerRpcSchemas.ts'
 import type { RpcSchemaMap } from './RpcSchemaMap.ts'
 import { XyoPermissionsRpcSchemas } from './XyoPermissionsRpcSchemas.ts'
@@ -6,6 +7,7 @@ import { XyoSignerRpcSchemas } from './XyoSignerRpcSchemas.ts'
 import { XyoViewerRpcSchemas } from './XyoViewerRpcSchemas.ts'
 
 export const AllRpcSchemas = {
+  ...AccountBalanceViewerRpcSchemas,
   ...XyoRunnerRpcSchemas,
   ...XyoSignerRpcSchemas,
   ...XyoViewerRpcSchemas,

package/src/types/schema/DataLakeViewerRpcSchema.ts

@@ -1,6 +1,6 @@
 import { HashZod } from '@xylabs/sdk-js'
 import { PayloadZod } from '@xyo-network/payload-model'
-import { ArrayBufferToJsonZod, JsonToArrayBufferZod } from '@xyo-network/xl1-protocol-sdk'
+import { ArrayBufferToJsonZod, JsonToArrayBufferZod } from '@xyo-network/xl1-protocol'
 import * as z from 'zod'
 
 import type { DataLakeViewerRpcMethodName } from '../DataLakeViewerRpc.ts'

package/src/types/schema/MempoolViewerRpcSchemas.ts

@@ -0,0 +1,19 @@
+import { SignedHydratedTransactionWithHashMetaZod } from '@xyo-network/xl1-protocol'
+import { PendingTransactionsOptionsZod } from '@xyo-network/xl1-protocol-sdk'
+import * as z from 'zod'
+
+import type { MempoolViewerRpcMethodName } from '../MempoolViewerRpc.ts'
+import type { RpcSchemaMap } from './RpcSchemaMap.ts'
+
+export const MempoolViewerRpcSchemas = {
+  mempoolViewer_pendingTransactions: {
+    params: {
+      to: z.tuple([PendingTransactionsOptionsZod.optional()]),
+      from: z.tuple([PendingTransactionsOptionsZod.optional()]),
+    },
+    result: {
+      to: z.array(SignedHydratedTransactionWithHashMetaZod),
+      from: z.array(SignedHydratedTransactionWithHashMetaZod),
+    },
+  },
+} satisfies RpcSchemaMap<MempoolViewerRpcMethodName>

package/src/types/schema/RewardsByPositionViewerRpcSchemas.ts

@@ -1,6 +1,5 @@
 import { BigIntToJsonZod, JsonToBigIntZod } from '@xylabs/sdk-js'
-import { asAttoXL1 } from '@xyo-network/xl1-protocol'
-import { RewardsRangeOptionsZod } from '@xyo-network/xl1-protocol-sdk'
+import { asAttoXL1, RewardsRangeOptionsZod } from '@xyo-network/xl1-protocol'
 import z from 'zod'
 
 import type { NetworkStakingStepRewardsByPositionViewerRpcMethodName } from '../NetworkStakingStepRewardsByPositionViewerRpc.ts'

package/src/types/schema/RewardsByStakerViewerRpcSchemas.ts

@@ -1,7 +1,7 @@
 import {
   AddressZod, BigIntToJsonZod, JsonToBigIntZod,
 } from '@xylabs/sdk-js'
-import { RewardsRangeOptionsZod } from '@xyo-network/xl1-protocol-sdk'
+import { RewardsRangeOptionsZod } from '@xyo-network/xl1-protocol'
 import z from 'zod'
 
 import type { NetworkStakingStepRewardsByStakerViewerRpcMethodName } from '../NetworkStakingStepRewardsByStakerViewerRpc.ts'

package/src/types/schema/RewardsByStepViewerRpcSchemas.ts

@@ -1,7 +1,7 @@
 import {
   AddressZod, BigIntToJsonZod, JsonToBigIntZod,
 } from '@xylabs/sdk-js'
-import { RewardsRangeOptionsZod } from '@xyo-network/xl1-protocol-sdk'
+import { RewardsRangeOptionsZod } from '@xyo-network/xl1-protocol'
 import z from 'zod'
 
 import type { NetworkStakingStepRewardsByStepViewerRpcMethodName } from '../NetworkStakingStepRewardsByStepViewerRpc.ts'

package/src/types/schema/RewardsTotalViewerRpcSchemas.ts

@@ -1,6 +1,5 @@
 import { BigIntToJsonZod, JsonToBigIntZod } from '@xylabs/sdk-js'
-import { asAttoXL1 } from '@xyo-network/xl1-protocol'
-import { RewardsRangeOptionsZod } from '@xyo-network/xl1-protocol-sdk'
+import { asAttoXL1, RewardsRangeOptionsZod } from '@xyo-network/xl1-protocol'
 import * as z from 'zod'
 
 import type { NetworkStakingStepRewardsTotalViewerRpcMethodName } from '../NetworkStakingStepRewardsTotalViewerRpc.ts'

package/src/types/schema/StepViewerRpcSchemas.ts

@@ -1,8 +1,9 @@
 import {
   AddressZod, BigIntToJsonZod, JsonToBigIntZod,
 } from '@xylabs/sdk-js'
-import { StepIdentityZod } from '@xyo-network/xl1-protocol'
-import { JsonToStakeZod, StakeToJsonZod } from '@xyo-network/xl1-protocol-sdk'
+import {
+  JsonToStakeZod, StakeToJsonZod, StepIdentityZod,
+} from '@xyo-network/xl1-protocol'
 import z from 'zod'
 
 import type { StepViewerMethodName } from '../StepViewerRpc.ts'

package/src/types/schema/TimeSyncViewerRpcSchema.ts

@@ -1,5 +1,4 @@
-import { TimePayloadZod } from '@xyo-network/xl1-protocol'
-import { TimeDomainZod } from '@xyo-network/xl1-protocol-sdk'
+import { TimeDomainZod, TimePayloadZod } from '@xyo-network/xl1-protocol'
 import * as z from 'zod'
 
 import type { TimeSyncViewerRpcMethodName } from '../TimeSyncViewerRpc.ts'

package/src/types/schema/XyoPermissionsRpcSchemas.ts

@@ -1,6 +1,6 @@
 import {
   InvokerPermissionZod, PermissionRequestZod, RequestedPermissionZod,
-} from '@xyo-network/xl1-protocol-sdk'
+} from '@xyo-network/xl1-protocol'
 import * as z from 'zod'
 
 import type { XyoPermissionsRpcMethodName } from '../XyoPermissions.ts'

package/src/types/schema/XyoRunnerRpcSchemas.ts

@@ -1,5 +1,5 @@
 import { HashToJsonZod, JsonToHashZod } from '@xylabs/sdk-js'
-import { SignedHydratedTransactionZod } from '@xyo-network/xl1-protocol-sdk'
+import { SignedHydratedTransactionZod } from '@xyo-network/xl1-protocol'
 import * as z from 'zod'
 
 import type { XyoRunnerRpcMethodName } from '../XyoRunnerRpc.ts'

package/src/types/schema/XyoSignerRpcSchemas.ts

@@ -1,6 +1,5 @@
 import { AddressZod } from '@xylabs/sdk-js'
-import { asHydratedTransactionWithStorageMeta } from '@xyo-network/xl1-protocol'
-import { SignedHydratedTransactionZod, UnsignedHydratedTransactionZod } from '@xyo-network/xl1-protocol-sdk'
+import { SignedHydratedTransactionWithHashMetaZod, UnsignedHydratedTransactionZod } from '@xyo-network/xl1-protocol'
 import { z } from 'zod'
 
 import type { XyoSignerRpcMethodName } from '../XyoSignerRpc.ts'
@@ -23,8 +22,8 @@ export const XyoSignerRpcSchemas = {
       from: z.tuple([UnsignedHydratedTransactionZod]),
     },
     result: {
-      to: SignedHydratedTransactionZod,
-      from: SignedHydratedTransactionZod.transform(data => asHydratedTransactionWithStorageMeta(data, { required: true })),
+      to: SignedHydratedTransactionWithHashMetaZod,
+      from: SignedHydratedTransactionWithHashMetaZod,
     },
   },
 } as const satisfies RpcSchemaMap<XyoSignerRpcMethodName>

package/src/types/schema/XyoViewerRpcSchemas.ts

@@ -4,11 +4,10 @@ import {
   JsonToHashZod,
 } from '@xylabs/sdk-js'
 import {
-  BlockNumberZod, BlockRangeZod, StepIdentityZod, XL1BlockNumberZod, XL1BlockRangeZod,
+  BlockNumberZod, BlockRangeZod, JsonToStakeZod, SignedHydratedBlockZod, SignedHydratedTransactionZod, StakeToJsonZod, StepIdentityZod, TransferPairZod,
+  XL1BlockNumberZod, XL1BlockRangeZod,
 } from '@xyo-network/xl1-protocol'
-import {
-  AccountBalanceHistoryItemZod, JsonToStakeZod, SignedHydratedBlockZod, SignedHydratedTransactionZod, StakeToJsonZod, TransferPairZod,
-} from '@xyo-network/xl1-protocol-sdk'
+import { AccountBalanceHistoryItemZod } from '@xyo-network/xl1-protocol-sdk'
 import * as z from 'zod'
 
 import type { XyoViewerRpcMethodName } from '../XyoViewerRpc.ts'

package/src/types/schema/index.ts

@@ -1,7 +1,9 @@
+export * from './AccountBalanceViewerRpcSchemas.ts'
 export * from './AllRpcSchemas.ts'
 export * from './createRequestSchema.ts'
 export * from './createResponseSchema.ts'
 export * from './DataLakeViewerRpcSchema.ts'
+export * from './MempoolViewerRpcSchemas.ts'
 export * from './NetworkStakeViewerRpcSchemas.ts'
 export * from './RewardsByPositionViewerRpcSchemas.ts'
 export * from './RewardsByStakerViewerRpcSchemas.ts'