ethereum.enable(): Promise<[String]>;

ethereum.send(method: String, params?: Array<any>): Promise<any>;

ethereum.subscribe(subscriptionType: String, params?: Array<any>): Promise<String>;

ethereum.on(subscriptionId, listener: (result: any) => void): this;

ethereum.unsubscribe(subscriptionId: String): Promise<Boolean>;

ethereum.on('connect', listener: () => void): this;

const network = await ethereum.send('net_version');

> ''

ethereum.on('close', listener: (code: Number, reason: String) => void): this;

ethereum.on('networkChanged', listener: (networkId: String) => void): this;

ethereum.on('accountsChanged', listener: (accounts: Array<String>) => void): this;

ethereum.constructor.name;

> 'EthereumProvider'

const ethereum = window.ethereum;

//这是两种使用方法，一种即将EthereumProvider设置到web3上，然后之后就能够使用web3的接口来调用方法，如web3.eth.sendTransaction({/* ... */});

// A) Primary use case - set provider in web3.js

web3.setProvider(ethereum);

//不然另一种方法就是直接使用ethereum，然后用本文上面的方式来进行方法的调用，即send\subscribe等

// B) Secondary use case - use provider object directly

// Example 1: Log last block

ethereum

  .send('eth_getBlockByNumber', ['latest', 'true'])//得到最新的区块账户信息

  .then(block => {

    console.log(`Block ${block.number}:\n${block}`);

  })

  .catch(error => {

    console.error(

      `Error fetching last block: ${error.message}.

       Code: ${error.code}. Data: ${error.data}`

    );

  });

// Example 2: Enable full provider

ethereum

  .enable()

  .then(accounts => {

    console.log(`Enabled accounts:\n${accounts.join('\n')}`);//得到钱包中所有的账户信息

  })

  .catch(error => {

    console.error(

      `Error enabling provider: ${error.message}.

      Code: ${error.code}. Data: ${error.data}`

    );

  });

// Example 3: Log available accounts

ethereum

  .send('eth_accounts')

  .then(accounts => {

    console.log(`Accounts:\n${accounts.join('\n')}`);//得到钱包中所有的账户信息

  })

  .catch(error => {

    console.error(

      `Error fetching accounts: ${error.message}.

       Code: ${error.code}. Data: ${error.data}`

    );

  });

}

// Example 4: Log new blocks

let subId;//全局变量，用于之后取消订阅

ethereum

  .subscribe('newHeads')//订阅得到新区块头的信息

  .then(subscriptionId => {

    subId = subscriptionId;

    ethereum.on(subscriptionId, block => {

      if (result instanceOf Error) {

        const error = result;

        console.error(

          `Error from newHeads subscription: ${error.message}.

           Code: ${error.code}. Data: ${error.data}`

        );

      } else {

        console.log(`New block ${block.number}:\n${block}`);

      }

    });

  })

  .catch(error => {

    console.error(

      `Error making newHeads subscription: ${error.message}.

       Code: ${error.code}. Data: ${error.data}`

     );

  });

// to unsubscribe

ethereum

  .unsubscribe(subId)//取消订阅

  .then(result => {

    console.log(`Unsubscribed newHeads subscription ${subscriptionId}`);

  })

  .catch(error => {

    console.error(

      `Error unsubscribing newHeads subscription: ${error.message}.

       Code: ${error.code}. Data: ${error.data}`

    );

  });

// Example 5: Log when accounts change

const logAccounts = accounts => {

  console.log(`Accounts:\n${accounts.join('\n')}`);

};

ethereum.on('accountsChanged', logAccounts);//账户更改的话则调用回调logAccounts

// to unsubscribe

ethereum.removeListener('accountsChanged', logAccounts);

// Example 6: Log if connection ends

ethereum.on('close', (code, reason) => {

  console.log(

    `Ethereum provider connection closed: ${reason}. Code: ${code}`

  );

});

 sendAsync(payload: Object, callback: (error: any, result: any) => void): void

isConnected(): Boolean.

class EthereumProvider extends EventEmitter {

  constructor() {

    // Call super for `this` to be defined

    super();

    // Init storage

    this._isConnected = false;

    this._nextJsonrpcId = ;

    this._promises = {};

    this._activeSubscriptions = [];

    // Fire the connect

    this._connect();

    // Listen for jsonrpc responses

    window.addEventListener('message', this._handleJsonrpcMessage.bind(this));

  }

  /* Methods */

  enable() {

    return new Promise((resolve, reject) => {

      window.mist

        .requestAccounts()

        .then(resolve)

        .catch(reject);

    });

  }

  send(method, params = []) {

    if (!method || typeof method !== 'string') {

      return new Error('Method is not a valid string.');

    }

    if (!(params instanceof Array)) {

      return new Error('Params is not a valid array.');

    }

    const id = this._nextJsonrpcId++;

    const jsonrpc = '2.0';

    const payload = { jsonrpc, id, method, params };

    const promise = new Promise((resolve, reject) => {

      this._promises[payload.id] = { resolve, reject };

    });

    // Send jsonrpc request to Mist

    window.postMessage(

      { type: 'mistAPI_ethereum_provider_write', message: payload },

      origin

    );

    return promise;

  }

  subscribe(subscriptionType, params) {

    return this.send('eth_subscribe', [subscriptionType, ...params]).then(

      subscriptionId => {

        this._activeSubscriptions.push(subscriptionId);

      }

    );

  }

  unsubscribe(subscriptionId) {

    return this.send('eth_unsubscribe', [subscriptionId]).then(success => {

      if (success) {

        // Remove subscription

        this._activeSubscription = this._activeSubscription.filter(

          id => id !== subscriptionId

        );

        // Remove listeners on subscriptionId

        this.removeAllListeners(subscriptionId);

      }

    });

  }

  /* Internal methods */

  _handleJsonrpcMessage(event) {

    // Return if no data to parse

    if (!event || !event.data) {

      return;

    }

    let data;

    try {

      data = JSON.parse(event.data);

    } catch (error) {

      // Return if we can't parse a valid object

      return;

    }

    // Return if not a jsonrpc response

    if (!data || !data.message || !data.message.jsonrpc) {

      return;

    }

    const message = data.message;

    const { id, method, error, result } = message;

    if (typeof id !== 'undefined') {

      const promise = this._promises[id];

      if (promise) {

        // Handle pending promise

        if (data.type === 'error') {

          promise.reject(message);

        } else if (message.error) {

          promise.reject(error);

        } else {

          promise.resolve(result);

        }

        delete this._promises[id];

      }

    } else {

      if (method && method.indexOf('_subscription') > -) {

        // Emit subscription result

        const { subscription, result } = message.params;

        this.emit(subscription, result);

      }

    }

  }

  /* Connection handling */

  _connect() {

    // Send to Mist

    window.postMessage({ type: 'mistAPI_ethereum_provider_connect' }, origin);

    // Reconnect on close

    this.once('close', this._connect.bind(this));

  }

  /* Events */

  _emitConnect() {

    this._isConnected = true;

    this.emit('connect');

  }

  _emitClose(code, reason) {

    this._isConnected = false;

    this.emit('close', code, reason);

    // Send Error objects to any open subscriptions

    this._activeSubscriptions.forEach(id => {

      const error = new Error(

        `Provider connection to network closed.

         Subscription lost, please subscribe again.`

      );

      this.emit(id, error);

    });

    // Clear subscriptions

    this._activeSubscriptions = [];

  }

  _emitNetworkChanged(networkId) {

    this.emit('networkChanged', networkId);

  }

  _emitAccountsChanged(accounts) {

    this.emit('accountsChanged', accounts);

  }

  /* web3.js provider compatibility */

  sendAsync(payload, callback) {

    return this.send(payload.method, payload.params)

      .then(result => {

        const response = payload;

        response.result = result;

        callback(null, response);

      })

      .catch(error => {

        callback(error, null);

        // eslint-disable-next-line no-console

        console.error(

          `Error from EthereumProvider sendAsync ${payload}: ${error}`

        );

      });

  }

  isConnected() {

    return this._isConnected;

  }

}