@portal-hq/web 0.0.1-beta-1

package/src/provider/index.ts

@@ -0,0 +1,314 @@
+import { ProviderRpcError, RpcErrorCodes } from '@portal-hq/utils'
+
+import Portal from '../index'
+
+import type { EventHandler, ProviderOptions, RegisteredEventHandler, RequestArguments } 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_v3',
+  'eth_signTypedData_v4',
+  'personal_sign',
+]
+
+class Provider {
+  public events: Record<string, RegisteredEventHandler[]>
+
+  private autoApprove: boolean
+  private portal: Portal
+
+  constructor({
+    autoApprove = false,
+    portal,
+  }: ProviderOptions) {
+    this.autoApprove = autoApprove
+    this.events = {}
+    this.portal = portal
+  }
+
+  /**
+   * 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
+  }
+
+  public removeEventListener(
+    event: string,
+    listenerToRemove?: EventHandler,
+  ): void {
+    if (!this.events[event]) {
+      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.portal.chainId
+    }
+
+    const isSignerMethod = signerMethods.includes(method)
+
+    let result: any
+    if (!isSignerMethod && !method.startsWith('wallet_')) {
+      // Send to Gateway for RPC calls
+      const response = await this.handleGatewayRequest({ 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.handleSigningRequest({
+        method,
+        params,
+      })
+
+      if (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
+  }
+
+  /************************
+   * Private Methods
+   ************************/
+
+  /**
+   * 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
+    }
+
+    const signingHandlers = this.events['portal_signingRequested']
+
+    if (!signingHandlers || signingHandlers.length === 0) {
+      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')
+
+      const handleApproval = ({ method: approvedMethod, params: approvedParams }: RequestArguments) => {
+        // 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)
+        }
+      }
+
+      const handleRejection = ({ method: rejectedMethod, params: rejectedParams }: RequestArguments) => {
+        // 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)
+        }
+      }
+
+      // If the signing has been approved, resolve to true
+      this.on('portal_signingApproved', handleApproval)
+
+      // If the signing request has been rejected, resolve to false
+      this.on('portal_signingRejected', handleRejection)
+
+      // Tell any listening clients that signing has been requested
+      this.emit('portal_signingRequested', {
+        method,
+        params,
+      })
+    })
+  }
+
+  /**
+   * Sends the provided request payload along to the RPC HttpRequester
+   *
+   * @param args The arguments of the request being made
+   * @returns Promise<any>
+   */
+  private async handleGatewayRequest({
+    method,
+    params,
+  }: RequestArguments): Promise<any> {
+    // Pass request off to the gateway
+    const result = await fetch(this.portal.getRpcUrl(), {
+      body: JSON.stringify({
+        jsonrpc: '2.0',
+        id: this.portal.chainId,
+        method,
+        params,
+      }),
+      method: 'POST',
+    })
+
+    return result.json()
+  }
+
+  /**
+   * Sends the provided request payload along to the Signer
+   *
+   * @param args The arguments of the request being made
+   * @returns Promise<any>
+   */
+  private async handleSigningRequest({
+    method,
+    params,
+  }: RequestArguments): Promise<any> {
+    const isApproved = passiveSignerMethods.includes(method)
+      ? true
+      : await this.getApproval({ method, params })
+
+    if (!isApproved) {
+      console.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.portal.chainId.toString(16)}`
+      case 'eth_accounts':
+      case 'eth_requestAccounts':
+        return [this.portal.address]
+      case 'eth_sendTransaction':
+      case 'eth_sign':
+      case 'eth_signTransaction':
+      case 'eth_signTypedData_v3':
+      case 'eth_signTypedData_v4':
+      case 'personal_sign':
+        const result = await this.portal.mpc.sign({
+          host: this.portal.mpcHost,
+          method,
+          mpcVersion: this.portal.mpcVersion,
+          params,
+        })
+
+        return result
+      default:
+        throw new Error(
+          '[PortalProvider] Method "' + method + '" not supported',
+        )
+    }
+  }
+}
+
+export default Provider

package/src/storage/index.ts

@@ -0,0 +1,29 @@
+import { Storage } from '@portal-hq/utils'
+
+class DefaultBackupStorage implements Storage {
+  public delete(): Promise<boolean> {
+    throw new Error(
+      '[Portal] Storage method delete cannot be called directly. Please extend Storage.',
+    )
+  }
+
+  public read(): Promise<string> {
+    throw new Error(
+      '[Portal] Storage method read cannot be called directly. Please extend Storage.',
+    )
+  }
+
+  public write(privateKey: string): Promise<string> {
+    throw new Error(
+      `[Portal] Storage method write(${privateKey}) cannot be called directly. Please extend Storage.`,
+    )
+  }
+
+  public validateOperations(): Promise<boolean> {
+    throw new Error(
+      '[Portal] Storage method validateOperations cannot be called directly. Please extend Storage.',
+    )
+  }
+}
+
+export default DefaultBackupStorage

package/types.d.ts

@@ -0,0 +1,341 @@
+import {
+  type DkgDataV1 as DkgData,
+  Storage,
+  PortalError,
+} from '@portal-hq/utils'
+import { MpcErrorCodes } from './src/mpc/errors'
+import { BackupMethods } from './src/mpc'
+import Provider from './src/provider'
+import Portal from './src/index'
+
+export type GatewayLike = GatewayConfig | string
+export type EventHandler = (event: Event<any>) => void | Promise<void>
+export type MessageData =
+  | BackupArgs
+  | DecryptArgs
+  | EncryptArgs
+  | GenerateArgs
+  | RecoverArgs
+  | SignArgs
+
+export type EthereumTransaction = EIP1559Transaction | LegacyTransaction
+
+// Interfaces
+
+export interface AddressResult {
+  data: string
+  type: string
+}
+
+export interface BackupArgs extends MpcOperationArgs {
+}
+
+export interface BackupResult {}
+
+export interface BackupOptions {
+  default?: Storage
+  gdrive?: Storage
+  icloud?: Storage
+}
+export interface Bk {
+  X: string
+  Rank: number
+}
+
+export interface Address {
+  id: string
+  network: Network
+  value: string
+}
+
+export interface DappOnNetwork {
+  clientUrl?: string
+  dapp: Dapp
+  id: string
+  network: Network
+}
+
+export interface Dapp {
+  id: string
+  name: string
+
+  addresses: Address[]
+  dappOnNetworks: DappOnNetwork[]
+  image: DappImage
+}
+
+export interface DappImage {
+  id: string
+  filename: string
+  data: string
+}
+
+export interface DecryptArgs {
+  cipherText: string
+  privateKey: string
+}
+
+export interface DkgResult {
+  share: string
+  pubkey: Pubkey
+  bks: Bk[]
+}
+
+export interface EIP1559Transaction {
+  from: string
+  to: string
+  
+  // Optional
+  data?: string
+  gasLimit?: string
+  maxFeePerGas?: string
+  maxPriorityFeePerGas?: string
+  nonce?: string
+  value?: string
+}
+
+export interface EncryptArgs {
+  dkgData: string
+}
+
+export interface EncryptedData {
+  cipherText: string
+  privateKey: string
+}
+
+export interface EncryptResult {
+  data: EncryptData
+  error: PortalError
+}
+
+export interface DecryptData {
+  plaintext: string
+}
+
+export interface DecryptResult {
+  data: DecryptData
+  error: PortalError
+}
+
+export interface GatewayConfig {
+  [key: number]: string
+}
+
+export interface GenerateArgs extends MpcOperationArgs {}
+
+export interface GenerateResult {
+  data: {
+    address: string
+    dkgResult: DkgData
+  }
+  error: PortalError
+}
+
+export interface GenerateResponse {
+  address: string
+  cipherText?: string
+  share?: string
+}
+
+export interface IframeConfigurationOptions {
+  apiHost: string
+  apiKey: string
+  autoApprove: boolean
+  chainId: number
+  mpcHost: string
+  rpcUrl: string
+}
+
+export interface LegacyTransaction {
+  from: string
+  to: string
+  
+  // Optional
+  data?: string
+  gasLimit?: string
+  gasPrice?: string
+  nonce?: string
+  value?: string
+}
+
+export interface MpcErrorData {
+  code: MpcErrorCodes
+  message: (str?: string) => string
+}
+
+export interface MpcOperationArgs {
+  host: string
+  mpcVersion: string
+}
+
+export interface MpcOptions {
+  apiHost: string
+  apiKey: string
+  autoApprove: boolean
+  chainId: number
+  mpcHost: string
+  rpcUrl: string
+  webHost: string
+  portal: Portal
+}
+
+export interface PortalApiOptions {
+  apiKey: string
+  chainId: number
+  host: string
+  portal: Portal
+}
+
+export interface PortalMpcOptions {
+  // Required options
+  chainId: number
+  keychain: KeychainAdapter
+  portal: Portal
+  rpc: string
+  storage: BackupOptions
+  token: string
+
+  // Optional options
+  mpcHost?: string
+  mpcVersion?: string
+  webHost?: string
+}
+
+export interface PortalOptions {
+  // Required options
+  apiKey: string
+  gatewayConfig: GatewayLike
+
+  // Optional options
+  apiHost?: string
+  autoApprove?: boolean
+  backup?: BackupOptions
+  chainId?: number
+  isSimulator?: boolean
+  keychain?: KeychainAdapter
+  mpcHost?: string
+  mpcVersion?: string
+  webHost?: string
+}
+
+export interface ProviderOptions {
+  // Required options
+  portal: Portal
+
+  // Optional options
+  autoApprove?: boolean
+  mpcHost?: string
+  mpcVersion?: string
+}
+
+export interface Pubkey {
+  X: string
+  Y: string
+}
+
+export interface QuoteArgs {
+  affiliateAddress?: string
+  buyAmount?: number
+  buyToken: string
+  buyTokenPercentageFee?: number
+  enableSlippageProtection?: boolean
+  excludedSources?: string
+  feeRecipient?: string
+  gasPrice?: number
+  includedSources?: string
+  intentOnFilling?: boolean
+  priceImpactProtectionPercentage?: number
+  sellAmount?: number
+  sellToken: string
+  skipValidation?: boolean
+  slippagePercentage?: number
+  takerAddress?: string
+}
+
+export interface QuoteResponse {
+  cost: string
+  transaction: Eip1559 | LegacyTx
+}
+
+export interface RegisteredEventHandler {
+  handler: EventHandler
+  once?: boolean
+}
+
+export interface RequestArguments {
+  method: string
+  params?: unknown[] | SigningRequestParams
+}
+
+export interface RecoverArgs extends MpcOperationArgs {
+}
+
+export interface RotateResult {
+  data: RotateData
+  error: PortalError
+}
+
+export interface RotateData {
+  address: string
+  dkgResult: DkgData
+}
+
+export interface SignArgs extends MpcOperationArgs {
+  method: string
+  params: string
+}
+
+export interface SignData {
+  R: string
+  S: string
+}
+
+export interface SignResult {
+  data: string
+  error: PortalError
+}
+
+export interface SignerOptions {
+  portal: Portal
+}
+
+export interface SwitchEthereumChainParameter {
+  chainId: number
+}
+
+export interface TypedData {
+  types: Type[]
+	primaryType: string
+	domain: string
+	message: string
+}
+
+export interface Type {
+  name: string
+  type: string
+}
+
+export interface WorkerMessage {
+  type: string
+  data:
+    | BackupArgs
+    | DecryptArgs
+    | EncryptArgs
+    | GenerateArgs
+    | RecoverArgs
+    | SignArgs
+}
+
+export interface WorkerResult {
+  type: string
+  data:
+    | boolean
+    | string
+    | BackupResult
+    | DecryptResult
+    | EncryptResult
+    | GenerateResult
+    | ReadyResult
+    | RecoverResult
+    | SignResult
+}