Calling Ethereum contract

Writing Contracts Building Clients Github
Search…
It is possible to perform a cross-chain call and access a contract that is deployed on Ethereum from within an Orbs contract.
The API for this is included in the ethereum library:
1
import (
2
	"github.com/orbs-network/orbs-contract-sdk/go/sdk/v1/ethereum"
3
)
Copied!
The library exposes several different functions described on this page.
GetBlockNumber
This function is used to get the latest 'safe' block number in Ethereum. The 'safe' block means a block which is in the past, around 25 minutes, to avoid forks.
1
GetBlockNumber()
Copied!
GetBlockNumberByTime
This function is used to get the block number which was mined just after the timestamp, as long as it is also 'safe'. Safe is defined internally by the SDK as a block which is in the past, around 25 minutes, to avoid forks.
1
GetBlockNumberByTime(
2
        ethBlockTimestamp uint64)
Copied!
The argument GetBlockNumberByTime takes is:
ethBlockTimestamp - The  Ethereum timestamp in Unix epoch nanoseconds to search for corresponding block.
GetBlockTime
This function is used to get the block timestamp (Unix epoch in nanoseconds) of the latest 'safe' block number in Ethereum. The 'safe' block means a block which is in the past, around 25 minutes, to avoid forks.
1
GetBlockTime()
Copied!
GetBlockTimeByNumber
This function is used to get the block timestamp (Unix epoch in nanoseconds) of the requested block number, as long as it is also 'safe'. Safe is defined internally by the SDK as a block which is in the past, around 25 minutes, to avoid forks.
1
GetBlockTimeByNumber(
2
        ethBlockNumber uint64)
Copied!
The argument GetBlockTimeByNumber takes is:
ethBlockNumber - The Ethereum block number to get the block's timestamp.
CallMethod
This function is used to perform a method call on ethereum, the action performed in this function is call in ethereum - we do not perform transactions from within our blockchain, mainly due to response time and finality considerations.
1
CallMethod(
2
        ethContractAddress string, 
3
        jsonAbi string, 
4
        methodName string, 
5
        out interface{}, 
6
        args ...interface{})
Copied!
The arguments CallMethod takes are:
contractAddress - The Ethereum contract address with a 0x prefix
 jsonAbi - The ABI of the call, as a JSON string
methodName - The method to call in the contract
out - The result of the contract call - this needs to be a pointer to the expected return value/struct, the struct members need to be defined as PascalCase style, see examples below
args - The variadic parameter list for the method you are calling on Ethereum
For example, using the following contract on Ethereum:
1
pragma solidity ^0.4.0;
2
contract SimpleStorage {
3
    struct Item {
4
        uint256 intValue;
5
        string stringValue;
6
    }
7
    Item item;
8
​
9
    constructor(uint256 _intValue, string _stringValue) public {
10
        set(_intValue, _stringValue);
11
    }
12
​
13
    function set(uint256 _intValue, string _stringValue) private {
14
        item.intValue = _intValue;
15
        item.stringValue = _stringValue;
16
    }
17
​
18
    function getInt() view public returns (uint256) {
19
        return item.intValue;
20
    }
21
​
22
    function getIntMultiple(uint256 _multiple) view public returns (uint256) {
23
        return _multiple * item.intValue;
24
    }
25
​
26
    function getString() view public returns (string) {
27
        return item.stringValue;
28
    }
29
​
30
    function getValues() public view returns (uint256 intValue, string stringValue) {
31
        intValue = item.intValue;
32
        stringValue = item.stringValue;
33
    }
34
}
Copied!
If we want to call getValues we use the following code in our Orbs contract:
1
package main
2
​
3
import (
4
	"github.com/orbs-network/orbs-contract-sdk/go/sdk/v1"
5
	"github.com/orbs-network/orbs-contract-sdk/go/sdk/v1/ethereum"
6
)
7
​
8
var PUBLIC = sdk.Export(readString, readStringFromValues)
9
var SYSTEM = sdk.Export(_init)
10
​
11
func _init() {
12
}
13
​
14
func readStringFromValues(address, abi string) string {
15
	// getValues return a uint256 and a string, note the PascalCase
16
	out := new(struct { // creates a pointer to a struct of the expected return value
17
		IntValue    *big.Int
18
		StringValue string
19
	})
20
		
21
	ethereum.CallMethod(address, abi, "getValues", out)
22
	return ret.StringValue
23
}
24
​
25
func readString(address, abi string) string {
26
	var out string
27
	ethereum.CallMethod(address, abi, "getString", &out)
28
	return out
29
}
Copied!
CallMethodAtBlock
This function is the same as the CallMethod function, and it only allows to define which block you want to use.
1
CallMethodAtBlock(
2
        ethBlockNumber uint64,
3
        ethContractAddress string, 
4
        jsonAbi string, 
5
        methodName string, 
6
        out interface{}, 
7
        args ...interface{})
Copied!
GetTransactionLog 
This function can enable you to access the Transaction Receipt of a specific transaction on Ethereum to access and filter its logs according to a specific event name.
1
GetTransactionLog(
2
                ethContractAddress string, 
3
                jsonAbi string, 
4
                ethTxHash string, 
5
                eventName string, 
6
                out interface{}) (ethBlockNumber uint64, ethTxIndex uint32)
Copied!
The arguments GetTransactionLog takes are:
ethContractAddress - The Ethereum contract address with a 0x prefix
jsonAbi - The ABI of the contract with the event, as a JSON string
ethTxHash - The Ethereum transaction address with a 0x prefix
eventName - The event to filter by
out - The event data, this needs to be a pointer to the expected return value/struct, the struct members need to be defined as PascalCase style. See an example below.
The function returns:
ethBlockNumber - The block number of the log requested
ethTxIndex - The transaction index in the block
An example of using the GetTransactionLog() for the following event ABI:
1
{
2
      "constant": false,
3
      "inputs": [
4
        {
5
          "name": "tuid",
6
          "type": "uint256"
7
        },
8
        {
9
          "name": "ethAddress",
10
          "type": "address"
11
        },
12
        {
13
          "name": "orbsAddress",
14
          "type": "bytes20"
15
        },
16
        {
17
          "name": "value",
18
          "type": "uint256"
19
        }
20
      ],
21
      "name": "transferOut",
22
      "outputs": [],
23
      "payable": false,
24
      "stateMutability": "nonpayable",
25
      "type": "function"
26
    }
Copied!
The Orbs contract code should look like:
1
package main
2
​
3
import (
4
	"github.com/orbs-network/orbs-contract-sdk/go/sdk/v1"
5
	"github.com/orbs-network/orbs-contract-sdk/go/sdk/v1/ethereum"
6
)
7
​
8
var PUBLIC = sdk.Export(filterLogs)
9
var SYSTEM = sdk.Export(_init)
10
​
11
func _init() {
12
}
13
​
14
type EmitEvent struct {
15
	Tuid        *big.Int
16
	EthAddress  [20]byte
17
	OrbsAddress [20]byte
18
	Value       *big.Int
19
}
20
​
21
func filterLogs(address, abi, txHash string) {
22
	event := new(EmitEvent)
23
	ethereum.GetTransactionLog(address, abi, txHash, "transferOut", event)
24
	// do something with the event data
25
}
Copied!
Orbs Contracts - Previous
Calling other contracts
Next - Orbs Contracts
API Reference
Last modified 2yr ago
Copy link
Contents