Question

我之前曾问过这个问题。我仔细地查看了我建议的交换部分，并且我认为交换部分没有问题。至少在我看来，这没有问题，而且我几乎不知道问题的原因。我感到非常沮丧，以至于我将所有内容都放入了代码中。如果有人可以为我们提供此问题的线索，请回复我。

interactions.js

import Web3 from 'web3'
import {
  web3Loaded,
  web3AccountLoaded,
  tokenLoaded,
  exchangeLoaded,
  cancelledOrdersLoaded
} from './actions'
import Token from '../abis/Token.json'
import Exchange from '../abis/Exchange.json'

export const loadWeb3 = (dispatch) => {
  const web3 = new Web3(Web3.givenProvider || 'http://localhost:7545')
  dispatch(web3Loaded(web3))
  return web3
}

export const loadAccount = async (web3, dispatch) => {
  const accounts = await web3.eth.getAccounts()
  const account = accounts[0]
  dispatch(web3AccountLoaded(account))
  return account
}

export const loadToken = async (web3, networkId, dispatch) => {
    try {
        const token = new web3.eth.Contract(Token.abi, Token.networks[networkId].address)       
        dispatch(tokenLoaded(token))
        return token
    } catch (error) {
        console.log('Contract not deployed to the current network. Please select another network with Metamask.')
        return null
    }
} 

export const loadExchange = async (web3, networkId, dispatch) => {
  try {
    const exchange = new web3.eth.Contract(Exchange.abi, Exchange.networks[networkId].address)      
    dispatch(exchangeLoaded(exchange))
    return exchange
  } catch (error) {
    console.log('Contract not deployed to the current network. Please select another network with Metamask.')
    return null
  }
}
export const loadAllOrders = async (exchange, dispatch) => {
  // if (exchange) { // Make sure exchange has been defined
    // const exchange = new web3.eth.Contract(Exchange.abi, Exchange.networks[networkId].address)
     const cancelStream = await exchange.getPastEvents('Cancel', { fromBlock: 0, toBlock: 'latest' })
     // // await loadAllOrders(this.props.exchange, dispatch)
     console.log(cancelStream)
  }

App.js

import React, { Component } from 'react';
import logo from './logo.svg';
import './App.css';
import Navbar from './Navbar'
import Web3 from 'web3';   
import Content from './Content'
import { connect } from 'react-redux'
// import Token from '../abis/Token.json'
import {
  loadWeb3,
  loadAccount,
  loadToken,
  loadExchange
} from '../store/interactions'
import { contractsLoadedSelector } from '../store/selectors'

class App extends Component {
  componentWillMount() {    
    this.loadBlockchainData(this.props.dispatch)
  }

async loadBlockchainData(dispatch) {
    const web3 = loadWeb3(dispatch)
    const network = await web3.eth.net.getNetworkType()
    const networkId = await web3.eth.net.getId()
    const accounts = await loadAccount(web3, dispatch)
    const token = await loadToken(web3, networkId, dispatch)
    if(!token) {
      window.alert('Token smart contract not detected on the current network. Please select another network with Metamask.')
      return
    }
    const exchange = await loadExchange(web3, networkId, dispatch)
    if(!exchange) {
      window.alert('Exchange smart contract not detected on the current network. Please select another network with Metamask.')
      return
    }
  }

  render() {
    return (
      <div>
      <Navbar />
        { this.props.contractsLoaded ? <Content /> : <div className="content"></div> }
           </div>
           );
         }
       }

function mapStateToProps(state) {
  return {
    contractsLoaded: contractsLoadedSelector(state)
  }
}

export default connect(mapStateToProps)(App);

reducers.js

import { combineReducers } from 'redux';

function web3(state={}, action) {
    switch (action.type) {
        case 'WEB3_LOADED':
            return { ...state,  connection: action.connection }
        case 'WEB3_ACCOUNT_LOADED':
            return { ...state, account: action.account }
        default:
            return state
    }
}

function token(state = {}, action) {
  switch (action.type) {
    case 'TOKEN_LOADED':
      return { ...state, loaded: true, contract: action.contract }
    default:
      return state
  }
}

function exchange(state = {}, action) {
  switch (action.type) {
    case 'EXCHANGE_LOADED':
      return { ...state, loaded: true, contract: action.contract }
    case 'CANCELLED_ORDERS_LOADED':
      return { ...state, cancelledOrders: { loaded: true, data: action.cancelledOrders } }
    // case 'FILLED_ORDERS_LOADED':
    //   return { ...state, filledOrders: { loaded: true, data: action.filledOrders } }
    // case 'ALL_ORDERS_LOADED':
    //   return { ...state, allOrders: { loaded: true, data: action.allOrders } }
    default:
      return state
  }
}

const rootReducer = combineReducers({
  web3,
  token,
  exchange
})

export default rootReducer

Content.js

import React, { Component } from 'react'
import { connect } from 'react-redux'
import { exchangeSelector } from '../store/selectors'
import { loadAllOrders } from '../store/interactions'

class Content extends Component {
  componentWillMount() {
    this.loadBlockchainData(this.props.dispatch)
  }

  // async loadBlockchainData(exchange, dispatch) {
  async loadBlockchainData(dispatch) {
    await loadAllOrders(this.props.exchange, dispatch)
    // this.loadBlockchainData(this.props.exchange)
      // await loadAllOrders(exchange, dispatch)
  }

function mapStateToProps(state) {
  return {
    exchange: state.exchangeSelector
  }
}

export default connect(mapStateToProps)(Content)

selectors.js

import { get } from 'lodash'
import { createSelector } from 'reselect'

const account = state => get(state, 'web3.account')
export const accountSelector = createSelector(account, a => a)

const tokenLoaded = state => get(state, 'token.loaded', false)
export const tokenLoadedSelector = createSelector(tokenLoaded, tl => tl)

const exchangeLoaded = state => get(state, 'exchange.loaded', false)
export const exchangeLoadedSelector = createSelector(exchangeLoaded, el => el)

const exchange = state => get(state, 'exchange.contract')
export const exchangeSelector = createSelector(exchange, e => e)

export const contractsLoadedSelector = createSelector(
  tokenLoaded,
  exchangeLoaded,
  (tl, el) => (tl && el)
)

Answer 1

选中exchange，以确保不undefined

export const loadAllOrders = async (exchange, dispatch) => {
     const cancelStream = exchange ? 
        await exchange.getPastEvents('Cancel', { fromBlock: 0, toBlock: 'latest' }) 
        : null // Check if exchange defined then call getPastEvents
     console.log(cancelStream)
}

getPastEvents未定义（重新）

1 个答案: