is it possible to pass an integer (in this case 141) represented by the variable z from a certain restfullAPI into the custom token function: balances[msg.sender]? So in the end I want to have my own Token with 14.1 UGAu (the value from the variable z).
For this purpose I use oraclize, https://remix.ethereum.org and metamask.

/* Public variables of the token */
/*
NOTE:
The following variables are OPTIONAL vanities. One does not have to include them.
They allow one to customise the token contract & in no way influences the core functionality.
Some wallets/interfaces might not even bother to look at this information.
*/
uint256 public z;
event newOraclizeQuery(string description);
string public name; // Token Name
uint8 public decimals; // How many decimals to show. To be standard complicant keep it 18
string public symbol; // An identifier: eg SBX, XPR etc..
string public version = 'H1.0';
uint256 public unitsOneEthCanBuy; // How many units of your coin can be bought by 1 ETH?
uint256 public totalEthInWei; // WEI is the smallest unit of ETH (the equivalent of cent in USD or satoshi in BTC). We'll store the total ETH raised via our ICO here.
address public fundsWallet; // Where should the raised ETH go?
// This is a constructor function
// which means the following function name has to match the contract name declared above
function UrbangoldToken() {
balances[msg.sender] = z; // Give the creator all initial tokens. This is set to 1000 for example. If you want your initial tokens to be X and your decimal is 5, set this value to X * 100000. (CHANGE THIS)
totalSupply = 1000; // Update total supply (1000 for example) (CHANGE THIS)
name = "UrbangoldToken"; // Set the name for display purposes (CHANGE THIS)
decimals = 1; // Amount of decimals for display purposes (CHANGE THIS)
symbol = "UGAu"; // Set the symbol for display purposes (CHANGE THIS)
unitsOneEthCanBuy = 10; // Set the price of your token for the ICO (CHANGE THIS)
fundsWallet = msg.sender;
update();
}
function __callback(bytes32 myid, string result) {
if (msg.sender != oraclize_cbAddress()) throw;
z = parseInt(result);
}
function update() payable {
newOraclizeQuery("Oraclize query was sent, standing by for the answer..");
oraclize_query("URL", "json(https://urbangold.localtunnel.me).z");
}
function() payable{
totalEthInWei = totalEthInWei + msg.value;
uint256 amount = msg.value * unitsOneEthCanBuy;
require(balances[fundsWallet] >= amount);
balances[fundsWallet] = balances[fundsWallet] - amount;
balances[msg.sender] = balances[msg.sender] + amount;
Transfer(fundsWallet, msg.sender, amount); // Broadcast a message to the blockchain
//Transfer ether to fundsWallet
fundsWallet.transfer(msg.value);
}
/* Approves and then calls the receiving contract */
function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
//call the receiveApproval function on the contract you want to be notified. This crafts the function signature manually so one doesn't have to include a contract in here just for this.
//receiveApproval(address _from, uint256 _value, address _tokenContract, bytes _extraData)
//it is assumed that when does this that the call *should* succeed, otherwise one would use vanilla approve instead.
if(!_spender.call(bytes4(bytes32(sha3("receiveApproval(address,uint256,address,bytes)"))), msg.sender, _value, this, _extraData)) { throw; }
return true;
}

1 Answer
1

Note, that you should probably use the constructor designator for constructors now over the contract name which has caused a number of exploits in the past.

If you set the value of something in the constructor, it's a one-shot deal that happens at deployment. Upon deployment the value of z is 0 (uninitialized), and therefore balances[msg.sender] will end up equalling 0. It doesn't pass a reference as you may have expected it.

What you will need to do instead, is create a mintTokens function that can only be fired once, in the constructor set an owner or whatever is the appropriate name variable for the msg.sender. Then, in the __callback function, once you have a result for z and it's parsed, you'll fire the mintTokens function for it. In this case, you also don't really need it to be a storage variable.

I would highly recommend then doing more tutorials and understanding how solidity contracts work better before continuing, as creating such a function is generally considered quite basic. Reading the documentation will help as well, of Solidity, and it's a better idea to get a grasp of contracts working in a more synchronistic fashion before moving on to ones that utilize Oraclize, which are required to operate more asynchronously.
– DenisMJan 6 at 21:51