@xyo-network/xl1-rpc 1.9.0 → 1.10.1

package/src/provider/host/Abstract.ts

@@ -1,42 +0,0 @@
-import { assertEx } from '@xylabs/assert'
-import type { Promisable } from '@xylabs/promise'
-import type { Payload } from '@xyo-network/payload-model'
-import type {
-  AllowedBlockPayload, HydratedTransaction, InvokerPermission, Permission, XyoConnectionProvider, XyoGatewayProvider, XyoRpcConnectionConfig, XyoSigner,
-} from '@xyo-network/xl1-protocol'
-
-export abstract class AbstractXyoGateway implements XyoGatewayProvider {
-  activeConnection(): Promisable<XyoConnectionProvider | undefined> {
-    throw new Error('Deprecated method not implemented.')
-  }
-
-  addConnection(_config: XyoRpcConnectionConfig): Promisable<XyoConnectionProvider> {
-    throw new Error('Deprecated method not implemented.')
-  }
-
-  connections(): Promisable<Record<string, XyoConnectionProvider>> {
-    throw new Error('Deprecated method not implemented.')
-  }
-
-  getPermissions(): Promisable<InvokerPermission[]> {
-    throw new Error('Deprecated method not implemented.')
-  }
-
-  requestPermissions(_permissions: Permission[]): Promisable<boolean> {
-    throw new Error('Deprecated method not implemented.')
-  }
-
-  revokePermissions(_permissions: Permission[]): Promisable<boolean> {
-    throw new Error('Deprecated method not implemented.')
-  }
-
-  async submitTransaction(elevatedPayloads: AllowedBlockPayload[], additionalPayloads: Payload[]): Promise<HydratedTransaction> {
-    const connection = await this.connection()
-    assertEx(connection.submitTransaction, () => 'Active connection does not support transaction submission')
-    const tx = await connection.submitTransaction?.(elevatedPayloads, additionalPayloads)
-    return assertEx(tx, () => 'Transaction submission failed')
-  }
-
-  abstract connection(): Promisable<XyoConnectionProvider>
-  abstract signer(): Promisable<XyoSigner>
-}

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

@@ -1,73 +0,0 @@
-import type { JsonRpcRequest } from '@metamask/utils'
-import { isDefined } from '@xylabs/typeof'
-import { v4 } from 'uuid'
-import type { z } from 'zod'
-
-import type { RpcSchemaMap } from '../../types/index.ts'
-import { jsonrpc, XyoGatewayRpcSchemas } from '../../types/index.ts'
-import type { RpcTransport } from '../RpcTransport.ts'
-import type { JsonRpcRequestWithId } from './helpers.ts'
-import { isRpcError } from './helpers.ts'
-import { buildSessionMessageRequest } from './SessionEnvelope.ts'
-
-/** @deprecated - now part of a client gateway */
-export class PostMessageRpcTransport<T extends RpcSchemaMap = RpcSchemaMap> implements RpcTransport<T> {
-  protected readonly destination?: string
-  protected readonly schemas: T
-
-  constructor(defaultDestination?: string, schemas: T = XyoGatewayRpcSchemas as T) {
-    this.schemas = schemas
-    this.destination = defaultDestination
-  }
-
-  async sendRequest<
-    TMethod extends keyof T & string,
-  >(
-    method: TMethod,
-    params?: z.infer<T[TMethod]['params']['to']>,
-  ): Promise<z.infer<T[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.infer<TSchemas[TMethod]['params']['to']>,
-  ): Promise<z.infer<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
-
-    return await new Promise((resolve, reject) => {
-      const id = body.id
-
-      const handler = (event: MessageEvent) => {
-        if (event.origin !== globalThis.window.origin) return
-        if ((event.data as JsonRpcRequestWithId).id !== id) return
-
-        globalThis.removeEventListener('message', handler)
-        if (event.data.result.some(isRpcError)) {
-          reject(event.data.result[0])
-        } else {
-          resolve(event.data.result[0])
-        }
-      }
-
-      globalThis.addEventListener('message', handler)
-
-      globalThis.postMessage(
-        buildSessionMessageRequest(body, this.destination),
-        globalThis.location.origin,
-      )
-    })
-  }
-}