@aeternity/aepp-sdk 12.0.0 → 12.1.2

package/src/aepp-wallet-communication/connection/BrowserWindowMessage.ts

@@ -15,23 +15,30 @@
  *  PERFORMANCE OF THIS SOFTWARE.
  */
 
-import BrowserConnection from './Browser'
-import { MESSAGE_DIRECTION } from '../schema'
-import { InternalError, RpcConnectionError } from '../../utils/errors'
+import BrowserConnection from './Browser';
+import { MESSAGE_DIRECTION } from '../schema';
+import { InternalError, RpcConnectionError } from '../../utils/errors';
 
-export type ImplPostMessage = Pick<Window, 'addEventListener' | 'removeEventListener' | 'postMessage'>
+export type ImplPostMessage = Pick<Window, 'addEventListener' | 'removeEventListener' | 'postMessage'>;
 
 /**
  * Browser window Post Message connector module
+ * @category aepp wallet communication
  */
 export default class BrowserWindowMessageConnection extends BrowserConnection {
-  origin?: string
-  sendDirection?: MESSAGE_DIRECTION
-  receiveDirection: MESSAGE_DIRECTION
-  listener?: (this: Window, ev: MessageEvent<any>) => void
-  #onDisconnect?: () => void
-  #target?: ImplPostMessage
-  #self: ImplPostMessage
+  origin?: string;
+
+  sendDirection?: MESSAGE_DIRECTION;
+
+  receiveDirection: MESSAGE_DIRECTION;
+
+  listener?: (this: Window, ev: MessageEvent<any>) => void;
+
+  #onDisconnect?: () => void;
+
+  #target?: ImplPostMessage;
+
+  #self: ImplPostMessage;
 
   /**
    * @param options - Options
@@ -43,7 +50,7 @@ export default class BrowserWindowMessageConnection extends BrowserConnection {
    * Used for handling messages between content script and page
    * @param options.receiveDirection Unwrapping messages from additional struct
    */
-  constructor ({
+  constructor({
     target,
     self = window,
     origin,
@@ -51,61 +58,65 @@ export default class BrowserWindowMessageConnection extends BrowserConnection {
     receiveDirection = MESSAGE_DIRECTION.to_aepp,
     ...options
   }: {
-    target?: ImplPostMessage
-    self?: ImplPostMessage
-    origin?: string
-    sendDirection?: MESSAGE_DIRECTION
-    receiveDirection?: MESSAGE_DIRECTION
-    debug?: boolean
+    target?: ImplPostMessage;
+    self?: ImplPostMessage;
+    origin?: string;
+    sendDirection?: MESSAGE_DIRECTION;
+    receiveDirection?: MESSAGE_DIRECTION;
+    debug?: boolean;
   } = {}) {
-    super(options)
-    this.#target = target
-    this.#self = self
-    this.origin = origin
-    this.sendDirection = sendDirection
-    this.receiveDirection = receiveDirection
+    super(options);
+    this.#target = target;
+    this.#self = self;
+    this.origin = origin;
+    this.sendDirection = sendDirection;
+    this.receiveDirection = receiveDirection;
   }
 
-  isConnected (): boolean {
-    return this.listener != null
+  isConnected(): boolean {
+    return this.listener != null;
   }
 
-  connect (
+  connect(
     onMessage: (message: any, origin: string, source: MessageEventSource | null) => void,
-    onDisconnect: () => void
+    onDisconnect: () => void,
   ): void {
-    super.connect(onMessage, onDisconnect)
+    super.connect(onMessage, onDisconnect);
     this.listener = (message: MessageEvent<any>) => {
-      if (typeof message.data !== 'object') return
-      if (this.origin != null && this.origin !== message.origin) return
-      if (this.#target != null && this.#target !== message.source) return
-      this.receiveMessage(message)
-      let { data } = message
+      // TODO: strict validate origin and source instead of checking message structure
+      if (
+        typeof message.data !== 'object'
+        || (message.data.jsonrpc ?? message.data.data?.jsonrpc) !== '2.0'
+      ) return;
+      if (this.origin != null && this.origin !== message.origin) return;
+      if (this.#target != null && this.#target !== message.source) return;
+      this.receiveMessage(message);
+      let { data } = message;
       if (data.type != null) {
-        if (message.data.type !== this.receiveDirection) return
-        data = data.data
+        if (message.data.type !== this.receiveDirection) return;
+        data = data.data;
       }
-      onMessage(data, message.origin, message.source)
-    }
-    this.#self.addEventListener('message', this.listener)
-    this.#onDisconnect = onDisconnect
+      onMessage(data, message.origin, message.source);
+    };
+    this.#self.addEventListener('message', this.listener);
+    this.#onDisconnect = onDisconnect;
   }
 
-  disconnect (): void {
-    super.disconnect()
+  disconnect(): void {
+    super.disconnect();
     if (this.listener == null || this.#onDisconnect == null) {
-      throw new InternalError('Expected to not happen, required for TS')
+      throw new InternalError('Expected to not happen, required for TS');
     }
-    this.#self.removeEventListener('message', this.listener)
-    delete this.listener
-    this.#onDisconnect()
-    this.#onDisconnect = undefined
+    this.#self.removeEventListener('message', this.listener);
+    delete this.listener;
+    this.#onDisconnect();
+    this.#onDisconnect = undefined;
   }
 
-  sendMessage (msg: any): void {
-    if (this.#target == null) throw new RpcConnectionError('Can\'t send messages without target')
-    const message = this.sendDirection != null ? { type: this.sendDirection, data: msg } : msg
-    super.sendMessage(message)
-    this.#target.postMessage(message, this.origin ?? '*')
+  sendMessage(msg: any): void {
+    if (this.#target == null) throw new RpcConnectionError('Can\'t send messages without target');
+    const message = this.sendDirection != null ? { type: this.sendDirection, data: msg } : msg;
+    super.sendMessage(message);
+    this.#target.postMessage(message, this.origin ?? '*');
   }
 }

package/src/aepp-wallet-communication/connection-proxy.ts

@@ -15,21 +15,22 @@
  *  PERFORMANCE OF THIS SOFTWARE.
  */
 
-import BrowserConnection from './connection/Browser'
+import BrowserConnection from './connection/Browser';
 
 /**
  * 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 default (con1: BrowserConnection, con2: BrowserConnection): () => void => {
-  con1.connect((msg: any) => con2.sendMessage(msg), () => con2.disconnect())
-  con2.connect((msg: any) => con1.sendMessage(msg), () => con1.disconnect())
+  con1.connect((msg: any) => con2.sendMessage(msg), () => con2.disconnect());
+  con2.connect((msg: any) => con1.sendMessage(msg), () => con1.disconnect());
 
   return () => {
-    con1.disconnect()
-    con2.disconnect()
-  }
-}
+    con1.disconnect();
+    con2.disconnect();
+  };
+};

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

@@ -1,102 +1,107 @@
-import { RpcError, RpcInternalError, RpcMethodNotFoundError } from '../schema'
-import BrowserConnection from '../connection/Browser'
-import { InvalidRpcMessageError, MissingCallbackError } from '../../utils/errors'
+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
+  jsonrpc: '2.0';
+  id: number;
+  method: string;
+  params?: any;
 }
 
 interface JsonRpcResponse {
-  jsonrpc: '2.0'
-  id: number
-  method: string
-  result?: any
+  jsonrpc: '2.0';
+  id: number;
+  method: string;
+  result?: any;
   error?: {
-    code: number
-    message: string
-    data?: any
-  }
+    code: number;
+    message: string;
+    data?: any;
+  };
 }
 
-type RpcApiHandler = (p?: any) => any | undefined
-type RpcApi<Api> = { [k in keyof Api]: RpcApiHandler }
+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>
+  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>
+  connection: BrowserConnection;
+
+  #callbacks = new Map<number, { resolve: (v: any) => void; reject: (e: Error) => void }>();
+
+  #messageId = 0;
+
+  #methods: WithOrigin<LocalApi>;
 
-  constructor (
+  constructor(
     connection: BrowserConnection,
     onDisconnect: () => void,
-    methods: WithOrigin<LocalApi>
+    methods: WithOrigin<LocalApi>,
   ) {
-    this.connection = connection
-    this.#methods = methods
-    connection.connect(this.#handleMessage.bind(this), onDisconnect)
+    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))
+  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
+      this.#processResponse(msg);
+      return;
     }
 
-    const request = msg as JsonRpcRequest
-    let result, error
+    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)
+      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()
+      error = e instanceof RpcError ? e : new RpcInternalError();
     }
     if (request.id != null) {
-      this.#sendResponse(request.id, request.method as keyof LocalApi, result, error)
+      this.#sendResponse(request.id, request.method as keyof LocalApi, result, error);
     }
   }
 
-  #sendRequest (
+  #sendRequest(
     id: number | undefined,
     method: keyof RemoteApi | keyof LocalApi,
-    params?: any
+    params?: any,
   ): void {
     this.connection.sendMessage({
       jsonrpc: '2.0',
       ...id != null ? { id } : {},
       method,
-      ...params != null ? { params } : {}
-    })
+      ...params != null ? { params } : {},
+    });
   }
 
-  #sendResponse (
+  #sendResponse(
     id: number,
     method: keyof RemoteApi | keyof LocalApi, // TODO: remove as far it is not required in JSON RPC
     result?: any,
-    error?: any
+    error?: any,
   ): void {
     this.connection.sendMessage({
       jsonrpc: '2.0',
       id,
       method,
-      ...error != null ? { error } : { result }
-    })
+      ...error != null ? { error } : { result },
+    });
   }
 
   /**
@@ -105,13 +110,14 @@ export default class RpcClient <
    * @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]
+  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 })
-    })
+    this.#sendRequest(this.#messageId += 1, name, params);
+    return new Promise((resolve, reject) => {
+      this.#callbacks.set(this.#messageId, { resolve, reject });
+    });
   }
 
   /**
@@ -119,19 +125,19 @@ export default class RpcClient <
    * @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)
+  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)
+  #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

@@ -1,66 +1,66 @@
-import { send } from '../../spend'
-import { EncodedData } from '../../utils/encoder'
-import { METHODS, SUBSCRIPTION_TYPES, WALLET_TYPE } from '../schema'
+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
+  id: string;
+  name: string;
+  networkId: string;
+  origin: string;
+  type: WALLET_TYPE;
 }
 
 export interface Accounts {
-  connected: { [pub: EncodedData<'ak'>]: {} }
-  current: { [pub: EncodedData<'ak'>]: {} }
+  connected: { [pub: Encoded.AccountAddress]: {} };
+  current: { [pub: Encoded.AccountAddress]: {} };
 }
 
 export interface Node {
-  name: string
-  url: string
+  name: string;
+  url: string;
 }
 
 export interface Network {
-  networkId: string
-  node?: Node
+  networkId: string;
+  node?: Node;
 }
 
-type Icons = Array<{ src: string, sizes?: string, type?: string, purpose?: string }>
+type Icons = Array<{ src: string; sizes?: string; type?: string; purpose?: string }>;
 
-export const RPC_VERSION = 1
+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 }>
+    p: { name: string; icons?: Icons; version: typeof RPC_VERSION; connectNode: boolean }
+  ) => Promise<WalletInfo & { node?: Node }>;
 
-  [METHODS.closeConnection]: (p: any) => void
+  [METHODS.closeConnection]: (p: any) => void;
 
   [METHODS.subscribeAddress]: (
-    p: { type: SUBSCRIPTION_TYPES, value: 'connected' | 'current' }
-  ) => Promise<{ subscription: Array<'connected' | 'current'>, address: Accounts }>
+    p: { type: SUBSCRIPTION_TYPES; value: 'connected' | 'current' }
+  ) => Promise<{ subscription: Array<'connected' | 'current'>; address: Accounts }>;
 
-  [METHODS.address]: () => Promise<Array<EncodedData<'ak'>>>
+  [METHODS.address]: () => Promise<Encoded.AccountAddress[]>;
 
   [METHODS.sign]: ((
-    p: { tx: EncodedData<'tx'>, onAccount: EncodedData<'ak'>, returnSigned: boolean }
+    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?: EncodedData<'tx'>
-  }>)
+    transactionHash?: Awaited<ReturnType<typeof send>>;
+    signedTransaction?: Encoded.Transaction;
+  }>);
 
   [METHODS.signMessage]: (
-    p: { message: string, onAccount: EncodedData<'ak'> }
-  ) => Promise<{ signature: string }>
+    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
+  [METHODS.updateAddress]: (a: Accounts) => void;
+  [METHODS.updateNetwork]: (a: Network) => void;
+  [METHODS.readyToConnect]: (w: WalletInfo) => void;
+  [METHODS.closeConnection]: (p: any) => void;
 }