aboutsummaryrefslogtreecommitdiffstats
path: root/eth/bind.go
blob: 6f7aee4f75f9a6ccc732b7806602a2cab8e4dae8 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
// Copyright 2015 The go-ethereum Authors
// This file is part of the go-ethereum library.
//
// The go-ethereum library is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// The go-ethereum library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.

package eth

import (
    "math/big"

    "github.com/ethereum/go-ethereum"
    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/common/hexutil"
    "github.com/ethereum/go-ethereum/core/types"
    "github.com/ethereum/go-ethereum/internal/ethapi"
    "github.com/ethereum/go-ethereum/rlp"
    "github.com/ethereum/go-ethereum/rpc"
    "golang.org/x/net/context"
)

// ContractBackend implements bind.ContractBackend with direct calls to Ethereum
// internals to support operating on contracts within subprotocols like eth and
// swarm.
//
// Internally this backend uses the already exposed API endpoints of the Ethereum
// object. These should be rewritten to internal Go method calls when the Go API
// is refactored to support a clean library use.
type ContractBackend struct {
    eapi  *ethapi.PublicEthereumAPI        // Wrapper around the Ethereum object to access metadata
    bcapi *ethapi.PublicBlockChainAPI      // Wrapper around the blockchain to access chain data
    txapi *ethapi.PublicTransactionPoolAPI // Wrapper around the transaction pool to access transaction data
}

// NewContractBackend creates a new native contract backend using an existing
// Etheruem object.
func NewContractBackend(apiBackend ethapi.Backend) *ContractBackend {
    return &ContractBackend{
        eapi:  ethapi.NewPublicEthereumAPI(apiBackend),
        bcapi: ethapi.NewPublicBlockChainAPI(apiBackend),
        txapi: ethapi.NewPublicTransactionPoolAPI(apiBackend),
    }
}

// CodeAt retrieves any code associated with the contract from the local API.
func (b *ContractBackend) CodeAt(ctx context.Context, contract common.Address, blockNum *big.Int) ([]byte, error) {
    out, err := b.bcapi.GetCode(ctx, contract, toBlockNumber(blockNum))
    return common.FromHex(out), err
}

// CodeAt retrieves any code associated with the contract from the local API.
func (b *ContractBackend) PendingCodeAt(ctx context.Context, contract common.Address) ([]byte, error) {
    out, err := b.bcapi.GetCode(ctx, contract, rpc.PendingBlockNumber)
    return common.FromHex(out), err
}

// ContractCall implements bind.ContractCaller executing an Ethereum contract
// call with the specified data as the input. The pending flag requests execution
// against the pending block, not the stable head of the chain.
func (b *ContractBackend) CallContract(ctx context.Context, msg ethereum.CallMsg, blockNum *big.Int) ([]byte, error) {
    out, err := b.bcapi.Call(ctx, toCallArgs(msg), toBlockNumber(blockNum))
    return common.FromHex(out), err
}

// ContractCall implements bind.ContractCaller executing an Ethereum contract
// call with the specified data as the input. The pending flag requests execution
// against the pending block, not the stable head of the chain.
func (b *ContractBackend) PendingCallContract(ctx context.Context, msg ethereum.CallMsg) ([]byte, error) {
    out, err := b.bcapi.Call(ctx, toCallArgs(msg), rpc.PendingBlockNumber)
    return common.FromHex(out), err
}

func toCallArgs(msg ethereum.CallMsg) ethapi.CallArgs {
    args := ethapi.CallArgs{
        To:   msg.To,
        From: msg.From,
        Data: common.ToHex(msg.Data),
    }
    if msg.Gas != nil {
        args.Gas = hexutil.Big(*msg.Gas)
    }
    if msg.GasPrice != nil {
        args.GasPrice = hexutil.Big(*msg.GasPrice)
    }
    if msg.Value != nil {
        args.Value = hexutil.Big(*msg.Value)
    }
    return args
}

func toBlockNumber(num *big.Int) rpc.BlockNumber {
    if num == nil {
        return rpc.LatestBlockNumber
    }
    return rpc.BlockNumber(num.Int64())
}

// PendingAccountNonce implements bind.ContractTransactor retrieving the current
// pending nonce associated with an account.
func (b *ContractBackend) PendingNonceAt(ctx context.Context, account common.Address) (nonce uint64, err error) {
    out, err := b.txapi.GetTransactionCount(ctx, account, rpc.PendingBlockNumber)
    if out != nil {
        nonce = uint64(*out)
    }
    return nonce, err
}

// SuggestGasPrice implements bind.ContractTransactor retrieving the currently
// suggested gas price to allow a timely execution of a transaction.
func (b *ContractBackend) SuggestGasPrice(ctx context.Context) (*big.Int, error) {
    return b.eapi.GasPrice(ctx)
}

// EstimateGasLimit implements bind.ContractTransactor triing to estimate the gas
// needed to execute a specific transaction based on the current pending state of
// the backend blockchain. There is no guarantee that this is the true gas limit
// requirement as other transactions may be added or removed by miners, but it
// should provide a basis for setting a reasonable default.
func (b *ContractBackend) EstimateGas(ctx context.Context, msg ethereum.CallMsg) (*big.Int, error) {
    out, err := b.bcapi.EstimateGas(ctx, toCallArgs(msg))
    return out.ToInt(), err
}

// SendTransaction implements bind.ContractTransactor injects the transaction
// into the pending pool for execution.
func (b *ContractBackend) SendTransaction(ctx context.Context, tx *types.Transaction) error {
    raw, _ := rlp.EncodeToBytes(tx)
    _, err := b.txapi.SendRawTransaction(ctx, common.ToHex(raw))
    return err
}