Ethereumスマート契約自動取引 - それは可能ですか？

Question

私はちょうどICOのためのsmartcontractを作った、と今私は、以下の機能を実装する必要があります。

1.Userは

2.Userがにトークンのいくつかの量を取得し、財布にETHの量を送りました彼の財布が送られたETHと自動的に交換されます

私は知りたいことがありますので、これも可能ですか（または手動モードでのみ）smartcontract自体ではない場合によっては、イベントを取得したり、何らかのAPIを使用してスマート請負業者から関数を呼び出すなど、別の方法でテストを行うこともできますプレ、PHPまたはJS？ 可能であれば、これについての情報をいつ見つけることができますか？ このような質問はいくつか見つかりましたが、回答はありません。ここで

は（hereからほとんど取ら）契約コードです：

pragma solidity ^0.4.2; 
contract owned { 
    address public owner; 

    function owned() { 
    owner = msg.sender; 
    } 

    modifier onlyOwner { 
    if (msg.sender != owner) return; 
    _; 
    } 

    function transferOwnership(address newOwner) onlyOwner { 
    owner = newOwner; 
    } 
} 

contract tokenRecipient { function receiveApproval(address _from, uint256 
_value, address _token, bytes _extraData); } 

contract token { 
/* Public variables of the token */ 
string public standard = 'Token 0.1'; 
string public name; 
string public symbol; 
uint8 public decimals; 
uint256 public totalSupply; 

/* 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); 

/* Initializes contract with initial supply tokens to the creator of the 
contract */ 
function token(
    uint256 initialSupply, 
    string tokenName, 
    uint8 decimalUnits, 
    string tokenSymbol 
    ) { 
    balanceOf[msg.sender] = initialSupply;    // Give the creator 
    all initial tokens 
    totalSupply = initialSupply;      // Update total 
    supply 
    name = tokenName;         // Set the name for 
    display purposes 
    symbol = tokenSymbol;        // Set the symbol 
    for display purposes 
    decimals = decimalUnits;       // Amount of 
    decimals for display purposes 
} 

/* Send coins */ 
function transfer(address _to, uint256 _value) { 
    if (balanceOf[msg.sender] < _value) return;   // Check if the 
sender has enough 
    if (balanceOf[_to] + _value < balanceOf[_to]) return; // Check for 
overflows 
    balanceOf[msg.sender] -= _value;      // Subtract from 
the sender 
    balanceOf[_to] += _value;       // Add the same to 
the recipient 
    Transfer(msg.sender, _to, _value);     // Notify anyone 
listening that this transfer took place 
} 

/* Allow another contract to spend some tokens in your behalf */ 
function approve(address _spender, uint256 _value) 
    returns (bool success) { 
    allowance[msg.sender][_spender] = _value; 
    return true; 
} 

/* Approve and then communicate the approved contract in a single tx */ 
function approveAndCall(address _spender, uint256 _value, bytes _extraData) 
    returns (bool success) {  
    tokenRecipient spender = tokenRecipient(_spender); 
    if (approve(_spender, _value)) { 
     spender.receiveApproval(msg.sender, _value, this, _extraData); 
     return true; 
    } 
} 

/* A contract attempts to get the coins */ 
function transferFrom(address _from, address _to, uint256 _value) returns 
(bool success) { 
    if (balanceOf[_from] < _value) return;     // Check if the 
sender has enough 
    if (balanceOf[_to] + _value < balanceOf[_to]) return; // Check for 
overflows 
    if (_value > allowance[_from][msg.sender]) return; // Check allowance 
    balanceOf[_from] -= _value;       // Subtract from 
the sender 
    balanceOf[_to] += _value;       // Add the same to 
the recipient 
    allowance[_from][msg.sender] -= _value; 
    Transfer(_from, _to, _value); 
    return true; 
} 

/* This unnamed function is called whenever someone tries to send ether to 
it */ 
function() { 
    return;  // Prevents accidental sending of ether 
} 
} 

contract MyAdvancedToken is owned, token { 

uint256 public sellPrice; 
uint256 public buyPrice; 

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(
    uint256 initialSupply, 
    string tokenName, 
    uint8 decimalUnits, 
    string tokenSymbol 
) token (initialSupply, tokenName, decimalUnits, tokenSymbol) {} 

/* Send coins */ 
function transfer(address _to, uint256 _value) { 
    if (balanceOf[msg.sender] < _value) return;   // Check if the 
sender has enough 
    if (balanceOf[_to] + _value < balanceOf[_to]) return; // Check for 
overflows 
    if (frozenAccount[msg.sender]) return;    // Check if frozen 
    balanceOf[msg.sender] -= _value;      // Subtract from 
the sender 
    balanceOf[_to] += _value;       // Add the same to 
the recipient 
    Transfer(msg.sender, _to, _value);     // Notify anyone 
listening that this transfer took place 
} 


/* A contract attempts to get the coins */ 
function transferFrom(address _from, address _to, uint256 _value) returns 
(bool success) { 
    if (frozenAccount[_from]) return;      // Check if 
frozen    
    if (balanceOf[_from] < _value) return;     // Check if the 
sender has enough 
    if (balanceOf[_to] + _value < balanceOf[_to]) return; // Check for 
overflows 
    if (_value > allowance[_from][msg.sender]) return; // Check allowance 
    balanceOf[_from] -= _value;       // Subtract from 
the sender 
    balanceOf[_to] += _value;       // Add the same to 
the recipient 
    allowance[_from][msg.sender] -= _value; 
    Transfer(_from, _to, _value); 
    return true; 
} 

function mintToken(address target, uint256 mintedAmount) onlyOwner { 
    balanceOf[target] += mintedAmount; 
    totalSupply += mintedAmount; 
    Transfer(0, this, mintedAmount); 
    Transfer(this, target, mintedAmount); 
} 

function freezeAccount(address target, bool freeze) onlyOwner { 
    frozenAccount[target] = freeze; 
    FrozenFunds(target, freeze); 
} 

function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner { 
    sellPrice = newSellPrice; 
    buyPrice = newBuyPrice; 
} 

function buy() payable { 
    uint amount = msg.value/buyPrice;    // calculates the 
amount 
    if (balanceOf[this] < amount) return;    // checks if it has 
enough to sell 
    balanceOf[msg.sender] += amount;     // adds the amount to 
buyer's balance 
    balanceOf[this] -= amount;       // subtracts amount 
from seller's balance 
    Transfer(this, msg.sender, amount);    // execute an event 
reflecting the change 
} 

function sell(uint256 amount) { 
    if (balanceOf[msg.sender] < amount) return;  // checks if the 
sender has enough to sell 
    balanceOf[this] += amount;       // adds the amount to 
owner's balance 
    balanceOf[msg.sender] -= amount;     // subtracts the 
amount from seller's balance 
    if (!msg.sender.send(amount * sellPrice)) {  // sends ether to the 
seller. It's important 
     return;           // to do this last 
to avoid recursion attacks 
    } else { 
     Transfer(msg.sender, this, amount);   // executes an event 
reflecting on the change 
    }    
} 
} 

は私の可能愚かさとの悪い英語:)のために

感謝をすみません。

Answer 1

実際、私はautomaticallyの意味を理解できませんでした。しかし、buyメソッドを呼び出すことなく、ETHをあなたの契約に送るすべての人にトークンを送信したいと思う。少なくとも、それは私がJincor Pre ICOのためにしたと、あなたの契約MyAdvancedTokenに追加することによって、あなたはそれを達成することができますGithub 上のコードを確認することができるものである：私はしなかった場合 `` `

function() payable { 
     buy(); 
    } 

` `` 申し訳ありませんあなたのメッセージをよくしてください。

Answer 2

エーテルは、アドレス関数と呼ば

function() payable {..} 

を契約しています。

あなたは契約で、この関数を定義し、globally available variables使用することができます。 msg.value - エーテルの量（魏の数） msg.sender - エーテルに