mirror of https://github.com/status-im/op-geth.git
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
This commit is contained in:
gary rong
Péter Szilágyi
parent
fd072c2fd1
commit
6069b1a5f5
|
|
@ -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 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 "*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))
|
||||
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)
|
||||
}
|
||||
}
|
||||
|
||||
// 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"
|
||||
}
|
||||
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"):
|
||||
//Note that uint and int (without digits) are also matched,
|
||||
// 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{
|
||||
|
|
@ -291,20 +228,48 @@ func bindUnnestedTypeJava(stringKind string) (int, string) {
|
|||
"64": "long",
|
||||
}[parts[2]]
|
||||
|
||||
//default to BigInt
|
||||
// default to BigInt
|
||||
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 len(stringKind), stringKind
|
||||
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 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 {
|
||||
|
|
|
|||
File diff suppressed because one or more lines are too long
|
|
@ -452,24 +452,22 @@ const tmplSourceJava = `
|
|||
package {{.Package}};
|
||||
|
||||
import org.ethereum.geth.*;
|
||||
import org.ethereum.geth.internal.*;
|
||||
|
||||
{{range $contract := .Contracts}}
|
||||
public class {{.Type}} {
|
||||
public class {{.Type}} {
|
||||
// ABI is the input ABI used to generate the binding from.
|
||||
public final static String ABI = "{{.InputABI}}";
|
||||
|
||||
{{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,12 +533,11 @@ 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}}
|
||||
}
|
||||
}
|
||||
{{end}}
|
||||
`
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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} }
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
|
|
|
|||
|
|
@ -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")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -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)
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue