@aeternity/aepp-sdk 13.3.2 → 14.0.0

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

@@ -1,105 +0,0 @@
-import BrowserConnection from './Browser';
-import { MESSAGE_DIRECTION } from '../schema';
-import { InternalError, RpcConnectionError } from '../../utils/errors';
-
-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;
-
-  readonly #target?: ImplPostMessage;
-
-  readonly #self: ImplPostMessage;
-
-  /**
-   * @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({
-    target,
-    self = window,
-    origin,
-    sendDirection,
-    receiveDirection = MESSAGE_DIRECTION.to_aepp,
-    ...options
-  }: {
-    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;
-  }
-
-  isConnected(): boolean {
-    return this.listener != null;
-  }
-
-  override connect(
-    onMessage: (message: any, origin: string, source: MessageEventSource | null) => void,
-    onDisconnect: () => void,
-  ): void {
-    super.connect(onMessage, onDisconnect);
-    this.listener = (message: MessageEvent<any>) => {
-      // 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;
-      }
-      onMessage(data, message.origin, message.source);
-    };
-    this.#self.addEventListener('message', this.listener);
-    this.#onDisconnect = onDisconnect;
-  }
-
-  override disconnect(): void {
-    super.disconnect();
-    if (this.listener == null || this.#onDisconnect == null) {
-      throw new InternalError('Expected to not happen, required for TS');
-    }
-    this.#self.removeEventListener('message', this.listener);
-    delete this.listener;
-    this.#onDisconnect();
-    this.#onDisconnect = undefined;
-  }
-
-  override 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

@@ -1,19 +0,0 @@
-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());
-
-  return () => {
-    con1.disconnect();
-    con2.disconnect();
-  };
-};

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

@@ -1,153 +0,0 @@
-import { RpcError, RpcInternalError, RpcMethodNotFoundError } from '../schema';
-import BrowserConnection from '../connection/Browser';
-import { InvalidRpcMessageError, MissingCallbackError } from '../../utils/errors';
-import { ensureError } from '../../utils/other';
-
-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;
-
-  readonly #callbacks = (
-    new Map<number, { resolve: (v: any) => void; reject: (e: Error) => void }>()
-  );
-
-  #messageId = 0;
-
-  readonly #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: Error | undefined;
-    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) {
-      ensureError(e);
-      error = e;
-    }
-    if (request.id != null) {
-      this.#sendResponse(
-        request.id,
-        request.method as keyof LocalApi,
-        result,
-        error == null || error instanceof RpcError ? error : new RpcInternalError(),
-      );
-    }
-    if (error != null && !(error instanceof RpcError)) throw 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?: RpcError,
-  ): void {
-    this.connection.sendMessage({
-      jsonrpc: '2.0',
-      id,
-      method,
-      ...error != null ? { error: error.toJSON() } : { 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

@@ -1,115 +0,0 @@
-import { Encoded } from '../../utils/encoder';
-import { Domain, AciValue } from '../../utils/typed-data';
-import { METHODS, SUBSCRIPTION_TYPES, WALLET_TYPE } from '../schema';
-import { TransformNodeType } from '../../Node';
-import { SignedTx } from '../../apis/node';
-import { AensName } from '../../tx/builder/constants';
-
-export interface WalletInfo {
-  id: string;
-  name: string;
-  networkId: string;
-  origin: string; // TODO: origin needs to be provided by transport
-  type: WALLET_TYPE;
-}
-
-export interface Accounts {
-  connected: { [pub: Encoded.AccountAddress]: {} };
-  current: { [pub: Encoded.AccountAddress]: {} };
-}
-
-export interface Node {
-  // TODO: name is not used, can be removed
-  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.unsafeSign]: (
-    p: { data: Encoded.Bytearray; onAccount: Encoded.AccountAddress }
-  ) => Promise<{ signature: Encoded.Signature }>;
-
-  [METHODS.sign]: ((
-    p: {
-      tx: Encoded.Transaction;
-      onAccount: Encoded.AccountAddress;
-      returnSigned: boolean;
-      /**
-       * @deprecated Wallet provided networkId will be used (current network)
-       * required to maintain backward compatibility with wallets using SDK v11.0.1 and below
-       * @see {@link https://github.com/aeternity/aepp-sdk-js/commit/153fd89a52c4eab39fcd659b356b36d32129c1ba}
-       */
-      networkId: string;
-      innerTx?: 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?: Partial<TransformNodeType<SignedTx>> & {
-      hash: Encoded.TxHash;
-      rawTx: Encoded.Transaction;
-    };
-    signedTransaction?: Encoded.Transaction;
-  }>);
-
-  [METHODS.signMessage]: (
-    p: { message: string; onAccount: Encoded.AccountAddress }
-  ) => Promise<{ signature: string }>;
-
-  [METHODS.signTypedData]: (
-    p: {
-      domain: Domain;
-      aci: AciValue;
-      data: Encoded.ContractBytearray;
-      onAccount: Encoded.AccountAddress;
-    },
-  ) => Promise<{ signature: Encoded.Signature }>;
-
-  [METHODS.signDelegationToContract]: (
-    p: {
-      contractAddress: Encoded.ContractAddress;
-      name?: AensName;
-      oracleQueryId?: Encoded.OracleQueryId;
-      allNames?: boolean;
-      isOracle?: boolean;
-      onAccount: Encoded.AccountAddress;
-    },
-  ) => Promise<{ signature: Encoded.Signature }>;
-
-  [METHODS.signDelegation]: (
-    p: {
-      delegation: Encoded.Bytearray;
-      onAccount: Encoded.AccountAddress;
-    },
-  ) => Promise<{ signature: Encoded.Signature }>;
-}
-
-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

@@ -1,212 +0,0 @@
-// 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',
-  unsafeSign = 'data.unsafeSign',
-  sign = 'transaction.sign',
-  signMessage = 'message.sign',
-  signTypedData = 'typedData.sign',
-  signDelegationToContract = 'delegationToContract.sign',
-  signDelegation = 'delegation.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 override code = 2;
-
-  override code = 2;
-
-  constructor(data?: any) {
-    super('Invalid transaction');
-    this.data = data;
-    this.name = 'RpcInvalidTransactionError';
-  }
-}
-rpcErrors.push(RpcInvalidTransactionError);
-
-/**
- * @category exception
- */
-export class RpcRejectedByUserError extends RpcError {
-  static override code = 4;
-
-  override 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 override code = 5;
-
-  override code = 5;
-
-  constructor() {
-    super('Unsupported Protocol Version');
-    this.name = 'RpcUnsupportedProtocolError';
-  }
-}
-rpcErrors.push(RpcUnsupportedProtocolError);
-
-/**
- * @category exception
- */
-export class RpcConnectionDenyError extends RpcError {
-  static override code = 9;
-
-  override 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 override code = 10;
-
-  override 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 override code = 11;
-
-  override 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 override code = 12;
-
-  override 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 override code = -32601;
-
-  override code = -32601;
-
-  constructor() {
-    super('Method not found');
-    this.name = 'RpcMethodNotFoundError';
-  }
-}
-rpcErrors.push(RpcMethodNotFoundError);

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

@@ -1,54 +0,0 @@
-import BrowserConnection from './connection/Browser';
-import BrowserWindowMessageConnection from './connection/BrowserWindowMessage';
-import { MESSAGE_DIRECTION, METHODS } from './schema';
-import { WalletInfo } from './rpc/types';
-import { UnsupportedPlatformError } from '../utils/errors';
-
-interface Wallet {
-  info: WalletInfo;
-  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: WalletInfo },
-    origin: string,
-    source: Window,
-  ) => {
-    if (method !== METHODS.readyToConnect || wallets[params.id] != null) return;
-
-    const wallet = {
-      info: params,
-      getConnection() {
-        return new BrowserWindowMessageConnection({
-          target: source,
-          ...params.type === 'extension' ? {
-            sendDirection: MESSAGE_DIRECTION.to_waellet,
-            receiveDirection: MESSAGE_DIRECTION.to_aepp,
-            ...window.origin !== 'null' && { origin: window.origin },
-          } : {
-            origin: params.origin,
-          },
-        });
-      },
-    };
-    wallets[wallet.info.id] = wallet;
-    onDetected({ wallets, newWallet: wallet });
-  }, () => {});
-
-  return () => connection.disconnect();
-};