@aeternity/aepp-sdk 11.0.1 → 12.0.0

package/src/aepp-wallet-communication/rpc/RpcClient.ts

@@ -0,0 +1,137 @@
+import { RpcError, RpcInternalError, RpcMethodNotFoundError } from '../schema'
+import BrowserConnection from '../connection/Browser'
+import { InvalidRpcMessageError, MissingCallbackError } from '../../utils/errors'
+
+interface JsonRpcRequest {
+  jsonrpc: '2.0'
+  id: number
+  method: string
+  params?: any
+}
+
+interface JsonRpcResponse {
+  jsonrpc: '2.0'
+  id: number
+  method: string
+  result?: any
+  error?: {
+    code: number
+    message: string
+    data?: any
+  }
+}
+
+type RpcApiHandler = (p?: any) => any | undefined
+type RpcApi<Api> = { [k in keyof Api]: RpcApiHandler }
+type WithOrigin<Api extends RpcApi<Api>> = {
+  [k in keyof Api]: (p: Parameters<Api[k]>[0], origin: string) => ReturnType<Api[k]>
+}
+
+/**
+ * Contain functionality for using RPC conection
+ * @param connection - Connection object
+ * @param onDisconnect - Disconnect callback
+ * @param methods - Object containing handlers for each request by name
+ */
+export default class RpcClient <
+  RemoteApi extends RpcApi<RemoteApi>, LocalApi extends RpcApi<LocalApi>
+> {
+  connection: BrowserConnection
+  #callbacks = new Map<number, { resolve: (v: any) => void, reject: (e: Error) => void }>()
+  #messageId = 0
+  #methods: WithOrigin<LocalApi>
+
+  constructor (
+    connection: BrowserConnection,
+    onDisconnect: () => void,
+    methods: WithOrigin<LocalApi>
+  ) {
+    this.connection = connection
+    this.#methods = methods
+    connection.connect(this.#handleMessage.bind(this), onDisconnect)
+  }
+
+  async #handleMessage (msg: JsonRpcRequest | JsonRpcResponse, origin: string): Promise<void> {
+    if (msg?.jsonrpc !== '2.0') throw new InvalidRpcMessageError(JSON.stringify(msg))
+    if ('result' in msg || 'error' in msg) {
+      this.#processResponse(msg)
+      return
+    }
+
+    const request = msg as JsonRpcRequest
+    let result, error
+    try {
+      if (!(request.method in this.#methods)) throw new RpcMethodNotFoundError()
+      const methodName = request.method as keyof LocalApi
+      result = await this.#methods[methodName](request.params, origin)
+    } catch (e) {
+      error = e instanceof RpcError ? e : new RpcInternalError()
+    }
+    if (request.id != null) {
+      this.#sendResponse(request.id, request.method as keyof LocalApi, result, error)
+    }
+  }
+
+  #sendRequest (
+    id: number | undefined,
+    method: keyof RemoteApi | keyof LocalApi,
+    params?: any
+  ): void {
+    this.connection.sendMessage({
+      jsonrpc: '2.0',
+      ...id != null ? { id } : {},
+      method,
+      ...params != null ? { params } : {}
+    })
+  }
+
+  #sendResponse (
+    id: number,
+    method: keyof RemoteApi | keyof LocalApi, // TODO: remove as far it is not required in JSON RPC
+    result?: any,
+    error?: any
+  ): void {
+    this.connection.sendMessage({
+      jsonrpc: '2.0',
+      id,
+      method,
+      ...error != null ? { error } : { result }
+    })
+  }
+
+  /**
+   * Make a request
+   * @param name - Method name
+   * @param params - Method params
+   * @returns Promise which will be resolved after receiving response message
+   */
+  async request<Name extends keyof RemoteApi> (
+    name: Name, params: Parameters<RemoteApi[Name]>[0]
+  ): Promise<ReturnType<RemoteApi[Name]>> {
+    this.#sendRequest(++this.#messageId, name, params)
+    return await new Promise((resolve, reject) => {
+      this.#callbacks.set(this.#messageId, { resolve, reject })
+    })
+  }
+
+  /**
+   * Make a notification
+   * @param name - Method name
+   * @param params - Method params
+   */
+  notify<Name extends keyof RemoteApi> (name: Name, params: Parameters<RemoteApi[Name]>[0]): void {
+    this.#sendRequest(undefined, name, params)
+  }
+
+  /**
+   * Process response message
+   * @param msg - Message object
+   */
+  #processResponse ({ id, error, result }: { id: number, error?: any, result?: any }): void {
+    const callbacks = this.#callbacks.get(id)
+    if (callbacks == null) throw new MissingCallbackError(id)
+    if (error != null) callbacks.reject(RpcError.deserialize(error))
+    else callbacks.resolve(result)
+    this.#callbacks.delete(id)
+  }
+}

package/src/aepp-wallet-communication/rpc/types.ts

@@ -0,0 +1,66 @@
+import { send } from '../../spend'
+import { EncodedData } from '../../utils/encoder'
+import { METHODS, SUBSCRIPTION_TYPES, WALLET_TYPE } from '../schema'
+
+export interface WalletInfo {
+  id: string
+  name: string
+  networkId: string
+  origin: string
+  type: WALLET_TYPE
+}
+
+export interface Accounts {
+  connected: { [pub: EncodedData<'ak'>]: {} }
+  current: { [pub: EncodedData<'ak'>]: {} }
+}
+
+export interface Node {
+  name: string
+  url: string
+}
+
+export interface Network {
+  networkId: string
+  node?: Node
+}
+
+type Icons = Array<{ src: string, sizes?: string, type?: string, purpose?: string }>
+
+export const RPC_VERSION = 1
+
+export interface WalletApi {
+  [METHODS.connect]: (
+    p: { name: string, icons?: Icons, version: typeof RPC_VERSION, connectNode: boolean }
+  ) => Promise<WalletInfo & { node?: Node }>
+
+  [METHODS.closeConnection]: (p: any) => void
+
+  [METHODS.subscribeAddress]: (
+    p: { type: SUBSCRIPTION_TYPES, value: 'connected' | 'current' }
+  ) => Promise<{ subscription: Array<'connected' | 'current'>, address: Accounts }>
+
+  [METHODS.address]: () => Promise<Array<EncodedData<'ak'>>>
+
+  [METHODS.sign]: ((
+    p: { tx: EncodedData<'tx'>, onAccount: EncodedData<'ak'>, returnSigned: boolean }
+  ) => Promise<{
+    /**
+     * @deprecated this is not a hash at all, will be removed later at the same time
+     * as dropping ability to broadcast transaction by wallet
+     */
+    transactionHash?: Awaited<ReturnType<typeof send>>
+    signedTransaction?: EncodedData<'tx'>
+  }>)
+
+  [METHODS.signMessage]: (
+    p: { message: string, onAccount: EncodedData<'ak'> }
+  ) => Promise<{ signature: string }>
+}
+
+export interface AeppApi {
+  [METHODS.updateAddress]: (a: Accounts) => void
+  [METHODS.updateNetwork]: (a: Network) => void
+  [METHODS.readyToConnect]: (w: WalletInfo) => void
+  [METHODS.closeConnection]: (p: any) => void
+}

package/src/aepp-wallet-communication/schema.ts

@@ -0,0 +1,181 @@
+import { EncodedData } from '../utils/encoder'
+import { BaseError, InternalError } from '../utils/errors'
+
+export const enum MESSAGE_DIRECTION {
+  to_waellet = 'to_waellet',
+  to_aepp = 'to_aepp'
+}
+
+export const enum WALLET_TYPE {
+  window = 'window',
+  extension = 'extension'
+}
+
+export const enum SUBSCRIPTION_TYPES {
+  subscribe = 'subscribe',
+  unsubscribe = 'unsubscribe'
+}
+
+export const enum METHODS {
+  readyToConnect = 'connection.announcePresence',
+  updateAddress = 'address.update',
+  address = 'address.get',
+  connect = 'connection.open',
+  sign = 'transaction.sign',
+  signMessage = 'message.sign',
+  subscribeAddress = 'address.subscribe',
+  updateNetwork = 'networkId.update',
+  closeConnection = 'connection.close'
+}
+
+export const enum RPC_STATUS {
+  CONNECTED = 'CONNECTED',
+  DISCONNECTED = 'DISCONNECTED',
+  WAITING_FOR_CONNECTION_REQUEST = 'WAITING_FOR_CONNECTION_REQUEST'
+}
+
+interface RpcErrorAsJson {
+  code: number
+  message: string
+  data?: any
+}
+
+/**
+ * @category exception
+ */
+export abstract class RpcError extends BaseError {
+  static code: number
+  code: number
+  data?: any
+
+  toJSON (): RpcErrorAsJson {
+    return {
+      code: this.code,
+      message: this.message,
+      data: this.data
+    }
+  }
+
+  static deserialize (json: RpcErrorAsJson): RpcError {
+    const RpcErr = [
+      RpcInvalidTransactionError, RpcBroadcastError, RpcRejectedByUserError,
+      RpcUnsupportedProtocolError, RpcConnectionDenyError, RpcNotAuthorizeError,
+      RpcPermissionDenyError, RpcInternalError
+    ].find(cl => cl.code === json.code)
+    if (RpcErr == null) throw new InternalError(`Can't find RpcError with code: ${json.code}`)
+    return new RpcErr(json.data)
+  }
+}
+
+/**
+ * @category exception
+ */
+export class RpcInvalidTransactionError extends RpcError {
+  static code = 2
+  code = 2
+  constructor (data?: any) {
+    super('Invalid transaction')
+    this.data = data
+    this.name = 'RpcInvalidTransactionError'
+  }
+}
+
+/**
+ * @category exception
+ */
+export class RpcBroadcastError extends RpcError {
+  static code = 3
+  code = 3
+  constructor (data?: any) {
+    super('Broadcast failed')
+    this.data = data
+    this.name = 'RpcBroadcastError'
+  }
+}
+
+/**
+ * @category exception
+ */
+export class RpcRejectedByUserError extends RpcError {
+  static code = 4
+  code = 4
+  constructor (data?: any) {
+    super('Operation rejected by user')
+    this.data = data
+    this.name = 'RpcRejectedByUserError'
+  }
+}
+
+/**
+ * @category exception
+ */
+export class RpcUnsupportedProtocolError extends RpcError {
+  static code = 5
+  code = 5
+  constructor () {
+    super('Unsupported Protocol Version')
+    this.name = 'RpcUnsupportedProtocolError'
+  }
+}
+
+/**
+ * @category exception
+ */
+export class RpcConnectionDenyError extends RpcError {
+  static code = 9
+  code = 9
+  constructor (data?: any) {
+    super('Wallet deny your connection request')
+    this.data = data
+    this.name = 'RpcConnectionDenyError'
+  }
+}
+
+/**
+ * @category exception
+ */
+export class RpcNotAuthorizeError extends RpcError {
+  static code = 10
+  code = 10
+  constructor () {
+    super('You are not connected to the wallet')
+    this.name = 'RpcNotAuthorizeError'
+  }
+}
+
+/**
+ * @category exception
+ */
+export class RpcPermissionDenyError extends RpcError {
+  static code = 11
+  code = 11
+  constructor (address: EncodedData<'ak'>) {
+    super(`You are not subscribed for account ${address}`)
+    this.data = address
+    this.name = 'RpcPermissionDenyError'
+  }
+}
+
+/**
+ * @category exception
+ */
+export class RpcInternalError extends RpcError {
+  static code = 12
+  code = 12
+  constructor () {
+    super('The peer failed to execute your request due to unknown error')
+    this.name = 'RpcInternalError'
+  }
+}
+
+/**
+ * @category exception
+ */
+export class RpcMethodNotFoundError extends RpcError {
+  static code = -32601
+  code = -32601
+  constructor () {
+    super('Method not found')
+    this.name = 'RpcMethodNotFoundError'
+  }
+}

package/src/aepp-wallet-communication/wallet-detector.ts

@@ -0,0 +1,71 @@
+/*
+ * ISC License (ISC)
+ * Copyright (c) 2022 aeternity developers
+ *
+ *  Permission to use, copy, modify, and/or distribute this software for any
+ *  purpose with or without fee is hereby granted, provided that the above
+ *  copyright notice and this permission notice appear in all copies.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+ *  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+ *  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+ *  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+ *  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+ *  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ *  PERFORMANCE OF THIS SOFTWARE.
+ */
+
+import BrowserConnection from './connection/Browser'
+import BrowserWindowMessageConnection from './connection/BrowserWindowMessage'
+import { MESSAGE_DIRECTION, METHODS } from './schema'
+import { UnsupportedPlatformError } from '../utils/errors'
+
+interface Wallet {
+  info: {
+    id: string
+    type: string
+    origin: string
+  }
+  getConnection: () => BrowserWindowMessageConnection
+}
+interface Wallets { [key: string]: Wallet }
+
+/**
+ * A function to detect available wallets
+ * @param connection - connection to use to detect wallets
+ * @param onDetected - call-back function which trigger on new wallet
+ * @returns a function to stop scanning
+ */
+export default (
+  connection: BrowserConnection = new BrowserWindowMessageConnection(),
+  onDetected: ({ wallets, newWallet }: { wallets: Wallets, newWallet?: Wallet }) => void
+): () => void => {
+  if (window == null) throw new UnsupportedPlatformError('Window object not found, you can run wallet detector only in browser')
+  const wallets: Wallets = {}
+
+  connection.connect((
+    { method, params }: { method: string, params: Wallet['info'] },
+    origin: string,
+    source: Window
+  ) => {
+    if (method !== METHODS.readyToConnect || wallets[params.id] != null) return
+
+    const wallet = {
+      info: params,
+      getConnection () {
+        const isExtension = params.type === 'extension'
+        return new BrowserWindowMessageConnection({
+          sendDirection: isExtension ? MESSAGE_DIRECTION.to_waellet : undefined,
+          receiveDirection: isExtension ? MESSAGE_DIRECTION.to_aepp : undefined,
+          target: source,
+          origin: isExtension ? window.origin : params.origin
+        })
+      }
+    }
+    wallets[wallet.info.id] = wallet
+    onDetected({ wallets, newWallet: wallet })
+  }, () => {})
+  if (Object.keys(wallets).length > 0) onDetected({ wallets })
+
+  return () => connection.disconnect()
+}