mobile: fix mobile interface (#19180)

* mobile: fix mobile interface

* mobile, accounts: generate correct java binding

* accounts: fix java type binding

* mobile: support integer slice

* accounts/abi/bind, cmd/abigen: implement java binding tests

accounts/abi/bind/bind.go

@@ -38,7 +38,6 @@ type Lang int
 const (
 	LangGo Lang = iota
 	LangJava
-	LangObjC
 )
 
 // Bind generates a Go wrapper around a contract ABI. This wrapper isn't meant
@@ -164,124 +163,62 @@ var bindType = map[Lang]func(kind abi.Type) string{
 	LangJava: bindTypeJava,
 }
 
-// Helper function for the binding generators.
-// It reads the unmatched characters after the inner type-match,
-//  (since the inner type is a prefix of the total type declaration),
-//  looks for valid arrays (possibly a dynamic one) wrapping the inner type,
-//  and returns the sizes of these arrays.
-//
-// Returned array sizes are in the same order as solidity signatures; inner array size first.
-// Array sizes may also be "", indicating a dynamic array.
-func wrapArray(stringKind string, innerLen int, innerMapping string) (string, []string) {
-	remainder := stringKind[innerLen:]
-	//find all the sizes
-	matches := regexp.MustCompile(`\[(\d*)\]`).FindAllStringSubmatch(remainder, -1)
-	parts := make([]string, 0, len(matches))
-	for _, match := range matches {
-		//get group 1 from the regex match
-		parts = append(parts, match[1])
-	}
-	return innerMapping, parts
-}
-
-// Translates the array sizes to a Go-lang declaration of a (nested) array of the inner type.
-// Simply returns the inner type if arraySizes is empty.
-func arrayBindingGo(inner string, arraySizes []string) string {
-	out := ""
-	//prepend all array sizes, from outer (end arraySizes) to inner (start arraySizes)
-	for i := len(arraySizes) - 1; i >= 0; i-- {
-		out += "[" + arraySizes[i] + "]"
-	}
-	out += inner
-	return out
-}
-
-// bindTypeGo converts a Solidity type to a Go one. Since there is no clear mapping
-// from all Solidity types to Go ones (e.g. uint17), those that cannot be exactly
-// mapped will use an upscaled type (e.g. *big.Int).
-func bindTypeGo(kind abi.Type) string {
-	stringKind := kind.String()
-	innerLen, innerMapping := bindUnnestedTypeGo(stringKind)
-	return arrayBindingGo(wrapArray(stringKind, innerLen, innerMapping))
-}
-
-// The inner function of bindTypeGo, this finds the inner type of stringKind.
-// (Or just the type itself if it is not an array or slice)
-// The length of the matched part is returned, with the translated type.
-func bindUnnestedTypeGo(stringKind string) (int, string) {
-
-	switch {
-	case strings.HasPrefix(stringKind, "address"):
-		return len("address"), "common.Address"
-
-	case strings.HasPrefix(stringKind, "bytes"):
-		parts := regexp.MustCompile(`bytes([0-9]*)`).FindStringSubmatch(stringKind)
-		return len(parts[0]), fmt.Sprintf("[%s]byte", parts[1])
-
-	case strings.HasPrefix(stringKind, "int") || strings.HasPrefix(stringKind, "uint"):
-		parts := regexp.MustCompile(`(u)?int([0-9]*)`).FindStringSubmatch(stringKind)
+// bindBasicTypeGo converts basic solidity types(except array, slice and tuple) to Go one.
+func bindBasicTypeGo(kind abi.Type) string {
+	switch kind.T {
+	case abi.AddressTy:
+		return "common.Address"
+	case abi.IntTy, abi.UintTy:
+		parts := regexp.MustCompile(`(u)?int([0-9]*)`).FindStringSubmatch(kind.String())
 		switch parts[2] {
 		case "8", "16", "32", "64":
-			return len(parts[0]), fmt.Sprintf("%sint%s", parts[1], parts[2])
-		}
-		return len(parts[0]), "*big.Int"
-
-	case strings.HasPrefix(stringKind, "bool"):
-		return len("bool"), "bool"
-
-	case strings.HasPrefix(stringKind, "string"):
-		return len("string"), "string"
-
+			return fmt.Sprintf("%sint%s", parts[1], parts[2])
+		}
+		return "*big.Int"
+	case abi.FixedBytesTy:
+		return fmt.Sprintf("[%d]byte", kind.Size)
+	case abi.BytesTy:
+		return "[]byte"
+	case abi.FunctionTy:
+		// todo(rjl493456442)
+		return ""
 	default:
-		return len(stringKind), stringKind
+		// string, bool types
+		return kind.String()
 	}
 }
 
-// Translates the array sizes to a Java declaration of a (nested) array of the inner type.
-// Simply returns the inner type if arraySizes is empty.
-func arrayBindingJava(inner string, arraySizes []string) string {
-	// Java array type declarations do not include the length.
-	return inner + strings.Repeat("[]", len(arraySizes))
-}
-
-// bindTypeJava converts a Solidity type to a Java one. Since there is no clear mapping
-// from all Solidity types to Java ones (e.g. uint17), those that cannot be exactly
+// bindTypeGo converts solidity types to Go ones. Since there is no clear mapping
+// from all Solidity types to Go ones (e.g. uint17), those that cannot be exactly
 // mapped will use an upscaled type (e.g. BigDecimal).
-func bindTypeJava(kind abi.Type) string {
-	stringKind := kind.String()
-	innerLen, innerMapping := bindUnnestedTypeJava(stringKind)
-	return arrayBindingJava(wrapArray(stringKind, innerLen, innerMapping))
-}
-
-// The inner function of bindTypeJava, this finds the inner type of stringKind.
-// (Or just the type itself if it is not an array or slice)
-// The length of the matched part is returned, with the translated type.
-func bindUnnestedTypeJava(stringKind string) (int, string) {
-
-	switch {
-	case strings.HasPrefix(stringKind, "address"):
-		parts := regexp.MustCompile(`address(\[[0-9]*\])?`).FindStringSubmatch(stringKind)
-		if len(parts) != 2 {
-			return len(stringKind), stringKind
-		}
-		if parts[1] == "" {
-			return len("address"), "Address"
+func bindTypeGo(kind abi.Type) string {
+	// todo(rjl493456442) tuple
+	switch kind.T {
+	case abi.ArrayTy:
+		return fmt.Sprintf("[%d]", kind.Size) + bindTypeGo(*kind.Elem)
+	case abi.SliceTy:
+		return "[]" + bindTypeGo(*kind.Elem)
+	default:
+		return bindBasicTypeGo(kind)
 	}
-		return len(parts[0]), "Addresses"
-
-	case strings.HasPrefix(stringKind, "bytes"):
-		parts := regexp.MustCompile(`bytes([0-9]*)`).FindStringSubmatch(stringKind)
-		if len(parts) != 2 {
-			return len(stringKind), stringKind
 }
-		return len(parts[0]), "byte[]"
 
-	case strings.HasPrefix(stringKind, "int") || strings.HasPrefix(stringKind, "uint"):
+// bindBasicTypeJava converts basic solidity types(except array, slice and tuple) to Java one.
+func bindBasicTypeJava(kind abi.Type) string {
+	switch kind.T {
+	case abi.AddressTy:
+		return "Address"
+	case abi.IntTy, abi.UintTy:
 		// Note that uint and int (without digits) are also matched,
 		// these are size 256, and will translate to BigInt (the default).
-		parts := regexp.MustCompile(`(u)?int([0-9]*)`).FindStringSubmatch(stringKind)
+		parts := regexp.MustCompile(`(u)?int([0-9]*)`).FindStringSubmatch(kind.String())
 		if len(parts) != 3 {
-			return len(stringKind), stringKind
+			return kind.String()
+		}
+		// All unsigned integers should be translated to BigInt since gomobile doesn't
+		// support them.
+		if parts[1] == "u" {
+			return "BigInt"
 		}
 
 		namedSize := map[string]string{
@@ -295,16 +232,44 @@ func bindUnnestedTypeJava(stringKind string) (int, string) {
 		if namedSize == "" {
 			namedSize = "BigInt"
 		}
-		return len(parts[0]), namedSize
-
-	case strings.HasPrefix(stringKind, "bool"):
-		return len("bool"), "boolean"
-
-	case strings.HasPrefix(stringKind, "string"):
-		return len("string"), "String"
+		return namedSize
+	case abi.FixedBytesTy, abi.BytesTy:
+		return "byte[]"
+	case abi.BoolTy:
+		return "boolean"
+	case abi.StringTy:
+		return "String"
+	case abi.FunctionTy:
+		// todo(rjl493456442)
+		return ""
+	default:
+		return kind.String()
+	}
+}
 
+// bindTypeJava converts a Solidity type to a Java one. Since there is no clear mapping
+// from all Solidity types to Java ones (e.g. uint17), those that cannot be exactly
+// mapped will use an upscaled type (e.g. BigDecimal).
+func bindTypeJava(kind abi.Type) string {
+	switch kind.T {
+	case abi.ArrayTy, abi.SliceTy:
+		// Explicitly convert multidimensional types to predefined type in go side.
+		inner := bindTypeJava(*kind.Elem)
+		switch inner {
+		case "boolean":
+			return "Bools"
+		case "String":
+			return "Strings"
+		case "Address":
+			return "Addresses"
+		case "byte[]":
+			return "Binaries"
+		case "BigInt":
+			return "BigInts"
+		}
+		return inner + "[]"
 	default:
-		return len(stringKind), stringKind
+		return bindBasicTypeJava(kind)
 	}
 }
 
@@ -329,7 +294,7 @@ func bindTopicTypeGo(kind abi.Type) string {
 // funcionality as for simple types, but dynamic types get converted to hashes.
 func bindTopicTypeJava(kind abi.Type) string {
 	bound := bindTypeJava(kind)
-	if bound == "String" || bound == "Bytes" {
+	if bound == "String" || bound == "byte[]" {
 		bound = "Hash"
 	}
 	return bound
@@ -348,18 +313,8 @@ func namedTypeJava(javaKind string, solKind abi.Type) string {
 	switch javaKind {
 	case "byte[]":
 		return "Binary"
-	case "byte[][]":
-		return "Binaries"
-	case "string":
-		return "String"
-	case "string[]":
-		return "Strings"
 	case "boolean":
 		return "Bool"
-	case "boolean[]":
-		return "Bools"
-	case "BigInt[]":
-		return "BigInts"
 	default:
 		parts := regexp.MustCompile(`(u)?int([0-9]*)(\[[0-9]*\])?`).FindStringSubmatch(solKind.String())
 		if len(parts) != 4 {

accounts/abi/bind/template.go

@@ -452,7 +452,6 @@ const tmplSourceJava = `
 package {{.Package}};
 
 import org.ethereum.geth.*;
-import org.ethereum.geth.internal.*;
 
 {{range $contract := .Contracts}}
 public class {{.Type}} {
@@ -461,15 +460,14 @@ import org.ethereum.geth.internal.*;
 
 	{{if .InputBin}}
 	// BYTECODE is the compiled bytecode used for deploying new contracts.
-			public final static byte[] BYTECODE = "{{.InputBin}}".getBytes();
+	public final static String BYTECODE = "0x{{.InputBin}}";
 
 	// deploy deploys a new Ethereum contract, binding an instance of {{.Type}} to it.
 	public static {{.Type}} deploy(TransactOpts auth, EthereumClient client{{range .Constructor.Inputs}}, {{bindtype .Type}} {{.Name}}{{end}}) throws Exception {
 		Interfaces args = Geth.newInterfaces({{(len .Constructor.Inputs)}});
-				{{range $index, $element := .Constructor.Inputs}}
-				  args.set({{$index}}, Geth.newInterface()); args.get({{$index}}).set{{namedtype (bindtype .Type) .Type}}({{.Name}});
+		{{range $index, $element := .Constructor.Inputs}}Interface arg{{$index}} = Geth.newInterface();arg{{$index}}.set{{namedtype (bindtype .Type) .Type}}({{.Name}});args.set({{$index}},arg{{$index}});
 		{{end}}
-				return new {{.Type}}(Geth.deployContract(auth, ABI, BYTECODE, client, args));
+		return new {{.Type}}(Geth.deployContract(auth, ABI, Geth.decodeFromHex(BYTECODE), client, args));
 	}
 
 	// Internal constructor used by contract deployment.
@@ -508,7 +506,7 @@ import org.ethereum.geth.internal.*;
 	// Solidity: {{.Original.String}}
 	public {{if gt (len .Normalized.Outputs) 1}}{{capitalise .Normalized.Name}}Results{{else}}{{range .Normalized.Outputs}}{{bindtype .Type}}{{end}}{{end}} {{.Normalized.Name}}(CallOpts opts{{range .Normalized.Inputs}}, {{bindtype .Type}} {{.Name}}{{end}}) throws Exception {
 		Interfaces args = Geth.newInterfaces({{(len .Normalized.Inputs)}});
-				{{range $index, $item := .Normalized.Inputs}}args.set({{$index}}, Geth.newInterface()); args.get({{$index}}).set{{namedtype (bindtype .Type) .Type}}({{.Name}});
+		{{range $index, $item := .Normalized.Inputs}}Interface arg{{$index}} = Geth.newInterface();arg{{$index}}.set{{namedtype (bindtype .Type) .Type}}({{.Name}});args.set({{$index}},arg{{$index}});
 		{{end}}
 
 		Interfaces results = Geth.newInterfaces({{(len .Normalized.Outputs)}});
@@ -535,9 +533,8 @@ import org.ethereum.geth.internal.*;
 	// Solidity: {{.Original.String}}
 	public Transaction {{.Normalized.Name}}(TransactOpts opts{{range .Normalized.Inputs}}, {{bindtype .Type}} {{.Name}}{{end}}) throws Exception {
 		Interfaces args = Geth.newInterfaces({{(len .Normalized.Inputs)}});
-				{{range $index, $item := .Normalized.Inputs}}args.set({{$index}}, Geth.newInterface()); args.get({{$index}}).set{{namedtype (bindtype .Type) .Type}}({{.Name}});
+		{{range $index, $item := .Normalized.Inputs}}Interface arg{{$index}} = Geth.newInterface();arg{{$index}}.set{{namedtype (bindtype .Type) .Type}}({{.Name}});args.set({{$index}},arg{{$index}});
 		{{end}}
-
 		return this.Contract.transact(opts, "{{.Original.Name}}"	, args);
 	}
 	{{end}}

cmd/abigen/main.go

@@ -69,8 +69,6 @@ func main() {
 		lang = bind.LangGo
 	case "java":
 		lang = bind.LangJava
-	case "objc":
-		lang = bind.LangObjC
 	default:
 		fmt.Printf("Unsupported destination language \"%s\" (--lang)\n", *langFlag)
 		os.Exit(-1)

mobile/bind.go

@@ -19,27 +19,30 @@
 package geth
 
 import (
+	"errors"
 	"math/big"
 	"strings"
 
 	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/accounts/keystore"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/crypto"
 )
 
-// Signer is an interaface defining the callback when a contract requires a
+// Signer is an interface defining the callback when a contract requires a
 // method to sign the transaction before submission.
 type Signer interface {
 	Sign(*Address, *Transaction) (tx *Transaction, _ error)
 }
 
-type signer struct {
+type MobileSigner struct {
 	sign bind.SignerFn
 }
 
-func (s *signer) Sign(addr *Address, unsignedTx *Transaction) (signedTx *Transaction, _ error) {
-	sig, err := s.sign(types.HomesteadSigner{}, addr.address, unsignedTx.tx)
+func (s *MobileSigner) Sign(addr *Address, unsignedTx *Transaction) (signedTx *Transaction, _ error) {
+	sig, err := s.sign(types.EIP155Signer{}, addr.address, unsignedTx.tx)
 	if err != nil {
 		return nil, err
 	}
@@ -73,6 +76,35 @@ type TransactOpts struct {
 	opts bind.TransactOpts
 }
 
+// NewTransactOpts creates a new option set for contract transaction.
+func NewTransactOpts() *TransactOpts {
+	return new(TransactOpts)
+}
+
+// NewKeyedTransactor is a utility method to easily create a transaction signer
+// from a single private key.
+func NewKeyedTransactOpts(keyJson []byte, passphrase string) (*TransactOpts, error) {
+	key, err := keystore.DecryptKey(keyJson, passphrase)
+	if err != nil {
+		return nil, err
+	}
+	keyAddr := crypto.PubkeyToAddress(key.PrivateKey.PublicKey)
+	opts := bind.TransactOpts{
+		From: keyAddr,
+		Signer: func(signer types.Signer, address common.Address, tx *types.Transaction) (*types.Transaction, error) {
+			if address != keyAddr {
+				return nil, errors.New("not authorized to sign this account")
+			}
+			signature, err := crypto.Sign(signer.Hash(tx).Bytes(), key.PrivateKey)
+			if err != nil {
+				return nil, err
+			}
+			return tx.WithSignature(signer, signature)
+		},
+	}
+	return &TransactOpts{opts}, nil
+}
+
 func (opts *TransactOpts) GetFrom() *Address    { return &Address{opts.opts.From} }
 func (opts *TransactOpts) GetNonce() int64      { return opts.opts.Nonce.Int64() }
 func (opts *TransactOpts) GetValue() *BigInt    { return &BigInt{opts.opts.Value} }

mobile/common.go

@@ -25,6 +25,7 @@ import (
 	"strings"
 
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/hexutil"
 )
 
 // Hash represents the 32 byte Keccak256 hash of arbitrary data.
@@ -228,3 +229,13 @@ func (a *Addresses) Set(index int, address *Address) error {
 func (a *Addresses) Append(address *Address) {
 	a.addresses = append(a.addresses, address.address)
 }
+
+// EncodeToHex encodes b as a hex string with 0x prefix.
+func EncodeToHex(b []byte) string {
+	return hexutil.Encode(b)
+}
+
+// DecodeFromHex decodes a hex string with 0x prefix.
+func DecodeFromHex(s string) ([]byte, error) {
+	return hexutil.Decode(s)
+}

mobile/interface.go

@@ -43,11 +43,11 @@ func NewInterface() *Interface {
 }
 
 func (i *Interface) SetBool(b bool)                 { i.object = &b }
-func (i *Interface) SetBools(bs []bool)            { i.object = &bs }
+func (i *Interface) SetBools(bs *Bools)             { i.object = &bs.bools }
 func (i *Interface) SetString(str string)           { i.object = &str }
 func (i *Interface) SetStrings(strs *Strings)       { i.object = &strs.strs }
 func (i *Interface) SetBinary(binary []byte)        { b := common.CopyBytes(binary); i.object = &b }
-func (i *Interface) SetBinaries(binaries [][]byte) { i.object = &binaries }
+func (i *Interface) SetBinaries(binaries *Binaries) { i.object = &binaries.binaries }
 func (i *Interface) SetAddress(address *Address)    { i.object = &address.address }
 func (i *Interface) SetAddresses(addrs *Addresses)  { i.object = &addrs.addresses }
 func (i *Interface) SetHash(hash *Hash)             { i.object = &hash.hash }
@@ -56,10 +56,66 @@ func (i *Interface) SetInt8(n int8)                { i.object = &n }
 func (i *Interface) SetInt16(n int16)               { i.object = &n }
 func (i *Interface) SetInt32(n int32)               { i.object = &n }
 func (i *Interface) SetInt64(n int64)               { i.object = &n }
+func (i *Interface) SetInt8s(bigints *BigInts) {
+	ints := make([]int8, 0, bigints.Size())
+	for _, bi := range bigints.bigints {
+		ints = append(ints, int8(bi.Int64()))
+	}
+	i.object = &ints
+}
+func (i *Interface) SetInt16s(bigints *BigInts) {
+	ints := make([]int16, 0, bigints.Size())
+	for _, bi := range bigints.bigints {
+		ints = append(ints, int16(bi.Int64()))
+	}
+	i.object = &ints
+}
+func (i *Interface) SetInt32s(bigints *BigInts) {
+	ints := make([]int32, 0, bigints.Size())
+	for _, bi := range bigints.bigints {
+		ints = append(ints, int32(bi.Int64()))
+	}
+	i.object = &ints
+}
+func (i *Interface) SetInt64s(bigints *BigInts) {
+	ints := make([]int64, 0, bigints.Size())
+	for _, bi := range bigints.bigints {
+		ints = append(ints, bi.Int64())
+	}
+	i.object = &ints
+}
 func (i *Interface) SetUint8(bigint *BigInt)  { n := uint8(bigint.bigint.Uint64()); i.object = &n }
 func (i *Interface) SetUint16(bigint *BigInt) { n := uint16(bigint.bigint.Uint64()); i.object = &n }
 func (i *Interface) SetUint32(bigint *BigInt) { n := uint32(bigint.bigint.Uint64()); i.object = &n }
 func (i *Interface) SetUint64(bigint *BigInt) { n := bigint.bigint.Uint64(); i.object = &n }
+func (i *Interface) SetUint8s(bigints *BigInts) {
+	ints := make([]uint8, 0, bigints.Size())
+	for _, bi := range bigints.bigints {
+		ints = append(ints, uint8(bi.Uint64()))
+	}
+	i.object = &ints
+}
+func (i *Interface) SetUint16s(bigints *BigInts) {
+	ints := make([]uint16, 0, bigints.Size())
+	for _, bi := range bigints.bigints {
+		ints = append(ints, uint16(bi.Uint64()))
+	}
+	i.object = &ints
+}
+func (i *Interface) SetUint32s(bigints *BigInts) {
+	ints := make([]uint32, 0, bigints.Size())
+	for _, bi := range bigints.bigints {
+		ints = append(ints, uint32(bi.Uint64()))
+	}
+	i.object = &ints
+}
+func (i *Interface) SetUint64s(bigints *BigInts) {
+	ints := make([]uint64, 0, bigints.Size())
+	for _, bi := range bigints.bigints {
+		ints = append(ints, bi.Uint64())
+	}
+	i.object = &ints
+}
 func (i *Interface) SetBigInt(bigint *BigInt)    { i.object = &bigint.bigint }
 func (i *Interface) SetBigInts(bigints *BigInts) { i.object = &bigints.bigints }
 
@@ -74,22 +130,30 @@ func (i *Interface) SetDefaultAddresses() { i.object = new([]common.Address) }
 func (i *Interface) SetDefaultHash()      { i.object = new(common.Hash) }
 func (i *Interface) SetDefaultHashes()    { i.object = new([]common.Hash) }
 func (i *Interface) SetDefaultInt8()      { i.object = new(int8) }
+func (i *Interface) SetDefaultInt8s()     { i.object = new([]int8) }
 func (i *Interface) SetDefaultInt16()     { i.object = new(int16) }
+func (i *Interface) SetDefaultInt16s()    { i.object = new([]int16) }
 func (i *Interface) SetDefaultInt32()     { i.object = new(int32) }
+func (i *Interface) SetDefaultInt32s()    { i.object = new([]int32) }
 func (i *Interface) SetDefaultInt64()     { i.object = new(int64) }
+func (i *Interface) SetDefaultInt64s()    { i.object = new([]int64) }
 func (i *Interface) SetDefaultUint8()     { i.object = new(uint8) }
+func (i *Interface) SetDefaultUint8s()    { i.object = new([]uint8) }
 func (i *Interface) SetDefaultUint16()    { i.object = new(uint16) }
+func (i *Interface) SetDefaultUint16s()   { i.object = new([]uint16) }
 func (i *Interface) SetDefaultUint32()    { i.object = new(uint32) }
+func (i *Interface) SetDefaultUint32s()   { i.object = new([]uint32) }
 func (i *Interface) SetDefaultUint64()    { i.object = new(uint64) }
+func (i *Interface) SetDefaultUint64s()   { i.object = new([]uint64) }
 func (i *Interface) SetDefaultBigInt()    { i.object = new(*big.Int) }
 func (i *Interface) SetDefaultBigInts()   { i.object = new([]*big.Int) }
 
 func (i *Interface) GetBool() bool            { return *i.object.(*bool) }
-func (i *Interface) GetBools() []bool         { return *i.object.(*[]bool) }
+func (i *Interface) GetBools() *Bools         { return &Bools{*i.object.(*[]bool)} }
 func (i *Interface) GetString() string        { return *i.object.(*string) }
 func (i *Interface) GetStrings() *Strings     { return &Strings{*i.object.(*[]string)} }
 func (i *Interface) GetBinary() []byte        { return *i.object.(*[]byte) }
-func (i *Interface) GetBinaries() [][]byte    { return *i.object.(*[][]byte) }
+func (i *Interface) GetBinaries() *Binaries   { return &Binaries{*i.object.(*[][]byte)} }
 func (i *Interface) GetAddress() *Address     { return &Address{*i.object.(*common.Address)} }
 func (i *Interface) GetAddresses() *Addresses { return &Addresses{*i.object.(*[]common.Address)} }
 func (i *Interface) GetHash() *Hash           { return &Hash{*i.object.(*common.Hash)} }
@@ -98,6 +162,38 @@ func (i *Interface) GetInt8() int8            { return *i.object.(*int8) }
 func (i *Interface) GetInt16() int16          { return *i.object.(*int16) }
 func (i *Interface) GetInt32() int32          { return *i.object.(*int32) }
 func (i *Interface) GetInt64() int64          { return *i.object.(*int64) }
+func (i *Interface) GetInt8s() *BigInts {
+	val := i.object.(*[]int8)
+	bigints := NewBigInts(len(*val))
+	for i, v := range *val {
+		bigints.Set(i, &BigInt{new(big.Int).SetInt64(int64(v))})
+	}
+	return bigints
+}
+func (i *Interface) GetInt16s() *BigInts {
+	val := i.object.(*[]int16)
+	bigints := NewBigInts(len(*val))
+	for i, v := range *val {
+		bigints.Set(i, &BigInt{new(big.Int).SetInt64(int64(v))})
+	}
+	return bigints
+}
+func (i *Interface) GetInt32s() *BigInts {
+	val := i.object.(*[]int32)
+	bigints := NewBigInts(len(*val))
+	for i, v := range *val {
+		bigints.Set(i, &BigInt{new(big.Int).SetInt64(int64(v))})
+	}
+	return bigints
+}
+func (i *Interface) GetInt64s() *BigInts {
+	val := i.object.(*[]int64)
+	bigints := NewBigInts(len(*val))
+	for i, v := range *val {
+		bigints.Set(i, &BigInt{new(big.Int).SetInt64(v)})
+	}
+	return bigints
+}
 func (i *Interface) GetUint8() *BigInt {
 	return &BigInt{new(big.Int).SetUint64(uint64(*i.object.(*uint8)))}
 }
@@ -110,6 +206,38 @@ func (i *Interface) GetUint32() *BigInt {
 func (i *Interface) GetUint64() *BigInt {
 	return &BigInt{new(big.Int).SetUint64(*i.object.(*uint64))}
 }
+func (i *Interface) GetUint8s() *BigInts {
+	val := i.object.(*[]uint8)
+	bigints := NewBigInts(len(*val))
+	for i, v := range *val {
+		bigints.Set(i, &BigInt{new(big.Int).SetUint64(uint64(v))})
+	}
+	return bigints
+}
+func (i *Interface) GetUint16s() *BigInts {
+	val := i.object.(*[]uint16)
+	bigints := NewBigInts(len(*val))
+	for i, v := range *val {
+		bigints.Set(i, &BigInt{new(big.Int).SetUint64(uint64(v))})
+	}
+	return bigints
+}
+func (i *Interface) GetUint32s() *BigInts {
+	val := i.object.(*[]uint32)
+	bigints := NewBigInts(len(*val))
+	for i, v := range *val {
+		bigints.Set(i, &BigInt{new(big.Int).SetUint64(uint64(v))})
+	}
+	return bigints
+}
+func (i *Interface) GetUint64s() *BigInts {
+	val := i.object.(*[]uint64)
+	bigints := NewBigInts(len(*val))
+	for i, v := range *val {
+		bigints.Set(i, &BigInt{new(big.Int).SetUint64(v)})
+	}
+	return bigints
+}
 func (i *Interface) GetBigInt() *BigInt   { return &BigInt{*i.object.(**big.Int)} }
 func (i *Interface) GetBigInts() *BigInts { return &BigInts{*i.object.(*[]*big.Int)} }
 
@@ -120,9 +248,7 @@ type Interfaces struct {
 
 // NewInterfaces creates a slice of uninitialized interfaces.
 func NewInterfaces(size int) *Interfaces {
-	return &Interfaces{
-		objects: make([]interface{}, size),
-	}
+	return &Interfaces{objects: make([]interface{}, size)}
 }
 
 // Size returns the number of interfaces in the slice.
@@ -131,11 +257,13 @@ func (i *Interfaces) Size() int {
 }
 
 // Get returns the bigint at the given index from the slice.
+// Notably the returned value can be changed without affecting the
+// interfaces itself.
 func (i *Interfaces) Get(index int) (iface *Interface, _ error) {
 	if index < 0 || index >= len(i.objects) {
 		return nil, errors.New("index out of bounds")
 	}
-	return &Interface{i.objects[index]}, nil
+	return &Interface{object: i.objects[index]}, nil
 }
 
 // Set sets the big int at the given index in the slice.

mobile/interface_test.go

@@ -0,0 +1,90 @@
+// Copyright 2019 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 geth
+
+import (
+	"fmt"
+	"math/big"
+	"reflect"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/common"
+)
+
+func TestInterfaceGetSet(t *testing.T) {
+	var tests = []struct {
+		method string
+		input  interface{}
+		expect interface{}
+	}{
+		{"Bool", true, true},
+		{"Bool", false, false},
+		{"Bools", &Bools{[]bool{false, true}}, &Bools{[]bool{false, true}}},
+		{"String", "go-ethereum", "go-ethereum"},
+		{"Strings", &Strings{strs: []string{"hello", "world"}}, &Strings{strs: []string{"hello", "world"}}},
+		{"Binary", []byte{0x01, 0x02}, []byte{0x01, 0x02}},
+		{"Binaries", &Binaries{[][]byte{{0x01, 0x02}, {0x03, 0x04}}}, &Binaries{[][]byte{{0x01, 0x02}, {0x03, 0x04}}}},
+		{"Address", &Address{common.HexToAddress("deadbeef")}, &Address{common.HexToAddress("deadbeef")}},
+		{"Addresses", &Addresses{[]common.Address{common.HexToAddress("deadbeef"), common.HexToAddress("cafebabe")}}, &Addresses{[]common.Address{common.HexToAddress("deadbeef"), common.HexToAddress("cafebabe")}}},
+		{"Hash", &Hash{common.HexToHash("deadbeef")}, &Hash{common.HexToHash("deadbeef")}},
+		{"Hashes", &Hashes{[]common.Hash{common.HexToHash("deadbeef"), common.HexToHash("cafebabe")}}, &Hashes{[]common.Hash{common.HexToHash("deadbeef"), common.HexToHash("cafebabe")}}},
+		{"Int8", int8(1), int8(1)},
+		{"Int16", int16(1), int16(1)},
+		{"Int32", int32(1), int32(1)},
+		{"Int64", int64(1), int64(1)},
+		{"Int8s", &BigInts{[]*big.Int{big.NewInt(1), big.NewInt(2)}}, &BigInts{[]*big.Int{big.NewInt(1), big.NewInt(2)}}},
+		{"Int16s", &BigInts{[]*big.Int{big.NewInt(1), big.NewInt(2)}}, &BigInts{[]*big.Int{big.NewInt(1), big.NewInt(2)}}},
+		{"Int32s", &BigInts{[]*big.Int{big.NewInt(1), big.NewInt(2)}}, &BigInts{[]*big.Int{big.NewInt(1), big.NewInt(2)}}},
+		{"Int64s", &BigInts{[]*big.Int{big.NewInt(1), big.NewInt(2)}}, &BigInts{[]*big.Int{big.NewInt(1), big.NewInt(2)}}},
+		{"Uint8", NewBigInt(1), NewBigInt(1)},
+		{"Uint16", NewBigInt(1), NewBigInt(1)},
+		{"Uint32", NewBigInt(1), NewBigInt(1)},
+		{"Uint64", NewBigInt(1), NewBigInt(1)},
+		{"Uint8s", &BigInts{[]*big.Int{big.NewInt(1), big.NewInt(2)}}, &BigInts{[]*big.Int{big.NewInt(1), big.NewInt(2)}}},
+		{"Uint16s", &BigInts{[]*big.Int{big.NewInt(1), big.NewInt(2)}}, &BigInts{[]*big.Int{big.NewInt(1), big.NewInt(2)}}},
+		{"Uint32s", &BigInts{[]*big.Int{big.NewInt(1), big.NewInt(2)}}, &BigInts{[]*big.Int{big.NewInt(1), big.NewInt(2)}}},
+		{"Uint64s", &BigInts{[]*big.Int{big.NewInt(1), big.NewInt(2)}}, &BigInts{[]*big.Int{big.NewInt(1), big.NewInt(2)}}},
+		{"BigInt", NewBigInt(1), NewBigInt(1)},
+		{"BigInts", &BigInts{[]*big.Int{big.NewInt(1), big.NewInt(2)}}, &BigInts{[]*big.Int{big.NewInt(1), big.NewInt(2)}}},
+	}
+
+	args := NewInterfaces(len(tests))
+
+	callFn := func(receiver interface{}, method string, arg interface{}) interface{} {
+		rval := reflect.ValueOf(receiver)
+		rval.MethodByName(fmt.Sprintf("Set%s", method)).Call([]reflect.Value{reflect.ValueOf(arg)})
+		res := rval.MethodByName(fmt.Sprintf("Get%s", method)).Call(nil)
+		if len(res) > 0 {
+			return res[0].Interface()
+		}
+		return nil
+	}
+
+	for index, c := range tests {
+		// In theory the change of iface shouldn't effect the args value
+		iface, _ := args.Get(index)
+		result := callFn(iface, c.method, c.input)
+		if !reflect.DeepEqual(result, c.expect) {
+			t.Errorf("Interface get/set mismatch, want %v, got %v", c.expect, result)
+		}
+		// Check whether the underlying value in args is still zero
+		iface, _ = args.Get(index)
+		if iface.object != nil {
+			t.Error("Get operation is not write safe")
+		}
+	}
+}

mobile/primitives.go

@@ -21,6 +21,8 @@ package geth
 import (
 	"errors"
 	"fmt"
+
+	"github.com/ethereum/go-ethereum/common"
 )
 
 // Strings represents s slice of strs.
@@ -52,3 +54,63 @@ func (s *Strings) Set(index int, str string) error {
 func (s *Strings) String() string {
 	return fmt.Sprintf("%v", s.strs)
 }
+
+// Bools represents a slice of bool.
+type Bools struct{ bools []bool }
+
+// Size returns the number of bool in the slice.
+func (bs *Bools) Size() int {
+	return len(bs.bools)
+}
+
+// Get returns the bool at the given index from the slice.
+func (bs *Bools) Get(index int) (b bool, _ error) {
+	if index < 0 || index >= len(bs.bools) {
+		return false, errors.New("index out of bounds")
+	}
+	return bs.bools[index], nil
+}
+
+// Set sets the bool at the given index in the slice.
+func (bs *Bools) Set(index int, b bool) error {
+	if index < 0 || index >= len(bs.bools) {
+		return errors.New("index out of bounds")
+	}
+	bs.bools[index] = b
+	return nil
+}
+
+// String implements the Stringer interface.
+func (bs *Bools) String() string {
+	return fmt.Sprintf("%v", bs.bools)
+}
+
+// Binaries represents a slice of byte slice
+type Binaries struct{ binaries [][]byte }
+
+// Size returns the number of byte slice in the slice.
+func (bs *Binaries) Size() int {
+	return len(bs.binaries)
+}
+
+// Get returns the byte slice at the given index from the slice.
+func (bs *Binaries) Get(index int) (binary []byte, _ error) {
+	if index < 0 || index >= len(bs.binaries) {
+		return nil, errors.New("index out of bounds")
+	}
+	return common.CopyBytes(bs.binaries[index]), nil
+}
+
+// Set sets the byte slice at the given index in the slice.
+func (bs *Binaries) Set(index int, binary []byte) error {
+	if index < 0 || index >= len(bs.binaries) {
+		return errors.New("index out of bounds")
+	}
+	bs.binaries[index] = common.CopyBytes(binary)
+	return nil
+}
+
+// String implements the Stringer interface.
+func (bs *Binaries) String() string {
+	return fmt.Sprintf("%v", bs.binaries)
+}