@xyo-network/xl1-rpc 1.16.1 → 1.16.2

package/src/provider/network/MemoryXyoNetwork.ts

@@ -1,48 +0,0 @@
-import { isUndefined } from '@xylabs/typeof'
-import type {
-  GatewayName,
-  NetworkStatus,
-} from '@xyo-network/xl1-protocol'
-import { isNetworkStatus } from '@xyo-network/xl1-protocol'
-import type { XyoNetwork } from '@xyo-network/xl1-protocol-sdk'
-import axios from 'axios'
-
-import {
-  errorStatus, StatusNetworks, unknownStatus,
-} from './lib/index.ts'
-
-export class MemoryXyoNetwork implements XyoNetwork {
-  protected readonly _networkId: GatewayName
-
-  constructor(networkId: GatewayName) {
-    this._networkId = networkId
-  }
-
-  async status(): Promise<NetworkStatus> {
-    const statusNetwork = StatusNetworks[this._networkId]
-    if (isUndefined(statusNetwork)) {
-      throw new Error(`Unknown status network ID: ${this._networkId}`)
-    }
-
-    return await this.makeRequest(statusNetwork.statusUrl)
-  }
-
-  private async makeRequest(url: string): Promise<NetworkStatus> {
-    try {
-      const response = await axios.get(url)
-      if (isNetworkStatus(response.data)) {
-        return response.data
-      } else {
-        if (response.status === 200) {
-          console.error('Unknown network status response:', response.data)
-
-          return unknownStatus
-        }
-        return errorStatus
-      }
-    } catch (error) {
-      console.error('Error fetching network status:', error)
-      return errorStatus
-    }
-  }
-}

package/src/provider/network/index.ts

@@ -1 +0,0 @@
-export * from './MemoryXyoNetwork.ts'

package/src/provider/network/lib/FailedNetworkStatusPayloads.ts

@@ -1,14 +0,0 @@
-import type { NetworkStatus } from '@xyo-network/xl1-protocol'
-import { NetworkStatusSchema } from '@xyo-network/xl1-protocol'
-
-export const unknownStatus: NetworkStatus = {
-  description: 'Unknown Network Status',
-  schema: NetworkStatusSchema,
-  state: 'unknown',
-}
-
-export const errorStatus: NetworkStatus = {
-  description: 'Error Fetching Network Status',
-  schema: NetworkStatusSchema,
-  state: 'unknown',
-}

package/src/provider/network/lib/StatusNetworks.ts

@@ -1,27 +0,0 @@
-import type { GatewayName } from '@xyo-network/xl1-protocol'
-
-export type StatusNetwork = {
-  id: GatewayName
-  statusUrl: string
-}
-
-export const MainNetworkStats: StatusNetwork = {
-  id: 'mainnet' as GatewayName,
-  statusUrl: 'https://xyo.network/chain-network-status-mainnet.json',
-}
-
-export const SequenceNetworkStats: StatusNetwork = {
-  id: 'sequence' as GatewayName,
-  statusUrl: 'https://beta.xyo.network/chain-network-status-sequence.json',
-}
-
-export const LocalNetworkStats: StatusNetwork = {
-  id: 'local' as GatewayName,
-  statusUrl: 'http://localhost:3002/chain-network-status-local.json',
-}
-
-export const StatusNetworks: Record<GatewayName, StatusNetwork> = {
-  ['mainnet' as GatewayName]: MainNetworkStats,
-  ['sequence' as GatewayName]: SequenceNetworkStats,
-  ['local' as GatewayName]: LocalNetworkStats,
-}

package/src/provider/network/lib/index.ts

@@ -1,2 +0,0 @@
-export * from './FailedNetworkStatusPayloads.ts'
-export * from './StatusNetworks.ts'

package/src/provider/network/spec/XyoNetwork.spec.ts

@@ -1,77 +0,0 @@
-import type { NetworkId } from '@xyo-network/xl1-protocol'
-import { NetworkStatusSchema } from '@xyo-network/xl1-protocol'
-import axios from 'axios'
-import type { Mocked } from 'vitest'
-import {
-  beforeEach, describe, expect, it, vitest,
-} from 'vitest'
-
-import {
-  errorStatus, StatusNetworks, unknownStatus,
-} from '../lib/index.ts'
-import { MemoryXyoNetwork } from '../MemoryXyoNetwork.ts'
-
-vitest.mock('axios')
-const mockedAxios = axios as Mocked<typeof axios>
-
-describe('MemoryXyoNetwork', () => {
-  const mockNetworkStatus = {
-    description: 'Mock Network Status',
-    schema: NetworkStatusSchema,
-    state: 'active',
-  }
-
-  const networks = Object.values(StatusNetworks)
-
-  beforeEach(() => {
-    vitest.clearAllMocks()
-  })
-
-  for (const { id, statusUrl } of networks) {
-    it(`should fetch the ${id} status successfully`, async () => {
-      mockedAxios.get.mockResolvedValueOnce({ data: mockNetworkStatus })
-
-      const network = new MemoryXyoNetwork(id)
-      const status = await network.status()
-
-      expect(mockedAxios.get).toHaveBeenCalledWith(statusUrl)
-      expect(status).toEqual(mockNetworkStatus)
-    })
-
-    it(`should return unknownStatus for invalid response data on ${id}`, async () => {
-      mockedAxios.get.mockResolvedValueOnce({ data: { invalid: 'data' }, status: 200 })
-
-      const network = new MemoryXyoNetwork(id)
-      const status = await network.status()
-
-      expect(mockedAxios.get).toHaveBeenCalledWith(statusUrl)
-      expect(status).toEqual(unknownStatus)
-    })
-
-    it(`should return errorStatus for non-200 response on ${id}`, async () => {
-      mockedAxios.get.mockResolvedValueOnce({ data: {}, status: 500 })
-
-      const network = new MemoryXyoNetwork(id)
-      const status = await network.status()
-
-      expect(mockedAxios.get).toHaveBeenCalledWith(statusUrl)
-      expect(status).toEqual(errorStatus)
-    })
-
-    it(`should return errorStatus for network errors on ${id}`, async () => {
-      mockedAxios.get.mockRejectedValueOnce(new Error('Network error'))
-
-      const network = new MemoryXyoNetwork(id)
-      const status = await network.status()
-
-      expect(mockedAxios.get).toHaveBeenCalledWith(statusUrl)
-      expect(status).toEqual(errorStatus)
-    })
-  }
-
-  it('should throw an error for unknown network ID', async () => {
-    const network = new MemoryXyoNetwork('invalid' as unknown as NetworkId)
-
-    await expect(network.status()).rejects.toThrow('Unknown status network ID: invalid')
-  })
-})

package/src/provider/permissions/MemoryXyoPermissions.ts

@@ -1,82 +0,0 @@
-import { assertEx } from '@xylabs/assert'
-import type {
-  CaveatTypes, InvokerPermission, PermissionRequest, RequestedPermission,
-  XyoPermissions,
-} from '@xyo-network/xl1-protocol-sdk'
-
-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/spec/MemoryXyoPermissions.spec.ts

@@ -1,93 +0,0 @@
-import type { PermissionRequest } from '@xyo-network/xl1-protocol-sdk'
-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

@@ -1,32 +0,0 @@
-import { assertEx } from '@xylabs/assert'
-import type { InvokerPermission } from '@xyo-network/xl1-protocol-sdk'
-
-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

@@ -1,15 +0,0 @@
-import type { InvokerPermission, PermissionsGetHandler } from '@xyo-network/xl1-protocol-sdk'
-
-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

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

package/src/provider/runner/MemoryXyoRunner.ts

@@ -1,23 +0,0 @@
-import type { Hash } from '@xylabs/hex'
-import { MemoryArchivist } from '@xyo-network/archivist-memory'
-import { PayloadBuilder } from '@xyo-network/payload-builder'
-import type { SignedHydratedTransactionWithStorageMeta } from '@xyo-network/xl1-protocol'
-import type { XyoRunner } from '@xyo-network/xl1-protocol-sdk'
-import { flattenHydratedTransaction } from '@xyo-network/xl1-protocol-sdk'
-
-export class MemoryXyoRunner implements XyoRunner {
-  protected _archivist: MemoryArchivist | undefined
-
-  async broadcastTransaction(transaction: SignedHydratedTransactionWithStorageMeta): Promise<Hash> {
-    const archivist = await this.getArchivist()
-    await archivist.insert(flattenHydratedTransaction(transaction))
-    return await PayloadBuilder.hash(transaction[0])
-  }
-
-  protected async getArchivist(): Promise<MemoryArchivist> {
-    if (!this._archivist) {
-      this._archivist = await MemoryArchivist.create({ account: 'random' })
-    }
-    return this._archivist
-  }
-}

package/src/provider/signer/MemoryXyoSigner.ts

@@ -1,49 +0,0 @@
-import type { Address } from '@xylabs/hex'
-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, ChainId, TransactionBoundWitness, TransactionFeesBigInt,
-} from '@xyo-network/xl1-protocol'
-import type { XyoSigner } from '@xyo-network/xl1-protocol-sdk'
-import { buildTransaction, signTransaction } from '@xyo-network/xl1-protocol-sdk'
-
-export class MemoryXyoSigner implements XyoSigner {
-  protected readonly _account: AccountInstance
-
-  constructor(account: AccountInstance) {
-    this._account = account
-  }
-
-  address(): Address {
-    return this._account.address
-  }
-
-  async createSignedTransaction(
-    chain: ChainId,
-    elevatedPayloads: AllowedBlockPayload[],
-    additionalPayloads: Payload[],
-    nbf: number,
-    exp: number,
-    fees: TransactionFeesBigInt,
-    from?: Address,
-  ): Promise<Signed<TransactionBoundWitness>> {
-    const fromAddress = from ?? this._account.address
-    const transaction = await buildTransaction(
-      chain,
-      elevatedPayloads,
-      additionalPayloads,
-      this._account,
-      nbf,
-      exp,
-      fromAddress,
-      fees,
-    )
-    return transaction[0]
-  }
-
-  async signTransaction(tx: [UnsignedBoundWitness<TransactionBoundWitness>, Payload[]]): Promise<[Signed<TransactionBoundWitness>, Payload[]]> {
-    const txBW = await signTransaction(tx[0], this._account)
-    return [txBW, tx[1]]
-  }
-}