示例#1
0
// Deploy deploys a fresh instance of the EtherAPIs contract, returning the
// transaction seeded into the network.
func (eapis *EtherAPIs) Deploy(from common.Address) (common.Address, *types.Transaction, error) {
	rpc, err := eapis.client.Stack().Attach()
	if err != nil {
		return common.Address{}, nil, err
	}
	auth := &bind.TransactOpts{
		From:   from,
		Signer: eapis.signer,
	}
	target, tx, etherapis, err := contract.DeployEtherAPIs(auth, backends.NewRPCBackend(rpc))
	if err == nil {
		eapis.contract = etherapis
	}
	return target, tx, err
}
示例#2
0
// New creates a new Ether APIs instance, connects with it to the Ethereum network
// via an embedded Geth instance and attaches an RPC in-process endpoint to it.
func New(datadir string, network geth.EthereumNetwork, address common.Address) (*EtherAPIs, error) {
	// Create a Geth instance and boot it up
	client, err := geth.New(datadir, network)
	if err != nil {
		return nil, err
	}
	if err := client.Start(); err != nil {
		return nil, err
	}
	// Retrieve the underlying ethereum service and attach global RPC interface
	var ethereum *eth.Ethereum
	if err := client.Stack().Service(&ethereum); err != nil {
		return nil, err
	}
	api, err := client.Attach()
	if err != nil {
		return nil, err
	}
	// Assemble an interface around the consensus contract
	rpcClient, err := client.Stack().Attach()
	if err != nil {
		return nil, err
	}
	contract, err := contract.NewEtherAPIs(address, backends.NewRPCBackend(rpcClient))
	if err != nil {
		return nil, err
	}
	// Assemble and return the Ether APIs instance
	return &EtherAPIs{
		client:   client,
		ethereum: ethereum,
		eventmux: client.Stack().EventMux(),
		rpcapi:   api,
		contract: contract,
		signer: func(from common.Address, tx *types.Transaction) (*types.Transaction, error) {
			signature, err := ethereum.AccountManager().Sign(accounts.Account{Address: from}, tx.SigHash().Bytes())
			if err != nil {
				return nil, err
			}
			return tx.WithSignature(signature)
		},
	}, nil
}