Este es mi contrato y la lógica dentro de la función de respaldo no es tan complicada, pero ¿por qué indica que mi función de respaldo requiere demasiada gasolina? ¿Cómo soluciono este problema?
pragma solidity ^0.4.16;
contract owned {
address public owner;
function owned() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
owner = newOwner;
}
}
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract MyCoin {
// Public variables of the token
string public name = "MyCoin";
string public symbol = "XYZ";
uint8 public decimals = 18;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
uint256 initialSupply = 50000000;
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
/**
* Constrctor function
*
* Initializes contract with initial supply tokens to the creator of the contract
*/
function MyCoin() public {
totalSupply = initialSupply * 10 ** uint256(decimals); // Update total supply with the decimal amount
balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens
//name = tokenName; // Set the name for display purposes
//symbol = tokenSymbol; // Set the symbol for display purposes
}
/**
* Internal transfer, only can be called by this contract
*/
function _transfer(address _from, address _to, uint _value) internal {
// Prevent transfer to 0x0 address. Use burn() instead
require(_to != 0x0);
// Check if the sender has enough
require(balanceOf[_from] >= _value);
// Check for overflows
require(balanceOf[_to] + _value > balanceOf[_to]);
// Save this for an assertion in the future
uint previousBalances = balanceOf[_from] + balanceOf[_to];
// Subtract from the sender
balanceOf[_from] -= _value;
// Add the same to the recipient
balanceOf[_to] += _value;
Transfer(_from, _to, _value);
// Asserts are used to use static analysis to find bugs in your code. They should never fail
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
/**
* Transfer tokens
*
* Send `_value` tokens to `_to` from your account
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transfer(address _to, uint256 _value) public {
_transfer(msg.sender, _to, _value);
}
/**
* Transfer tokens from other address
*
* Send `_value` tokens to `_to` in behalf of `_from`
*
* @param _from The address of the sender
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]); // Check allowance
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
/**
* Set allowance for other address
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
*/
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
/**
* Set allowance for other address and notify
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf, and then ping the contract about it
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
* @param _extraData some extra information to send to the approved contract
*/
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
/**
* Destroy tokens
*
* Remove `_value` tokens from the system irreversibly
*
* @param _value the amount of money to burn
*/
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value); // Check if the sender has enough
balanceOf[msg.sender] -= _value; // Subtract from the sender
totalSupply -= _value; // Updates totalSupply
Burn(msg.sender, _value);
return true;
}
/**
* Destroy tokens from other account
*
* Remove `_value` tokens from the system irreversibly on behalf of `_from`.
*
* @param _from the address of the sender
* @param _value the amount of money to burn
*/
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value); // Check if the targeted balance is enough
require(_value <= allowance[_from][msg.sender]); // Check allowance
balanceOf[_from] -= _value; // Subtract from the targeted balance
allowance[_from][msg.sender] -= _value; // Subtract from the sender's allowance
totalSupply -= _value; // Update totalSupply
Burn(_from, _value);
return true;
}
}
/******************************************/
/* ADVANCED TOKEN STARTS HERE */
/******************************************/
contract MyAdvancedToken is owned, MyCoin {
uint256 public sellPrice = 500;
uint256 public buyPrice = 500;
uint256 private endTime = 123456; //@TODO
mapping (address => bool) public frozenAccount;
/* This generates a public event on the blockchain that will notify clients */
event FrozenFunds(address target, bool frozen);
/* Initializes contract with initial supply tokens to the creator of the contract */
function MyAdvancedToken() MyCoin() public {}
/* Internal transfer, only can be called by this contract */
function _transfer(address _from, address _to, uint _value) internal {
require (_to != 0x0); // Prevent transfer to 0x0 address. Use burn() instead
require (balanceOf[_from] > _value); // Check if the sender has enough
require (balanceOf[_to] + _value > balanceOf[_to]); // Check for overflows
require(!frozenAccount[_from]); // Check if sender is frozen
require(!frozenAccount[_to]); // Check if recipient is frozen
balanceOf[_from] -= _value; // Subtract from the sender
balanceOf[_to] += _value; // Add the same to the recipient
Transfer(_from, _to, _value);
}
/// @notice Create `mintedAmount` tokens and send it to `target`
/// @param target Address to receive the tokens
/// @param mintedAmount the amount of tokens it will receive
function mintToken(address target, uint256 mintedAmount) onlyOwner public {
balanceOf[target] += mintedAmount;
totalSupply += mintedAmount;
Transfer(0, this, mintedAmount);
Transfer(this, target, mintedAmount);
}
/// @notice `freeze? Prevent | Allow` `target` from sending & receiving tokens
/// @param target Address to be frozen
/// @param freeze either to freeze it or not
function freezeAccount(address target, bool freeze) onlyOwner public {
frozenAccount[target] = freeze;
FrozenFunds(target, freeze);
}
/// @notice Allow users to buy tokens for `newBuyPrice` eth and sell tokens for `newSellPrice` eth
/// @param newSellPrice Price the users can sell to the contract
/// @param newBuyPrice Price users can buy from the contract
function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner public {
sellPrice = newSellPrice;
buyPrice = newBuyPrice;
}
/// @notice Buy tokens from contract by sending ether
function () payable public {
//this is minimum what you can buy
require(msg.value >= 1 / buyPrice);
//ICO has to be active
require(now < endTime);
//get amount of tokens to send to the seller
uint amount = calculateAmount(msg.value);
uint bonus = getBonus(amount);
//Xmas or NewYear give them 50% more tokens
//uint bonus = ;
_transfer(this, msg.sender, amount + bonus);
}
/**
* Get bonus for Xmas and New Year
*/
function getBonus(uint _amount) constant private returns (uint256) {
if(now >= 5000 && now <= 5001 || now >= 6000 && now <= 6001) { //@TODO pripremi vrijeme, dodaj jos koji random dan za popuste
return _amount * 50 / 100;
}
return 0;
}
/**
* Calculate how mush XYZ you need to send
*/
function calculateAmount(uint _amount) constant private returns (uint256) {
//phase 1 (10 days)
if(now >= 1000 && now <= 20000) { //@TODO
// calculates the amount
return _amount * buyPrice + (buyPrice * 50 / 100);
}
//phase 2 (15 days)
else if (now >= 1000 && now <= 20000) { //@TODO
return _amount * buyPrice;
}
//phase 3 (20 days)
else {
return _amount * buyPrice - (buyPrice * 50 / 100);
}
}
/// @notice Sell `amount` tokens to contract
/// @param amount amount of tokens to be sold
function sell(uint256 amount) public {
require(this.balance >= amount * sellPrice); // checks if the contract has enough ether to buy
_transfer(msg.sender, this, amount); // makes the transfers
msg.sender.transfer(amount * sellPrice); // sends ether to the seller. It's important to do this last to avoid recursion attacks
}
}
Su función alternativa realiza la transferencia de tokens, y la transferencia de tokens modifica los saldos de titulares de tokens en el almacenamiento del contrato. Cualquier modificación de almacenamiento cuesta más de 2300 gas, y se supone que la función de respaldo, cuando se llama sin datos, encaja en 2300 gas. Si la función de respaldo no se ajusta al gas 2300 cuando se llama sin datos, entonces no se puede enviar éter a su contrato desde otros contratos a través de send
o transfer
funciones. Sin embargo, aún se puede enviar ether a su contrato desde cuentas de Ethereum simples (sin contrato), y aún se puede enviar ether a su contrato desde otros contratos a través de call
o selfdestruct
funciones. Muchos contratos de crowdsale tienen funciones alternativas que no encajan en 2300 gas.
PD La mayoría de las billeteras multisig utilizan call
la función para enviar ether, por lo que será posible enviar ether desde billeteras multisig a su contrato, incluso si la función de respaldo en su contrato no se ajusta a 2300 gas.
Según el documento oficial ( here ) , la función de respaldo puede tener acceso a solo 2300 gas si se llama con send()
. En ese caso, no hay forma de especificar una cantidad de gas para reenviar a su función de respaldo (solo es suficiente para enviar éter y luego realizar una operación de registro básica).
Sin embargo, puede llamar a la misma función alternativa con call()
y luego especificar una cantidad de gas para reenviar. ( aquí un buen enlace hablando de eso)
Su endTime
token de avance está configurado en uint256 private endTime = 123456; //@TODO
. Cuando fallback
se llama a su función, se verifica require(now < endTime);
que, dado que es falsa, no funcionará.
Debería intentar establecer un valor real y probarlo de nuevo. Sé que en Mist si tu contrato falla, te avisa y el precio de la gasolina será muy alto.
EDITAR
De acuerdo, el problema es que cuando estás creando tu moneda, le das al propietario todo el suministro inicial y luego, cuando recibes ether, intentas enviar tokens del contrato, pero el contrato no posee ningún token. Puedes cambiarlo para dar los tokens iniciales al contrato.
function MyCoin() public {
totalSupply = initialSupply * 10 ** uint256(decimals); // Update total supply with the decimal amount
balanceOf[this] = totalSupply; // Give the creator all initial tokens
//name = tokenName; // Set the name for display purposes
//symbol = tokenSymbol; // Set the symbol for display purposes
}
getBonus
función
FosAvance