I have a contract and I'm super confused how to interact with it. The submitting part works fine and I get a contract id. After that, I don't really understand if I'm supposed to send it a transaction or do something else? What's the lifecycle? It says the constructor is executed when the contract runs. When is that? When it's mined? Everytime a person sends it a message. How do I send it a message? Does the consumer of a contract send gas? The creator? Both? If two people send messages are there two contracts or one?

Using this as a base: https://gist.github.com/tomconte/4edb83cf505f1e7faf172b9252fff9bf#file-web3-solc-contract-compile-deploy-js-L20

Have this function:

function testContract(address) {
    // Reference to the deployed contract
    const greeter = contract.at(address);
    //var msg = greeter.greet.estimateGas();
    //const destAccount = '0x002D61B362ead60A632c0e6B43fCff4A7a259285';

I've tried greeter.greet, greeter.almosteverything.

The object for greeter looks like this:

       [ { constant: false,
           inputs: [],
           name: 'kill',
           outputs: [],
           payable: false,
           type: 'function' },
         { constant: true,
           inputs: [],
           name: 'greet',
           outputs: [Object],
           payable: false,
           type: 'function' },
         { inputs: [Object], payable: false, type: 'constructor' } ],
       { [Function: bound ]
         request: [Function: bound ],
         call: [Function: bound ],
         sendTransaction: [Function: bound ],
         estimateGas: [Function: bound ],
         getData: [Function: bound ],
         '': [Circular] },
       { [Function: bound ]
         request: [Function: bound ],
         call: [Function: bound ],
         sendTransaction: [Function: bound ],
         estimateGas: [Function: bound ],
         getData: [Function: bound ],
         '': [Circular] },
      allEvents: [Function: bound ] }

Sol code:

pragma solidity ^0.4.10;

contract mortal {
    /* Define variable owner of the type address*/
    address owner;

    /* this function is executed at initialization and sets the owner of the contract */
    function mortal() { owner = msg.sender; }

    /* Function to recover the funds on the contract */
    function kill() { if (msg.sender == owner) selfdestruct(owner); }

contract greeter is mortal {
    /* define variable greeting of the type string */
    string greeting;

    /* this runs when the contract is executed */
    function greeter(string _greeting) public {
        greeting = _greeting;

    /* main function */
    function greet() constant returns (string) {
        return greeting;
  • How do you deploy and plan to interact with the contract? Geth? Parity? Solidity+metamask? Private testnet or public? If public: would you share the address that you got upon successful deploy? – SCBuergel.eth May 26 '17 at 8:38
  • I'm using a geth server with the web3 node.js library. The code I have above calls the contract. I can't see any output for it – Justin Thomas May 27 '17 at 4:58

Generally there will be one node which initiates the contract. and when it is mined, the contract would be added to the blockchain which returns a contract address.

The peer nodes which are interested in the contract, must know two things that needs to be shared.

  1. the contract address
  2. the contract abi

with the help of this two the other peer nodes could interact with the contract.

| improve this answer | |
  • Do you need gas to interact with the contract? What should happen when I call greet? – Justin Thomas May 27 '17 at 5:04
  • @JustinThomas, For deploying a contract we required some gas. But to just call a contract data, we don't require any gas. Once the contract is deployed and if you are able to connect to it. you can directly call the greet method which will return the greeting message. – praveen kumar May 27 '17 at 6:45
  • But what if the contract updates a mapping or stores data? Like in the example of creating a new token and transferring to another user. – Justin Thomas May 30 '17 at 3:06
  • @JustinThomas, Then we will surely need to have some ether to make such type of transactions. – praveen kumar May 30 '17 at 4:38
  • The person calling the contract? Or the contract creator? – Justin Thomas May 31 '17 at 6:08

From this video: https://www.youtube.com/watch?v=8jI1TuEaTro

I discovered Truffle (https://github.com/trufflesuite/truffle)

Couple of things on life cycle:

  1. The contract creator pays gas to get the contract into the block chain.
  2. If the method or access is constant, the client and do the operation. Constant operations do not modify the block chain, so they are free.
  3. If the method is not constant, then it costs gas to run it.

Some code using web3 on node console:

# Beware the promise
> var helloWorld; HelloWorld.deployed().then((a) => helloWorld = a);
# Free
> hello.balance.call()
# Not free
> hello.getBalanceBaller.sendTransaction()
> hello.balance.call()
{ [String: '412'] s: 1, e: 2, c: [ 412 ] }
# Account value
> web3.eth.getBalance(account)
{ [String: '4.824337705048486307205e+21'] s: 1, e: 21, c: [ 48243377, 5048486307205 ] }
# Block was mined
> hello.getBalance.call()
{ [String: '824'] s: 1, e: 2, c: [ 824 ] }
# Balance of account is deducted
> web3.eth.getBalance(account)
{ [String: '4.829335031748486307205e+21'] s: 1, e: 21, c: [ 48293350, 31748486307205 ] }
| improve this answer | |

I was struggling with similar questions. I have just put this tutorial online, in order to explain to get started with contract creation, and interaction from a web page : https://steemit.com/ethereum/@yalb/hello-world-ethereum-create-an-ethereum-smart-contract-and-interact-with-it-from-a-website

| improve this answer | |

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.