@aeternity/aepp-sdk 11.0.0 → 12.1.0

package/{es/utils/crypto-ts.mjs → src/aepp-wallet-communication/connection-proxy.ts}

@@ -1,11 +1,6 @@
-import _buffer from "buffer";
-const {
-  Buffer: _Buffer
-} = _buffer;
-
 /*
  * ISC License (ISC)
- * Copyright 2021 aeternity developers
+ * 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
@@ -19,18 +14,23 @@ const {
  *  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  *  PERFORMANCE OF THIS SOFTWARE.
  */
-import _aeternityBlakejs from '@aeternity/blakejs';
-const {
-  blake2b
-} = _aeternityBlakejs;
+
+import BrowserConnection from './connection/Browser';
 
 /**
- * Calculate 256bits Blake2b hash of `input`
- * @rtype (input: String) => hash: String
- * @param {Data} input - Data to hash
- * @return {Buffer} Hash
+ * Browser connection proxy
+ * Provide functionality to easily forward messages from one connection to another and back
+ * @category aepp wallet communication
+ * @param con1 - first connection
+ * @param con2 - second connection
+ * @returns a function to stop proxying
  */
-export function hash(input) {
-  return _Buffer.from(blake2b(input, undefined, 32)); // 256 bits
-}
-//# sourceMappingURL=crypto-ts.mjs.map
+export default (con1: BrowserConnection, con2: BrowserConnection): () => void => {
+  con1.connect((msg: any) => con2.sendMessage(msg), () => con2.disconnect());
+  con2.connect((msg: any) => con1.sendMessage(msg), () => con1.disconnect());
+
+  return () => {
+    con1.disconnect();
+    con2.disconnect();
+  };
+};

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

@@ -0,0 +1,143 @@
+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
+ * @category aepp wallet communication
+ * @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; let
+      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 += 1, name, params);
+    return 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 { Encoded } 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: Encoded.AccountAddress]: {} };
+  current: { [pub: Encoded.AccountAddress]: {} };
+}
+
+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<Encoded.AccountAddress[]>;
+
+  [METHODS.sign]: ((
+    p: { tx: Encoded.Transaction; onAccount: Encoded.AccountAddress; 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?: Encoded.Transaction;
+  }>);
+
+  [METHODS.signMessage]: (
+    p: { message: string; onAccount: Encoded.AccountAddress }
+  ) => 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,224 @@
+// eslint-disable-next-line max-classes-per-file
+import { Encoded } from '../utils/encoder';
+import { BaseError, InternalError } from '../utils/errors';
+
+/**
+ * @category aepp wallet communication
+ */
+export const enum MESSAGE_DIRECTION {
+  to_waellet = 'to_waellet',
+  to_aepp = 'to_aepp',
+}
+
+/**
+ * @category aepp wallet communication
+ */
+export const enum WALLET_TYPE {
+  window = 'window',
+  extension = 'extension',
+}
+
+/**
+ * @category aepp wallet communication
+ */
+export const enum SUBSCRIPTION_TYPES {
+  subscribe = 'subscribe',
+  unsubscribe = 'unsubscribe',
+}
+
+/**
+ * @category aepp wallet communication
+ */
+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',
+}
+
+/**
+ * @category aepp wallet communication
+ */
+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;
+}
+
+const rpcErrors: Array<(new (data?: any) => RpcError) & { code: number }> = [];
+
+/**
+ * @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 = rpcErrors.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';
+  }
+}
+rpcErrors.push(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';
+  }
+}
+rpcErrors.push(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';
+  }
+}
+rpcErrors.push(RpcRejectedByUserError);
+
+/**
+ * @category exception
+ */
+export class RpcUnsupportedProtocolError extends RpcError {
+  static code = 5;
+
+  code = 5;
+
+  constructor() {
+    super('Unsupported Protocol Version');
+    this.name = 'RpcUnsupportedProtocolError';
+  }
+}
+rpcErrors.push(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';
+  }
+}
+rpcErrors.push(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';
+  }
+}
+rpcErrors.push(RpcNotAuthorizeError);
+
+/**
+ * @category exception
+ */
+export class RpcPermissionDenyError extends RpcError {
+  static code = 11;
+
+  code = 11;
+
+  constructor(address: Encoded.AccountAddress) {
+    super(`You are not subscribed for account ${address}`);
+    this.data = address;
+    this.name = 'RpcPermissionDenyError';
+  }
+}
+rpcErrors.push(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';
+  }
+}
+rpcErrors.push(RpcInternalError);
+
+/**
+ * @category exception
+ */
+export class RpcMethodNotFoundError extends RpcError {
+  static code = -32601;
+
+  code = -32601;
+
+  constructor() {
+    super('Method not found');
+    this.name = 'RpcMethodNotFoundError';
+  }
+}
+rpcErrors.push(RpcMethodNotFoundError);

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

@@ -0,0 +1,72 @@
+/*
+ * 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
+ * @category aepp wallet communication
+ * @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,
+  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();
+};