ethereum - 断言错误：预期 '0x0000000000000000000000000000000000000000'

Question

我在测试我的可升级智能合约时遇到了这个错误。我真的被这个困住了，谁能帮我摆脱困境？

合约/StakingContract.sol

//SPDX-License-Identifier: MIT

pragma solidity ^0.6.0;

import "@openzeppelin/contracts-upgradeable/math/SafeMathUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/PausableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC20/SafeERC20Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/ReentrancyGuardUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/Initializable.sol";

contract StakingContract is ERC20Upgradeable, OwnableUpgradeable, ReentrancyGuardUpgradeable {
    using SafeMathUpgradeable for uint256;
    using AddressUpgradeable for address;
    using SafeERC20Upgradeable for IERC20Upgradeable;
    
    event TokensStaked(address _tokenStaker, uint256 _amount, uint256 unlockTime);
    event TokenUnstaked(address _tokenStaker, uint256 _amount);
    
    // Variable that prevents _deposit method from being called 2 times
    bool private locked;
    
    // The total staked amount
    uint256 public totalStaked;
    
    mapping (address => uint256) public stakeBalances;
    mapping(address => uint256) private timestamp;
    
    function initialize(uint256 initialSupply)  public  initializer {
        __ERC20_init("MyToken", "TKN");
        _mint(owner(), initialSupply);
    }
    
    function stakeTokens(address token, uint amount) external {
        stakeBalances[msg.sender] = stakeBalances[msg.sender].add(amount);
        timestamp[msg.sender] = block.timestamp.add(30 days);
        require(IERC20Upgradeable(token).allowance(msg.sender, address(this)) >= amount, "Check the token allowance");
        require(IERC20Upgradeable(token).transferFrom(msg.sender, address(this), amount), "Transfer failed!");
        totalStaked = totalStaked.add(amount);
        
        emit TokensStaked(msg.sender, amount, timestamp[msg.sender]);
    }
    
    function unstakeTokens(address token, uint256 amount) external nonReentrant() {
        require(amount <= stakeBalances[msg.sender], "Sorry! You don't have sufficient stake balance.");
        require(block.timestamp >= timestamp[msg.sender], "Sorry! you cannot withdraw tokens before your stake time.");
        stakeBalances[msg.sender] = stakeBalances[msg.sender].sub(amount);
        require(IERC20Upgradeable(token).transfer(msg.sender, amount));
        totalStaked = totalStaked.sub(amount);
        
        emit TokenUnstaked(msg.sender, amount);
    }
    
    function ownerWithdraw(address token) external onlyOwner() nonReentrant() {
        require(IERC20Upgradeable(token).transfer(owner(), totalStaked), "Transfer Failed!");
        uint256 ownerStakedBalance = stakeBalances[msg.sender];
        stakeBalances[msg.sender] = stakeBalances[msg.sender].sub(ownerStakedBalance);
        totalStaked = totalStaked.sub(totalStaked);
    }
}

测试/StakingContract.test.js

const { accounts, contract, web3 } = require('@openzeppelin/test-environment');
const { expect } = require('chai');

const { TestHelper } = require('@openzeppelin/cli');
const { Contracts, ZWeb3 } = require('@openzeppelin/upgrades');

// Import utilities from Test Helpers
const { BN, expectEvent, expectRevert } = require('@openzeppelin/test-helpers');

ZWeb3.initialize(web3.currentProvider);

const Box = Contracts.getFromLocal('StakingContract');

describe('StakingContract', function () {
  const [ owner, other ] = accounts;

  beforeEach(async function () {
    this.project = await TestHelper();
    this.proxy = await this.project.createProxy(Box);
  });

  it('retrieve returns a value previously stored', async function () {
    // Use large integer comparisons
    expect(await this.proxy.methods.owner().call()).to.equal(owner);
  });
});

它给出了以下错误：

0 passing (864ms)
  1 failing

  1) StakingContract
       retrieve returns a value previously stored:

      AssertionError: expected '0x0000000000000000000000000000000000000000' to equal '0xA05c7D52b924DceB23a766ccB1e91e67b4aCF014'
      + expected - actual

      -0x0000000000000000000000000000000000000000
      +0xA05c7D52b924DceB23a766ccB1e91e67b4aCF014

我试图用其他东西修复它，但问题仍然存在。提前致谢。

标签： ethereumsolidity