Тест трюфеля дает «Ошибка: Попытка запустить транзакцию, которая вызывает функцию контракта, но адрес получателя ___ не является адресом контракта»

Question

Когда я запускаю truffle test на терминале, я получаю следующую ошибку Error: Attempting to run transaction which calls a contract function, but recipient address 0x3ad2c00512808bd7fafa6dce844a583621f3df87 is not a contract address Я не понимаю, почему я получаю это, потому что моя папка build нормальная, то есть, если я запускаю truffle migrate --reset, адрес в терминале являетсятакой же, как адрес в файле сборки.когда я бегу трюфель мигрировать, это работает.Кроме того, каждый раз, когда я запускаю трюфельный тест, адрес получателя всегда меняется.Я не знаю, что делать, чтобы помочь.

Еще одна вещь, это происходит только после того, как я использую код selfdestruct(admin);, тогда я получаю эту ошибку.администратор = msg.sender, который является первым аккаунтом в ganache, поэтому я не знаю, что не так.

Я использую это видео.Я снял все остальные видео этого парня, и все в порядке, пока в минуту 15:11 он делает последний тест, и для него это работает, но для меня это выдает ошибку выше.

ЛюбойПожалуйста, помогите

Это мой тест (javascript)

var CinoCoin = artifacts.require("./CinoCoin.sol");
var CinoCoinSale = artifacts.require("./CinoCoinSale.sol");


contract('CinoCoinSale', function(accounts) {
  var tokenInstance;
  var tokenSaleInstance;
  var admin = accounts[0];
  var buyer = accounts[1];
  var tokenPrice = 1000000000000000; // in wei 0.01 ether
  var tokensAvailable = 750000;
  var numberOfTokens;

  it('initializes the contract with the correct values', function() {
    return CinoCoinSale.deployed().then(function(instance) {
      tokenSaleInstance = instance;
      return tokenSaleInstance.address
    }).then(function(address) {
      assert.notEqual(address, 0x0, 'has contract address');
      return tokenSaleInstance.tokenContract();
    }).then(function(address) {
      assert.notEqual(address, 0x0, 'has token contract address');
      return tokenSaleInstance.tokenPrice();
    }).then(function(price) {
      assert.equal(price, tokenPrice, 'token price is correct');
    });
  });

  it('facilitats token buying', function() {
    return CinoCoin.deployed().then(function(instance) {
      //Grab token instance first
      tokenInstance = instance;
      return CinoCoinSale.deployed();
    }).then(function(instance) {
      //Then grab token sale instance
      tokenSaleInstance = instance;
      //Provision 75% of all tokens to the token sale contract
      return tokenInstance.transfer(tokenSaleInstance.address, tokensAvailable, { from: admin})
    }).then(function(receipt) {
      numberOfTokens = 10;
      return tokenSaleInstance.buyTokens(numberOfTokens, { from: buyer, value: numberOfTokens * tokenPrice })
    }).then(function(receipt) {
      assert.equal(receipt.logs.length, 1, 'triggers one event');
      assert.equal(receipt.logs[0].event, 'Sell', 'should be the "Sell" event');
      assert.equal(receipt.logs[0].args._buyer, buyer, 'logs the account that purchased the tokens');
      assert.equal(receipt.logs[0].args._amount, numberOfTokens, 'logs the number of tokens purchased');
      return tokenSaleInstance.tokensSold();
    }).then(function(amount) {
      assert.equal(amount.toNumber(), numberOfTokens, 'increments the number of tokens sold');
      return tokenInstance.balanceOf(buyer);
    }).then(function(balance) {
      assert.equal(balance.toNumber(), numberOfTokens);
      return tokenInstance.balanceOf(tokenSaleInstance.address);
    }).then(function(balance) {
      assert.equal(balance.toNumber(), tokensAvailable - numberOfTokens);
      //Try to buy tokens different from the ether value
      return tokenSaleInstance.buyTokens(numberOfTokens, { from: buyer, value: 1 });
    }).then(assert.fail).catch(function(error) {
      assert(error.message.indexOf('revert') >= 0, 'msg.value must equal number of tokens in wei');
      return tokenSaleInstance.buyTokens(800000, { from: buyer, value: numberOfTokens * tokenPrice });
    }).then(assert.fail).catch(function(error) {
      assert(error.message.indexOf('revert') >= 0, 'connot purchase more tokens than available');
    });
  });

  it('ends token sale', function () {
    return CinoCoin.deployed().then(function(instance) {
      //Grab token instance first
      tokenInstance = instance;
      return CinoCoinSale.deployed();
    }).then(function(instance) {
      //Then grab token sale instance
      tokenSaleInstance = instance;
      //try to end sale from account other than admin
      return tokenSaleInstance.endSale({ from: buyer });
    }).then(assert.fail).catch(function(error) {
      assert(error.message.indexOf('revert' >= 0, 'must be admin to end sale'));
      //End sale as admin
      return tokenSaleInstance.endSale({ from: admin });
    }).then(function(receipt) {
      return tokenInstance.balanceOf(admin);
    }).then(function(balance) {
      assert.equal(balance.toNumber(), 999990, 'returns all unsold cino coins to admin');
      //Check that the token price was reset when selfFestruct was called
      return tokenSaleInstance.tokenPrice();
    }).then(function(price) {
      assert.equal(price.toNumber(), 0, 'token price was reset');
    });
  });
});

А это мой код контракта (солидность)

pragma solidity ^0.4.23;

import "./CinoCoin.sol";

contract CinoCoinSale {
  address admin;
  CinoCoin public tokenContract;
  uint256 public tokenPrice;
  uint256 public tokensSold;

  event Sell(address _buyer, uint256 _amount);

  function CinoCoinSale(CinoCoin _tokenContract, uint256 _tokenPrice) public {
    //Assign an admin / an external account connected to the blockchain that has certain priviliges
    admin = msg.sender;
    //Assign token contract
    tokenContract = _tokenContract;
    //Token Price how much the token will cost
    tokenPrice = _tokenPrice;
  }

  //multiply function for
  function multiply(uint x, uint y) internal pure returns (uint z) {
    require(y == 0 || (z = x * y) / y == x);
  }

  //Buy tokens
  function buyTokens(uint256 _numberOfTokens) public payable {
    //Require that the value is equal to tokens
    require(msg.value == multiply(_numberOfTokens, tokenPrice));
    //Require that there are enough tokens in the contrat
    require(tokenContract.balanceOf(this) >= _numberOfTokens);
    //Require the transfer is successful
    require(tokenContract.transfer(msg.sender, _numberOfTokens));
    //Keep track of number of tokens sold
    tokensSold += _numberOfTokens;
    //Trigger a sell event
    Sell(msg.sender, _numberOfTokens);
  }

  //ending token CinoCoinSale
  function endSale()public {
    //Only an admin can end the end the sale
    require(msg.sender == admin);
    //Transfer the amount of token in the sale back to the admin
    require(tokenContract.transfer(admin, tokenContract.balanceOf(this)));
    //Destroy contract
    selfdestruct(admin);
  }
}

Там написано, что мой тест проходит, когдаЯ закомментирую selfdestruct(admin);, так что, похоже, проблема с этим

спасибо за помощь

Answer 1

рад, что вы уже исправили ошибку.Просматривая ваш код, я заметил, что за тестовым файлом довольно сложно следить из-за больших цепочек обещаний.Я преобразовал файл в async / await, который в будущем будет проще обслуживать и отлаживать.

Я также заметил, что вы пытаетесь утверждать пропущенные события и отмены, проверяя журналы вручную и отслеживая возвратисключение.Я на самом деле написал библиотеку, чтобы сделать это немного проще, поэтому я также добавил код для этого.

Библиотека может быть установлена ​​с помощью npm:

npm install truffle-assertions

После этого новый тестовый код должен работать.Я надеюсь, что это поможет, и удачи в разработке Dapp.

const CinoCoin = artifacts.require("CinoCoin");
const CinoCoinSale = artifacts.require("CinoCoinSale");
const truffleAssert = require("truffle-assertions");

contract('CinoCoinSale', function(accounts) {
  let tokenInstance;
  let tokenSaleInstance;
  let admin = accounts[0];
  let buyer = accounts[1];
  let tokenPrice = 1000000000000000; // in wei 0.01 ether
  let tokensAvailable = 750000;

  it('initializes the contract with the correct values', async function() {
    tokenInstance = await CinoCoin.deployed();
    tokenSaleInstance = await CinoCoinSale.deployed();

    assert.notEqual(tokenSaleInstance.address, 0x0, 'has contract address');
    assert.notEqual(await tokenSaleInstance.tokenContract(), 0x0, 'has token contract address');
    assert.equal(await tokenSaleInstance.tokenPrice(), tokenPrice, 'token price is correct');
    assert.equal(await tokenSaleInstance.admin(), admin, 'admin is correct');
  });

  it('facilitates token buying', async function() {
    tokenInstance = await CinoCoin.deployed();
    tokenSaleInstance = await CinoCoinSale.deployed();
    await tokenInstance.transfer(tokenSaleInstance.address, tokensAvailable, { from: admin });

    const numberOfTokens = 10;
    const receipt = await tokenSaleInstance.buyTokens(numberOfTokens, { from: buyer, value: numberOfTokens * tokenPrice });

    truffleAssert.eventEmitted(receipt, 'Sell', (ev) => {
      return ev._buyer === buyer && ev._amount.toNumber() === numberOfTokens;
    });

    const tokensSold = await tokenSaleInstance.tokensSold();
    assert.equal(tokensSold.toNumber(), numberOfTokens, 'increments the number of tokens sold');

    const buyerBalance = await tokenInstance.balanceOf(tokenSaleInstance.address);
    assert.equal(buyerBalance.toNumber(), numberOfTokens);

    const tokenSaleBalance = await tokenInstance.balanceOf(tokenSaleInstance.address);
    assert.equal(tokenSaleBalance.toNumber(), tokensAvailable - numberOfTokens);

    truffleAssert.reverts(
      tokenSaleInstance.buyTokens(numberOfTokens, { from: buyer, value: 1 }),
      null,
      'msg.value must equal number of tokens in wei'
    );

    truffleAssert.reverts(
      tokenSaleInstance.buyTokens(800000, { from: buyer, value: numberOfTokens * tokenPrice }),
      null,
      'connot purchase more tokens than available'
    );
  });

  it('ends token sale', async function () {
    tokenInstance = await CinoCoin.deployed();
    tokenSaleInstance = await CinoCoinSale.deployed();

    truffleAssert.reverts(tokenSaleInstance.endSale({ from: buyer }), null, 'must be admin to end sale');

    await tokenSaleInstance.endSale({ from: admin });

    const adminBalance = await tokenInstance.balanceOf(admin);
    assert.equal(adminBalance.toNumber(), 999990, 'returns all unsold cino coins to admin');

    const tokenPrice = await tokenSaleInstance.tokenPrice();
    assert.equal(tokenPrice.toNumber(), 0, 'token price was reset');
  });
});