Dies ist mein Vertrag und die Logik innerhalb der Fallback-Funktion ist nicht so kompliziert, aber warum sagt es, dass meine Fallback-Funktion zu viel Gas benötigt? Wie behebe ich dieses Problem?
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
}
}
Ihre Fallback-Funktion führt eine Token-Übertragung durch, und die Token-Übertragung ändert die Salden der Token-Inhaber im Speicher des Vertrags. Jede Speicheränderung kostet mehr als 2300 Gas, und die Fallback-Funktion, wenn sie ohne Daten aufgerufen wird, soll in 2300 Gas passen. Wenn die Fallback-Funktion beim Aufruf ohne Daten nicht in 2300 Gas passt, können Ether von anderen Verträgen nicht über send
oder - transfer
Funktionen an Ihren Vertrag gesendet werden. Ether kann jedoch weiterhin von einfachen (nicht vertragsgebundenen) Ethereum-Konten an Ihren Vertrag gesendet werden, und Ether kann weiterhin von anderen Verträgen über call
oder selfdestruct
Funktionen an Ihren Vertrag gesendet werden. Viele Crowdsale-Verträge haben Fallback-Funktionen, die nicht in 2300 Gas passen.
PS Die meisten Multisig-Wallets verwenden die call
Funktion zum Senden von Ether, sodass es möglich ist, Ether von Multisig-Wallets an Ihren Vertrag zu senden, auch wenn die Fallback-Funktion in Ihrem Vertrag nicht in 2300 Gas passt.
Gemäß dem offiziellen Dokument ( hier ) kann die Fallback-Funktion nur auf 2300 Gas zugreifen, wenn sie mit aufgerufen wird send()
. In diesem Fall gibt es keine Möglichkeit, eine Gasmenge anzugeben, die an Ihre Fallback-Funktion weitergeleitet werden soll (es reicht nur aus, Ether zu senden und dann eine grundlegende Protokolloperation durchzuführen).
Sie können jedoch mit dieselbe Fallback-Funktion aufrufen call()
und dann eine weiterzuleitende Gasmenge angeben. ( hier ein netter Link, der darüber spricht)
Ihr endTime
Token in your advance ist auf gesetzt uint256 private endTime = 123456; //@TODO
. Wenn Ihre fallback
Funktion aufgerufen wird, überprüft require(now < endTime);
sie, dass sie nicht funktioniert, da sie falsch ist.
Sie sollten versuchen, einen tatsächlichen Wert einzustellen und erneut zu testen. Ich weiß, dass in Mist, wenn Ihr Vertrag scheitert, Sie gewarnt werden und der Benzinpreis sehr hoch sein wird.
BEARBEITEN
Okay, das Problem ist, dass Sie beim Erstellen Ihrer Münze dem Besitzer die gesamte Erstausstattung geben und dann beim Empfangen von Ether versuchen, Token aus dem Vertrag zu senden, aber der Vertrag besitzt keinen Token. Sie können es ändern, um dem Vertrag die anfänglichen Token zu geben
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
Funktion
FosAvance