@portal-hq/provider 0.2.0-beta10

package/src/providers/index.ts

@@ -0,0 +1,494 @@
+import {
+  InvalidApiKeyError,
+  InvalidChainIdError,
+  InvalidGatewayConfigError,
+  KeychainAdapter,
+  ProviderRpcError,
+  RpcErrorCodes,
+} from '@portal-hq/utils'
+
+import { HttpRequester } from '../requesters'
+import { HttpSigner, MpcSigner, Signer } from '../signers'
+import {
+  type EventHandler,
+  type GatewayLike,
+  type ProviderOptions,
+  type RegisteredEventHandler,
+  type RequestArguments,
+  type SwitchEthereumChainParameter,
+} from '../../types'
+
+const passiveSignerMethods = [
+  'eth_accounts',
+  'eth_chainId',
+  'eth_requestAccounts',
+]
+
+const signerMethods = [
+  'eth_accounts',
+  'eth_chainId',
+  'eth_requestAccounts',
+  'eth_sendTransaction',
+  'eth_sign',
+  'eth_signTransaction',
+  'eth_signTypedData',
+  'personal_sign',
+]
+
+class Provider {
+  public readonly mpcUrl: string
+  public readonly portal: HttpRequester
+  public apiKey: string
+
+  public chainId: number
+  public isMPC?: boolean
+
+  private _address: string
+  private apiUrl: string
+  private autoApprove?: boolean
+  private events: Record<string, RegisteredEventHandler[]>
+  private keychain: KeychainAdapter
+  private log: Console
+  private gatewayConfig: GatewayLike
+  private rpc: HttpRequester
+
+  public signer?: Signer
+
+  constructor({
+    // Required options
+    apiKey,
+    chainId,
+    keychain,
+
+    // Optional options
+    apiUrl = 'api.portalhq.io',
+    autoApprove = false,
+    enableMpc = true,
+    mpcUrl = 'mpc.portalhq.io',
+    gatewayConfig = {},
+  }: ProviderOptions) {
+    // Handle required fields
+    if (!apiKey || apiKey.length === 0) {
+      throw new InvalidApiKeyError()
+    }
+    if (!chainId) {
+      throw new InvalidChainIdError()
+    }
+    if (!gatewayConfig) {
+      throw new InvalidGatewayConfigError()
+    }
+
+    // Handle the stuff we can auto-set
+    this.apiKey = apiKey
+    this.apiUrl = apiUrl
+    this.autoApprove = autoApprove
+    this.chainId = chainId
+    this.events = {}
+    this.isMPC = enableMpc
+    this.keychain = keychain
+    this.log = console
+    this.mpcUrl = mpcUrl
+    this.portal = new HttpRequester({
+      baseUrl: this.apiUrl,
+    })
+
+    // Handle RPC Initialization
+    this.gatewayConfig = gatewayConfig
+
+    this.rpc = new HttpRequester({
+      baseUrl: this.getRpcUrl(),
+    })
+
+    if (this.isMPC) {
+      // If MPC is enabled, initialize an MpcSigner
+      this.signer = new MpcSigner({
+        mpcUrl: this.mpcUrl,
+        keychain: this.keychain,
+      })
+    } else {
+      // If MPC is disabled, initialize an HttpSigner, talking to whatever httpHost was provided
+      this.signer = new HttpSigner({
+        portal: this.portal,
+      })
+    }
+
+    this.dispatchConnect()
+  }
+
+  get address(): string {
+    return this._address
+  }
+
+  set address(value: string) {
+    this._address = value
+
+    if (this.signer && this.isMPC) {
+      ;(this.signer as MpcSigner)._address = value
+    }
+  }
+
+  get rpcUrl(): string {
+    return this.getRpcUrl()
+  }
+
+  /**
+   * Invokes all registered event handlers with the data provided
+   * - If any `once` handlers exist, they are removed after all handlers are invoked
+   *
+   * @param event The name of the event to be handled
+   * @param data The data to be passed to registered event handlers
+   * @returns BaseProvider
+   */
+  public emit(event: string, data: any): Provider {
+    // Grab the registered event handlers if any are available
+    const handlers = this.events[event] || []
+
+    // Execute every event handler
+    for (const registeredEventHandler of handlers) {
+      registeredEventHandler.handler(data)
+    }
+
+    // Remove any registered event handlers with the `once` flag
+    this.events[event] = handlers.filter((handler) => !handler.once)
+
+    return this
+  }
+
+  /**
+   * Registers an event handler for the provided event
+   *
+   * @param event The event name to add a handler to
+   * @param callback The callback to be invoked when the event is emitted
+   * @returns BaseProvider
+   */
+  public on(event: string, callback: EventHandler): Provider {
+    // If no handlers are registered for this event, create an entry for the event
+    if (!this.events[event]) {
+      this.events[event] = []
+    }
+
+    // Register event handler with the rudimentary event bus
+    if (typeof callback !== 'undefined') {
+      this.events[event].push({
+        handler: callback,
+        once: false,
+      })
+    }
+
+    return this
+  }
+
+  /**
+   * Registers a single-execution event handler for the provided event
+   *
+   * @param event The event name to add a handler to
+   * @param callback The callback to be invoked the next time the event is emitted
+   * @returns BaseProvider
+   */
+  public once(event: string, callback: EventHandler): Provider {
+    // If no handlers are registered for this event, create an entry for the event
+    if (!this.events[event]) {
+      this.events[event] = []
+    }
+
+    // Register event handler with the rudimentary event bus
+    if (typeof callback !== 'undefined') {
+      this.events[event].push({
+        handler: callback,
+        once: true,
+      })
+    }
+
+    return this
+  }
+
+  public removeEventListener(
+    event: string,
+    listenerToRemove?: EventHandler,
+  ): void {
+    if (!this.events[event]) {
+      this.log.info(
+        `[PortalProvider] Attempted to remove a listener from unregistered event '${event}'. Ignoring.`,
+      )
+      return
+    }
+
+    if (!listenerToRemove) {
+      this.events[event] = []
+    } else {
+      const filterEventHandlers = (
+        registeredEventHandler: RegisteredEventHandler,
+      ) => {
+        return registeredEventHandler.handler !== listenerToRemove
+      }
+
+      this.events[event] = this.events[event].filter(filterEventHandlers)
+    }
+  }
+
+  /**
+   * Handles request routing in compliance with the EIP-1193 Ethereum Javascript Provider API
+   * - See here for more info: https://eips.ethereum.org/EIPS/eip-1193
+   *
+   * @param args The arguments of the request being made
+   * @returns Promise<any>
+   */
+  public async request({ method, params }: RequestArguments): Promise<any> {
+    if (method === 'eth_chainId') {
+      return this.chainId
+    }
+
+    const isSignerMethod = signerMethods.includes(method)
+
+    let result: any
+    if (!isSignerMethod && !method.startsWith('wallet_')) {
+      // Send to Gateway for RPC calls
+      const response = await this.handleGatewayRequests({ method, params })
+
+      this.emit('portal_signatureReceived', {
+        method,
+        params,
+        signature: response,
+      })
+
+      if (response.error) {
+        throw new ProviderRpcError(response.error)
+      }
+
+      result = response.result
+    } else if (isSignerMethod) {
+      // Handle signing
+      const transactionHash = await this.handleSigningRequests({
+        method,
+        params,
+      })
+
+      if (transactionHash) {
+        console.log(`Received transaction hash: `, transactionHash)
+
+        this.emit('portal_signatureReceived', {
+          method,
+          params,
+          signature: transactionHash,
+        })
+
+        result = transactionHash
+      }
+    } else {
+      // Unsupported method
+      throw new ProviderRpcError({
+        code: RpcErrorCodes.UnsupportedMethod,
+        data: {
+          method,
+          params,
+        },
+      })
+    }
+
+    return result
+  }
+
+  /**
+   * Updates the chainId of this instance and builds a new RPC HttpRequester for
+   * the gateway used for the new chain
+   *
+   * @param chainId A hex string of the chainId to use for this connection
+   * @returns BaseProvider
+   */
+  public async updateChainId(chainId: string): Promise<Provider> {
+    this.chainId = Number(`${chainId}`)
+
+    this.rpc = new HttpRequester({
+      baseUrl: this.getRpcUrl(),
+    })
+
+    this.emit('chainChanged', { chainId } as SwitchEthereumChainParameter)
+
+    return this
+  }
+
+  /**
+   * Kicks off the approval flow for a given request
+   *
+   * @param args The arguments of the request being made
+   */
+  protected async getApproval({
+    method,
+    params,
+  }: RequestArguments): Promise<boolean> {
+    // If autoApprove is enabled, just resolve to true
+    if (this.autoApprove) {
+      return true
+    }
+
+    if (!this.events['portal_signingRequested']) {
+      throw new Error(
+        `[PortalProvider] Auto-approve is disabled. Cannot perform signing requests without an event handler for the 'portal_signingRequested' event.`,
+      )
+    }
+
+    return new Promise((resolve) => {
+      // Remove already used listeners
+      this.removeEventListener('portal_signingApproved')
+      this.removeEventListener('portal_signingRejected')
+
+      // If the signing has been approved, resolve to true
+      this.once(
+        'portal_signingApproved',
+        ({ method: approvedMethod, params: approvedParams }) => {
+          console.log(`[PortalProvider] Signing Approved`, method, params)
+          // Remove already used listeners
+          this.removeEventListener('portal_signingApproved')
+          this.removeEventListener('portal_signingRejected')
+
+          // First verify that this is the same signing request
+          if (
+            method === approvedMethod &&
+            JSON.stringify(params) === JSON.stringify(approvedParams)
+          ) {
+            resolve(true)
+          }
+        },
+      )
+
+      // If the signing request has been rejected, resolve to false
+      this.once(
+        'portal_signingRejected',
+        ({ method: rejectedMethod, params: rejectedParams }) => {
+          console.log(`[PortalProvider] Signing Approved`, method, params)
+          // Remove already used listeners
+          this.removeEventListener('portal_signingApproved')
+          this.removeEventListener('portal_signingRejected')
+
+          // First verify that this is the same signing request
+          if (
+            method === rejectedMethod &&
+            JSON.stringify(params) === JSON.stringify(rejectedParams)
+          ) {
+            resolve(false)
+          }
+        },
+      )
+
+      // Tell any listening clients that signing has been requested
+      this.emit('portal_signingRequested', {
+        method,
+        params,
+      })
+    })
+  }
+
+  private async dispatchConnect(): Promise<void> {
+    console.log(
+      `[PortalProvider] Connected on chainId: 0x${this.chainId.toString(16)}`,
+    )
+    this.emit('connect', {
+      chainId: `0x${this.chainId.toString(16)}`,
+    })
+  }
+
+  private async dispatchDisconnect(): Promise<void> {
+    this.emit('disconnect', {
+      error: new ProviderRpcError({
+        code: RpcErrorCodes.Disconnected,
+      }),
+    })
+  }
+
+  /**
+   * Determines the RPC URL to be used for the current chain
+   *
+   * @returns string
+   */
+  private getRpcUrl(): string {
+    if (typeof this.gatewayConfig === 'string') {
+      // If the gatewayConfig is just a static URL, return that
+      return this.gatewayConfig
+    } else if (
+      typeof this.gatewayConfig === 'object' &&
+      !this.gatewayConfig.hasOwnProperty(this.chainId)
+    ) {
+      // If there's no explicit mapping for the current chainId, error out
+      throw new Error(
+        `[PortalProvider] No RPC endpoint configured for chainId: ${this.chainId}`,
+      )
+    }
+
+    // Get the entry for the current chainId from the gatewayConfig
+    const config = this.gatewayConfig[this.chainId]
+
+    if (typeof config === 'string') {
+      return config
+    }
+
+    // If we got this far, there's no way to support the chain with the current config
+    throw new Error(
+      `[PortalProvider] Could not find a valid gatewayConfig entry for chainId: ${this.chainId}`,
+    )
+  }
+
+  /**
+   * Sends the provided request payload along to the RPC HttpRequester
+   *
+   * @param args The arguments of the request being made
+   * @returns Promise<any>
+   */
+  private async handleGatewayRequests({
+    method,
+    params,
+  }: RequestArguments): Promise<any> {
+    // Pass request off to the gateway
+    return await this.rpc.post<any>('', {
+      body: {
+        jsonrpc: '2.0',
+        id: this.chainId,
+        method,
+        params,
+      },
+    })
+  }
+
+  /**
+   * Sends the provided request payload along to the Signer
+   *
+   * @param args The arguments of the request being made
+   * @returns Promise<any>
+   */
+  private async handleSigningRequests({
+    method,
+    params,
+  }: RequestArguments): Promise<any> {
+    const isApproved = passiveSignerMethods.includes(method)
+      ? true
+      : await this.getApproval({ method, params })
+
+    if (!isApproved) {
+      this.log.info(
+        `[PortalProvider] Request for signing method '${method}' could not be completed because it was not approved by the user.`,
+      )
+      return
+    }
+
+    switch (method) {
+      case 'eth_chainId':
+        return `0x${this.chainId.toString(16)}`
+      case 'eth_accounts':
+      case 'eth_requestAccounts':
+      case 'eth_sendTransaction':
+      case 'eth_sign':
+      case 'eth_signTransaction':
+      case 'eth_signTypedData':
+      case 'personal_sign':
+        return await this.signer?.sign(
+          { chainId: this.chainId, method, params },
+          this,
+        )
+      default:
+        throw new Error(
+          '[PortalProvider] Method "' + method + '" not supported',
+        )
+    }
+  }
+}
+
+export default Provider

package/src/requesters/http.ts

@@ -0,0 +1,61 @@
+import { HttpRequest } from '@portal-hq/utils'
+import {
+  type HttpRequestOptions,
+  type HttpOptions,
+  type HttpRequesterOptions,
+} from '@portal-hq/utils/types'
+
+class HttpRequester {
+  private baseUrl: string
+
+  constructor({ baseUrl }: HttpRequesterOptions) {
+    this.baseUrl = baseUrl.startsWith('https://')
+      ? baseUrl
+      : `https://${baseUrl}`
+  }
+
+  public async get<T>(path: string, options?: HttpOptions): Promise<T> {
+    const requestOptions = {
+      method: 'GET',
+      url: `${this.baseUrl}${path}`,
+    } as HttpRequestOptions
+
+    if (options && options.headers) {
+      requestOptions.headers = this.buildHeaders(options.headers)
+    }
+
+    const request = new HttpRequest(requestOptions)
+    const response = (await request.send()) as T
+
+    return response
+  }
+
+  public async post<T>(path: string, options?: HttpOptions): Promise<T> {
+    const requestOptions = {
+      method: 'POST',
+      url: `${this.baseUrl}${path}`,
+    } as HttpRequestOptions
+
+    requestOptions.headers = this.buildHeaders(
+      options && options.headers ? options.headers : {},
+    )
+
+    if (options && options.body) {
+      requestOptions.body = options.body
+    }
+
+    const request = new HttpRequest(requestOptions)
+    const response = (await request.send()) as T
+
+    return response
+  }
+
+  private buildHeaders(headers: Record<string, any>): Record<string, any> {
+    return {
+      'Content-Type': 'application/json',
+      ...headers,
+    }
+  }
+}
+
+export default HttpRequester

package/src/requesters/index.ts

@@ -0,0 +1 @@
+export { default as HttpRequester } from './http'

package/src/signers/abstract.ts

@@ -0,0 +1,14 @@
+import { type SigningRequestArguments, type SignResult } from '../../types'
+
+abstract class Signer {
+  public async sign(
+    message: SigningRequestArguments,
+    provider?: any,
+  ): Promise<SignResult> {
+    throw new Error(
+      '[Portal] sign() method must be implemented in a child of BaseSigner',
+    )
+  }
+}
+
+export default Signer

package/src/signers/http.ts

@@ -0,0 +1,79 @@
+import { Keychain } from '@portal-hq/keychain'
+import { MissingOptionError } from '@portal-hq/utils'
+
+import {
+  type HttpSignerOptions,
+  type SigningRequestArguments,
+  type SignResult,
+} from '../../types'
+
+import Signer from './abstract'
+import { Provider } from '../index'
+import HttpRequester from '../requesters/http'
+
+class HttpSigner implements Signer {
+  private portal: HttpRequester
+  private keychain: Keychain
+
+  constructor(opts: HttpSignerOptions) {
+    if (!opts.portal) {
+      throw new MissingOptionError({
+        className: 'HttpSigner',
+        option: 'portal',
+      })
+    }
+
+    this.keychain = new Keychain()
+    this.portal = opts.portal
+  }
+
+  public async sign(
+    message: SigningRequestArguments,
+    provider: Provider,
+  ): Promise<any> {
+    const address = await this.keychain.getAddress()
+    const arrayMethods = ['personal_sign']
+    const { chainId, method, params } = message
+
+    switch (method) {
+      case 'eth_requestAccounts':
+        return [address]
+      case 'eth_accounts':
+        return [address]
+      default:
+        break
+    }
+
+    console.log(
+      `[Portal:HttpSigner] Requesting signature from exchange for:`,
+      JSON.stringify(
+        {
+          chainId,
+          method,
+          params: JSON.stringify([params]),
+        },
+        null,
+        2,
+      ),
+    )
+
+    const signatureResponse = await this.portal.post<SignResult>(
+      '/api/v1/clients/transactions/sign',
+      {
+        body: {
+          chainId,
+          method,
+          params: JSON.stringify([params]),
+        },
+        headers: {
+          Authorization: `Bearer ${provider.apiKey}`,
+          'Content-Type': 'application/json',
+        },
+      },
+    )
+
+    return signatureResponse
+  }
+}
+
+export default HttpSigner

package/src/signers/index.ts

@@ -0,0 +1,3 @@
+export { default as Signer } from './abstract'
+export { default as HttpSigner } from './http'
+export { default as MpcSigner } from './mpc'