@xyo-network/xl1-rpc 1.15.1 → 1.15.3

package/src/provider/client/MemoryXyoClient.ts

@@ -1,12 +1,13 @@
 import type {
   PermissionsProvider, XyoClient, XyoGatewayProvider,
+  XyoPermissions,
 } from '@xyo-network/xl1-protocol'
 
 export class MemoryXyoClient implements XyoClient {
   gateways: Readonly<Record<string, XyoGatewayProvider>>
   permissions: PermissionsProvider
 
-  constructor(gateways: Readonly<Record<string, XyoGatewayProvider>>, permissions: PermissionsProvider) {
+  constructor(gateways: Readonly<Record<string, XyoGatewayProvider>>, permissions: XyoPermissions) {
     this.gateways = gateways
     this.permissions = permissions
   }

package/src/provider/client/index.ts

@@ -1,2 +1 @@
 export * from './MemoryXyoClient.ts'
-export * from './PermissionsStore/index.ts'

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

@@ -1,35 +1,27 @@
-import { isHash } from '@xylabs/hex'
 import type { AccountInstance } from '@xyo-network/account-model'
-import { PayloadBuilder } from '@xyo-network/payload-builder'
-import type { Payload } from '@xyo-network/payload-model'
 import { HDWallet } from '@xyo-network/wallet'
 import type {
-  AllowedBlockPayload, GatewayName, HashPayload, XyoClient,
-  XyoConnection,
+  GatewayName, XyoClient, XyoConnection,
 } from '@xyo-network/xl1-protocol'
-import { HashSchema } from '@xyo-network/xl1-protocol'
 import { ADDRESS_INDEX, generateXyoBaseWalletFromPhrase } from '@xyo-network/xl1-protocol-sdk'
 import {
-  beforeAll, beforeEach, describe, expect, it,
+  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 { MemoryPermissionsStore } from '../PermissionsStore/index.ts'
 
-type TestPayload = Payload<{
-  id: string
-  schema: 'network.xyo.test'
-}>
-
-describe.skip('Client', () => {
+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 store: MemoryPermissionsStore
+  let store
+  let permissions: MemoryXyoPermissions
   let connection: XyoConnection
   let gateway: MemoryXyoGateway
   let client: XyoClient
@@ -39,27 +31,26 @@ describe.skip('Client', () => {
     const wallet = await generateXyoBaseWalletFromPhrase(mnemonic)
     account = await wallet.derivePath(ADDRESS_INDEX.XYO)
     signer = new MemoryXyoSigner(account)
-    store = new MemoryPermissionsStore()
+    store = new MemoryPermissionsStore(invoker)
+    permissions = new MemoryXyoPermissions(store)
     connection = new HttpRpcXyoConnection({
       endpoint,
       account,
       // storage: dataLakeEndpoint,
     })
     gateway = new MemoryXyoGateway(signer, connection)
-    client = new MemoryXyoClient({ localhost: gateway }, store)
+    client = new MemoryXyoClient({ localhost: gateway }, permissions)
+  })
+
+  describe('permissions', () => {
+    it('should be have permissions', () => {
+      const permissions = client.permissions
+      expect(permissions).toBeDefined()
+    })
   })
 
   describe('gateways', () => {
     describe('connection', () => {
-      let onChainPayloads: AllowedBlockPayload[]
-      let offChainPayloads: Payload[]
-      beforeAll(async () => {
-        const id = new PayloadBuilder<TestPayload>({ schema: 'network.xyo.test' }).fields({ id: Date.now().toString() }).build()
-        const hash = await PayloadBuilder.hash(id)
-        const hashPayload: HashPayload = new PayloadBuilder<HashPayload>({ schema: HashSchema }).fields({ hash }).build()
-        onChainPayloads = [hashPayload]
-        offChainPayloads = [id]
-      })
       it('should be defined', () => {
         const gateway = client.gateways['localhost' as GatewayName].connection()
         expect(gateway).toBeDefined()
@@ -68,11 +59,6 @@ describe.skip('Client', () => {
         const chainId = await (await client.gateways['localhost' as GatewayName]?.connection())?.viewer?.chainId()
         expect(chainId).toBeDefined()
       })
-      it.only('should allow for submitting transactions', async () => {
-        const [hash, tx] = await client.gateways['localhost' as GatewayName]?.addPayloadsToChain?.(onChainPayloads, offChainPayloads) ?? []
-        expect(isHash(hash)).toBeTruthy()
-        expect(tx).toBeDefined()
-      })
     })
   })
 })

package/src/provider/index.ts

@@ -3,6 +3,7 @@ export * from './connection/index.ts'
 export * from './datalake/index.ts'
 export * from './gateway/index.ts'
 export * from './network/index.ts'
+export * from './permissions/index.ts'
 export * from './runner/index.ts'
 export * from './signer/index.ts'
 export * from './viewer/index.ts'

package/src/provider/permissions/MemoryXyoPermissions.ts

@@ -0,0 +1,82 @@
+import { assertEx } from '@xylabs/assert'
+import type {
+  CaveatTypes, InvokerPermission, PermissionRequest, RequestedPermission,
+  XyoPermissions,
+} from '@xyo-network/xl1-protocol'
+
+import type { Invoker, PermissionsStore } from './store/index.ts'
+
+/**
+ * In-memory implementation of XyoPermissions for testing or ephemeral use cases.
+ * Does not persist data beyond the lifetime of the instance.
+ * Assumes all permission requests are granted and revocations always succeed.
+ */
+export class MemoryXyoPermissions implements XyoPermissions {
+  invoker: Invoker
+  private _store: PermissionsStore
+
+  constructor(store: PermissionsStore) {
+    this._store = store
+    this.invoker = store.invoker
+  }
+
+  get store(): PermissionsStore {
+    return assertEx(this._store, () => 'Store must be defined to get permissions')
+  }
+
+  async getPermissions(): Promise<InvokerPermission[]> {
+    return await this.store.getPermissions()
+  }
+
+  // assumed the permissions are always granted
+  async requestPermissions(permissions: PermissionRequest[]): Promise<RequestedPermission[]> {
+    await Promise.resolve()
+    // Flatten PermissionRequest[] into InvokerPermission[]
+    const newPermissions: InvokerPermission[] = []
+    const now = Date.now()
+    for (const req of permissions) {
+      for (const parentCapability in req) {
+        newPermissions.push({
+          invoker: this.invoker,
+          parentCapability,
+          caveats: Object.entries(req[parentCapability]).map(([type, value]) => ({ type: type as CaveatTypes, value })),
+          date: now,
+        })
+      }
+    }
+
+    // Update or add permissions in the store
+    const existingPermissions = await this.getPermissions()
+    for (const perm of newPermissions) {
+      const idx = existingPermissions.findIndex(
+        p => p.invoker === perm.invoker && p.parentCapability === perm.parentCapability,
+      )
+      if (idx === -1) {
+        existingPermissions.push(perm)
+      } else {
+        existingPermissions[idx] = perm
+      }
+    }
+    await this.store.setPermissions(existingPermissions)
+
+    // Return the granted permissions in RequestedPermission shape
+    return newPermissions.map(({ parentCapability, date }) => ({ parentCapability, date }))
+  }
+
+  // Assumes the permissions are always revoked
+  async revokePermissions(permissions: PermissionRequest): Promise<RequestedPermission[]> {
+    const existingPermissions = await this.getPermissions()
+    const revoked: RequestedPermission[] = []
+    for (const parentCapability in permissions) {
+      const idx = existingPermissions.findIndex(
+        p => p.invoker === this.invoker && p.parentCapability === parentCapability,
+      )
+      if (idx !== -1) {
+        const removed = existingPermissions.splice(idx, 1)[0]
+        revoked.push({ parentCapability: removed.parentCapability, date: removed.date })
+      }
+    }
+    await this.store.setPermissions(existingPermissions)
+    return revoked
+  }
+}

package/src/provider/permissions/RpcXyoPermissions.ts

@@ -0,0 +1,30 @@
+import type {
+  InvokerPermission,
+  PermissionRequest,
+  RequestedPermission,
+  XyoPermissions,
+} from '@xyo-network/xl1-protocol'
+
+import type { RpcTransport } from '../../transport/index.ts'
+import type { XyoPermissionsRpcSchemas } from '../../types/index.ts'
+
+export class RpcXyoPermissions implements XyoPermissions {
+  protected readonly transport: RpcTransport<typeof XyoPermissionsRpcSchemas>
+
+  constructor(transport: RpcTransport<typeof XyoPermissionsRpcSchemas>) {
+    this.transport = transport
+  }
+
+  async getPermissions(): Promise<InvokerPermission[]> {
+    return await this.transport.sendRequest('xyoPermissions_getPermissions', [])
+  }
+
+  async requestPermissions(permissions: PermissionRequest[]): Promise<RequestedPermission[]> {
+    return await this.transport.sendRequest('xyoPermissions_requestPermissions', [permissions])
+  }
+
+  async revokePermissions(_permissions: PermissionRequest): Promise<RequestedPermission[]> {
+    await Promise.resolve()
+    throw new Error('Method not implemented.')
+  }
+}

package/src/provider/permissions/index.ts

@@ -0,0 +1,3 @@
+export * from './MemoryXyoPermissions.ts'
+export * from './RpcXyoPermissions.ts'
+export * from './store/index.ts'

package/src/provider/permissions/spec/MemoryXyoPermissions.spec.ts

@@ -0,0 +1,93 @@
+import type { PermissionRequest } from '@xyo-network/xl1-protocol'
+import {
+  beforeEach, describe, expect, it,
+} from 'vitest'
+
+import { MemoryXyoPermissions } from '../MemoryXyoPermissions.ts'
+import { MemoryPermissionsStore } from '../store/index.ts'
+
+describe('MemoryXyoPermissions', () => {
+  const invoker = 'https://example.com'
+  const parentCapability = 'xyoViewer_chainId'
+  let memoryPermissions: MemoryXyoPermissions
+
+  // Helper to build PermissionRequest
+  const buildPermissionRequest = (cap: string, caveats: Record<string, unknown> = {}) =>
+    ({ [cap]: caveats }) as PermissionRequest
+
+  beforeEach(() => {
+    memoryPermissions = new MemoryXyoPermissions(new MemoryPermissionsStore(invoker))
+  })
+
+  it('returns an empty list initially', async () => {
+    const permissions = await memoryPermissions.getPermissions()
+    expect(permissions).toEqual([])
+  })
+
+  it('adds and retrieves a permission', async () => {
+    const req = buildPermissionRequest(parentCapability)
+    const result = await memoryPermissions.requestPermissions([req])
+    expect(Array.isArray(result)).toBe(true)
+    expect(result.length).toBe(1)
+    expect(result[0].parentCapability).toBe(parentCapability)
+    expect(typeof result[0].date).toBe('number')
+
+    const permissions = await memoryPermissions.getPermissions()
+    expect(permissions.length).toBe(1)
+    expect(permissions[0].parentCapability).toBe(parentCapability)
+    expect(permissions[0].invoker).toBe(invoker)
+    expect(typeof permissions[0].date).toBe('number')
+  })
+
+  it('replaces an existing permission with the same key', async () => {
+    const req = buildPermissionRequest(parentCapability)
+    await memoryPermissions.requestPermissions([req])
+    const originalDate = (await memoryPermissions.getPermissions())[0].date
+
+    await new Promise(r => setTimeout(r, 5)) // ensure timestamp difference
+    await memoryPermissions.requestPermissions([req])
+    const updatedDate = (await memoryPermissions.getPermissions())[0].date
+
+    expect(updatedDate).toBeGreaterThan(originalDate!)
+  })
+
+  it('revokes a previously granted permission', async () => {
+    const req = buildPermissionRequest(parentCapability)
+    await memoryPermissions.requestPermissions([req])
+    expect((await memoryPermissions.getPermissions()).length).toBe(1)
+
+    const result = await memoryPermissions.revokePermissions(req)
+    expect(Array.isArray(result)).toBe(true)
+    expect(result.length).toBe(1)
+    expect(result[0].parentCapability).toBe(parentCapability)
+
+    const permissions = await memoryPermissions.getPermissions()
+    expect(permissions).toEqual([])
+  })
+
+  it('revoking a non-existent permission does nothing and returns empty array', async () => {
+    const req = buildPermissionRequest(parentCapability)
+    const result = await memoryPermissions.revokePermissions(req)
+    expect(result).toEqual([])
+    expect(await memoryPermissions.getPermissions()).toEqual([])
+  })
+
+  it('can handle multiple permissions from different invokers', async () => {
+    const memoryPermissionsA = new MemoryXyoPermissions(new MemoryPermissionsStore('https://a.com'))
+    const memoryPermissionsB = new MemoryXyoPermissions(new MemoryPermissionsStore('https://b.com'))
+    const reqA1 = buildPermissionRequest('xyo_1')
+    const reqA2 = buildPermissionRequest('xyo_3')
+    const reqB = buildPermissionRequest('xyo_2')
+
+    await memoryPermissionsA.requestPermissions([reqA1, reqA2])
+    await memoryPermissionsB.requestPermissions([reqB])
+
+    const resultsA = await memoryPermissionsA.getPermissions()
+    const resultsB = await memoryPermissionsB.getPermissions()
+
+    expect(resultsA.length).toBe(2)
+    expect(resultsB.length).toBe(1)
+    expect(resultsA.map(p => p.parentCapability).toSorted((a, b) => a.localeCompare(b))).toEqual(['xyo_1', 'xyo_3'])
+    expect(resultsB[0].parentCapability).toBe('xyo_2')
+  })
+})

package/src/provider/permissions/store/MemoryPermissions.ts

@@ -0,0 +1,32 @@
+import { assertEx } from '@xylabs/assert'
+import type { InvokerPermission } from '@xyo-network/xl1-protocol'
+
+import type { Invoker, PermissionsStore } from './PermissionsStore.ts'
+
+/**
+ * In-memory implementation of XyoPermissions for testing or ephemeral use cases.
+ * Does not persist data beyond the lifetime of the instance.
+ * Assumes all permission requests are granted and revocations always succeed.
+ */
+export class MemoryPermissionsStore implements PermissionsStore {
+  private _invoker: Invoker
+  private permissions: InvokerPermission[] = []
+
+  constructor(invoker: Invoker) {
+    this._invoker = invoker
+  }
+
+  get invoker(): Invoker {
+    return assertEx(this._invoker, () => 'Invoker must be defined to get permissions')
+  }
+
+  async getPermissions(): Promise<InvokerPermission[]> {
+    await Promise.resolve()
+    return this.permissions
+  }
+
+  async setPermissions(permissions: InvokerPermission[]): Promise<void> {
+    await Promise.resolve()
+    this.permissions = permissions
+  }
+}

package/src/provider/permissions/store/PermissionsStore.ts

@@ -0,0 +1,15 @@
+import type { InvokerPermission, PermissionsGetHandler } from '@xyo-network/xl1-protocol'
+
+export type Invoker = string
+export type ParentCapability = string
+/**
+ * Interface for a permissions store that abstracts away the storage medium.
+ * (i.e. in-memory, browser storage, database, etc.)
+ */
+export interface PermissionsStore extends PermissionsGetHandler {
+  // The invoker associated with this permissions store
+  readonly invoker: Invoker
+  // Retrieve all permissions associated with the invoker.
+  // Store or update permissions for the invoker
+  setPermissions(permissions: InvokerPermission[]): Promise<void>
+}

package/src/provider/permissions/store/index.ts

@@ -0,0 +1,2 @@
+export * from './MemoryPermissions.ts'
+export * from './PermissionsStore.ts'

package/src/provider/signer/JsonRpcXyoSigner.ts

@@ -3,7 +3,7 @@ import type { Signed } from '@xyo-network/boundwitness-model'
 import type { Payload } from '@xyo-network/payload-model'
 import type {
   AllowedBlockPayload,
-  Chain,
+  ChainId,
   SignedHydratedTransaction,
   TransactionBoundWitness,
   TransactionFeesBigInt,
@@ -25,8 +25,9 @@ export class RpcXyoSigner implements XyoSigner {
     return await this.transport.sendRequest('xyoSigner_address')
   }
 
+  /** @deprecated - use signTransaction instead */
   async createSignedTransaction(
-    chain: Chain,
+    chain: ChainId,
     elevatedPayloads: AllowedBlockPayload[],
     additionalPayloads: Payload[],
     nbf: number,

package/src/provider/signer/MemoryXyoSigner.ts

@@ -3,7 +3,7 @@ import type { AccountInstance } from '@xyo-network/account-model'
 import type { Signed, UnsignedBoundWitness } from '@xyo-network/boundwitness-model'
 import { type Payload } from '@xyo-network/payload-model'
 import type {
-  AllowedBlockPayload, Chain, TransactionBoundWitness, TransactionFeesBigInt, XyoSigner,
+  AllowedBlockPayload, ChainId, TransactionBoundWitness, TransactionFeesBigInt, XyoSigner,
 } from '@xyo-network/xl1-protocol'
 import { buildTransaction, signTransaction } from '@xyo-network/xl1-protocol-sdk'
 
@@ -19,7 +19,7 @@ export class MemoryXyoSigner implements XyoSigner {
   }
 
   async createSignedTransaction(
-    chain: Chain,
+    chain: ChainId,
     elevatedPayloads: AllowedBlockPayload[],
     additionalPayloads: Payload[],
     nbf: number,

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

@@ -1,13 +1,13 @@
 import { asAddress, toAddress } from '@xylabs/hex'
 import { Account } from '@xyo-network/account'
-import type { Chain, XyoSigner } from '@xyo-network/xl1-protocol'
+import type { ChainId, XyoSigner } from '@xyo-network/xl1-protocol'
 import { defaultTransactionFees } from '@xyo-network/xl1-protocol'
 import {
   beforeAll, describe, expect, it,
 } from 'vitest'
 
 // eslint-disable-next-line import-x/no-internal-modules
-import { rpcEngineFromProvider } from '../../../engine/index-node.ts'
+import { rpcEngineFromConnection } from '../../../engine/index-node.ts'
 import { XyoSignerRpcSchemas } from '../../../index-node.ts'
 import { MemoryRpcTransport } from '../../../transport/index.ts'
 import { XyoBaseConnection } from '../../connection/index.ts'
@@ -16,12 +16,12 @@ import { MemoryXyoSigner } from '../MemoryXyoSigner.ts'
 
 describe('RpcEngine - XyoSigner', () => {
   let sut: XyoSigner
-  const chain = toAddress('2AAE728aFd1777b79c34D79c4523797F9D9965b0') as Chain
+  const chain = toAddress('2AAE728aFd1777b79c34D79c4523797F9D9965b0') as ChainId
   beforeAll(async () => {
     const account = await Account.random()
     const signer = new MemoryXyoSigner(account)
-    const provider = new XyoBaseConnection({ signer })
-    const engine = rpcEngineFromProvider(provider)
+    const connection = new XyoBaseConnection({ signer })
+    const engine = rpcEngineFromConnection(connection)
     const transport = new MemoryRpcTransport(engine, XyoSignerRpcSchemas)
     sut = new RpcXyoSigner(transport)
   })

package/src/provider/viewer/JsonRpcXyoViewer.ts

@@ -1,14 +1,17 @@
 import type { Address, Hash } from '@xylabs/hex'
-import type { Promisable } from '@xylabs/promise'
-import {
-  asAttoXL1,
-  type AttoXL1,
-  type ForkHistory,
-  type HydratedBlock, type SignedHydratedTransaction,
-  type Stake,
-  type Transfer,
-  type XyoViewer,
+import type {
+  AttoXL1,
+  ChainId,
+  ForkHistory,
+  HydratedBlock, SignedHydratedTransaction,
+  Stake,
+  StepContext,
+  Transfer,
+  TransferBalanceHistoryItem,
+  TransferPair,
+  XyoViewer,
 } from '@xyo-network/xl1-protocol'
+import { asAttoXL1, asHydratedBlock } from '@xyo-network/xl1-protocol'
 
 import type { RpcTransport } from '../../transport/index.ts'
 import type { XyoViewerRpcSchemas } from '../../types/index.ts'
@@ -24,63 +27,119 @@ export class JsonRpcXyoViewer implements XyoViewer {
   }
 
   async accountBalanceHistory(address: Address): Promise<[Hash, Hash, Transfer][]> {
-    return (await this.transport.sendRequest('xyoViewer_accountBalanceHistory', [address])) as [Hash, Hash, Transfer][]
+    return (await this.transport.sendRequest('xyoViewer_accountBalanceHistory', [address]))
   }
 
   async blockByHash(hash: Hash): Promise<HydratedBlock | null> {
-    return (await this.transport.sendRequest('xyoViewer_blockByHash', [hash])) as HydratedBlock | null
+    return asHydratedBlock(await this.transport.sendRequest('xyoViewer_blockByHash', [hash])) ?? null
   }
 
   async blockByNumber(blockNumber: number): Promise<HydratedBlock | null> {
-    return (await this.transport.sendRequest('xyoViewer_blockByNumber', [blockNumber])) as HydratedBlock | null
+    return asHydratedBlock(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])) as HydratedBlock[]
+    return (await this.transport.sendRequest('xyoViewer_blocksByHash', [hash, limit])).map(b => asHydratedBlock(b, { required: true }))
   }
 
   async chainId(): Promise<Address> {
     return await this.transport.sendRequest('xyoViewer_chainId')
   }
 
-  async chainIdAtBlock(blockNumber: number): Promise<Address> {
-    return (await this.transport.sendRequest('xyoViewer_chainIdAtBlock', [blockNumber])) as Address
+  async chainIdAtBlock(blockNumber: number): Promise<ChainId | undefined> {
+    return (await this.transport.sendRequest('xyoViewer_chainIdAtBlock', [blockNumber]))
   }
 
   async currentBlock(): Promise<HydratedBlock> {
-    return (await this.transport.sendRequest('xyoViewer_currentBlock')) as HydratedBlock
+    return asHydratedBlock(await this.transport.sendRequest('xyoViewer_currentBlock'), { required: true })
   }
 
   async currentBlockHash(): Promise<Hash> {
-    return (await this.transport.sendRequest('xyoViewer_currentBlockHash')) as Hash
+    return (await this.transport.sendRequest('xyoViewer_currentBlockHash'))
   }
 
   async currentBlockNumber(): Promise<number> {
-    return (await this.transport.sendRequest('xyoViewer_currentBlockNumber')) as number
+    return (await this.transport.sendRequest('xyoViewer_currentBlockNumber'))
   }
 
-  forkHistory(): Promisable<ForkHistory> {
-    throw new Error('Method not implemented.')
+  async forkHistory(): Promise<ForkHistory> {
+    return (await this.transport.sendRequest('xyoViewer_forkHistory'))
   }
 
-  async stakeByAddress(address: Address, slot: number): Promise<Stake> {
-    return (await this.transport.sendRequest('xyoViewer_stakeByAddress', [address, slot]))
+  async networkStakeStepRewardAddressHistory(address: Address): Promise<Record<Address, bigint>> {
+    return (await this.transport.sendRequest('xyoViewer_networkStakeStepRewardAddressHistory', [address]))
   }
 
-  stakeById(_id: number): Promisable<Stake> {
-    throw new Error('Method not implemented.')
+  async networkStakeStepRewardAddressReward(context: StepContext, address: Address): Promise<Record<Address, bigint>> {
+    return (await this.transport.sendRequest('xyoViewer_networkStakeStepRewardAddressReward', [context, address]))
   }
 
-  stakedByStaker(_staker: Address): Promisable<Address[]> {
-    throw new Error('Method not implemented.')
+  async networkStakeStepRewardAddressShare(context: StepContext, address: Address): Promise<[bigint, bigint]> {
+    return (await this.transport.sendRequest('xyoViewer_networkStakeStepRewardAddressShare', [context, address]))
   }
 
-  stakesByStaked(_staked: Address): Promisable<Stake[]> {
-    throw new Error('Method not implemented.')
+  async networkStakeStepRewardClaimedByAddress(address: Address): Promise<bigint> {
+    return (await this.transport.sendRequest('xyoViewer_networkStakeStepRewardClaimedByAddress', [address]))
   }
 
-  stakesByStaker(_staker: Address): Promisable<Stake[]> {
-    throw new Error('Method not implemented.')
+  async networkStakeStepRewardForStep(context: StepContext): Promise<bigint> {
+    return (await this.transport.sendRequest('xyoViewer_networkStakeStepRewardForStep', [context]))
+  }
+
+  async networkStakeStepRewardForStepForPosition(context: StepContext, position: number): Promise<[bigint, bigint]> {
+    return (await this.transport.sendRequest('xyoViewer_networkStakeStepRewardForStepForPosition', [context, position]))
+  }
+
+  async networkStakeStepRewardPoolRewards(context: StepContext): Promise<Record<Address, bigint>> {
+    return (await this.transport.sendRequest('xyoViewer_networkStakeStepRewardPoolRewards', [context]))
+  }
+
+  async networkStakeStepRewardPoolShares(context: StepContext): Promise<Record<Address, bigint>> {
+    return (await this.transport.sendRequest('xyoViewer_networkStakeStepRewardPoolShares', [context]))
+  }
+
+  async networkStakeStepRewardPositionWeight(context: StepContext, position: number): Promise<bigint> {
+    return (await this.transport.sendRequest('xyoViewer_networkStakeStepRewardPositionWeight', [context, position]))
+  }
+
+  async networkStakeStepRewardPotentialPositionLoss(context: StepContext, position: number): Promise<bigint> {
+    return (await this.transport.sendRequest('xyoViewer_networkStakeStepRewardPotentialPositionLoss', [context, position]))
+  }
+
+  async networkStakeStepRewardRandomizer(context: StepContext): Promise<bigint> {
+    return (await this.transport.sendRequest('xyoViewer_networkStakeStepRewardRandomizer', [context]))
+  }
+
+  async networkStakeStepRewardStakerCount(context: StepContext): Promise<number> {
+    return (await this.transport.sendRequest('xyoViewer_networkStakeStepRewardStakerCount', [context]))
+  }
+
+  async networkStakeStepRewardUnclaimedByAddress(address: Address): Promise<bigint> {
+    return (await this.transport.sendRequest('xyoViewer_networkStakeStepRewardUnclaimedByAddress', [address]))
+  }
+
+  async networkStakeStepRewardWeightForAddress(context: StepContext, address: Address): Promise<bigint> {
+    return (await this.transport.sendRequest('xyoViewer_networkStakeStepRewardWeightForAddress', [context, address]))
+  }
+
+  async stakeById(id: number): Promise<Stake> {
+    return (await this.transport.sendRequest('xyoViewer_stakeById', [id]))
+  }
+
+  async stakeByStaker(staker: Address, slot: number): Promise<Stake> {
+    return (await this.transport.sendRequest('xyoViewer_stakeByStaker', [staker, slot]))
+  }
+
+  async stakedByStaker(staker: Address): Promise<Address[]> {
+    return (await this.transport.sendRequest('xyoViewer_stakedByStaker', [staker]))
+  }
+
+  async stakesByStaked(staked: Address): Promise<Stake[]> {
+    return (await this.transport.sendRequest('xyoViewer_stakesByStaked', [staked]))
+  }
+
+  async stakesByStaker(staker: Address): Promise<Stake[]> {
+    return (await this.transport.sendRequest('xyoViewer_stakesByStaker', [staker]))
   }
 
   async transactionByBlockHashAndIndex(blockHash: Hash, transactionIndex: number): Promise<SignedHydratedTransaction | null> {
@@ -94,4 +153,20 @@ export class JsonRpcXyoViewer implements XyoViewer {
   async transactionByHash(transactionHash: Hash): Promise<SignedHydratedTransaction | null> {
     return (await this.transport.sendRequest('xyoViewer_transactionByHash', [transactionHash])) as SignedHydratedTransaction | null
   }
+
+  async transferBalance(address: Address): Promise<AttoXL1> {
+    return asAttoXL1(await this.transport.sendRequest('xyoViewer_transferBalance', [address]))
+  }
+
+  async transferBalanceHistory(address: Address): Promise<TransferBalanceHistoryItem[]> {
+    return (await this.transport.sendRequest('xyoViewer_transferBalanceHistory', [address])) as TransferBalanceHistoryItem[]
+  }
+
+  async transferPairBalance(address: TransferPair): Promise<AttoXL1> {
+    return asAttoXL1(await this.transport.sendRequest('xyoViewer_transferPairBalance', [address]))
+  }
+
+  async transferPairBalanceHistory(address: TransferPair): Promise<TransferBalanceHistoryItem[]> {
+    return (await this.transport.sendRequest('xyoViewer_transferPairBalanceHistory', [address])) as TransferBalanceHistoryItem[]
+  }
 }

package/src/transport/post-message/index.ts

@@ -1,2 +1 @@
-export * from './LegacyPostMessageRpcTransport.ts'
 export * from './SessionEnvelope.ts'

package/src/types/ErrorCodes.ts

@@ -6,4 +6,5 @@ export const JsonRpcErrorCodes: Record<string, { code: number; message: string }
   InvalidParams: { code: -32_602, message: 'Invalid method parameter(s).' },
   InvalidRequest: { code: -32_600, message: 'The JSON sent is not a valid Request object.' },
   MethodNotFound: { code: -32_601, message: 'The method does not exist or is not available.' },
+  UserRejected: { code: 4001, message: 'User rejected the request.' },
 }