@xyo-network/xl1-rpc 1.15.1 → 1.15.3

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

@@ -1,120 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import type { JsonRpcRequest } from '@metamask/utils'
-import {
-  isJsonRpcError,
-  isJsonRpcSuccess,
-} from '@metamask/utils'
-import { isDefined } from '@xylabs/typeof'
-import { v4 } from 'uuid'
-import type * as z from 'zod'
-
-import type { RpcSchemaMap, XyoGatewayRpcMethodName } from '../../types/index.ts'
-import { jsonrpc, XyoGatewayRpcSchemas } from '../../types/index.ts'
-import type { RpcTransport } from '../RpcTransport.ts'
-// eslint-disable-next-line sonarjs/deprecation
-import { isRpcError } from './helpers.ts'
-import { resolvedEvent } from './resolveData.ts'
-
-const isValidBaseRpcEvent = (data: any) => {
-  return !!(data && typeof data === 'object'
-    && 'jsonrpc' in data && data.jsonrpc === '2.0'
-    && 'method' in data && typeof data.method === 'string'
-    && 'id' in data && typeof data.id === 'string')
-}
-
-const isRpcResponse = (data: any, targetId: string) => {
-  return isValidBaseRpcEvent(data) && (isDefined(targetId) ? data.id === targetId : true) && 'result' in data && Array.isArray(data.result)
-}
-
-/** @deprecated - now part of a client gateway */
-export class LegacyPostMessageRpcTransport implements RpcTransport<RpcSchemaMap<XyoGatewayRpcMethodName>> {
-  protected readonly destination?: string
-  protected readonly schemas: RpcSchemaMap<XyoGatewayRpcMethodName>
-  protected readonly sessionId?: string
-
-  constructor(defaultDestination?: string, sessionId?: string) {
-    this.schemas = XyoGatewayRpcSchemas
-    this.destination = defaultDestination
-    this.sessionId = sessionId
-  }
-
-  async sendRequest<
-    TMethod extends keyof RpcSchemaMap<XyoGatewayRpcMethodName>,
-  >(
-    method: TMethod,
-    params?: z.input<RpcSchemaMap<XyoGatewayRpcMethodName>[TMethod]['params']['to']>,
-  ): Promise<z.output<RpcSchemaMap<XyoGatewayRpcMethodName>[TMethod]['result']['from']>> {
-    const id = v4()
-    return await this.callRpc(this.schemas, method, id, params)
-  }
-
-  private async callRpc<
-    TSchemas extends RpcSchemaMap,
-    TMethod extends keyof TSchemas,
-  >(
-    schemas: TSchemas,
-    method: TMethod,
-    id: string,
-    params?: z.input<TSchemas[TMethod]['params']['to']>,
-  ): Promise<z.output<TSchemas[TMethod]['result']['from']>> {
-    const body: JsonRpcRequest = {
-      jsonrpc,
-      id,
-      method: method as string,
-    }
-
-    body.params = ((isDefined(params) && isDefined(schemas[method])) ? schemas[method].params.to.parse(params) : params) as JsonRpcRequest
-
-    return await new Promise((resolve, reject) => {
-      const id = body.id
-
-      const handler = (event: MessageEvent) => {
-        if (event.origin !== globalThis.window.origin) return
-        if (!isRpcResponse(event.data, id as string)) return
-        const data = resolvedEvent(event, id as string)
-        if (data === false) return
-
-        globalThis.removeEventListener('message', handler)
-
-        if (data.legacyEventData) {
-          // Handle legacy event data
-          // eslint-disable-next-line sonarjs/deprecation
-          if (data.legacyEventData.result.some(isRpcError)) {
-            reject(data.legacyEventData.result[0])
-          } else {
-            resolve(data.legacyEventData.result[0])
-          }
-          return
-        }
-
-        if (data.eventData) {
-          // Handle new event data
-          if (isJsonRpcError(data.eventData)) {
-            reject(data.eventData)
-            return
-          }
-          if (isJsonRpcSuccess(data.eventData)) {
-            resolve(data.eventData as z.infer<TSchemas[TMethod]['result']['from']>)
-            return
-          }
-          reject(new Error('Unexpected response format'))
-        }
-      }
-
-      globalThis.addEventListener('message', handler)
-
-      globalThis.postMessage(
-        {
-          data: body,
-          destination: this.destination,
-          sessionId: this.sessionId,
-        },
-        globalThis.location.origin,
-      )
-    })
-  }
-}
-
-/** @deprecated - use LegacyPostMessageRpcTransport but rely on wallet release > 1.17.1 to handle the postMessage flow */
-// eslint-disable-next-line sonarjs/deprecation
-export const PostMessageRpcTransport = LegacyPostMessageRpcTransport

package/src/types/XyoGatewayRpc.ts

@@ -1,15 +0,0 @@
-import type { XyoGatewayProvider } from '@xyo-network/xl1-protocol'
-
-export type XyoGatewayMethodPrefix = 'xyoGateway'
-
-export type XyoGatewayMethodName = keyof Pick<XyoGatewayProvider, 'submitTransaction'>
-
-// Convert `getPermissions` to `xyoGateway_getPermissions`, etc.
-export type XyoGatewayRpcMethodName = `${XyoGatewayMethodPrefix}_${XyoGatewayMethodName}`
-
-// Map each XYO RPC method string to the corresponding function type from XyoGateway
-export type XyoGatewayRpcMethodHandlers = {
-  [K in XyoGatewayMethodName as `${XyoGatewayMethodPrefix}_${K}`]: (
-    params: Parameters<Exclude<XyoGatewayProvider[K], undefined>>
-  ) => ReturnType<Exclude<XyoGatewayProvider[K], undefined>>
-}

package/src/types/schema/XyoGatewayRpcSchemas.ts

@@ -1,108 +0,0 @@
-import type { Chain } from '@xyo-network/xl1-protocol'
-import * as z from 'zod'
-
-import type { XyoGatewayRpcMethodName } from '../XyoGatewayRpc.ts'
-import { BlockBoundWitnessZod, HydratedTransactionZod } from './common/index.ts'
-import type { RpcSchemaMap } from './RpcSchemaMap.ts'
-
-export const ChainConnectionZod = z.object({
-  chainId: z.union([z.string(), z.custom<Chain>()]).optional(),
-  name: z.string(),
-  url: z.string(),
-})
-
-export const CaveatTypesZod = z.enum(['chain', 'expiration', 'filteredResponse', 'rateLimit'])
-
-export const CaveatsZod = z.object({
-  type: CaveatTypesZod,
-  value: z.unknown(), // JsonValue is usually unknown, adjust if you have a stricter type
-})
-
-export const PermissionZod = z.object({
-  capability: z.string(),
-  caveats: CaveatsZod.array().optional(),
-  invoker: z.string(),
-})
-
-export const InvokerPermissionZod = PermissionZod.extend({ date: z.number().optional() })
-
-export type ChainConnection = z.infer<typeof ChainConnectionZod>
-
-export const XyoGatewayRpcSchemas = {
-  /*
-  xyoGateway_addConnection: {
-    params: {
-      to: z.tuple([ChainConnectionSchema]),
-      from: z.tuple([ChainConnectionSchema]),
-    },
-    result: {
-      to: z.tuple([z.boolean()]),
-      from: z.tuple([z.boolean()]),
-    },
-  },
-  xyoGateway_connections: {
-    params: {
-      to: z.array(z.any()).length(0).optional(),
-      from: z.array(z.any()).length(0).optional(),
-    },
-    result: {
-      to: z.array(ChainConnectionSchema),
-      from: z.array(ChainConnectionSchema),
-    },
-  },
-  xyoGateway_getPermissions: {
-    params: {
-      to: z.array(z.any()).length(0).optional(),
-      from: z.array(z.any()).length(0).optional(),
-    },
-    result: {
-      to: z.array(InvokerPermissionSchema),
-      from: z.array(InvokerPermissionSchema),
-    },
-  },
-  xyoGateway_requestPermissions: {
-    params: {
-      to: z.array(PermissionSchema),
-      from: z.array(PermissionSchema),
-    },
-    result: {
-      to: z.boolean(),
-      from: z.boolean(),
-    },
-  },
-  xyoGateway_revokePermissions: {
-    params: {
-      to: z.array(PermissionSchema),
-      from: z.array(PermissionSchema),
-    },
-    result: {
-      to: z.boolean(),
-      from: z.boolean(),
-    },
-  },
-  xyoGateway_activeConnection: {
-    params: {
-      from: z.never(),
-      to: z.never(),
-    },
-    result: {
-      from: z.string().optional(),
-      to: z.string().optional(),
-    },
-  },
-  */
-  xyoGateway_submitTransaction: {
-    params: {
-      from: z.array(
-        HydratedTransactionZod,
-      ),
-      to: z.array(
-        HydratedTransactionZod,
-      ),
-    },
-    result: {
-      from: BlockBoundWitnessZod,
-      to: BlockBoundWitnessZod,
-    },
-  },
-} satisfies RpcSchemaMap<XyoGatewayRpcMethodName>