func (t *EthTx) Links() []*node.Link {
	return nil
}
Links is a helper function that returns all links within this object
package ipldeth
import (
	"bytes"
	"encoding/json"
	"fmt"
	cid "github.com/ipfs/go-cid"
	node "github.com/ipfs/go-ipld-format"
	hexutil "github.com/ethereum/go-ethereum/common/hexutil"
	types "github.com/ethereum/go-ethereum/core/types"
	rlp "github.com/ethereum/go-ethereum/rlp"
)
type EthTx struct {
	*types.Transaction
	cid     *cid.Cid
	rawdata []byte
}
var _ node.Node = (*EthTx)(nil)
func NewTx(t *types.Transaction) *EthTx {
	buf := new(bytes.Buffer)
	if err := t.EncodeRLP(buf); err != nil {
		panic(err)
	}
	rawdata := buf.Bytes()
	return &EthTx{
		Transaction: t,
		cid:         rawdataToCid(MEthTx, rawdata),
		rawdata:     rawdata,
	}
}
func DecodeEthTx(c *cid.Cid, b []byte) (*EthTx, error) {
	var t types.Transaction
	err := rlp.DecodeBytes(b, &t)
	if err != nil {
		return nil, err
	}
	return &EthTx{
		Transaction: &t,
		cid:         c,
		rawdata:     b,
	}, nil
}
func (t *EthTx) RawData() []byte {
	return t.rawdata
}
func (t *EthTx) Cid() *cid.Cid {
	return t.cid
}
func (t *EthTx) String() string {
	return fmt.Sprintf("<EthereumTx %s>", t.cid)
}
func (t *EthTx) Loggable() map[string]interface{} {
	return map[string]interface{}{
		"type": "eth-tx",
	}
}
func (t *EthTx) Resolve(p []string) (interface{}, []string, error) {
	if len(p) == 0 {
		return t, nil, nil
	}
	if len(p) > 1 {
		return nil, nil, fmt.Errorf("unexpected path elements past %s", p[0])
	}
	switch p[0] {
	case "gas":
		return t.Gas(), nil, nil
	case "gasPrice":
		return t.GasPrice(), nil, nil
	case "input":
		return fmt.Sprintf("%x", t.Data()), nil, nil
	case "nonce":
		return t.Nonce(), nil, nil
	case "r":
		_, r, _ := t.RawSignatureValues()
		return hexutil.EncodeBig(r), nil, nil
	case "s":
		_, _, s := t.RawSignatureValues()
		return hexutil.EncodeBig(s), nil, nil
	case "toAddress":
		return t.To(), nil, nil
	case "v":
		v, _, _ := t.RawSignatureValues()
		return hexutil.EncodeBig(v), nil, nil
	case "value":
		return hexutil.EncodeBig(t.Value()), nil, nil
	default:
		return nil, nil, fmt.Errorf("no such link")
	}
}
func (t *EthTx) Tree(p string, depth int) []string {
	if p != "" || depth == 0 {
		return nil
	}
	return []string{"gas", "gasPrice", "input", "nonce", "r", "s", "toAddress", "v", "value"}
}
func (t *EthTx) ResolveLink(p []string) (*node.Link, []string, error) {
	obj, rest, err := t.Resolve(p)
	if err != nil {
		return nil, nil, err
	}
	if lnk, ok := obj.(*node.Link); ok {
		return lnk, rest, nil
	}
	return nil, nil, fmt.Errorf("resolved item was not a link")
}
func (t *EthTx) Copy() node.Node {
	panic("dont use this yet")
}