@aeternity/aepp-sdk 10.0.0 → 12.0.0

package/es/aepp-wallet-communication/connection/BrowserWindowMessage.mjs

@@ -0,0 +1,142 @@
+import _classPrivateFieldGet from "@babel/runtime-corejs3/helpers/classPrivateFieldGet";
+import _classPrivateFieldSet from "@babel/runtime-corejs3/helpers/classPrivateFieldSet";
+
+function _classPrivateFieldInitSpec(obj, privateMap, value) { _checkPrivateRedeclaration(obj, privateMap); privateMap.set(obj, value); }
+
+function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
+
+/*
+ * 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 "./Browser.mjs";
+import { MESSAGE_DIRECTION } from "../schema.mjs";
+import { InternalError, RpcConnectionError } from "../../utils/errors.mjs";
+
+var _onDisconnect = /*#__PURE__*/new WeakMap();
+
+var _target = /*#__PURE__*/new WeakMap();
+
+var _self = /*#__PURE__*/new WeakMap();
+
+/**
+ * Browser window Post Message connector module
+ */
+export default class BrowserWindowMessageConnection extends BrowserConnection {
+  /**
+   * @param options - Options
+   * @param options.target Target window for message
+   * @param options.self Host window for message
+   * @param options.origin Origin of receiver
+   * @param options.sendDirection Wrapping messages into additional struct
+   * `({ type: 'to_aepp' || 'to_waellet', data })`
+   * Used for handling messages between content script and page
+   * @param options.receiveDirection Unwrapping messages from additional struct
+   */
+  constructor() {
+    let {
+      target,
+      self = window,
+      origin,
+      sendDirection,
+      receiveDirection = MESSAGE_DIRECTION.to_aepp,
+      ...options
+    } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    super(options);
+
+    _classPrivateFieldInitSpec(this, _onDisconnect, {
+      writable: true,
+      value: void 0
+    });
+
+    _classPrivateFieldInitSpec(this, _target, {
+      writable: true,
+      value: void 0
+    });
+
+    _classPrivateFieldInitSpec(this, _self, {
+      writable: true,
+      value: void 0
+    });
+
+    _classPrivateFieldSet(this, _target, target);
+
+    _classPrivateFieldSet(this, _self, self);
+
+    this.origin = origin;
+    this.sendDirection = sendDirection;
+    this.receiveDirection = receiveDirection;
+  }
+
+  isConnected() {
+    return this.listener != null;
+  }
+
+  connect(onMessage, onDisconnect) {
+    super.connect(onMessage, onDisconnect);
+
+    this.listener = message => {
+      if (typeof message.data !== 'object') return;
+      if (this.origin != null && this.origin !== message.origin) return;
+      if (_classPrivateFieldGet(this, _target) != null && _classPrivateFieldGet(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;
+      }
+
+      onMessage(data, message.origin, message.source);
+    };
+
+    _classPrivateFieldGet(this, _self).addEventListener('message', this.listener);
+
+    _classPrivateFieldSet(this, _onDisconnect, onDisconnect);
+  }
+
+  disconnect() {
+    super.disconnect();
+
+    if (this.listener == null || _classPrivateFieldGet(this, _onDisconnect) == null) {
+      throw new InternalError('Expected to not happen, required for TS');
+    }
+
+    _classPrivateFieldGet(this, _self).removeEventListener('message', this.listener);
+
+    delete this.listener;
+
+    _classPrivateFieldGet(this, _onDisconnect).call(this);
+
+    _classPrivateFieldSet(this, _onDisconnect, undefined);
+  }
+
+  sendMessage(msg) {
+    var _this$origin;
+
+    if (_classPrivateFieldGet(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);
+
+    _classPrivateFieldGet(this, _target).postMessage(message, (_this$origin = this.origin) !== null && _this$origin !== void 0 ? _this$origin : '*');
+  }
+
+}
+//# sourceMappingURL=BrowserWindowMessage.mjs.map

package/es/aepp-wallet-communication/connection/BrowserWindowMessage.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"BrowserWindowMessage.mjs","names":["BrowserConnection","MESSAGE_DIRECTION","InternalError","RpcConnectionError","BrowserWindowMessageConnection","constructor","target","self","window","origin","sendDirection","receiveDirection","to_aepp","options","isConnected","listener","connect","onMessage","onDisconnect","message","data","source","receiveMessage","type","addEventListener","disconnect","removeEventListener","undefined","sendMessage","msg","postMessage"],"sources":["../../../src/aepp-wallet-communication/connection/BrowserWindowMessage.ts"],"sourcesContent":["/*\n * ISC License (ISC)\n * Copyright (c) 2022 aeternity developers\n *\n *  Permission to use, copy, modify, and/or distribute this software for any\n *  purpose with or without fee is hereby granted, provided that the above\n *  copyright notice and this permission notice appear in all copies.\n *\n *  THE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\n *  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\n *  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\n *  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\n *  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\n *  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\n *  PERFORMANCE OF THIS SOFTWARE.\n */\n\nimport BrowserConnection from './Browser'\nimport { MESSAGE_DIRECTION } from '../schema'\nimport { InternalError, RpcConnectionError } from '../../utils/errors'\n\nexport type ImplPostMessage = Pick<Window, 'addEventListener' | 'removeEventListener' | 'postMessage'>\n\n/**\n * Browser window Post Message connector module\n */\nexport default class BrowserWindowMessageConnection extends BrowserConnection {\n  origin?: string\n  sendDirection?: MESSAGE_DIRECTION\n  receiveDirection: MESSAGE_DIRECTION\n  listener?: (this: Window, ev: MessageEvent<any>) => void\n  #onDisconnect?: () => void\n  #target?: ImplPostMessage\n  #self: ImplPostMessage\n\n  /**\n   * @param options - Options\n   * @param options.target Target window for message\n   * @param options.self Host window for message\n   * @param options.origin Origin of receiver\n   * @param options.sendDirection Wrapping messages into additional struct\n   * `({ type: 'to_aepp' || 'to_waellet', data })`\n   * Used for handling messages between content script and page\n   * @param options.receiveDirection Unwrapping messages from additional struct\n   */\n  constructor ({\n    target,\n    self = window,\n    origin,\n    sendDirection,\n    receiveDirection = MESSAGE_DIRECTION.to_aepp,\n    ...options\n  }: {\n    target?: ImplPostMessage\n    self?: ImplPostMessage\n    origin?: string\n    sendDirection?: MESSAGE_DIRECTION\n    receiveDirection?: MESSAGE_DIRECTION\n    debug?: boolean\n  } = {}) {\n    super(options)\n    this.#target = target\n    this.#self = self\n    this.origin = origin\n    this.sendDirection = sendDirection\n    this.receiveDirection = receiveDirection\n  }\n\n  isConnected (): boolean {\n    return this.listener != null\n  }\n\n  connect (\n    onMessage: (message: any, origin: string, source: MessageEventSource | null) => void,\n    onDisconnect: () => void\n  ): void {\n    super.connect(onMessage, onDisconnect)\n    this.listener = (message: MessageEvent<any>) => {\n      if (typeof message.data !== 'object') return\n      if (this.origin != null && this.origin !== message.origin) return\n      if (this.#target != null && this.#target !== message.source) return\n      this.receiveMessage(message)\n      let { data } = message\n      if (data.type != null) {\n        if (message.data.type !== this.receiveDirection) return\n        data = data.data\n      }\n      onMessage(data, message.origin, message.source)\n    }\n    this.#self.addEventListener('message', this.listener)\n    this.#onDisconnect = onDisconnect\n  }\n\n  disconnect (): void {\n    super.disconnect()\n    if (this.listener == null || this.#onDisconnect == null) {\n      throw new InternalError('Expected to not happen, required for TS')\n    }\n    this.#self.removeEventListener('message', this.listener)\n    delete this.listener\n    this.#onDisconnect()\n    this.#onDisconnect = undefined\n  }\n\n  sendMessage (msg: any): void {\n    if (this.#target == null) throw new RpcConnectionError('Can\\'t send messages without target')\n    const message = this.sendDirection != null ? { type: this.sendDirection, data: msg } : msg\n    super.sendMessage(message)\n    this.#target.postMessage(message, this.origin ?? '*')\n  }\n}\n"],"mappings":";;;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;OAEOA,iB;SACEC,iB;SACAC,a,EAAeC,kB;;;;;;;;AAIxB;AACA;AACA;AACA,eAAe,MAAMC,8BAAN,SAA6CJ,iBAA7C,CAA+D;EAS5E;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACEK,WAAW,GAcH;IAAA,IAdK;MACXC,MADW;MAEXC,IAAI,GAAGC,MAFI;MAGXC,MAHW;MAIXC,aAJW;MAKXC,gBAAgB,GAAGV,iBAAiB,CAACW,OAL1B;MAMX,GAAGC;IANQ,CAcL,uEAAJ,EAAI;IACN,MAAMA,OAAN;;IADM;MAAA;MAAA;IAAA;;IAAA;MAAA;MAAA;IAAA;;IAAA;MAAA;MAAA;IAAA;;IAEN,qCAAeP,MAAf;;IACA,mCAAaC,IAAb;;IACA,KAAKE,MAAL,GAAcA,MAAd;IACA,KAAKC,aAAL,GAAqBA,aAArB;IACA,KAAKC,gBAAL,GAAwBA,gBAAxB;EACD;;EAEDG,WAAW,GAAa;IACtB,OAAO,KAAKC,QAAL,IAAiB,IAAxB;EACD;;EAEDC,OAAO,CACLC,SADK,EAELC,YAFK,EAGC;IACN,MAAMF,OAAN,CAAcC,SAAd,EAAyBC,YAAzB;;IACA,KAAKH,QAAL,GAAiBI,OAAD,IAAgC;MAC9C,IAAI,OAAOA,OAAO,CAACC,IAAf,KAAwB,QAA5B,EAAsC;MACtC,IAAI,KAAKX,MAAL,IAAe,IAAf,IAAuB,KAAKA,MAAL,KAAgBU,OAAO,CAACV,MAAnD,EAA2D;MAC3D,IAAI,wCAAgB,IAAhB,IAAwB,yCAAiBU,OAAO,CAACE,MAArD,EAA6D;MAC7D,KAAKC,cAAL,CAAoBH,OAApB;MACA,IAAI;QAAEC;MAAF,IAAWD,OAAf;;MACA,IAAIC,IAAI,CAACG,IAAL,IAAa,IAAjB,EAAuB;QACrB,IAAIJ,OAAO,CAACC,IAAR,CAAaG,IAAb,KAAsB,KAAKZ,gBAA/B,EAAiD;QACjDS,IAAI,GAAGA,IAAI,CAACA,IAAZ;MACD;;MACDH,SAAS,CAACG,IAAD,EAAOD,OAAO,CAACV,MAAf,EAAuBU,OAAO,CAACE,MAA/B,CAAT;IACD,CAXD;;IAYA,mCAAWG,gBAAX,CAA4B,SAA5B,EAAuC,KAAKT,QAA5C;;IACA,2CAAqBG,YAArB;EACD;;EAEDO,UAAU,GAAU;IAClB,MAAMA,UAAN;;IACA,IAAI,KAAKV,QAAL,IAAiB,IAAjB,IAAyB,8CAAsB,IAAnD,EAAyD;MACvD,MAAM,IAAIb,aAAJ,CAAkB,yCAAlB,CAAN;IACD;;IACD,mCAAWwB,mBAAX,CAA+B,SAA/B,EAA0C,KAAKX,QAA/C;;IACA,OAAO,KAAKA,QAAZ;;IACA;;IACA,2CAAqBY,SAArB;EACD;;EAEDC,WAAW,CAAEC,GAAF,EAAkB;IAAA;;IAC3B,IAAI,wCAAgB,IAApB,EAA0B,MAAM,IAAI1B,kBAAJ,CAAuB,qCAAvB,CAAN;IAC1B,MAAMgB,OAAO,GAAG,KAAKT,aAAL,IAAsB,IAAtB,GAA6B;MAAEa,IAAI,EAAE,KAAKb,aAAb;MAA4BU,IAAI,EAAES;IAAlC,CAA7B,GAAuEA,GAAvF;IACA,MAAMD,WAAN,CAAkBT,OAAlB;;IACA,qCAAaW,WAAb,CAAyBX,OAAzB,kBAAkC,KAAKV,MAAvC,uDAAiD,GAAjD;EACD;;AAnF2E"}

package/es/aepp-wallet-communication/connection-proxy.d.ts

@@ -0,0 +1,10 @@
+import BrowserConnection from './connection/Browser';
+/**
+ * Browser connection proxy
+ * Provide functionality to easily forward messages from one connection to another and back
+ * @param con1 - first connection
+ * @param con2 - second connection
+ * @returns a function to stop proxying
+ */
+declare const _default: (con1: BrowserConnection, con2: BrowserConnection) => () => void;
+export default _default;

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

@@ -1,6 +1,6 @@
 /*
  * 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
@@ -15,15 +15,19 @@
  *  PERFORMANCE OF THIS SOFTWARE.
  */
 
-import { blake2b } from 'blakejs'
-import type { Data } from 'blakejs'
-
 /**
- * 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
+ * @param con1 - first connection
+ * @param con2 - second connection
+ * @returns a function to stop proxying
  */
-export function hash (input: Data): Buffer {
-  return Buffer.from(blake2b(input, null, 32)) // 256 bits
-}
+export default ((con1, con2) => {
+  con1.connect(msg => con2.sendMessage(msg), () => con2.disconnect());
+  con2.connect(msg => con1.sendMessage(msg), () => con1.disconnect());
+  return () => {
+    con1.disconnect();
+    con2.disconnect();
+  };
+});
+//# sourceMappingURL=connection-proxy.mjs.map

package/es/aepp-wallet-communication/connection-proxy.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection-proxy.mjs","names":["con1","con2","connect","msg","sendMessage","disconnect"],"sources":["../../src/aepp-wallet-communication/connection-proxy.ts"],"sourcesContent":["/*\n * ISC License (ISC)\n * Copyright (c) 2022 aeternity developers\n *\n *  Permission to use, copy, modify, and/or distribute this software for any\n *  purpose with or without fee is hereby granted, provided that the above\n *  copyright notice and this permission notice appear in all copies.\n *\n *  THE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\n *  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\n *  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\n *  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\n *  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\n *  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\n *  PERFORMANCE OF THIS SOFTWARE.\n */\n\nimport BrowserConnection from './connection/Browser'\n\n/**\n * Browser connection proxy\n * Provide functionality to easily forward messages from one connection to another and back\n * @param con1 - first connection\n * @param con2 - second connection\n * @returns a function to stop proxying\n */\nexport default (con1: BrowserConnection, con2: BrowserConnection): () => void => {\n  con1.connect((msg: any) => con2.sendMessage(msg), () => con2.disconnect())\n  con2.connect((msg: any) => con1.sendMessage(msg), () => con1.disconnect())\n\n  return () => {\n    con1.disconnect()\n    con2.disconnect()\n  }\n}\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAe,CAACA,IAAD,EAA0BC,IAA1B,KAAkE;EAC/ED,IAAI,CAACE,OAAL,CAAcC,GAAD,IAAcF,IAAI,CAACG,WAAL,CAAiBD,GAAjB,CAA3B,EAAkD,MAAMF,IAAI,CAACI,UAAL,EAAxD;EACAJ,IAAI,CAACC,OAAL,CAAcC,GAAD,IAAcH,IAAI,CAACI,WAAL,CAAiBD,GAAjB,CAA3B,EAAkD,MAAMH,IAAI,CAACK,UAAL,EAAxD;EAEA,OAAO,MAAM;IACXL,IAAI,CAACK,UAAL;IACAJ,IAAI,CAACI,UAAL;EACD,CAHD;AAID,CARD"}

package/es/aepp-wallet-communication/rpc/RpcClient.d.ts

@@ -0,0 +1,33 @@
+import BrowserConnection from '../connection/Browser';
+declare type RpcApiHandler = (p?: any) => any | undefined;
+declare type RpcApi<Api> = {
+    [k in keyof Api]: RpcApiHandler;
+};
+declare 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>> {
+    #private;
+    connection: BrowserConnection;
+    constructor(connection: BrowserConnection, onDisconnect: () => void, methods: WithOrigin<LocalApi>);
+    /**
+     * Make a request
+     * @param name - Method name
+     * @param params - Method params
+     * @returns Promise which will be resolved after receiving response message
+     */
+    request<Name extends keyof RemoteApi>(name: Name, params: Parameters<RemoteApi[Name]>[0]): Promise<ReturnType<RemoteApi[Name]>>;
+    /**
+     * Make a notification
+     * @param name - Method name
+     * @param params - Method params
+     */
+    notify<Name extends keyof RemoteApi>(name: Name, params: Parameters<RemoteApi[Name]>[0]): void;
+}
+export {};

package/es/aepp-wallet-communication/rpc/RpcClient.mjs

@@ -0,0 +1,169 @@
+import _classPrivateFieldGet from "@babel/runtime-corejs3/helpers/classPrivateFieldGet";
+import _classPrivateFieldSet from "@babel/runtime-corejs3/helpers/classPrivateFieldSet";
+
+function _classPrivateMethodInitSpec(obj, privateSet) { _checkPrivateRedeclaration(obj, privateSet); privateSet.add(obj); }
+
+function _classPrivateFieldInitSpec(obj, privateMap, value) { _checkPrivateRedeclaration(obj, privateMap); privateMap.set(obj, value); }
+
+function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
+
+function _classPrivateMethodGet(receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return fn; }
+
+import { RpcError, RpcInternalError, RpcMethodNotFoundError } from "../schema.mjs";
+import { InvalidRpcMessageError, MissingCallbackError } from "../../utils/errors.mjs";
+
+var _callbacks = /*#__PURE__*/new WeakMap();
+
+var _messageId = /*#__PURE__*/new WeakMap();
+
+var _methods = /*#__PURE__*/new WeakMap();
+
+var _handleMessage = /*#__PURE__*/new WeakSet();
+
+var _sendRequest = /*#__PURE__*/new WeakSet();
+
+var _sendResponse = /*#__PURE__*/new WeakSet();
+
+var _processResponse = /*#__PURE__*/new WeakSet();
+
+/**
+ * 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 {
+  constructor(connection, onDisconnect, methods) {
+    _classPrivateMethodInitSpec(this, _processResponse);
+
+    _classPrivateMethodInitSpec(this, _sendResponse);
+
+    _classPrivateMethodInitSpec(this, _sendRequest);
+
+    _classPrivateMethodInitSpec(this, _handleMessage);
+
+    _classPrivateFieldInitSpec(this, _callbacks, {
+      writable: true,
+      value: new Map()
+    });
+
+    _classPrivateFieldInitSpec(this, _messageId, {
+      writable: true,
+      value: 0
+    });
+
+    _classPrivateFieldInitSpec(this, _methods, {
+      writable: true,
+      value: void 0
+    });
+
+    this.connection = connection;
+
+    _classPrivateFieldSet(this, _methods, methods);
+
+    connection.connect(_classPrivateMethodGet(this, _handleMessage, _handleMessage2).bind(this), onDisconnect);
+  }
+
+  /**
+   * Make a request
+   * @param name - Method name
+   * @param params - Method params
+   * @returns Promise which will be resolved after receiving response message
+   */
+  async request(name, params) {
+    var _this$messageId;
+
+    _classPrivateMethodGet(this, _sendRequest, _sendRequest2).call(this, _classPrivateFieldSet(this, _messageId, (_this$messageId = _classPrivateFieldGet(this, _messageId), ++_this$messageId)), name, params);
+
+    return await new Promise((resolve, reject) => {
+      _classPrivateFieldGet(this, _callbacks).set(_classPrivateFieldGet(this, _messageId), {
+        resolve,
+        reject
+      });
+    });
+  }
+  /**
+   * Make a notification
+   * @param name - Method name
+   * @param params - Method params
+   */
+
+
+  notify(name, params) {
+    _classPrivateMethodGet(this, _sendRequest, _sendRequest2).call(this, undefined, name, params);
+  }
+  /**
+   * Process response message
+   * @param msg - Message object
+   */
+
+
+}
+
+async function _handleMessage2(msg, origin) {
+  if ((msg === null || msg === void 0 ? void 0 : msg.jsonrpc) !== '2.0') throw new InvalidRpcMessageError(JSON.stringify(msg));
+
+  if ('result' in msg || 'error' in msg) {
+    _classPrivateMethodGet(this, _processResponse, _processResponse2).call(this, msg);
+
+    return;
+  }
+
+  const request = msg;
+  let result, error;
+
+  try {
+    if (!(request.method in _classPrivateFieldGet(this, _methods))) throw new RpcMethodNotFoundError();
+    const methodName = request.method;
+    result = await _classPrivateFieldGet(this, _methods)[methodName](request.params, origin);
+  } catch (e) {
+    error = e instanceof RpcError ? e : new RpcInternalError();
+  }
+
+  if (request.id != null) {
+    _classPrivateMethodGet(this, _sendResponse, _sendResponse2).call(this, request.id, request.method, result, error);
+  }
+}
+
+function _sendRequest2(id, method, params) {
+  this.connection.sendMessage({
+    jsonrpc: '2.0',
+    ...(id != null ? {
+      id
+    } : {}),
+    method,
+    ...(params != null ? {
+      params
+    } : {})
+  });
+}
+
+function _sendResponse2(id, method, // TODO: remove as far it is not required in JSON RPC
+result, error) {
+  this.connection.sendMessage({
+    jsonrpc: '2.0',
+    id,
+    method,
+    ...(error != null ? {
+      error
+    } : {
+      result
+    })
+  });
+}
+
+function _processResponse2(_ref) {
+  let {
+    id,
+    error,
+    result
+  } = _ref;
+
+  const callbacks = _classPrivateFieldGet(this, _callbacks).get(id);
+
+  if (callbacks == null) throw new MissingCallbackError(id);
+  if (error != null) callbacks.reject(RpcError.deserialize(error));else callbacks.resolve(result);
+
+  _classPrivateFieldGet(this, _callbacks).delete(id);
+}
+//# sourceMappingURL=RpcClient.mjs.map

package/es/aepp-wallet-communication/rpc/RpcClient.mjs.map

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

package/es/aepp-wallet-communication/rpc/types.d.ts

@@ -0,0 +1,77 @@
+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;
+}
+declare type Icons = Array<{
+    src: string;
+    sizes?: string;
+    type?: string;
+    purpose?: string;
+}>;
+export declare 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;
+}
+export {};

package/es/aepp-wallet-communication/rpc/types.mjs

@@ -0,0 +1,3 @@
+import { METHODS } from "../schema.mjs";
+export const RPC_VERSION = 1;
+//# sourceMappingURL=types.mjs.map

package/es/aepp-wallet-communication/rpc/types.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.mjs","names":["METHODS","RPC_VERSION"],"sources":["../../../src/aepp-wallet-communication/rpc/types.ts"],"sourcesContent":["import { send } from '../../spend'\nimport { EncodedData } from '../../utils/encoder'\nimport { METHODS, SUBSCRIPTION_TYPES, WALLET_TYPE } from '../schema'\n\nexport interface WalletInfo {\n  id: string\n  name: string\n  networkId: string\n  origin: string\n  type: WALLET_TYPE\n}\n\nexport interface Accounts {\n  connected: { [pub: EncodedData<'ak'>]: {} }\n  current: { [pub: EncodedData<'ak'>]: {} }\n}\n\nexport interface Node {\n  name: string\n  url: string\n}\n\nexport interface Network {\n  networkId: string\n  node?: Node\n}\n\ntype Icons = Array<{ src: string, sizes?: string, type?: string, purpose?: string }>\n\nexport const RPC_VERSION = 1\n\nexport interface WalletApi {\n  [METHODS.connect]: (\n    p: { name: string, icons?: Icons, version: typeof RPC_VERSION, connectNode: boolean }\n  ) => Promise<WalletInfo & { node?: Node }>\n\n  [METHODS.closeConnection]: (p: any) => void\n\n  [METHODS.subscribeAddress]: (\n    p: { type: SUBSCRIPTION_TYPES, value: 'connected' | 'current' }\n  ) => Promise<{ subscription: Array<'connected' | 'current'>, address: Accounts }>\n\n  [METHODS.address]: () => Promise<Array<EncodedData<'ak'>>>\n\n  [METHODS.sign]: ((\n    p: { tx: EncodedData<'tx'>, onAccount: EncodedData<'ak'>, returnSigned: boolean }\n  ) => Promise<{\n    /**\n     * @deprecated this is not a hash at all, will be removed later at the same time\n     * as dropping ability to broadcast transaction by wallet\n     */\n    transactionHash?: Awaited<ReturnType<typeof send>>\n    signedTransaction?: EncodedData<'tx'>\n  }>)\n\n  [METHODS.signMessage]: (\n    p: { message: string, onAccount: EncodedData<'ak'> }\n  ) => Promise<{ signature: string }>\n}\n\nexport interface AeppApi {\n  [METHODS.updateAddress]: (a: Accounts) => void\n  [METHODS.updateNetwork]: (a: Network) => void\n  [METHODS.readyToConnect]: (w: WalletInfo) => void\n  [METHODS.closeConnection]: (p: any) => void\n}\n"],"mappings":"SAESA,O;AA2BT,OAAO,MAAMC,WAAW,GAAG,CAApB"}

package/es/aepp-wallet-communication/schema.d.ts

@@ -0,0 +1,118 @@
+import { EncodedData } from '../utils/encoder';
+import { BaseError } from '../utils/errors';
+export declare const enum MESSAGE_DIRECTION {
+    to_waellet = "to_waellet",
+    to_aepp = "to_aepp"
+}
+export declare const enum WALLET_TYPE {
+    window = "window",
+    extension = "extension"
+}
+export declare const enum SUBSCRIPTION_TYPES {
+    subscribe = "subscribe",
+    unsubscribe = "unsubscribe"
+}
+export declare 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 declare 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 declare abstract class RpcError extends BaseError {
+    static code: number;
+    code: number;
+    data?: any;
+    toJSON(): RpcErrorAsJson;
+    static deserialize(json: RpcErrorAsJson): RpcError;
+}
+/**
+ * @category exception
+ */
+export declare class RpcInvalidTransactionError extends RpcError {
+    static code: number;
+    code: number;
+    constructor(data?: any);
+}
+/**
+ * @category exception
+ */
+export declare class RpcBroadcastError extends RpcError {
+    static code: number;
+    code: number;
+    constructor(data?: any);
+}
+/**
+ * @category exception
+ */
+export declare class RpcRejectedByUserError extends RpcError {
+    static code: number;
+    code: number;
+    constructor(data?: any);
+}
+/**
+ * @category exception
+ */
+export declare class RpcUnsupportedProtocolError extends RpcError {
+    static code: number;
+    code: number;
+    constructor();
+}
+/**
+ * @category exception
+ */
+export declare class RpcConnectionDenyError extends RpcError {
+    static code: number;
+    code: number;
+    constructor(data?: any);
+}
+/**
+ * @category exception
+ */
+export declare class RpcNotAuthorizeError extends RpcError {
+    static code: number;
+    code: number;
+    constructor();
+}
+/**
+ * @category exception
+ */
+export declare class RpcPermissionDenyError extends RpcError {
+    static code: number;
+    code: number;
+    constructor(address: EncodedData<'ak'>);
+}
+/**
+ * @category exception
+ */
+export declare class RpcInternalError extends RpcError {
+    static code: number;
+    code: number;
+    constructor();
+}
+/**
+ * @category exception
+ */
+export declare class RpcMethodNotFoundError extends RpcError {
+    static code: number;
+    code: number;
+    constructor();
+}
+export {};