@aeternity/aepp-sdk/es/AeSdkAepp.js

SDK for the æternity blockchain

import AeSdkBase from './AeSdkBase.js';
import AccountRpc from './account/Rpc.js';
import { decode } from './utils/encoder.js';
import { RPC_VERSION } from './aepp-wallet-communication/rpc/types.js';
import RpcClient from './aepp-wallet-communication/rpc/RpcClient.js';
import { METHODS } from './aepp-wallet-communication/schema.js';
import { AlreadyConnectedError, NoWalletConnectedError, UnsubscribedAccountError, UnAuthorizedAccountError, RpcConnectionError } from './utils/errors.js';
import Node from './Node.js';
/**
 * RPC handler for AEPP side
 * Contain functionality for wallet interaction and connect it to sdk
 * @deprecated use WalletConnectorFrame instead
 * @category aepp wallet communication
 */
export default class AeSdkAepp extends AeSdkBase {
  /**
   * @param options - Options
   * @param options.name - Aepp name
   * @param options.onAddressChange - Call-back function for update address event
   * @param options.onDisconnect - Call-back function for disconnect event
   * @param options.onNetworkChange - Call-back function for update network event
   */
  constructor({
    name,
    onAddressChange = () => {},
    onDisconnect = () => {},
    onNetworkChange = () => {},
    ...other
  }) {
    super(other);
    this.onAddressChange = onAddressChange;
    this.onDisconnect = onDisconnect;
    this.onNetworkChange = onNetworkChange;
    this.name = name;
  }
  _resolveAccount(account = this.addresses()[0]) {
    if (typeof account === 'string') {
      const address = account;
      decode(address);
      if (!this.addresses().includes(address)) throw new UnAuthorizedAccountError(address);
      this._ensureConnected();
      account = new AccountRpc(this.rpcClient, address);
    }
    if (account == null) this._ensureAccountAccess();
    return super._resolveAccount(account);
  }
  addresses() {
    if (this._accounts == null) return [];
    const current = Object.keys(this._accounts.current)[0];
    return [...(current != null ? [current] : []), ...Object.keys(this._accounts.connected)];
  }

  /**
   * Connect to wallet
   * @param connection - Wallet connection object
   * @param options - Options
   * @param options.connectNode - Request wallet to bind node
   * @param options.name - Node name
   */
  async connectToWallet(connection, {
    connectNode = false,
    name = 'wallet-node'
  } = {}) {
    if (this.rpcClient != null) throw new AlreadyConnectedError('You are already connected to wallet');
    let disconnectParams;
    const updateNetwork = params => {
      if (connectNode) {
        if (params.node?.url == null) throw new RpcConnectionError('Missing URLs of the Node');
        this.pool.delete(name);
        this.addNode(name, new Node(params.node.url), true);
      }
      this.onNetworkChange(params);
    };
    const client = new RpcClient(connection, () => {
      delete this.rpcClient;
      delete this._accounts;
      this.onDisconnect(disconnectParams);
    }, {
      [METHODS.updateAddress]: params => {
        this._accounts = params;
        this.onAddressChange(params);
      },
      [METHODS.updateNetwork]: updateNetwork,
      [METHODS.closeConnection]: params => {
        disconnectParams = params;
        client.connection.disconnect();
      },
      [METHODS.readyToConnect]: () => {}
    });
    const walletInfo = await client.request(METHODS.connect, {
      name: this.name,
      version: RPC_VERSION,
      connectNode
    });
    updateNetwork(walletInfo);
    this.rpcClient = client;
    return walletInfo;
  }

  /**
   * Disconnect from wallet
   */
  disconnectWallet() {
    this._ensureConnected();
    this.rpcClient.notify(METHODS.closeConnection, {
      reason: 'bye'
    });
    this.rpcClient.connection.disconnect();
  }

  /**
   * Ask addresses from wallet
   * @returns Addresses from wallet
   */
  async askAddresses() {
    this._ensureConnected();
    return this.rpcClient.request(METHODS.address, undefined);
  }

  /**
   * Subscribe for addresses from wallet
   * @param type - Subscription type
   * @param value - Should be one of 'current' (the selected account), 'connected' (all)
   * @returns Accounts from wallet
   */
  async subscribeAddress(type, value) {
    this._ensureConnected();
    const result = await this.rpcClient.request(METHODS.subscribeAddress, {
      type,
      value
    });
    this._accounts = result.address;
    return result;
  }

  /**
   * Ask wallet to select a network
   */
  async askToSelectNetwork(network) {
    this._ensureConnected();
    await this.rpcClient.request(METHODS.updateNetwork, network);
  }
  _ensureConnected() {
    if (this.rpcClient != null) return;
    throw new NoWalletConnectedError('You are not connected to Wallet');
  }
  _ensureAccountAccess() {
    this._ensureConnected();
    if (this.addresses().length !== 0) return;
    throw new UnsubscribedAccountError();
  }
}
//# sourceMappingURL=AeSdkAepp.js.map