@aeternity/aepp-sdk 11.0.0 → 12.1.0

package/src/AeSdkBase.ts

@@ -0,0 +1,338 @@
+import * as chainMethods from './chain';
+import * as txMethods from './tx';
+import * as aensMethods from './aens';
+import * as spendMethods from './spend';
+import * as oracleMethods from './oracle';
+import * as contractMethods from './contract/methods';
+import * as contractGaMethods from './contract/ga';
+import * as deprecatedMethods from './deprecated/methods';
+import { _buildTx } from './tx';
+import { mapObject } from './utils/other';
+import Node, { getNetworkId } from './Node';
+import { AE_AMOUNT_FORMATS } from './utils/amount-formatter';
+import { AMOUNT } from './tx/builder/schema';
+import { Tag } from './tx/builder/constants';
+import MemoryAccount, { Keypair } from './account/Memory';
+import AccountBase, { isAccountBase } from './account/Base';
+import {
+  CompilerError,
+  DuplicateNodeError,
+  NodeNotFoundError,
+  NotImplementedError,
+  TypeError,
+} from './utils/errors';
+import { Encoded } from './utils/encoder';
+import Compiler from './contract/Compiler';
+
+export type Account = Keypair | AccountBase | any;
+
+type NodeInfo = Awaited<ReturnType<Node['getNodeInfo']>> & { name: string };
+
+function getValueOrErrorProxy<Value extends object>(valueCb: () => Value): Value {
+  try {
+    return valueCb();
+  } catch (error) {
+    return new Proxy(
+      {},
+      Object.fromEntries(['get', 'set', 'has'].map((name) => [name, () => { throw error; }])),
+    ) as Value;
+  }
+}
+
+/**
+ * Basic AeSdk class
+ *
+ * AeSdkBase objects are the composition of:
+ * - chain methods
+ * - tx methods
+ * - aens methods
+ * - spend methods
+ * - oracle methods
+ * - contract methods
+ * - contract ga methods
+ * Only by providing the joint functionality of them, most more advanced
+ * operations, i.e. the ones with actual use value on the chain, become
+ * available.
+ */
+class AeSdkBase {
+  _options: {
+    denomination: AE_AMOUNT_FORMATS;
+    amount: number;
+    [key: string]: any;
+  } = { denomination: AE_AMOUNT_FORMATS.AETTOS, amount: AMOUNT };
+
+  pool: Map<string, Node> = new Map();
+
+  selectedNodeName?: string;
+
+  compilerApi: Compiler;
+
+  /**
+   * @param options - Options
+   * @param options.nodes - Array of nodes
+   * @param options.compilerUrl - Url for compiler API
+   * @param options.ignoreVersion - Don't check node or compiler version
+   */
+  constructor(
+    {
+      nodes = [], compilerUrl, ignoreVersion = false, ...options
+    }:
+    {
+      nodes?: Array<{ name: string; instance: Node }>;
+      compilerUrl?: string;
+      ignoreVersion?: boolean;
+      [key: string]: any; // TODO: consider combining all possible options instead
+    } = {},
+  ) {
+    Object.assign(this._options, options);
+
+    nodes.forEach(({ name, instance }, i) => this.addNode(name, instance, i === 0));
+
+    if (compilerUrl == null) {
+      this.compilerApi = getValueOrErrorProxy(() => {
+        throw new CompilerError('You can\'t use Compiler API. Compiler is not ready!');
+      });
+    } else this.setCompilerUrl(compilerUrl, { ignoreVersion });
+  }
+
+  setCompilerUrl(
+    compilerUrl: string,
+    { ignoreVersion = false }: { ignoreVersion?: boolean } = {},
+  ): void {
+    this.compilerApi = new Compiler(compilerUrl, { ignoreVersion });
+  }
+
+  get api(): Node {
+    this.ensureNodeConnected();
+    return this.pool.get(this.selectedNodeName) as Node;
+  }
+
+  /**
+   * Add Node
+   * @param name - Node name
+   * @param node - Node instance
+   * @param select - Select this node as current
+   * @example
+   * ```js
+   * // add and select new node with name 'testNode'
+   * aeSdkBase.addNode('testNode', new Node({ url }), true)
+   * ```
+   */
+  addNode(name: string, node: Node, select = false): void {
+    if (this.pool.has(name)) throw new DuplicateNodeError(name);
+
+    this.pool.set(name, node);
+    if (select || this.selectedNodeName == null) {
+      this.selectNode(name);
+    }
+  }
+
+  /**
+   * Select Node
+   * @param name - Node name
+   * @example
+   * nodePool.selectNode('testNode')
+   */
+  selectNode(name: string): void {
+    if (!this.pool.has(name)) throw new NodeNotFoundError(`Node with name ${name} not in pool`);
+    this.selectedNodeName = name;
+  }
+
+  /**
+   * Get NetworkId of current Node
+   * @example
+   * nodePool.getNetworkId()
+   */
+  readonly getNetworkId = getNetworkId;
+
+  /**
+   * Check if you have selected node
+   * @example
+   * nodePool.isNodeConnected()
+   */
+  isNodeConnected(): this is AeSdkBase & { selectedNodeName: string } {
+    return this.selectedNodeName != null;
+  }
+
+  protected ensureNodeConnected(): asserts this is AeSdkBase & { selectedNodeName: string } {
+    if (!this.isNodeConnected()) {
+      throw new NodeNotFoundError('You can\'t use Node API. Node is not connected or not defined!');
+    }
+  }
+
+  /**
+   * Get information about node
+   * @example
+   * ```js
+   * nodePool.getNodeInfo() // { name, version, networkId, protocol, ... }
+   * ```
+   */
+  async getNodeInfo(): Promise<NodeInfo> {
+    this.ensureNodeConnected();
+    return {
+      name: this.selectedNodeName,
+      ...await this.api.getNodeInfo(),
+    };
+  }
+
+  /**
+   * Get array of available nodes
+   * @example
+   * nodePool.getNodesInPool()
+   */
+  async getNodesInPool(): Promise<NodeInfo[]> {
+    return Promise.all(
+      Array.from(this.pool.entries()).map(async ([name, node]) => ({
+        name,
+        ...await node.getNodeInfo(),
+      })),
+    );
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  addresses(): Encoded.AccountAddress[] {
+    return [];
+  }
+
+  async address({ onAccount }: { onAccount?: Account } = {}): Promise<Encoded.AccountAddress> {
+    return this._resolveAccount(onAccount).address();
+  }
+
+  async sign(
+    data: string | Uint8Array,
+    { onAccount, ...options }: { onAccount?: Account } = {},
+  ): Promise<Uint8Array> {
+    return this._resolveAccount(onAccount).sign(data, options);
+  }
+
+  async signTransaction(
+    tx: Encoded.Transaction,
+    { onAccount, ...options }: { onAccount?: Account } & Parameters<AccountBase['signTransaction']>[1] = {},
+  ): Promise<Encoded.Transaction> {
+    return this._resolveAccount(onAccount)
+      .signTransaction(tx, { ...options, networkId: await this.getNetworkId(options) });
+  }
+
+  async signMessage(
+    message: string,
+    { onAccount, ...options }: { onAccount?: Account } & Parameters<AccountBase['signMessage']>[1] = {},
+  ): Promise<string | Uint8Array> {
+    return this._resolveAccount(onAccount).signMessage(message, options);
+  }
+
+  async verifyMessage(
+    message: string,
+    signature: string | Uint8Array,
+    { onAccount, ...options }: { onAccount?: Account } & Parameters<AccountBase['verifyMessage']>[2] = {},
+  ): Promise<boolean> {
+    return this._resolveAccount(onAccount).verifyMessage(message, signature, options);
+  }
+
+  /**
+   * Resolves an account
+   * @param account - ak-address, instance of AccountBase, or keypair
+   */
+  // eslint-disable-next-line class-methods-use-this
+  _resolveAccount(account?: Account): AccountBase {
+    switch (account !== null && typeof account) {
+      case 'string':
+        throw new NotImplementedError('Address in AccountResolver');
+      case 'object':
+        return isAccountBase(account) ? account : new MemoryAccount({ keypair: account });
+      default:
+        throw new TypeError(
+          'Account should be an address (ak-prefixed string), '
+          + `keypair, or instance of AccountBase, got ${String(account)} instead`,
+        );
+    }
+  }
+
+  _getOptions(): {
+    onNode: Node;
+    onAccount: AccountBase;
+    onCompiler: Compiler;
+  } {
+    return {
+      ...this._options,
+      onNode: getValueOrErrorProxy(() => this.api),
+      onAccount: getValueOrErrorProxy(() => this._resolveAccount()),
+      onCompiler: getValueOrErrorProxy(() => this.compilerApi),
+    };
+  }
+
+  async buildTx<TxType extends Tag>(
+    txType: TxType,
+    options: Omit<Parameters<typeof _buildTx<TxType>>[1], 'onNode'> & { onNode?: Node },
+  ): Promise<Encoded.Transaction> {
+    // @ts-expect-error TODO: need to figure out what's wrong here
+    return _buildTx<TxType>(txType, {
+      ...this._getOptions(),
+      ...options,
+    });
+  }
+}
+
+const { _buildTx: _, ...txMethodsOther } = txMethods;
+const { InvalidTxError: _2, ...chainMethodsOther } = chainMethods;
+
+const methods = {
+  ...chainMethodsOther,
+  ...txMethodsOther,
+  ...aensMethods,
+  ...spendMethods,
+  ...oracleMethods,
+  ...contractMethods,
+  ...contractGaMethods,
+  ...deprecatedMethods,
+} as const;
+
+type RequiredKeys<T> = {
+  [K in keyof T]-?: {} extends Pick<T, K> ? never : K
+}[keyof T];
+
+type OptionalIfNotRequired<T extends [any]> = RequiredKeys<T[0]> extends never ? T | [] : T;
+
+type MakeOptional<Args extends any[]> = Args extends [infer Head, ...infer Tail]
+  ? Tail extends []
+    ? Head extends object
+      ? OptionalIfNotRequired<[Omit<Head, 'onNode' | 'onCompiler' | 'onAccount'>
+      & {
+        onNode?: Node;
+        onCompiler?: Compiler;
+        onAccount?: AccountBase | Encoded.AccountAddress | Keypair;
+      }]>
+      : [Head]
+    : [Head, ...MakeOptional<Tail>]
+  : never;
+
+type TransformMethods <Methods extends { [key: string]: Function }> =
+  {
+    [Name in keyof Methods]:
+    Methods[Name] extends (...args: infer Args) => infer Ret
+      ? (...args: MakeOptional<Args>) => Ret
+      : never
+  };
+
+interface AeSdkBaseMethods extends TransformMethods<typeof methods> {}
+
+Object.assign(AeSdkBase.prototype, mapObject<Function, Function>(
+  methods,
+  ([name, handler]) => [
+    name,
+    function methodWrapper(...args: any[]) {
+      const instanceOptions = this._getOptions();
+      const lastArg = args[args.length - 1];
+      if (lastArg != null && typeof lastArg === 'object' && lastArg.constructor === Object) {
+        args[args.length - 1] = {
+          ...instanceOptions,
+          ...lastArg,
+          ...lastArg.onAccount != null && { onAccount: this._resolveAccount(lastArg.onAccount) },
+        };
+      } else args.push(instanceOptions);
+      return handler(...args);
+    },
+  ],
+));
+
+export default AeSdkBase as new (options?: ConstructorParameters<typeof AeSdkBase>[0]) =>
+AeSdkBase & AeSdkBaseMethods;

package/src/AeSdkWallet.ts

@@ -0,0 +1,348 @@
+import { v4 as uuid } from '@aeternity/uuid';
+import AeSdk from './AeSdk';
+import { Account } from './AeSdkBase';
+import verifyTransaction from './tx/validator';
+import RpcClient from './aepp-wallet-communication/rpc/RpcClient';
+import {
+  METHODS, RPC_STATUS, SUBSCRIPTION_TYPES, WALLET_TYPE,
+  RpcBroadcastError, RpcInvalidTransactionError,
+  RpcNotAuthorizeError, RpcPermissionDenyError, RpcUnsupportedProtocolError,
+} from './aepp-wallet-communication/schema';
+import { InternalError, UnknownRpcClientError } from './utils/errors';
+import AccountBase from './account/Base';
+import BrowserConnection from './aepp-wallet-communication/connection/Browser';
+import {
+  Accounts,
+  AeppApi,
+  Network,
+  RPC_VERSION,
+  WalletApi,
+  WalletInfo,
+} from './aepp-wallet-communication/rpc/types';
+import { Encoded } from './utils/encoder';
+import jsonBig from './utils/json-big';
+
+type RpcClientWallet = RpcClient<AeppApi, WalletApi>;
+
+type OnConnection = (
+  clientId: string, params: Omit<Parameters<WalletApi[METHODS.connect]>[0], 'version'>, origin: string
+) => void;
+
+type OnSubscription = (
+  clientId: string, params: Parameters<WalletApi[METHODS.subscribeAddress]>[0], origin: string
+) => void;
+
+type OnSign = (
+  clientId: string, params: Parameters<WalletApi[METHODS.sign]>[0], origin: string
+) => Promise<{ tx?: Encoded.Transaction; onAccount?: Account } | undefined> | Promise<void>;
+
+type OnDisconnect = (
+  clientId: string, params: Parameters<WalletApi[METHODS.closeConnection]>[0]
+) => void;
+
+type OnAskAccounts = (
+  clientId: string, params: undefined, origin: string
+) => void;
+
+type OnMessageSign = (
+  clientId: string, params: Parameters<WalletApi[METHODS.signMessage]>[0], origin: string
+) => Promise<{ onAccount?: Account } | undefined> | Promise<void>;
+
+interface RpcClientsInfo {
+  id: string;
+  status: RPC_STATUS;
+  connectNode: boolean;
+  addressSubscription: Set<'connected' | 'current'>;
+  rpc: RpcClientWallet;
+}
+
+/**
+ * Contain functionality for aepp interaction and managing multiple aepps
+ * @category aepp wallet communication
+ */
+export default class AeSdkWallet extends AeSdk {
+  id: string;
+
+  _type: WALLET_TYPE;
+
+  name: string;
+
+  _clients: Map<string, RpcClientsInfo>;
+
+  onConnection: OnConnection;
+
+  onSubscription: OnSubscription;
+
+  onSign: OnSign;
+
+  onDisconnect: OnDisconnect;
+
+  onAskAccounts: OnAskAccounts;
+
+  onMessageSign: OnMessageSign;
+
+  /**
+   * @param options - Options
+   * @param options.name - Wallet name
+   * @param options.id - Wallet id
+   * @param options.type - Wallet type
+   * @param options.onConnection - Call-back function for incoming AEPP connection
+   * @param options.onSubscription - Call-back function for incoming AEPP account subscription
+   * @param options.onSign - Call-back function for incoming AEPP sign request
+   * @param options.onAskAccounts - Call-back function for incoming AEPP get address request
+   * @param options.onMessageSign - Call-back function for incoming AEPP sign message request
+   * @param options.onDisconnect - Call-back function for disconnect event
+   */
+  constructor({
+    name,
+    id,
+    type,
+    onConnection,
+    onSubscription,
+    onSign,
+    onDisconnect,
+    onAskAccounts,
+    onMessageSign,
+    ...options
+  }: {
+    id: string;
+    type: WALLET_TYPE;
+    name: string;
+    onConnection: OnConnection;
+    onSubscription: OnSubscription;
+    onSign: OnSign;
+    onDisconnect: OnDisconnect;
+    onAskAccounts: OnAskAccounts;
+    onMessageSign: OnMessageSign;
+  } & ConstructorParameters<typeof AeSdk>[0]) {
+    super(options);
+    this.onConnection = onConnection;
+    this.onSubscription = onSubscription;
+    this.onSign = onSign;
+    this.onDisconnect = onDisconnect;
+    this.onAskAccounts = onAskAccounts;
+    this.onMessageSign = onMessageSign;
+    this._clients = new Map();
+    this.name = name;
+    this.id = id;
+    this._type = type;
+  }
+
+  _pushAccountsToApps(): void {
+    Array.from(this._clients.keys())
+      .filter((clientId) => this._isRpcClientSubscribed(clientId))
+      .map((clientId) => this._getClient(clientId).rpc)
+      .forEach((client) => client.notify(METHODS.updateAddress, this.getAccounts()));
+  }
+
+  selectAccount(address: Encoded.AccountAddress): void {
+    super.selectAccount(address);
+    this._pushAccountsToApps();
+  }
+
+  async addAccount(
+    account: AccountBase,
+    options?: Parameters<AeSdk['addAccount']>[1],
+  ): Promise<void> {
+    await super.addAccount(account, options);
+    this._pushAccountsToApps();
+  }
+
+  _getNode(): { node: Network['node'] } {
+    this.ensureNodeConnected();
+    return { node: { url: this.api.url, name: this.selectedNodeName } };
+  }
+
+  async selectNode(name: string): Promise<void> {
+    super.selectNode(name);
+    const networkId = await this.getNetworkId();
+    Array.from(this._clients.keys())
+      .filter((clientId) => this._isRpcClientConnected(clientId))
+      .map((clientId) => this._getClient(clientId))
+      .forEach((client) => {
+        client.rpc.notify(METHODS.updateNetwork, {
+          networkId,
+          ...client.connectNode && this._getNode(),
+        });
+      });
+  }
+
+  _getClient(clientId: string): RpcClientsInfo {
+    const client = this._clients.get(clientId);
+    if (client == null) throw new UnknownRpcClientError(clientId);
+    return client;
+  }
+
+  _isRpcClientSubscribed(clientId: string): boolean {
+    return this._isRpcClientConnected(clientId)
+      && this._getClient(clientId).addressSubscription.size !== 0;
+  }
+
+  _isRpcClientConnected(clientId: string): boolean {
+    return RPC_STATUS.CONNECTED === this._getClient(clientId).status
+      && this._getClient(clientId).rpc.connection.isConnected();
+  }
+
+  _disconnectRpcClient(clientId: string): void {
+    const client = this._getClient(clientId);
+    client.rpc.connection.disconnect();
+    client.status = RPC_STATUS.DISCONNECTED;
+    client.addressSubscription = new Set();
+  }
+
+  /**
+   * Remove specific RpcClient by ID
+   * @param id - Client ID
+   */
+  removeRpcClient(id: string): void {
+    this._disconnectRpcClient(id);
+    this._clients.delete(id);
+  }
+
+  /**
+   * Add new client by AEPP connection
+   * @param clientConnection - AEPP connection object
+   * @returns Client ID
+   */
+  addRpcClient(clientConnection: BrowserConnection): string {
+    // @TODO  detect if aepp has some history based on origin????
+    // if yes use this instance for connection
+    const id = uuid();
+    let disconnectParams: any;
+    const client: RpcClientsInfo = {
+      id,
+      status: RPC_STATUS.WAITING_FOR_CONNECTION_REQUEST,
+      addressSubscription: new Set(),
+      connectNode: false,
+      rpc: new RpcClient<AeppApi, WalletApi>(
+        clientConnection,
+        () => {
+          this._clients.delete(id);
+          this.onDisconnect(id, disconnectParams); // also related info
+        },
+        {
+          [METHODS.closeConnection]: (params) => {
+            disconnectParams = params;
+            this._disconnectRpcClient(id);
+          },
+          // Store client info and prepare two fn for each client `connect` and `denyConnection`
+          // which automatically prepare and send response for that client
+          [METHODS.connect]: async ({
+            name, version, icons, connectNode,
+          }, origin) => {
+            if (version !== RPC_VERSION) throw new RpcUnsupportedProtocolError();
+
+            await this.onConnection(id, { name, icons, connectNode }, origin);
+            client.status = RPC_STATUS.CONNECTED;
+            client.connectNode = connectNode;
+            return {
+              ...await this.getWalletInfo(),
+              ...connectNode && this._getNode(),
+            };
+          },
+          [METHODS.subscribeAddress]: async ({ type, value }, origin) => {
+            if (!this._isRpcClientConnected(id)) throw new RpcNotAuthorizeError();
+
+            await this.onSubscription(id, { type, value }, origin);
+
+            switch (type) {
+              case SUBSCRIPTION_TYPES.subscribe:
+                client.addressSubscription.add(value);
+                break;
+              case SUBSCRIPTION_TYPES.unsubscribe:
+                client.addressSubscription.delete(value);
+                break;
+              default:
+                throw new InternalError(`Unknown subscription type: ${type}`);
+            }
+
+            return {
+              subscription: Array.from(client.addressSubscription),
+              address: this.getAccounts(),
+            };
+          },
+          [METHODS.address]: async (params, origin) => {
+            if (!this._isRpcClientSubscribed(id)) throw new RpcNotAuthorizeError();
+            await this.onAskAccounts(id, params, origin);
+            return this.addresses();
+          },
+          [METHODS.sign]: async ({ tx, onAccount, returnSigned }, origin) => {
+            if (!this._isRpcClientConnected(id)) throw new RpcNotAuthorizeError();
+            onAccount ??= await this.address();
+            if (!this.addresses().includes(onAccount)) {
+              throw new RpcPermissionDenyError(onAccount);
+            }
+
+            const overrides = await this.onSign(id, { tx, returnSigned, onAccount }, origin);
+            onAccount = overrides?.onAccount ?? onAccount;
+            tx = overrides?.tx ?? tx;
+            if (returnSigned) {
+              return { signedTransaction: await this.signTransaction(tx, { onAccount }) };
+            }
+            try {
+              return jsonBig.parse(jsonBig.stringify({
+                transactionHash: await this.send(tx, { onAccount, verify: false }),
+              }));
+            } catch (error) {
+              const validation = await verifyTransaction(tx, this.api);
+              if (validation.length > 0) throw new RpcInvalidTransactionError(validation);
+              throw new RpcBroadcastError(error.message);
+            }
+          },
+          [METHODS.signMessage]: async ({ message, onAccount }, origin) => {
+            if (!this._isRpcClientConnected(id)) throw new RpcNotAuthorizeError();
+            onAccount ??= await this.address();
+            if (!this.addresses().includes(onAccount)) {
+              throw new RpcPermissionDenyError(onAccount);
+            }
+
+            const overrides = await this.onMessageSign(id, { message, onAccount }, origin);
+            onAccount = overrides?.onAccount ?? onAccount;
+            return {
+              // TODO: fix signMessage return type
+              signature: await this.signMessage(message, { onAccount, returnHex: true }) as
+                unknown as string,
+            };
+          },
+        },
+      ),
+    };
+    this._clients.set(id, client);
+    return id;
+  }
+
+  /**
+   * Send shareWalletInfo message to notify AEPP about wallet
+   * @param clientId - ID of RPC client send message to
+   */
+  async shareWalletInfo(clientId: string): Promise<void> {
+    this._getClient(clientId).rpc.notify(METHODS.readyToConnect, await this.getWalletInfo());
+  }
+
+  /**
+   * Get Wallet info object
+   * @returns Object with wallet information
+   */
+  async getWalletInfo(): Promise<WalletInfo> {
+    return {
+      id: this.id,
+      name: this.name,
+      networkId: await this.getNetworkId(),
+      origin: window.location.origin,
+      type: this._type,
+    };
+  }
+
+  /**
+   * Get Wallet accounts
+   * @returns Object with accounts information (\{ connected: Object, current: Object \})
+   */
+  getAccounts(): Accounts {
+    return {
+      current: this.selectedAddress != null ? { [this.selectedAddress]: {} } : {},
+      connected: this.addresses()
+        .filter((a) => a !== this.selectedAddress)
+        .reduce((acc, a) => ({ ...acc, [a]: {} }), {}),
+    };
+  }
+}