diff --git a/.travis.yml b/.travis.yml index 7d0777fee9..8ff5fa3cfb 100644 --- a/.travis.yml +++ b/.travis.yml @@ -232,4 +232,4 @@ matrix: go: 1.12.x git: submodules: false # avoid cloning ethereum/tests - script: ./build/travis_keepalive.sh go test -v -timeout 20m -race ./swarm... + script: ./build/travis_keepalive.sh go test -timeout 20m -race ./swarm... ./p2p/{protocols,simulations,testing}/... diff --git a/appveyor.yml b/appveyor.yml index 515f3d9fbe..0eb9163d75 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -23,8 +23,8 @@ environment: install: - git submodule update --init - rmdir C:\go /s /q - - appveyor DownloadFile https://dl.google.com/go/go1.12.windows-%GETH_ARCH%.zip - - 7z x go1.12.windows-%GETH_ARCH%.zip -y -oC:\ > NUL + - appveyor DownloadFile https://dl.google.com/go/go1.12.1.windows-%GETH_ARCH%.zip + - 7z x go1.12.1.windows-%GETH_ARCH%.zip -y -oC:\ > NUL - go version - gcc --version diff --git a/cmd/geth/main.go b/cmd/geth/main.go index f966905a92..83847fc533 100644 --- a/cmd/geth/main.go +++ b/cmd/geth/main.go @@ -137,7 +137,6 @@ var ( utils.RPCCORSDomainFlag, utils.RPCVirtualHostsFlag, utils.EthStatsURLFlag, - utils.MetricsEnabledFlag, utils.FakePoWFlag, utils.NoCompactionFlag, utils.GpoBlocksFlag, @@ -174,6 +173,8 @@ var ( } metricsFlags = []cli.Flag{ + utils.MetricsEnabledFlag, + utils.MetricsEnabledExpensiveFlag, utils.MetricsEnableInfluxDBFlag, utils.MetricsInfluxDBEndpointFlag, utils.MetricsInfluxDBDatabaseFlag, diff --git a/cmd/geth/usage.go b/cmd/geth/usage.go index a4787fff2b..8658a3fdcf 100644 --- a/cmd/geth/usage.go +++ b/cmd/geth/usage.go @@ -225,16 +225,8 @@ var AppHelpFlagGroups = []flagGroup{ }, debug.Flags...), }, { - Name: "METRICS AND STATS", - Flags: []cli.Flag{ - utils.MetricsEnabledFlag, - utils.MetricsEnableInfluxDBFlag, - utils.MetricsInfluxDBEndpointFlag, - utils.MetricsInfluxDBDatabaseFlag, - utils.MetricsInfluxDBUsernameFlag, - utils.MetricsInfluxDBPasswordFlag, - utils.MetricsInfluxDBTagsFlag, - }, + Name: "METRICS AND STATS", + Flags: metricsFlags, }, { Name: "WHISPER (EXPERIMENTAL)", diff --git a/cmd/swarm/config.go b/cmd/swarm/config.go index a941b37579..32cd442a03 100644 --- a/cmd/swarm/config.go +++ b/cmd/swarm/config.go @@ -123,18 +123,22 @@ func buildConfig(ctx *cli.Context) (config *bzzapi.Config, err error) { } //finally, after the configuration build phase is finished, initialize -func initSwarmNode(config *bzzapi.Config, stack *node.Node, ctx *cli.Context) { +func initSwarmNode(config *bzzapi.Config, stack *node.Node, ctx *cli.Context, nodeconfig *node.Config) error { //at this point, all vars should be set in the Config //get the account for the provided swarm account prvkey := getAccount(config.BzzAccount, ctx, stack) //set the resolved config path (geth --datadir) config.Path = expandPath(stack.InstanceDir()) //finally, initialize the configuration - config.Init(prvkey) + err := config.Init(prvkey, nodeconfig.NodeKey()) + if err != nil { + return err + } //configuration phase completed here log.Debug("Starting Swarm with the following parameters:") //after having created the config, print it to screen log.Debug(printConfig(config)) + return nil } //configFileOverride overrides the current config with the config file, if a config file has been provided diff --git a/cmd/swarm/hash.go b/cmd/swarm/hash.go index 471feb53d6..2df02c0ed7 100644 --- a/cmd/swarm/hash.go +++ b/cmd/swarm/hash.go @@ -19,10 +19,13 @@ package main import ( "context" + "encoding/hex" "fmt" "os" "github.com/ethereum/go-ethereum/cmd/utils" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/contracts/ens" "github.com/ethereum/go-ethereum/swarm/storage" "gopkg.in/urfave/cli.v1" ) @@ -34,7 +37,33 @@ var hashCommand = cli.Command{ Usage: "print the swarm hash of a file or directory", ArgsUsage: "", Description: "Prints the swarm hash of file or directory", -} + Subcommands: []cli.Command{ + { + CustomHelpTemplate: helpTemplate, + Name: "ens", + Usage: "converts a swarm hash to an ens EIP1577 compatible CIDv1 hash", + ArgsUsage: "", + Description: "", + Subcommands: []cli.Command{ + { + Action: encodeEipHash, + CustomHelpTemplate: helpTemplate, + Name: "contenthash", + Usage: "converts a swarm hash to an ens EIP1577 compatible CIDv1 hash", + ArgsUsage: "", + Description: "", + }, + { + Action: ensNodeHash, + CustomHelpTemplate: helpTemplate, + Name: "node", + Usage: "converts an ens name to an ENS node hash", + ArgsUsage: "", + Description: "", + }, + }, + }, + }} func hash(ctx *cli.Context) { args := ctx.Args() @@ -56,3 +85,31 @@ func hash(ctx *cli.Context) { fmt.Printf("%v\n", addr) } } +func ensNodeHash(ctx *cli.Context) { + args := ctx.Args() + if len(args) < 1 { + utils.Fatalf("Usage: swarm hash ens node ") + } + ensName := args[0] + + hash := ens.EnsNode(ensName) + + stringHex := hex.EncodeToString(hash[:]) + fmt.Println(stringHex) +} +func encodeEipHash(ctx *cli.Context) { + args := ctx.Args() + if len(args) < 1 { + utils.Fatalf("Usage: swarm hash ens ") + } + swarmHash := args[0] + + hash := common.HexToHash(swarmHash) + ensHash, err := ens.EncodeSwarmHash(hash) + if err != nil { + utils.Fatalf("error converting swarm hash", err) + } + + stringHex := hex.EncodeToString(ensHash) + fmt.Println(stringHex) +} diff --git a/cmd/swarm/main.go b/cmd/swarm/main.go index 06d5b0bb2b..a4041eb3d1 100644 --- a/cmd/swarm/main.go +++ b/cmd/swarm/main.go @@ -298,7 +298,10 @@ func bzzd(ctx *cli.Context) error { //a few steps need to be done after the config phase is completed, //due to overriding behavior - initSwarmNode(bzzconfig, stack, ctx) + err = initSwarmNode(bzzconfig, stack, ctx, &cfg) + if err != nil { + return err + } //register BZZ as node.Service in the ethereum node registerBzzService(bzzconfig, stack) //start the node diff --git a/cmd/swarm/swarm-smoke/main.go b/cmd/swarm/swarm-smoke/main.go index ac2e3377cb..b382ed9832 100644 --- a/cmd/swarm/swarm-smoke/main.go +++ b/cmd/swarm/swarm-smoke/main.go @@ -40,6 +40,7 @@ var ( allhosts string hosts []string filesize int + inputSeed int syncDelay int httpPort int wsPort int @@ -74,6 +75,12 @@ func main() { Usage: "ws port", Destination: &wsPort, }, + cli.IntFlag{ + Name: "seed", + Value: 0, + Usage: "input seed in case we need deterministic upload", + Destination: &inputSeed, + }, cli.IntFlag{ Name: "filesize", Value: 1024, diff --git a/cmd/swarm/swarm-smoke/upload_and_sync.go b/cmd/swarm/swarm-smoke/upload_and_sync.go index d1032f8210..6c20a4fa63 100644 --- a/cmd/swarm/swarm-smoke/upload_and_sync.go +++ b/cmd/swarm/swarm-smoke/upload_and_sync.go @@ -39,6 +39,11 @@ import ( ) func uploadAndSyncCmd(ctx *cli.Context, tuid string) error { + // use input seed if it has been set + if inputSeed != 0 { + seed = inputSeed + } + randomBytes := testutil.RandomBytes(seed, filesize*1000) errc := make(chan error) @@ -47,37 +52,28 @@ func uploadAndSyncCmd(ctx *cli.Context, tuid string) error { errc <- uploadAndSync(ctx, randomBytes, tuid) }() + var err error select { - case err := <-errc: + case err = <-errc: if err != nil { metrics.GetOrRegisterCounter(fmt.Sprintf("%s.fail", commandName), nil).Inc(1) } - return err case <-time.After(time.Duration(timeout) * time.Second): metrics.GetOrRegisterCounter(fmt.Sprintf("%s.timeout", commandName), nil).Inc(1) - e := fmt.Errorf("timeout after %v sec", timeout) - // trigger debug functionality on randomBytes - err := trackChunks(randomBytes[:]) - if err != nil { - e = fmt.Errorf("%v; triggerChunkDebug failed: %v", e, err) - } - - return e + err = fmt.Errorf("timeout after %v sec", timeout) } - // trigger debug functionality on randomBytes even on successful runs - err := trackChunks(randomBytes[:]) - if err != nil { - log.Error(err.Error()) + // trigger debug functionality on randomBytes + e := trackChunks(randomBytes[:]) + if e != nil { + log.Error(e.Error()) } - return nil + return err } func trackChunks(testData []byte) error { - log.Warn("Test timed out, running chunk debug sequence") - addrs, err := getAllRefs(testData) if err != nil { return err @@ -94,14 +90,14 @@ func trackChunks(testData []byte) error { rpcClient, err := rpc.Dial(httpHost) if err != nil { - log.Error("Error dialing host", "err", err) + log.Error("error dialing host", "err", err, "host", httpHost) continue } var hasInfo []api.HasInfo err = rpcClient.Call(&hasInfo, "bzz_has", addrs) if err != nil { - log.Error("Error calling host", "err", err) + log.Error("error calling rpc client", "err", err, "host", httpHost) continue } @@ -125,7 +121,6 @@ func trackChunks(testData []byte) error { } func getAllRefs(testData []byte) (storage.AddressCollection, error) { - log.Trace("Getting all references for given root hash") datadir, err := ioutil.TempDir("", "chunk-debug") if err != nil { return nil, fmt.Errorf("unable to create temp dir: %v", err) diff --git a/cmd/utils/flags.go b/cmd/utils/flags.go index e00f92fa75..bf433242ec 100644 --- a/cmd/utils/flags.go +++ b/cmd/utils/flags.go @@ -226,7 +226,7 @@ var ( } // Dashboard settings DashboardEnabledFlag = cli.BoolFlag{ - Name: metrics.DashboardEnabledFlag, + Name: "dashboard", Usage: "Enable the dashboard", } DashboardAddrFlag = cli.StringFlag{ @@ -644,9 +644,13 @@ var ( // Metrics flags MetricsEnabledFlag = cli.BoolFlag{ - Name: metrics.MetricsEnabledFlag, + Name: "metrics", Usage: "Enable metrics collection and reporting", } + MetricsEnabledExpensiveFlag = cli.BoolFlag{ + Name: "metrics.expensive", + Usage: "Enable expensive metrics collection and reporting", + } MetricsEnableInfluxDBFlag = cli.BoolFlag{ Name: "metrics.influxdb", Usage: "Enable metrics export/push to an external InfluxDB database", diff --git a/contracts/ens/README.md b/contracts/ens/README.md index c09b47e39d..f2ea1330c5 100644 --- a/contracts/ens/README.md +++ b/contracts/ens/README.md @@ -18,3 +18,13 @@ The go bindings for ENS contracts are generated using `abigen` via the go genera ```shell go generate ./contracts/ens ``` + +## Fallback contract support + +In order to better support content resolution on different service providers (such as Swarm and IPFS), [EIP-1577](https://eips.ethereum.org/EIPS/eip-1577) +was introduced and with it changes that allow applications to know _where_ content hashes are stored (i.e. if the +requested hash resides on Swarm or IPFS). + +The code under `contracts/ens/contract` reflects the new Public Resolver changes and the code under `fallback_contract` allows +us to support the old contract resolution in cases where the ENS name owner did not update her Resolver contract, until the migration +period ends (date arbitrarily set to June 1st, 2019). diff --git a/contracts/ens/cid.go b/contracts/ens/cid.go new file mode 100644 index 0000000000..fae9bfd0a1 --- /dev/null +++ b/contracts/ens/cid.go @@ -0,0 +1,121 @@ +// Copyright 2016 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 . + +package ens + +import ( + "encoding/binary" + "errors" + "fmt" + + "github.com/ethereum/go-ethereum/common" +) + +const ( + cidv1 = 0x1 + + nsIpfs = 0xe3 + nsSwarm = 0xe4 + + swarmTypecode = 0xfa //swarm manifest, see https://github.com/multiformats/multicodec/blob/master/table.csv + swarmHashtype = 0xd6 // BMT, see https://github.com/multiformats/multicodec/blob/master/table.csv + + hashLength = 32 +) + +// deocodeEIP1577ContentHash decodes a chain-stored content hash from an ENS record according to EIP-1577 +// a successful decode will result the different parts of the content hash in accordance to the CID spec +// Note: only CIDv1 is supported +func decodeEIP1577ContentHash(buf []byte) (storageNs, contentType, hashType, hashLength uint64, hash []byte, err error) { + if len(buf) < 10 { + return 0, 0, 0, 0, nil, errors.New("buffer too short") + } + + storageNs, n := binary.Uvarint(buf) + + buf = buf[n:] + vers, n := binary.Uvarint(buf) + + if vers != 1 { + return 0, 0, 0, 0, nil, fmt.Errorf("expected cid v1, got: %d", vers) + } + buf = buf[n:] + contentType, n = binary.Uvarint(buf) + + buf = buf[n:] + hashType, n = binary.Uvarint(buf) + + buf = buf[n:] + hashLength, n = binary.Uvarint(buf) + + hash = buf[n:] + + if len(hash) != int(hashLength) { + return 0, 0, 0, 0, nil, errors.New("hash length mismatch") + } + return storageNs, contentType, hashType, hashLength, hash, nil +} + +func extractContentHash(buf []byte) (common.Hash, error) { + storageNs, _ /*contentType*/, _ /* hashType*/, decodedHashLength, hashBytes, err := decodeEIP1577ContentHash(buf) + + if err != nil { + return common.Hash{}, err + } + + if storageNs != nsSwarm { + return common.Hash{}, errors.New("unknown storage system") + } + + //todo: for the time being we implement loose enforcement for the EIP rules until ENS manager is updated + /*if contentType != swarmTypecode { + return common.Hash{}, errors.New("unknown content type") + } + + if hashType != swarmHashtype { + return common.Hash{}, errors.New("unknown multihash type") + }*/ + + if decodedHashLength != hashLength { + return common.Hash{}, errors.New("odd hash length, swarm expects 32 bytes") + } + + if len(hashBytes) != int(hashLength) { + return common.Hash{}, errors.New("hash length mismatch") + } + + return common.BytesToHash(buf), nil +} + +func EncodeSwarmHash(hash common.Hash) ([]byte, error) { + var cidBytes []byte + var headerBytes = []byte{ + nsSwarm, //swarm namespace + cidv1, // CIDv1 + swarmTypecode, // swarm hash + swarmHashtype, // swarm bmt hash + hashLength, //hash length. 32 bytes + } + + varintbuf := make([]byte, binary.MaxVarintLen64) + for _, v := range headerBytes { + n := binary.PutUvarint(varintbuf, uint64(v)) + cidBytes = append(cidBytes, varintbuf[:n]...) + } + + cidBytes = append(cidBytes, hash[:]...) + return cidBytes, nil +} diff --git a/contracts/ens/cid_test.go b/contracts/ens/cid_test.go new file mode 100644 index 0000000000..f2f1880846 --- /dev/null +++ b/contracts/ens/cid_test.go @@ -0,0 +1,158 @@ +// Copyright 2016 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 . + +package ens + +import ( + "bytes" + "encoding/binary" + "encoding/hex" + "fmt" + "testing" + + "github.com/ethereum/go-ethereum/common" +) + +// Tests for the decoding of the example ENS +func TestEIPSpecCidDecode(t *testing.T) { + const ( + eipSpecHash = "e3010170122029f2d17be6139079dc48696d1f582a8530eb9805b561eda517e22a892c7e3f1f" + eipHash = "29f2d17be6139079dc48696d1f582a8530eb9805b561eda517e22a892c7e3f1f" + dagPb = 0x70 + sha2256 = 0x12 + ) + b, err := hex.DecodeString(eipSpecHash) + if err != nil { + t.Fatal(err) + } + hashBytes, err := hex.DecodeString(eipHash) + + if err != nil { + t.Fatal(err) + } + + storageNs, contentType, hashType, hashLength, decodedHashBytes, err := decodeEIP1577ContentHash(b) + + if err != nil { + t.Fatal(err) + } + if storageNs != nsIpfs { + t.Fatal("wrong ns") + } + if contentType != dagPb { + t.Fatal("should be ipfs typecode") + } + if hashType != sha2256 { + t.Fatal("should be sha2-256") + } + if hashLength != 32 { + t.Fatal("should be 32") + } + if !bytes.Equal(hashBytes, decodedHashBytes) { + t.Fatal("should be equal") + } + +} +func TestManualCidDecode(t *testing.T) { + // call cid encode method with hash. expect byte slice returned, compare according to spec + + for _, v := range []struct { + name string + headerBytes []byte + wantErr bool + }{ + { + name: "values correct, should not fail", + headerBytes: []byte{0xe4, 0x01, 0xfa, 0xd6, 0x20}, + wantErr: false, + }, + { + name: "cid version wrong, should fail", + headerBytes: []byte{0xe4, 0x00, 0xfa, 0xd6, 0x20}, + wantErr: true, + }, + { + name: "hash length wrong, should fail", + headerBytes: []byte{0xe4, 0x01, 0xfa, 0xd6, 0x1f}, + wantErr: true, + }, + { + name: "values correct for ipfs, should fail", + headerBytes: []byte{0xe3, 0x01, 0x70, 0x12, 0x20}, + wantErr: true, + }, + { + name: "loose values for swarm, todo remove, should not fail", + headerBytes: []byte{0xe4, 0x01, 0x70, 0x12, 0x20}, + wantErr: false, + }, + { + name: "loose values for swarm, todo remove, should not fail", + headerBytes: []byte{0xe4, 0x01, 0x99, 0x99, 0x20}, + wantErr: false, + }, + } { + t.Run(v.name, func(t *testing.T) { + const eipHash = "29f2d17be6139079dc48696d1f582a8530eb9805b561eda517e22a892c7e3f1f" + + var bb []byte + buf := make([]byte, binary.MaxVarintLen64) + for _, vv := range v.headerBytes { + n := binary.PutUvarint(buf, uint64(vv)) + bb = append(bb, buf[:n]...) + } + + h := common.HexToHash(eipHash) + bb = append(bb, h[:]...) + str := hex.EncodeToString(bb) + fmt.Println(str) + decodedHash, e := extractContentHash(bb) + switch v.wantErr { + case true: + if e == nil { + t.Fatal("the decode should fail") + } + case false: + if e != nil { + t.Fatalf("the deccode shouldnt fail: %v", e) + } + if !bytes.Equal(decodedHash[:], h[:]) { + t.Fatal("hashes not equal") + } + } + }) + } +} + +func TestManuelCidEncode(t *testing.T) { + // call cid encode method with hash. expect byte slice returned, compare according to spec + const eipHash = "29f2d17be6139079dc48696d1f582a8530eb9805b561eda517e22a892c7e3f1f" + cidBytes, err := EncodeSwarmHash(common.HexToHash(eipHash)) + if err != nil { + t.Fatal(err) + } + + // logic in extractContentHash is unit tested thoroughly + // hence we just check that the returned hash is equal + h, err := extractContentHash(cidBytes) + if err != nil { + t.Fatal(err) + } + + if bytes.Equal(h[:], cidBytes) { + t.Fatal("should be equal") + } +} diff --git a/contracts/ens/contract/AbstractENS.sol b/contracts/ens/contract/AbstractENS.sol deleted file mode 100644 index b80a1b0e6b..0000000000 --- a/contracts/ens/contract/AbstractENS.sol +++ /dev/null @@ -1,23 +0,0 @@ -pragma solidity ^0.4.0; - -contract AbstractENS { - function owner(bytes32 node) constant returns(address); - function resolver(bytes32 node) constant returns(address); - function ttl(bytes32 node) constant returns(uint64); - function setOwner(bytes32 node, address owner); - function setSubnodeOwner(bytes32 node, bytes32 label, address owner); - function setResolver(bytes32 node, address resolver); - function setTTL(bytes32 node, uint64 ttl); - - // Logged when the owner of a node assigns a new owner to a subnode. - event NewOwner(bytes32 indexed node, bytes32 indexed label, address owner); - - // Logged when the owner of a node transfers ownership to a new account. - event Transfer(bytes32 indexed node, address owner); - - // Logged when the resolver for a node changes. - event NewResolver(bytes32 indexed node, address resolver); - - // Logged when the TTL of a node changes - event NewTTL(bytes32 indexed node, uint64 ttl); -} diff --git a/contracts/ens/contract/ENS.sol b/contracts/ens/contract/ENS.sol index 47050c19da..5ab8c92b41 100644 --- a/contracts/ens/contract/ENS.sol +++ b/contracts/ens/contract/ENS.sol @@ -1,94 +1,26 @@ -pragma solidity ^0.4.0; +pragma solidity >=0.4.24; -import './AbstractENS.sol'; +interface ENS { -/** - * The ENS registry contract. - */ -contract ENS is AbstractENS { - struct Record { - address owner; - address resolver; - uint64 ttl; - } + // Logged when the owner of a node assigns a new owner to a subnode. + event NewOwner(bytes32 indexed node, bytes32 indexed label, address owner); - mapping(bytes32=>Record) records; + // Logged when the owner of a node transfers ownership to a new account. + event Transfer(bytes32 indexed node, address owner); - // Permits modifications only by the owner of the specified node. - modifier only_owner(bytes32 node) { - if (records[node].owner != msg.sender) throw; - _; - } + // Logged when the resolver for a node changes. + event NewResolver(bytes32 indexed node, address resolver); - /** - * Constructs a new ENS registrar. - */ - function ENS() { - records[0].owner = msg.sender; - } + // Logged when the TTL of a node changes + event NewTTL(bytes32 indexed node, uint64 ttl); - /** - * Returns the address that owns the specified node. - */ - function owner(bytes32 node) constant returns (address) { - return records[node].owner; - } - /** - * Returns the address of the resolver for the specified node. - */ - function resolver(bytes32 node) constant returns (address) { - return records[node].resolver; - } + function setSubnodeOwner(bytes32 node, bytes32 label, address owner) external; + function setResolver(bytes32 node, address resolver) external; + function setOwner(bytes32 node, address owner) external; + function setTTL(bytes32 node, uint64 ttl) external; + function owner(bytes32 node) external view returns (address); + function resolver(bytes32 node) external view returns (address); + function ttl(bytes32 node) external view returns (uint64); - /** - * Returns the TTL of a node, and any records associated with it. - */ - function ttl(bytes32 node) constant returns (uint64) { - return records[node].ttl; - } - - /** - * Transfers ownership of a node to a new address. May only be called by the current - * owner of the node. - * @param node The node to transfer ownership of. - * @param owner The address of the new owner. - */ - function setOwner(bytes32 node, address owner) only_owner(node) { - Transfer(node, owner); - records[node].owner = owner; - } - - /** - * Transfers ownership of a subnode sha3(node, label) to a new address. May only be - * called by the owner of the parent node. - * @param node The parent node. - * @param label The hash of the label specifying the subnode. - * @param owner The address of the new owner. - */ - function setSubnodeOwner(bytes32 node, bytes32 label, address owner) only_owner(node) { - var subnode = sha3(node, label); - NewOwner(node, label, owner); - records[subnode].owner = owner; - } - - /** - * Sets the resolver address for the specified node. - * @param node The node to update. - * @param resolver The address of the resolver. - */ - function setResolver(bytes32 node, address resolver) only_owner(node) { - NewResolver(node, resolver); - records[node].resolver = resolver; - } - - /** - * Sets the TTL for the specified node. - * @param node The node to update. - * @param ttl The TTL in seconds. - */ - function setTTL(bytes32 node, uint64 ttl) only_owner(node) { - NewTTL(node, ttl); - records[node].ttl = ttl; - } -} +} \ No newline at end of file diff --git a/contracts/ens/contract/ENSRegistry.sol b/contracts/ens/contract/ENSRegistry.sol new file mode 100644 index 0000000000..fa19131de0 --- /dev/null +++ b/contracts/ens/contract/ENSRegistry.sol @@ -0,0 +1,99 @@ +pragma solidity ^0.5.0; + +import "./ENS.sol"; + +/** + * The ENS registry contract. + */ +contract ENSRegistry is ENS { + struct Record { + address owner; + address resolver; + uint64 ttl; + } + + mapping (bytes32 => Record) records; + + // Permits modifications only by the owner of the specified node. + modifier only_owner(bytes32 node) { + require(records[node].owner == msg.sender); + _; + } + + /** + * @dev Constructs a new ENS registrar. + */ + constructor() public { + records[0x0].owner = msg.sender; + } + + /** + * @dev Transfers ownership of a node to a new address. May only be called by the current owner of the node. + * @param node The node to transfer ownership of. + * @param owner The address of the new owner. + */ + function setOwner(bytes32 node, address owner) external only_owner(node) { + emit Transfer(node, owner); + records[node].owner = owner; + } + + /** + * @dev Transfers ownership of a subnode keccak256(node, label) to a new address. May only be called by the owner of the parent node. + * @param node The parent node. + * @param label The hash of the label specifying the subnode. + * @param owner The address of the new owner. + */ + function setSubnodeOwner(bytes32 node, bytes32 label, address owner) external only_owner(node) { + bytes32 subnode = keccak256(abi.encodePacked(node, label)); + emit NewOwner(node, label, owner); + records[subnode].owner = owner; + } + + /** + * @dev Sets the resolver address for the specified node. + * @param node The node to update. + * @param resolver The address of the resolver. + */ + function setResolver(bytes32 node, address resolver) external only_owner(node) { + emit NewResolver(node, resolver); + records[node].resolver = resolver; + } + + /** + * @dev Sets the TTL for the specified node. + * @param node The node to update. + * @param ttl The TTL in seconds. + */ + function setTTL(bytes32 node, uint64 ttl) external only_owner(node) { + emit NewTTL(node, ttl); + records[node].ttl = ttl; + } + + /** + * @dev Returns the address that owns the specified node. + * @param node The specified node. + * @return address of the owner. + */ + function owner(bytes32 node) external view returns (address) { + return records[node].owner; + } + + /** + * @dev Returns the address of the resolver for the specified node. + * @param node The specified node. + * @return address of the resolver. + */ + function resolver(bytes32 node) external view returns (address) { + return records[node].resolver; + } + + /** + * @dev Returns the TTL of a node, and any records associated with it. + * @param node The specified node. + * @return ttl of the node. + */ + function ttl(bytes32 node) external view returns (uint64) { + return records[node].ttl; + } + +} \ No newline at end of file diff --git a/contracts/ens/contract/FIFSRegistrar.sol b/contracts/ens/contract/FIFSRegistrar.sol index 51629c2b65..19287408f6 100644 --- a/contracts/ens/contract/FIFSRegistrar.sol +++ b/contracts/ens/contract/FIFSRegistrar.sol @@ -1,20 +1,17 @@ -pragma solidity ^0.4.0; +pragma solidity ^0.5.0; -import './AbstractENS.sol'; +import "./ENS.sol"; /** * A registrar that allocates subdomains to the first person to claim them. */ contract FIFSRegistrar { - AbstractENS ens; + ENS ens; bytes32 rootNode; - modifier only_owner(bytes32 subnode) { - var node = sha3(rootNode, subnode); - var currentOwner = ens.owner(node); - - if (currentOwner != 0 && currentOwner != msg.sender) throw; - + modifier only_owner(bytes32 label) { + address currentOwner = ens.owner(keccak256(abi.encodePacked(rootNode, label))); + require(currentOwner == address(0x0) || currentOwner == msg.sender); _; } @@ -23,17 +20,17 @@ contract FIFSRegistrar { * @param ensAddr The address of the ENS registry. * @param node The node that this registrar administers. */ - function FIFSRegistrar(AbstractENS ensAddr, bytes32 node) { + constructor(ENS ensAddr, bytes32 node) public { ens = ensAddr; rootNode = node; } /** * Register a name, or change the owner of an existing registration. - * @param subnode The hash of the label to register. + * @param label The hash of the label to register. * @param owner The address of the new owner. */ - function register(bytes32 subnode, address owner) only_owner(subnode) { - ens.setSubnodeOwner(rootNode, subnode, owner); + function register(bytes32 label, address owner) public only_owner(label) { + ens.setSubnodeOwner(rootNode, label, owner); } -} +} \ No newline at end of file diff --git a/contracts/ens/contract/PublicResolver.sol b/contracts/ens/contract/PublicResolver.sol index 9dcc95689e..cfcd5dd6b3 100644 --- a/contracts/ens/contract/PublicResolver.sol +++ b/contracts/ens/contract/PublicResolver.sol @@ -1,26 +1,27 @@ -pragma solidity ^0.4.0; +pragma solidity >=0.4.25; -import './AbstractENS.sol'; +import "./ENS.sol"; /** * A simple resolver anyone can use; only allows the owner of a node to set its * address. */ contract PublicResolver { + bytes4 constant INTERFACE_META_ID = 0x01ffc9a7; bytes4 constant ADDR_INTERFACE_ID = 0x3b3b57de; - bytes4 constant CONTENT_INTERFACE_ID = 0xd8389dc5; bytes4 constant NAME_INTERFACE_ID = 0x691f3431; bytes4 constant ABI_INTERFACE_ID = 0x2203ab56; bytes4 constant PUBKEY_INTERFACE_ID = 0xc8690233; bytes4 constant TEXT_INTERFACE_ID = 0x59d1d43c; + bytes4 constant CONTENTHASH_INTERFACE_ID = 0xbc1c58d1; event AddrChanged(bytes32 indexed node, address a); - event ContentChanged(bytes32 indexed node, bytes32 hash); event NameChanged(bytes32 indexed node, string name); event ABIChanged(bytes32 indexed node, uint256 indexed contentType); event PubkeyChanged(bytes32 indexed node, bytes32 x, bytes32 y); - event TextChanged(bytes32 indexed node, string indexed indexedKey, string key); + event TextChanged(bytes32 indexed node, string indexedKey, string key); + event ContenthashChanged(bytes32 indexed node, bytes hash); struct PublicKey { bytes32 x; @@ -29,18 +30,19 @@ contract PublicResolver { struct Record { address addr; - bytes32 content; string name; PublicKey pubkey; mapping(string=>string) text; mapping(uint256=>bytes) abis; + bytes contenthash; } - AbstractENS ens; - mapping(bytes32=>Record) records; + ENS ens; - modifier only_owner(bytes32 node) { - if (ens.owner(node) != msg.sender) throw; + mapping (bytes32 => Record) records; + + modifier onlyOwner(bytes32 node) { + require(ens.owner(node) == msg.sender); _; } @@ -48,77 +50,30 @@ contract PublicResolver { * Constructor. * @param ensAddr The ENS registrar contract. */ - function PublicResolver(AbstractENS ensAddr) { + constructor(ENS ensAddr) public { ens = ensAddr; } - /** - * Returns true if the resolver implements the interface specified by the provided hash. - * @param interfaceID The ID of the interface to check for. - * @return True if the contract implements the requested interface. - */ - function supportsInterface(bytes4 interfaceID) constant returns (bool) { - return interfaceID == ADDR_INTERFACE_ID || - interfaceID == CONTENT_INTERFACE_ID || - interfaceID == NAME_INTERFACE_ID || - interfaceID == ABI_INTERFACE_ID || - interfaceID == PUBKEY_INTERFACE_ID || - interfaceID == TEXT_INTERFACE_ID || - interfaceID == INTERFACE_META_ID; - } - - /** - * Returns the address associated with an ENS node. - * @param node The ENS node to query. - * @return The associated address. - */ - function addr(bytes32 node) constant returns (address ret) { - ret = records[node].addr; - } - /** * Sets the address associated with an ENS node. * May only be called by the owner of that node in the ENS registry. * @param node The node to update. * @param addr The address to set. */ - function setAddr(bytes32 node, address addr) only_owner(node) { + function setAddr(bytes32 node, address addr) external onlyOwner(node) { records[node].addr = addr; - AddrChanged(node, addr); + emit AddrChanged(node, addr); } /** - * Returns the content hash associated with an ENS node. - * Note that this resource type is not standardized, and will likely change - * in future to a resource type based on multihash. - * @param node The ENS node to query. - * @return The associated content hash. - */ - function content(bytes32 node) constant returns (bytes32 ret) { - ret = records[node].content; - } - - /** - * Sets the content hash associated with an ENS node. + * Sets the contenthash associated with an ENS node. * May only be called by the owner of that node in the ENS registry. - * Note that this resource type is not standardized, and will likely change - * in future to a resource type based on multihash. * @param node The node to update. - * @param hash The content hash to set + * @param hash The contenthash to set */ - function setContent(bytes32 node, bytes32 hash) only_owner(node) { - records[node].content = hash; - ContentChanged(node, hash); - } - - /** - * Returns the name associated with an ENS node, for reverse records. - * Defined in EIP181. - * @param node The ENS node to query. - * @return The associated name. - */ - function name(bytes32 node) constant returns (string ret) { - ret = records[node].name; + function setContenthash(bytes32 node, bytes calldata hash) external onlyOwner(node) { + records[node].contenthash = hash; + emit ContenthashChanged(node, hash); } /** @@ -127,28 +82,9 @@ contract PublicResolver { * @param node The node to update. * @param name The name to set. */ - function setName(bytes32 node, string name) only_owner(node) { + function setName(bytes32 node, string calldata name) external onlyOwner(node) { records[node].name = name; - NameChanged(node, name); - } - - /** - * Returns the ABI associated with an ENS node. - * Defined in EIP205. - * @param node The ENS node to query - * @param contentTypes A bitwise OR of the ABI formats accepted by the caller. - * @return contentType The content type of the return value - * @return data The ABI data - */ - function ABI(bytes32 node, uint256 contentTypes) constant returns (uint256 contentType, bytes data) { - var record = records[node]; - for(contentType = 1; contentType <= contentTypes; contentType <<= 1) { - if ((contentType & contentTypes) != 0 && record.abis[contentType].length > 0) { - data = record.abis[contentType]; - return; - } - } - contentType = 0; + emit NameChanged(node, name); } /** @@ -159,22 +95,12 @@ contract PublicResolver { * @param contentType The content type of the ABI * @param data The ABI data. */ - function setABI(bytes32 node, uint256 contentType, bytes data) only_owner(node) { + function setABI(bytes32 node, uint256 contentType, bytes calldata data) external onlyOwner(node) { // Content types must be powers of 2 - if (((contentType - 1) & contentType) != 0) throw; + require(((contentType - 1) & contentType) == 0); records[node].abis[contentType] = data; - ABIChanged(node, contentType); - } - - /** - * Returns the SECP256k1 public key associated with an ENS node. - * Defined in EIP 619. - * @param node The ENS node to query - * @return x, y the X and Y coordinates of the curve point for the public key. - */ - function pubkey(bytes32 node) constant returns (bytes32 x, bytes32 y) { - return (records[node].pubkey.x, records[node].pubkey.y); + emit ABIChanged(node, contentType); } /** @@ -183,19 +109,9 @@ contract PublicResolver { * @param x the X coordinate of the curve point for the public key. * @param y the Y coordinate of the curve point for the public key. */ - function setPubkey(bytes32 node, bytes32 x, bytes32 y) only_owner(node) { + function setPubkey(bytes32 node, bytes32 x, bytes32 y) external onlyOwner(node) { records[node].pubkey = PublicKey(x, y); - PubkeyChanged(node, x, y); - } - - /** - * Returns the text data associated with an ENS node and key. - * @param node The ENS node to query. - * @param key The text data key to query. - * @return The associated text data. - */ - function text(bytes32 node, string key) constant returns (string ret) { - ret = records[node].text[key]; + emit PubkeyChanged(node, x, y); } /** @@ -205,8 +121,92 @@ contract PublicResolver { * @param key The key to set. * @param value The text data value to set. */ - function setText(bytes32 node, string key, string value) only_owner(node) { + function setText(bytes32 node, string calldata key, string calldata value) external onlyOwner(node) { records[node].text[key] = value; - TextChanged(node, key, key); + emit TextChanged(node, key, key); + } + + /** + * Returns the text data associated with an ENS node and key. + * @param node The ENS node to query. + * @param key The text data key to query. + * @return The associated text data. + */ + function text(bytes32 node, string calldata key) external view returns (string memory) { + return records[node].text[key]; + } + + /** + * Returns the SECP256k1 public key associated with an ENS node. + * Defined in EIP 619. + * @param node The ENS node to query + * @return x, y the X and Y coordinates of the curve point for the public key. + */ + function pubkey(bytes32 node) external view returns (bytes32 x, bytes32 y) { + return (records[node].pubkey.x, records[node].pubkey.y); + } + + /** + * Returns the ABI associated with an ENS node. + * Defined in EIP205. + * @param node The ENS node to query + * @param contentTypes A bitwise OR of the ABI formats accepted by the caller. + * @return contentType The content type of the return value + * @return data The ABI data + */ + function ABI(bytes32 node, uint256 contentTypes) external view returns (uint256, bytes memory) { + Record storage record = records[node]; + + for (uint256 contentType = 1; contentType <= contentTypes; contentType <<= 1) { + if ((contentType & contentTypes) != 0 && record.abis[contentType].length > 0) { + return (contentType, record.abis[contentType]); + } + } + + bytes memory empty; + return (0, empty); + } + + /** + * Returns the name associated with an ENS node, for reverse records. + * Defined in EIP181. + * @param node The ENS node to query. + * @return The associated name. + */ + function name(bytes32 node) external view returns (string memory) { + return records[node].name; + } + + /** + * Returns the address associated with an ENS node. + * @param node The ENS node to query. + * @return The associated address. + */ + function addr(bytes32 node) external view returns (address) { + return records[node].addr; + } + + /** + * Returns the contenthash associated with an ENS node. + * @param node The ENS node to query. + * @return The associated contenthash. + */ + function contenthash(bytes32 node) external view returns (bytes memory) { + return records[node].contenthash; + } + + /** + * Returns true if the resolver implements the interface specified by the provided hash. + * @param interfaceID The ID of the interface to check for. + * @return True if the contract implements the requested interface. + */ + function supportsInterface(bytes4 interfaceID) external pure returns (bool) { + return interfaceID == ADDR_INTERFACE_ID || + interfaceID == NAME_INTERFACE_ID || + interfaceID == ABI_INTERFACE_ID || + interfaceID == PUBKEY_INTERFACE_ID || + interfaceID == TEXT_INTERFACE_ID || + interfaceID == CONTENTHASH_INTERFACE_ID || + interfaceID == INTERFACE_META_ID; } } diff --git a/contracts/ens/contract/ens.go b/contracts/ens/contract/ens.go index 8827071afc..7c0aed342e 100644 --- a/contracts/ens/contract/ens.go +++ b/contracts/ens/contract/ens.go @@ -4,6 +4,7 @@ package contract import ( + "math/big" "strings" ethereum "github.com/ethereum/go-ethereum" @@ -14,11 +15,23 @@ import ( "github.com/ethereum/go-ethereum/event" ) +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = abi.U256 + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription +) + // ENSABI is the input ABI used to generate the binding from. -const ENSABI = "[{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"}],\"name\":\"resolver\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"}],\"name\":\"owner\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"label\",\"type\":\"bytes32\"},{\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"setSubnodeOwner\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"ttl\",\"type\":\"uint64\"}],\"name\":\"setTTL\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"}],\"name\":\"ttl\",\"outputs\":[{\"name\":\"\",\"type\":\"uint64\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"resolver\",\"type\":\"address\"}],\"name\":\"setResolver\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"setOwner\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":true,\"name\":\"label\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"NewOwner\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"resolver\",\"type\":\"address\"}],\"name\":\"NewResolver\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"ttl\",\"type\":\"uint64\"}],\"name\":\"NewTTL\",\"type\":\"event\"}]" +const ENSABI = "[{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"}],\"name\":\"resolver\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"}],\"name\":\"owner\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"label\",\"type\":\"bytes32\"},{\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"setSubnodeOwner\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"ttl\",\"type\":\"uint64\"}],\"name\":\"setTTL\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"}],\"name\":\"ttl\",\"outputs\":[{\"name\":\"\",\"type\":\"uint64\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"resolver\",\"type\":\"address\"}],\"name\":\"setResolver\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"setOwner\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":true,\"name\":\"label\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"NewOwner\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"resolver\",\"type\":\"address\"}],\"name\":\"NewResolver\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"ttl\",\"type\":\"uint64\"}],\"name\":\"NewTTL\",\"type\":\"event\"}]" // ENSBin is the compiled bytecode used for deploying new contracts. -const ENSBin = `0x6060604052341561000f57600080fd5b60008080526020527fad3228b676f7d3cd4284a5443f17f1962b36e491b30a40b2405849e597ba5fb58054600160a060020a033316600160a060020a0319909116179055610503806100626000396000f3006060604052600436106100825763ffffffff7c01000000000000000000000000000000000000000000000000000000006000350416630178b8bf811461008757806302571be3146100b957806306ab5923146100cf57806314ab9038146100f657806316a25cbd146101195780631896f70a1461014c5780635b0fc9c31461016e575b600080fd5b341561009257600080fd5b61009d600435610190565b604051600160a060020a03909116815260200160405180910390f35b34156100c457600080fd5b61009d6004356101ae565b34156100da57600080fd5b6100f4600435602435600160a060020a03604435166101c9565b005b341561010157600080fd5b6100f460043567ffffffffffffffff6024351661028b565b341561012457600080fd5b61012f600435610357565b60405167ffffffffffffffff909116815260200160405180910390f35b341561015757600080fd5b6100f4600435600160a060020a036024351661038e565b341561017957600080fd5b6100f4600435600160a060020a0360243516610434565b600090815260208190526040902060010154600160a060020a031690565b600090815260208190526040902054600160a060020a031690565b600083815260208190526040812054849033600160a060020a039081169116146101f257600080fd5b8484604051918252602082015260409081019051908190039020915083857fce0457fe73731f824cc272376169235128c118b49d344817417c6d108d155e8285604051600160a060020a03909116815260200160405180910390a3506000908152602081905260409020805473ffffffffffffffffffffffffffffffffffffffff1916600160a060020a03929092169190911790555050565b600082815260208190526040902054829033600160a060020a039081169116146102b457600080fd5b827f1d4f9bbfc9cab89d66e1a1562f2233ccbf1308cb4f63de2ead5787adddb8fa688360405167ffffffffffffffff909116815260200160405180910390a250600091825260208290526040909120600101805467ffffffffffffffff90921674010000000000000000000000000000000000000000027fffffffff0000000000000000ffffffffffffffffffffffffffffffffffffffff909216919091179055565b60009081526020819052604090206001015474010000000000000000000000000000000000000000900467ffffffffffffffff1690565b600082815260208190526040902054829033600160a060020a039081169116146103b757600080fd5b827f335721b01866dc23fbee8b6b2c7b1e14d6f05c28cd35a2c934239f94095602a083604051600160a060020a03909116815260200160405180910390a250600091825260208290526040909120600101805473ffffffffffffffffffffffffffffffffffffffff1916600160a060020a03909216919091179055565b600082815260208190526040902054829033600160a060020a0390811691161461045d57600080fd5b827fd4735d920b0f87494915f556dd9b54c8f309026070caea5c737245152564d26683604051600160a060020a03909116815260200160405180910390a250600091825260208290526040909120805473ffffffffffffffffffffffffffffffffffffffff1916600160a060020a039092169190911790555600a165627a7a72305820f4c798d4c84c9912f389f64631e85e8d16c3e6644f8c2e1579936015c7d5f6660029` +const ENSBin = `0x` // DeployENS deploys a new Ethereum contract, binding an instance of ENS to it. func DeployENS(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *ENS, error) { @@ -177,7 +190,7 @@ func (_ENS *ENSTransactorRaw) Transact(opts *bind.TransactOpts, method string, p // Owner is a free data retrieval call binding the contract method 0x02571be3. // -// Solidity: function owner(node bytes32) constant returns(address) +// Solidity: function owner(bytes32 node) constant returns(address) func (_ENS *ENSCaller) Owner(opts *bind.CallOpts, node [32]byte) (common.Address, error) { var ( ret0 = new(common.Address) @@ -189,21 +202,21 @@ func (_ENS *ENSCaller) Owner(opts *bind.CallOpts, node [32]byte) (common.Address // Owner is a free data retrieval call binding the contract method 0x02571be3. // -// Solidity: function owner(node bytes32) constant returns(address) +// Solidity: function owner(bytes32 node) constant returns(address) func (_ENS *ENSSession) Owner(node [32]byte) (common.Address, error) { return _ENS.Contract.Owner(&_ENS.CallOpts, node) } // Owner is a free data retrieval call binding the contract method 0x02571be3. // -// Solidity: function owner(node bytes32) constant returns(address) +// Solidity: function owner(bytes32 node) constant returns(address) func (_ENS *ENSCallerSession) Owner(node [32]byte) (common.Address, error) { return _ENS.Contract.Owner(&_ENS.CallOpts, node) } // Resolver is a free data retrieval call binding the contract method 0x0178b8bf. // -// Solidity: function resolver(node bytes32) constant returns(address) +// Solidity: function resolver(bytes32 node) constant returns(address) func (_ENS *ENSCaller) Resolver(opts *bind.CallOpts, node [32]byte) (common.Address, error) { var ( ret0 = new(common.Address) @@ -215,22 +228,22 @@ func (_ENS *ENSCaller) Resolver(opts *bind.CallOpts, node [32]byte) (common.Addr // Resolver is a free data retrieval call binding the contract method 0x0178b8bf. // -// Solidity: function resolver(node bytes32) constant returns(address) +// Solidity: function resolver(bytes32 node) constant returns(address) func (_ENS *ENSSession) Resolver(node [32]byte) (common.Address, error) { return _ENS.Contract.Resolver(&_ENS.CallOpts, node) } // Resolver is a free data retrieval call binding the contract method 0x0178b8bf. // -// Solidity: function resolver(node bytes32) constant returns(address) +// Solidity: function resolver(bytes32 node) constant returns(address) func (_ENS *ENSCallerSession) Resolver(node [32]byte) (common.Address, error) { return _ENS.Contract.Resolver(&_ENS.CallOpts, node) } -// TTL is a free data retrieval call binding the contract method 0x16a25cbd. +// Ttl is a free data retrieval call binding the contract method 0x16a25cbd. // -// Solidity: function ttl(node bytes32) constant returns(uint64) -func (_ENS *ENSCaller) TTL(opts *bind.CallOpts, node [32]byte) (uint64, error) { +// Solidity: function ttl(bytes32 node) constant returns(uint64) +func (_ENS *ENSCaller) Ttl(opts *bind.CallOpts, node [32]byte) (uint64, error) { var ( ret0 = new(uint64) ) @@ -239,100 +252,100 @@ func (_ENS *ENSCaller) TTL(opts *bind.CallOpts, node [32]byte) (uint64, error) { return *ret0, err } -// TTL is a free data retrieval call binding the contract method 0x16a25cbd. +// Ttl is a free data retrieval call binding the contract method 0x16a25cbd. // -// Solidity: function ttl(node bytes32) constant returns(uint64) -func (_ENS *ENSSession) TTL(node [32]byte) (uint64, error) { - return _ENS.Contract.TTL(&_ENS.CallOpts, node) +// Solidity: function ttl(bytes32 node) constant returns(uint64) +func (_ENS *ENSSession) Ttl(node [32]byte) (uint64, error) { + return _ENS.Contract.Ttl(&_ENS.CallOpts, node) } -// TTL is a free data retrieval call binding the contract method 0x16a25cbd. +// Ttl is a free data retrieval call binding the contract method 0x16a25cbd. // -// Solidity: function ttl(node bytes32) constant returns(uint64) -func (_ENS *ENSCallerSession) TTL(node [32]byte) (uint64, error) { - return _ENS.Contract.TTL(&_ENS.CallOpts, node) +// Solidity: function ttl(bytes32 node) constant returns(uint64) +func (_ENS *ENSCallerSession) Ttl(node [32]byte) (uint64, error) { + return _ENS.Contract.Ttl(&_ENS.CallOpts, node) } // SetOwner is a paid mutator transaction binding the contract method 0x5b0fc9c3. // -// Solidity: function setOwner(node bytes32, owner address) returns() +// Solidity: function setOwner(bytes32 node, address owner) returns() func (_ENS *ENSTransactor) SetOwner(opts *bind.TransactOpts, node [32]byte, owner common.Address) (*types.Transaction, error) { return _ENS.contract.Transact(opts, "setOwner", node, owner) } // SetOwner is a paid mutator transaction binding the contract method 0x5b0fc9c3. // -// Solidity: function setOwner(node bytes32, owner address) returns() +// Solidity: function setOwner(bytes32 node, address owner) returns() func (_ENS *ENSSession) SetOwner(node [32]byte, owner common.Address) (*types.Transaction, error) { return _ENS.Contract.SetOwner(&_ENS.TransactOpts, node, owner) } // SetOwner is a paid mutator transaction binding the contract method 0x5b0fc9c3. // -// Solidity: function setOwner(node bytes32, owner address) returns() +// Solidity: function setOwner(bytes32 node, address owner) returns() func (_ENS *ENSTransactorSession) SetOwner(node [32]byte, owner common.Address) (*types.Transaction, error) { return _ENS.Contract.SetOwner(&_ENS.TransactOpts, node, owner) } // SetResolver is a paid mutator transaction binding the contract method 0x1896f70a. // -// Solidity: function setResolver(node bytes32, resolver address) returns() +// Solidity: function setResolver(bytes32 node, address resolver) returns() func (_ENS *ENSTransactor) SetResolver(opts *bind.TransactOpts, node [32]byte, resolver common.Address) (*types.Transaction, error) { return _ENS.contract.Transact(opts, "setResolver", node, resolver) } // SetResolver is a paid mutator transaction binding the contract method 0x1896f70a. // -// Solidity: function setResolver(node bytes32, resolver address) returns() +// Solidity: function setResolver(bytes32 node, address resolver) returns() func (_ENS *ENSSession) SetResolver(node [32]byte, resolver common.Address) (*types.Transaction, error) { return _ENS.Contract.SetResolver(&_ENS.TransactOpts, node, resolver) } // SetResolver is a paid mutator transaction binding the contract method 0x1896f70a. // -// Solidity: function setResolver(node bytes32, resolver address) returns() +// Solidity: function setResolver(bytes32 node, address resolver) returns() func (_ENS *ENSTransactorSession) SetResolver(node [32]byte, resolver common.Address) (*types.Transaction, error) { return _ENS.Contract.SetResolver(&_ENS.TransactOpts, node, resolver) } // SetSubnodeOwner is a paid mutator transaction binding the contract method 0x06ab5923. // -// Solidity: function setSubnodeOwner(node bytes32, label bytes32, owner address) returns() +// Solidity: function setSubnodeOwner(bytes32 node, bytes32 label, address owner) returns() func (_ENS *ENSTransactor) SetSubnodeOwner(opts *bind.TransactOpts, node [32]byte, label [32]byte, owner common.Address) (*types.Transaction, error) { return _ENS.contract.Transact(opts, "setSubnodeOwner", node, label, owner) } // SetSubnodeOwner is a paid mutator transaction binding the contract method 0x06ab5923. // -// Solidity: function setSubnodeOwner(node bytes32, label bytes32, owner address) returns() +// Solidity: function setSubnodeOwner(bytes32 node, bytes32 label, address owner) returns() func (_ENS *ENSSession) SetSubnodeOwner(node [32]byte, label [32]byte, owner common.Address) (*types.Transaction, error) { return _ENS.Contract.SetSubnodeOwner(&_ENS.TransactOpts, node, label, owner) } // SetSubnodeOwner is a paid mutator transaction binding the contract method 0x06ab5923. // -// Solidity: function setSubnodeOwner(node bytes32, label bytes32, owner address) returns() +// Solidity: function setSubnodeOwner(bytes32 node, bytes32 label, address owner) returns() func (_ENS *ENSTransactorSession) SetSubnodeOwner(node [32]byte, label [32]byte, owner common.Address) (*types.Transaction, error) { return _ENS.Contract.SetSubnodeOwner(&_ENS.TransactOpts, node, label, owner) } // SetTTL is a paid mutator transaction binding the contract method 0x14ab9038. // -// Solidity: function setTTL(node bytes32, ttl uint64) returns() +// Solidity: function setTTL(bytes32 node, uint64 ttl) returns() func (_ENS *ENSTransactor) SetTTL(opts *bind.TransactOpts, node [32]byte, ttl uint64) (*types.Transaction, error) { return _ENS.contract.Transact(opts, "setTTL", node, ttl) } // SetTTL is a paid mutator transaction binding the contract method 0x14ab9038. // -// Solidity: function setTTL(node bytes32, ttl uint64) returns() +// Solidity: function setTTL(bytes32 node, uint64 ttl) returns() func (_ENS *ENSSession) SetTTL(node [32]byte, ttl uint64) (*types.Transaction, error) { return _ENS.Contract.SetTTL(&_ENS.TransactOpts, node, ttl) } // SetTTL is a paid mutator transaction binding the contract method 0x14ab9038. // -// Solidity: function setTTL(node bytes32, ttl uint64) returns() +// Solidity: function setTTL(bytes32 node, uint64 ttl) returns() func (_ENS *ENSTransactorSession) SetTTL(node [32]byte, ttl uint64) (*types.Transaction, error) { return _ENS.Contract.SetTTL(&_ENS.TransactOpts, node, ttl) } @@ -392,7 +405,7 @@ func (it *ENSNewOwnerIterator) Next() bool { } } -// Error retruned any retrieval or parsing error occurred during filtering. +// Error returns any retrieval or parsing error occurred during filtering. func (it *ENSNewOwnerIterator) Error() error { return it.fail } @@ -414,7 +427,7 @@ type ENSNewOwner struct { // FilterNewOwner is a free log retrieval operation binding the contract event 0xce0457fe73731f824cc272376169235128c118b49d344817417c6d108d155e82. // -// Solidity: event NewOwner(node indexed bytes32, label indexed bytes32, owner address) +// Solidity: event NewOwner(bytes32 indexed node, bytes32 indexed label, address owner) func (_ENS *ENSFilterer) FilterNewOwner(opts *bind.FilterOpts, node [][32]byte, label [][32]byte) (*ENSNewOwnerIterator, error) { var nodeRule []interface{} @@ -435,7 +448,7 @@ func (_ENS *ENSFilterer) FilterNewOwner(opts *bind.FilterOpts, node [][32]byte, // WatchNewOwner is a free log subscription operation binding the contract event 0xce0457fe73731f824cc272376169235128c118b49d344817417c6d108d155e82. // -// Solidity: event NewOwner(node indexed bytes32, label indexed bytes32, owner address) +// Solidity: event NewOwner(bytes32 indexed node, bytes32 indexed label, address owner) func (_ENS *ENSFilterer) WatchNewOwner(opts *bind.WatchOpts, sink chan<- *ENSNewOwner, node [][32]byte, label [][32]byte) (event.Subscription, error) { var nodeRule []interface{} @@ -534,7 +547,7 @@ func (it *ENSNewResolverIterator) Next() bool { } } -// Error retruned any retrieval or parsing error occurred during filtering. +// Error returns any retrieval or parsing error occurred during filtering. func (it *ENSNewResolverIterator) Error() error { return it.fail } @@ -555,7 +568,7 @@ type ENSNewResolver struct { // FilterNewResolver is a free log retrieval operation binding the contract event 0x335721b01866dc23fbee8b6b2c7b1e14d6f05c28cd35a2c934239f94095602a0. // -// Solidity: event NewResolver(node indexed bytes32, resolver address) +// Solidity: event NewResolver(bytes32 indexed node, address resolver) func (_ENS *ENSFilterer) FilterNewResolver(opts *bind.FilterOpts, node [][32]byte) (*ENSNewResolverIterator, error) { var nodeRule []interface{} @@ -572,7 +585,7 @@ func (_ENS *ENSFilterer) FilterNewResolver(opts *bind.FilterOpts, node [][32]byt // WatchNewResolver is a free log subscription operation binding the contract event 0x335721b01866dc23fbee8b6b2c7b1e14d6f05c28cd35a2c934239f94095602a0. // -// Solidity: event NewResolver(node indexed bytes32, resolver address) +// Solidity: event NewResolver(bytes32 indexed node, address resolver) func (_ENS *ENSFilterer) WatchNewResolver(opts *bind.WatchOpts, sink chan<- *ENSNewResolver, node [][32]byte) (event.Subscription, error) { var nodeRule []interface{} @@ -667,7 +680,7 @@ func (it *ENSNewTTLIterator) Next() bool { } } -// Error retruned any retrieval or parsing error occurred during filtering. +// Error returns any retrieval or parsing error occurred during filtering. func (it *ENSNewTTLIterator) Error() error { return it.fail } @@ -682,13 +695,13 @@ func (it *ENSNewTTLIterator) Close() error { // ENSNewTTL represents a NewTTL event raised by the ENS contract. type ENSNewTTL struct { Node [32]byte - TTL uint64 + Ttl uint64 Raw types.Log // Blockchain specific contextual infos } // FilterNewTTL is a free log retrieval operation binding the contract event 0x1d4f9bbfc9cab89d66e1a1562f2233ccbf1308cb4f63de2ead5787adddb8fa68. // -// Solidity: event NewTTL(node indexed bytes32, ttl uint64) +// Solidity: event NewTTL(bytes32 indexed node, uint64 ttl) func (_ENS *ENSFilterer) FilterNewTTL(opts *bind.FilterOpts, node [][32]byte) (*ENSNewTTLIterator, error) { var nodeRule []interface{} @@ -705,7 +718,7 @@ func (_ENS *ENSFilterer) FilterNewTTL(opts *bind.FilterOpts, node [][32]byte) (* // WatchNewTTL is a free log subscription operation binding the contract event 0x1d4f9bbfc9cab89d66e1a1562f2233ccbf1308cb4f63de2ead5787adddb8fa68. // -// Solidity: event NewTTL(node indexed bytes32, ttl uint64) +// Solidity: event NewTTL(bytes32 indexed node, uint64 ttl) func (_ENS *ENSFilterer) WatchNewTTL(opts *bind.WatchOpts, sink chan<- *ENSNewTTL, node [][32]byte) (event.Subscription, error) { var nodeRule []interface{} @@ -800,7 +813,7 @@ func (it *ENSTransferIterator) Next() bool { } } -// Error retruned any retrieval or parsing error occurred during filtering. +// Error returns any retrieval or parsing error occurred during filtering. func (it *ENSTransferIterator) Error() error { return it.fail } @@ -821,7 +834,7 @@ type ENSTransfer struct { // FilterTransfer is a free log retrieval operation binding the contract event 0xd4735d920b0f87494915f556dd9b54c8f309026070caea5c737245152564d266. // -// Solidity: event Transfer(node indexed bytes32, owner address) +// Solidity: event Transfer(bytes32 indexed node, address owner) func (_ENS *ENSFilterer) FilterTransfer(opts *bind.FilterOpts, node [][32]byte) (*ENSTransferIterator, error) { var nodeRule []interface{} @@ -838,7 +851,7 @@ func (_ENS *ENSFilterer) FilterTransfer(opts *bind.FilterOpts, node [][32]byte) // WatchTransfer is a free log subscription operation binding the contract event 0xd4735d920b0f87494915f556dd9b54c8f309026070caea5c737245152564d266. // -// Solidity: event Transfer(node indexed bytes32, owner address) +// Solidity: event Transfer(bytes32 indexed node, address owner) func (_ENS *ENSFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ENSTransfer, node [][32]byte) (event.Subscription, error) { var nodeRule []interface{} diff --git a/contracts/ens/contract/ensregistry.go b/contracts/ens/contract/ensregistry.go new file mode 100644 index 0000000000..ca89a87bc2 --- /dev/null +++ b/contracts/ens/contract/ensregistry.go @@ -0,0 +1,892 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package contract + +import ( + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = abi.U256 + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription +) + +// ENSRegistryABI is the input ABI used to generate the binding from. +const ENSRegistryABI = "[{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"}],\"name\":\"resolver\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"}],\"name\":\"owner\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"label\",\"type\":\"bytes32\"},{\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"setSubnodeOwner\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"ttl\",\"type\":\"uint64\"}],\"name\":\"setTTL\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"}],\"name\":\"ttl\",\"outputs\":[{\"name\":\"\",\"type\":\"uint64\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"resolver\",\"type\":\"address\"}],\"name\":\"setResolver\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"setOwner\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":true,\"name\":\"label\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"NewOwner\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"resolver\",\"type\":\"address\"}],\"name\":\"NewResolver\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"ttl\",\"type\":\"uint64\"}],\"name\":\"NewTTL\",\"type\":\"event\"}]" + +// ENSRegistryBin is the compiled bytecode used for deploying new contracts. +const ENSRegistryBin = `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` + +// DeployENSRegistry deploys a new Ethereum contract, binding an instance of ENSRegistry to it. +func DeployENSRegistry(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *ENSRegistry, error) { + parsed, err := abi.JSON(strings.NewReader(ENSRegistryABI)) + if err != nil { + return common.Address{}, nil, nil, err + } + address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(ENSRegistryBin), backend) + if err != nil { + return common.Address{}, nil, nil, err + } + return address, tx, &ENSRegistry{ENSRegistryCaller: ENSRegistryCaller{contract: contract}, ENSRegistryTransactor: ENSRegistryTransactor{contract: contract}, ENSRegistryFilterer: ENSRegistryFilterer{contract: contract}}, nil +} + +// ENSRegistry is an auto generated Go binding around an Ethereum contract. +type ENSRegistry struct { + ENSRegistryCaller // Read-only binding to the contract + ENSRegistryTransactor // Write-only binding to the contract + ENSRegistryFilterer // Log filterer for contract events +} + +// ENSRegistryCaller is an auto generated read-only Go binding around an Ethereum contract. +type ENSRegistryCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ENSRegistryTransactor is an auto generated write-only Go binding around an Ethereum contract. +type ENSRegistryTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ENSRegistryFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type ENSRegistryFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ENSRegistrySession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type ENSRegistrySession struct { + Contract *ENSRegistry // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// ENSRegistryCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type ENSRegistryCallerSession struct { + Contract *ENSRegistryCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// ENSRegistryTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type ENSRegistryTransactorSession struct { + Contract *ENSRegistryTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// ENSRegistryRaw is an auto generated low-level Go binding around an Ethereum contract. +type ENSRegistryRaw struct { + Contract *ENSRegistry // Generic contract binding to access the raw methods on +} + +// ENSRegistryCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type ENSRegistryCallerRaw struct { + Contract *ENSRegistryCaller // Generic read-only contract binding to access the raw methods on +} + +// ENSRegistryTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type ENSRegistryTransactorRaw struct { + Contract *ENSRegistryTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewENSRegistry creates a new instance of ENSRegistry, bound to a specific deployed contract. +func NewENSRegistry(address common.Address, backend bind.ContractBackend) (*ENSRegistry, error) { + contract, err := bindENSRegistry(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &ENSRegistry{ENSRegistryCaller: ENSRegistryCaller{contract: contract}, ENSRegistryTransactor: ENSRegistryTransactor{contract: contract}, ENSRegistryFilterer: ENSRegistryFilterer{contract: contract}}, nil +} + +// NewENSRegistryCaller creates a new read-only instance of ENSRegistry, bound to a specific deployed contract. +func NewENSRegistryCaller(address common.Address, caller bind.ContractCaller) (*ENSRegistryCaller, error) { + contract, err := bindENSRegistry(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &ENSRegistryCaller{contract: contract}, nil +} + +// NewENSRegistryTransactor creates a new write-only instance of ENSRegistry, bound to a specific deployed contract. +func NewENSRegistryTransactor(address common.Address, transactor bind.ContractTransactor) (*ENSRegistryTransactor, error) { + contract, err := bindENSRegistry(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &ENSRegistryTransactor{contract: contract}, nil +} + +// NewENSRegistryFilterer creates a new log filterer instance of ENSRegistry, bound to a specific deployed contract. +func NewENSRegistryFilterer(address common.Address, filterer bind.ContractFilterer) (*ENSRegistryFilterer, error) { + contract, err := bindENSRegistry(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &ENSRegistryFilterer{contract: contract}, nil +} + +// bindENSRegistry binds a generic wrapper to an already deployed contract. +func bindENSRegistry(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := abi.JSON(strings.NewReader(ENSRegistryABI)) + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_ENSRegistry *ENSRegistryRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { + return _ENSRegistry.Contract.ENSRegistryCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_ENSRegistry *ENSRegistryRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _ENSRegistry.Contract.ENSRegistryTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_ENSRegistry *ENSRegistryRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _ENSRegistry.Contract.ENSRegistryTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_ENSRegistry *ENSRegistryCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { + return _ENSRegistry.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_ENSRegistry *ENSRegistryTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _ENSRegistry.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_ENSRegistry *ENSRegistryTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _ENSRegistry.Contract.contract.Transact(opts, method, params...) +} + +// Owner is a free data retrieval call binding the contract method 0x02571be3. +// +// Solidity: function owner(bytes32 node) constant returns(address) +func (_ENSRegistry *ENSRegistryCaller) Owner(opts *bind.CallOpts, node [32]byte) (common.Address, error) { + var ( + ret0 = new(common.Address) + ) + out := ret0 + err := _ENSRegistry.contract.Call(opts, out, "owner", node) + return *ret0, err +} + +// Owner is a free data retrieval call binding the contract method 0x02571be3. +// +// Solidity: function owner(bytes32 node) constant returns(address) +func (_ENSRegistry *ENSRegistrySession) Owner(node [32]byte) (common.Address, error) { + return _ENSRegistry.Contract.Owner(&_ENSRegistry.CallOpts, node) +} + +// Owner is a free data retrieval call binding the contract method 0x02571be3. +// +// Solidity: function owner(bytes32 node) constant returns(address) +func (_ENSRegistry *ENSRegistryCallerSession) Owner(node [32]byte) (common.Address, error) { + return _ENSRegistry.Contract.Owner(&_ENSRegistry.CallOpts, node) +} + +// Resolver is a free data retrieval call binding the contract method 0x0178b8bf. +// +// Solidity: function resolver(bytes32 node) constant returns(address) +func (_ENSRegistry *ENSRegistryCaller) Resolver(opts *bind.CallOpts, node [32]byte) (common.Address, error) { + var ( + ret0 = new(common.Address) + ) + out := ret0 + err := _ENSRegistry.contract.Call(opts, out, "resolver", node) + return *ret0, err +} + +// Resolver is a free data retrieval call binding the contract method 0x0178b8bf. +// +// Solidity: function resolver(bytes32 node) constant returns(address) +func (_ENSRegistry *ENSRegistrySession) Resolver(node [32]byte) (common.Address, error) { + return _ENSRegistry.Contract.Resolver(&_ENSRegistry.CallOpts, node) +} + +// Resolver is a free data retrieval call binding the contract method 0x0178b8bf. +// +// Solidity: function resolver(bytes32 node) constant returns(address) +func (_ENSRegistry *ENSRegistryCallerSession) Resolver(node [32]byte) (common.Address, error) { + return _ENSRegistry.Contract.Resolver(&_ENSRegistry.CallOpts, node) +} + +// Ttl is a free data retrieval call binding the contract method 0x16a25cbd. +// +// Solidity: function ttl(bytes32 node) constant returns(uint64) +func (_ENSRegistry *ENSRegistryCaller) Ttl(opts *bind.CallOpts, node [32]byte) (uint64, error) { + var ( + ret0 = new(uint64) + ) + out := ret0 + err := _ENSRegistry.contract.Call(opts, out, "ttl", node) + return *ret0, err +} + +// Ttl is a free data retrieval call binding the contract method 0x16a25cbd. +// +// Solidity: function ttl(bytes32 node) constant returns(uint64) +func (_ENSRegistry *ENSRegistrySession) Ttl(node [32]byte) (uint64, error) { + return _ENSRegistry.Contract.Ttl(&_ENSRegistry.CallOpts, node) +} + +// Ttl is a free data retrieval call binding the contract method 0x16a25cbd. +// +// Solidity: function ttl(bytes32 node) constant returns(uint64) +func (_ENSRegistry *ENSRegistryCallerSession) Ttl(node [32]byte) (uint64, error) { + return _ENSRegistry.Contract.Ttl(&_ENSRegistry.CallOpts, node) +} + +// SetOwner is a paid mutator transaction binding the contract method 0x5b0fc9c3. +// +// Solidity: function setOwner(bytes32 node, address owner) returns() +func (_ENSRegistry *ENSRegistryTransactor) SetOwner(opts *bind.TransactOpts, node [32]byte, owner common.Address) (*types.Transaction, error) { + return _ENSRegistry.contract.Transact(opts, "setOwner", node, owner) +} + +// SetOwner is a paid mutator transaction binding the contract method 0x5b0fc9c3. +// +// Solidity: function setOwner(bytes32 node, address owner) returns() +func (_ENSRegistry *ENSRegistrySession) SetOwner(node [32]byte, owner common.Address) (*types.Transaction, error) { + return _ENSRegistry.Contract.SetOwner(&_ENSRegistry.TransactOpts, node, owner) +} + +// SetOwner is a paid mutator transaction binding the contract method 0x5b0fc9c3. +// +// Solidity: function setOwner(bytes32 node, address owner) returns() +func (_ENSRegistry *ENSRegistryTransactorSession) SetOwner(node [32]byte, owner common.Address) (*types.Transaction, error) { + return _ENSRegistry.Contract.SetOwner(&_ENSRegistry.TransactOpts, node, owner) +} + +// SetResolver is a paid mutator transaction binding the contract method 0x1896f70a. +// +// Solidity: function setResolver(bytes32 node, address resolver) returns() +func (_ENSRegistry *ENSRegistryTransactor) SetResolver(opts *bind.TransactOpts, node [32]byte, resolver common.Address) (*types.Transaction, error) { + return _ENSRegistry.contract.Transact(opts, "setResolver", node, resolver) +} + +// SetResolver is a paid mutator transaction binding the contract method 0x1896f70a. +// +// Solidity: function setResolver(bytes32 node, address resolver) returns() +func (_ENSRegistry *ENSRegistrySession) SetResolver(node [32]byte, resolver common.Address) (*types.Transaction, error) { + return _ENSRegistry.Contract.SetResolver(&_ENSRegistry.TransactOpts, node, resolver) +} + +// SetResolver is a paid mutator transaction binding the contract method 0x1896f70a. +// +// Solidity: function setResolver(bytes32 node, address resolver) returns() +func (_ENSRegistry *ENSRegistryTransactorSession) SetResolver(node [32]byte, resolver common.Address) (*types.Transaction, error) { + return _ENSRegistry.Contract.SetResolver(&_ENSRegistry.TransactOpts, node, resolver) +} + +// SetSubnodeOwner is a paid mutator transaction binding the contract method 0x06ab5923. +// +// Solidity: function setSubnodeOwner(bytes32 node, bytes32 label, address owner) returns() +func (_ENSRegistry *ENSRegistryTransactor) SetSubnodeOwner(opts *bind.TransactOpts, node [32]byte, label [32]byte, owner common.Address) (*types.Transaction, error) { + return _ENSRegistry.contract.Transact(opts, "setSubnodeOwner", node, label, owner) +} + +// SetSubnodeOwner is a paid mutator transaction binding the contract method 0x06ab5923. +// +// Solidity: function setSubnodeOwner(bytes32 node, bytes32 label, address owner) returns() +func (_ENSRegistry *ENSRegistrySession) SetSubnodeOwner(node [32]byte, label [32]byte, owner common.Address) (*types.Transaction, error) { + return _ENSRegistry.Contract.SetSubnodeOwner(&_ENSRegistry.TransactOpts, node, label, owner) +} + +// SetSubnodeOwner is a paid mutator transaction binding the contract method 0x06ab5923. +// +// Solidity: function setSubnodeOwner(bytes32 node, bytes32 label, address owner) returns() +func (_ENSRegistry *ENSRegistryTransactorSession) SetSubnodeOwner(node [32]byte, label [32]byte, owner common.Address) (*types.Transaction, error) { + return _ENSRegistry.Contract.SetSubnodeOwner(&_ENSRegistry.TransactOpts, node, label, owner) +} + +// SetTTL is a paid mutator transaction binding the contract method 0x14ab9038. +// +// Solidity: function setTTL(bytes32 node, uint64 ttl) returns() +func (_ENSRegistry *ENSRegistryTransactor) SetTTL(opts *bind.TransactOpts, node [32]byte, ttl uint64) (*types.Transaction, error) { + return _ENSRegistry.contract.Transact(opts, "setTTL", node, ttl) +} + +// SetTTL is a paid mutator transaction binding the contract method 0x14ab9038. +// +// Solidity: function setTTL(bytes32 node, uint64 ttl) returns() +func (_ENSRegistry *ENSRegistrySession) SetTTL(node [32]byte, ttl uint64) (*types.Transaction, error) { + return _ENSRegistry.Contract.SetTTL(&_ENSRegistry.TransactOpts, node, ttl) +} + +// SetTTL is a paid mutator transaction binding the contract method 0x14ab9038. +// +// Solidity: function setTTL(bytes32 node, uint64 ttl) returns() +func (_ENSRegistry *ENSRegistryTransactorSession) SetTTL(node [32]byte, ttl uint64) (*types.Transaction, error) { + return _ENSRegistry.Contract.SetTTL(&_ENSRegistry.TransactOpts, node, ttl) +} + +// ENSRegistryNewOwnerIterator is returned from FilterNewOwner and is used to iterate over the raw logs and unpacked data for NewOwner events raised by the ENSRegistry contract. +type ENSRegistryNewOwnerIterator struct { + Event *ENSRegistryNewOwner // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ENSRegistryNewOwnerIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ENSRegistryNewOwner) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ENSRegistryNewOwner) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ENSRegistryNewOwnerIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ENSRegistryNewOwnerIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ENSRegistryNewOwner represents a NewOwner event raised by the ENSRegistry contract. +type ENSRegistryNewOwner struct { + Node [32]byte + Label [32]byte + Owner common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterNewOwner is a free log retrieval operation binding the contract event 0xce0457fe73731f824cc272376169235128c118b49d344817417c6d108d155e82. +// +// Solidity: event NewOwner(bytes32 indexed node, bytes32 indexed label, address owner) +func (_ENSRegistry *ENSRegistryFilterer) FilterNewOwner(opts *bind.FilterOpts, node [][32]byte, label [][32]byte) (*ENSRegistryNewOwnerIterator, error) { + + var nodeRule []interface{} + for _, nodeItem := range node { + nodeRule = append(nodeRule, nodeItem) + } + var labelRule []interface{} + for _, labelItem := range label { + labelRule = append(labelRule, labelItem) + } + + logs, sub, err := _ENSRegistry.contract.FilterLogs(opts, "NewOwner", nodeRule, labelRule) + if err != nil { + return nil, err + } + return &ENSRegistryNewOwnerIterator{contract: _ENSRegistry.contract, event: "NewOwner", logs: logs, sub: sub}, nil +} + +// WatchNewOwner is a free log subscription operation binding the contract event 0xce0457fe73731f824cc272376169235128c118b49d344817417c6d108d155e82. +// +// Solidity: event NewOwner(bytes32 indexed node, bytes32 indexed label, address owner) +func (_ENSRegistry *ENSRegistryFilterer) WatchNewOwner(opts *bind.WatchOpts, sink chan<- *ENSRegistryNewOwner, node [][32]byte, label [][32]byte) (event.Subscription, error) { + + var nodeRule []interface{} + for _, nodeItem := range node { + nodeRule = append(nodeRule, nodeItem) + } + var labelRule []interface{} + for _, labelItem := range label { + labelRule = append(labelRule, labelItem) + } + + logs, sub, err := _ENSRegistry.contract.WatchLogs(opts, "NewOwner", nodeRule, labelRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ENSRegistryNewOwner) + if err := _ENSRegistry.contract.UnpackLog(event, "NewOwner", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ENSRegistryNewResolverIterator is returned from FilterNewResolver and is used to iterate over the raw logs and unpacked data for NewResolver events raised by the ENSRegistry contract. +type ENSRegistryNewResolverIterator struct { + Event *ENSRegistryNewResolver // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ENSRegistryNewResolverIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ENSRegistryNewResolver) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ENSRegistryNewResolver) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ENSRegistryNewResolverIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ENSRegistryNewResolverIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ENSRegistryNewResolver represents a NewResolver event raised by the ENSRegistry contract. +type ENSRegistryNewResolver struct { + Node [32]byte + Resolver common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterNewResolver is a free log retrieval operation binding the contract event 0x335721b01866dc23fbee8b6b2c7b1e14d6f05c28cd35a2c934239f94095602a0. +// +// Solidity: event NewResolver(bytes32 indexed node, address resolver) +func (_ENSRegistry *ENSRegistryFilterer) FilterNewResolver(opts *bind.FilterOpts, node [][32]byte) (*ENSRegistryNewResolverIterator, error) { + + var nodeRule []interface{} + for _, nodeItem := range node { + nodeRule = append(nodeRule, nodeItem) + } + + logs, sub, err := _ENSRegistry.contract.FilterLogs(opts, "NewResolver", nodeRule) + if err != nil { + return nil, err + } + return &ENSRegistryNewResolverIterator{contract: _ENSRegistry.contract, event: "NewResolver", logs: logs, sub: sub}, nil +} + +// WatchNewResolver is a free log subscription operation binding the contract event 0x335721b01866dc23fbee8b6b2c7b1e14d6f05c28cd35a2c934239f94095602a0. +// +// Solidity: event NewResolver(bytes32 indexed node, address resolver) +func (_ENSRegistry *ENSRegistryFilterer) WatchNewResolver(opts *bind.WatchOpts, sink chan<- *ENSRegistryNewResolver, node [][32]byte) (event.Subscription, error) { + + var nodeRule []interface{} + for _, nodeItem := range node { + nodeRule = append(nodeRule, nodeItem) + } + + logs, sub, err := _ENSRegistry.contract.WatchLogs(opts, "NewResolver", nodeRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ENSRegistryNewResolver) + if err := _ENSRegistry.contract.UnpackLog(event, "NewResolver", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ENSRegistryNewTTLIterator is returned from FilterNewTTL and is used to iterate over the raw logs and unpacked data for NewTTL events raised by the ENSRegistry contract. +type ENSRegistryNewTTLIterator struct { + Event *ENSRegistryNewTTL // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ENSRegistryNewTTLIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ENSRegistryNewTTL) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ENSRegistryNewTTL) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ENSRegistryNewTTLIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ENSRegistryNewTTLIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ENSRegistryNewTTL represents a NewTTL event raised by the ENSRegistry contract. +type ENSRegistryNewTTL struct { + Node [32]byte + Ttl uint64 + Raw types.Log // Blockchain specific contextual infos +} + +// FilterNewTTL is a free log retrieval operation binding the contract event 0x1d4f9bbfc9cab89d66e1a1562f2233ccbf1308cb4f63de2ead5787adddb8fa68. +// +// Solidity: event NewTTL(bytes32 indexed node, uint64 ttl) +func (_ENSRegistry *ENSRegistryFilterer) FilterNewTTL(opts *bind.FilterOpts, node [][32]byte) (*ENSRegistryNewTTLIterator, error) { + + var nodeRule []interface{} + for _, nodeItem := range node { + nodeRule = append(nodeRule, nodeItem) + } + + logs, sub, err := _ENSRegistry.contract.FilterLogs(opts, "NewTTL", nodeRule) + if err != nil { + return nil, err + } + return &ENSRegistryNewTTLIterator{contract: _ENSRegistry.contract, event: "NewTTL", logs: logs, sub: sub}, nil +} + +// WatchNewTTL is a free log subscription operation binding the contract event 0x1d4f9bbfc9cab89d66e1a1562f2233ccbf1308cb4f63de2ead5787adddb8fa68. +// +// Solidity: event NewTTL(bytes32 indexed node, uint64 ttl) +func (_ENSRegistry *ENSRegistryFilterer) WatchNewTTL(opts *bind.WatchOpts, sink chan<- *ENSRegistryNewTTL, node [][32]byte) (event.Subscription, error) { + + var nodeRule []interface{} + for _, nodeItem := range node { + nodeRule = append(nodeRule, nodeItem) + } + + logs, sub, err := _ENSRegistry.contract.WatchLogs(opts, "NewTTL", nodeRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ENSRegistryNewTTL) + if err := _ENSRegistry.contract.UnpackLog(event, "NewTTL", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ENSRegistryTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the ENSRegistry contract. +type ENSRegistryTransferIterator struct { + Event *ENSRegistryTransfer // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ENSRegistryTransferIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ENSRegistryTransfer) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ENSRegistryTransfer) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ENSRegistryTransferIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ENSRegistryTransferIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ENSRegistryTransfer represents a Transfer event raised by the ENSRegistry contract. +type ENSRegistryTransfer struct { + Node [32]byte + Owner common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterTransfer is a free log retrieval operation binding the contract event 0xd4735d920b0f87494915f556dd9b54c8f309026070caea5c737245152564d266. +// +// Solidity: event Transfer(bytes32 indexed node, address owner) +func (_ENSRegistry *ENSRegistryFilterer) FilterTransfer(opts *bind.FilterOpts, node [][32]byte) (*ENSRegistryTransferIterator, error) { + + var nodeRule []interface{} + for _, nodeItem := range node { + nodeRule = append(nodeRule, nodeItem) + } + + logs, sub, err := _ENSRegistry.contract.FilterLogs(opts, "Transfer", nodeRule) + if err != nil { + return nil, err + } + return &ENSRegistryTransferIterator{contract: _ENSRegistry.contract, event: "Transfer", logs: logs, sub: sub}, nil +} + +// WatchTransfer is a free log subscription operation binding the contract event 0xd4735d920b0f87494915f556dd9b54c8f309026070caea5c737245152564d266. +// +// Solidity: event Transfer(bytes32 indexed node, address owner) +func (_ENSRegistry *ENSRegistryFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ENSRegistryTransfer, node [][32]byte) (event.Subscription, error) { + + var nodeRule []interface{} + for _, nodeItem := range node { + nodeRule = append(nodeRule, nodeItem) + } + + logs, sub, err := _ENSRegistry.contract.WatchLogs(opts, "Transfer", nodeRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ENSRegistryTransfer) + if err := _ENSRegistry.contract.UnpackLog(event, "Transfer", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} diff --git a/contracts/ens/contract/fifsregistrar.go b/contracts/ens/contract/fifsregistrar.go index a08380adfc..97263cbefa 100644 --- a/contracts/ens/contract/fifsregistrar.go +++ b/contracts/ens/contract/fifsregistrar.go @@ -4,19 +4,34 @@ package contract import ( + "math/big" "strings" + ethereum "github.com/ethereum/go-ethereum" "github.com/ethereum/go-ethereum/accounts/abi" "github.com/ethereum/go-ethereum/accounts/abi/bind" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = abi.U256 + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription ) // FIFSRegistrarABI is the input ABI used to generate the binding from. -const FIFSRegistrarABI = "[{\"constant\":false,\"inputs\":[{\"name\":\"subnode\",\"type\":\"bytes32\"},{\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"register\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"name\":\"ensAddr\",\"type\":\"address\"},{\"name\":\"node\",\"type\":\"bytes32\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"}]" +const FIFSRegistrarABI = "[{\"constant\":false,\"inputs\":[{\"name\":\"label\",\"type\":\"bytes32\"},{\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"register\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"name\":\"ensAddr\",\"type\":\"address\"},{\"name\":\"node\",\"type\":\"bytes32\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"}]" // FIFSRegistrarBin is the compiled bytecode used for deploying new contracts. -const FIFSRegistrarBin = `0x6060604052341561000f57600080fd5b604051604080610224833981016040528080519190602001805160008054600160a060020a03909516600160a060020a03199095169490941790935550506001556101c58061005f6000396000f3006060604052600436106100275763ffffffff60e060020a600035041663d22057a9811461002c575b600080fd5b341561003757600080fd5b61004e600435600160a060020a0360243516610050565b005b816000806001548360405191825260208201526040908101905190819003902060008054919350600160a060020a03909116906302571be39084906040516020015260405160e060020a63ffffffff84160281526004810191909152602401602060405180830381600087803b15156100c857600080fd5b6102c65a03f115156100d957600080fd5b5050506040518051915050600160a060020a0381161580159061010e575033600160a060020a031681600160a060020a031614155b1561011857600080fd5b600054600154600160a060020a03909116906306ab592390878760405160e060020a63ffffffff861602815260048101939093526024830191909152600160a060020a03166044820152606401600060405180830381600087803b151561017e57600080fd5b6102c65a03f1151561018f57600080fd5b50505050505050505600a165627a7a723058206fb963cb168d5e3a51af12cd6bb23e324dbd32dd4954f43653ba27e66b68ea650029` +const FIFSRegistrarBin = `0x608060405234801561001057600080fd5b506040516040806102cc8339810180604052604081101561003057600080fd5b50805160209091015160008054600160a060020a031916600160a060020a0390931692909217825560015561026190819061006b90396000f3fe6080604052600436106100405763ffffffff7c0100000000000000000000000000000000000000000000000000000000600035041663d22057a98114610045575b600080fd5b34801561005157600080fd5b5061008b6004803603604081101561006857600080fd5b508035906020013573ffffffffffffffffffffffffffffffffffffffff1661008d565b005b6000805460015460408051602080820193909352808201879052815180820383018152606082018084528151918501919091207f02571be3000000000000000000000000000000000000000000000000000000009091526064820152905186949373ffffffffffffffffffffffffffffffffffffffff16926302571be39260848082019391829003018186803b15801561012657600080fd5b505afa15801561013a573d6000803e3d6000fd5b505050506040513d602081101561015057600080fd5b5051905073ffffffffffffffffffffffffffffffffffffffff8116158061018c575073ffffffffffffffffffffffffffffffffffffffff811633145b151561019757600080fd5b60008054600154604080517f06ab592300000000000000000000000000000000000000000000000000000000815260048101929092526024820188905273ffffffffffffffffffffffffffffffffffffffff878116604484015290519216926306ab59239260648084019382900301818387803b15801561021757600080fd5b505af115801561022b573d6000803e3d6000fd5b505050505050505056fea165627a7a723058200f21424d48c6fc6f2bc79f5b36b3a0e3067a97d4ce084ab0e0f9106303a3ee520029` // DeployFIFSRegistrar deploys a new Ethereum contract, binding an instance of FIFSRegistrar to it. func DeployFIFSRegistrar(auth *bind.TransactOpts, backend bind.ContractBackend, ensAddr common.Address, node [32]byte) (common.Address, *types.Transaction, *FIFSRegistrar, error) { @@ -175,21 +190,21 @@ func (_FIFSRegistrar *FIFSRegistrarTransactorRaw) Transact(opts *bind.TransactOp // Register is a paid mutator transaction binding the contract method 0xd22057a9. // -// Solidity: function register(subnode bytes32, owner address) returns() -func (_FIFSRegistrar *FIFSRegistrarTransactor) Register(opts *bind.TransactOpts, subnode [32]byte, owner common.Address) (*types.Transaction, error) { - return _FIFSRegistrar.contract.Transact(opts, "register", subnode, owner) +// Solidity: function register(bytes32 label, address owner) returns() +func (_FIFSRegistrar *FIFSRegistrarTransactor) Register(opts *bind.TransactOpts, label [32]byte, owner common.Address) (*types.Transaction, error) { + return _FIFSRegistrar.contract.Transact(opts, "register", label, owner) } // Register is a paid mutator transaction binding the contract method 0xd22057a9. // -// Solidity: function register(subnode bytes32, owner address) returns() -func (_FIFSRegistrar *FIFSRegistrarSession) Register(subnode [32]byte, owner common.Address) (*types.Transaction, error) { - return _FIFSRegistrar.Contract.Register(&_FIFSRegistrar.TransactOpts, subnode, owner) +// Solidity: function register(bytes32 label, address owner) returns() +func (_FIFSRegistrar *FIFSRegistrarSession) Register(label [32]byte, owner common.Address) (*types.Transaction, error) { + return _FIFSRegistrar.Contract.Register(&_FIFSRegistrar.TransactOpts, label, owner) } // Register is a paid mutator transaction binding the contract method 0xd22057a9. // -// Solidity: function register(subnode bytes32, owner address) returns() -func (_FIFSRegistrar *FIFSRegistrarTransactorSession) Register(subnode [32]byte, owner common.Address) (*types.Transaction, error) { - return _FIFSRegistrar.Contract.Register(&_FIFSRegistrar.TransactOpts, subnode, owner) +// Solidity: function register(bytes32 label, address owner) returns() +func (_FIFSRegistrar *FIFSRegistrarTransactorSession) Register(label [32]byte, owner common.Address) (*types.Transaction, error) { + return _FIFSRegistrar.Contract.Register(&_FIFSRegistrar.TransactOpts, label, owner) } diff --git a/contracts/ens/contract/publicresolver.go b/contracts/ens/contract/publicresolver.go index c567d5884a..01bfce5e15 100644 --- a/contracts/ens/contract/publicresolver.go +++ b/contracts/ens/contract/publicresolver.go @@ -15,11 +15,23 @@ import ( "github.com/ethereum/go-ethereum/event" ) +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = abi.U256 + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription +) + // PublicResolverABI is the input ABI used to generate the binding from. -const PublicResolverABI = "[{\"constant\":true,\"inputs\":[{\"name\":\"interfaceID\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"key\",\"type\":\"string\"},{\"name\":\"value\",\"type\":\"string\"}],\"name\":\"setText\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"contentTypes\",\"type\":\"uint256\"}],\"name\":\"ABI\",\"outputs\":[{\"name\":\"contentType\",\"type\":\"uint256\"},{\"name\":\"data\",\"type\":\"bytes\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"x\",\"type\":\"bytes32\"},{\"name\":\"y\",\"type\":\"bytes32\"}],\"name\":\"setPubkey\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"}],\"name\":\"content\",\"outputs\":[{\"name\":\"ret\",\"type\":\"bytes32\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"}],\"name\":\"addr\",\"outputs\":[{\"name\":\"ret\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"key\",\"type\":\"string\"}],\"name\":\"text\",\"outputs\":[{\"name\":\"ret\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"contentType\",\"type\":\"uint256\"},{\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"setABI\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"}],\"name\":\"name\",\"outputs\":[{\"name\":\"ret\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"name\",\"type\":\"string\"}],\"name\":\"setName\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"hash\",\"type\":\"bytes32\"}],\"name\":\"setContent\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"}],\"name\":\"pubkey\",\"outputs\":[{\"name\":\"x\",\"type\":\"bytes32\"},{\"name\":\"y\",\"type\":\"bytes32\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"addr\",\"type\":\"address\"}],\"name\":\"setAddr\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"name\":\"ensAddr\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"a\",\"type\":\"address\"}],\"name\":\"AddrChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"hash\",\"type\":\"bytes32\"}],\"name\":\"ContentChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"name\",\"type\":\"string\"}],\"name\":\"NameChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":true,\"name\":\"contentType\",\"type\":\"uint256\"}],\"name\":\"ABIChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"x\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"y\",\"type\":\"bytes32\"}],\"name\":\"PubkeyChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":true,\"name\":\"indexedKey\",\"type\":\"string\"},{\"indexed\":false,\"name\":\"key\",\"type\":\"string\"}],\"name\":\"TextChanged\",\"type\":\"event\"}]" +const PublicResolverABI = "[{\"constant\":true,\"inputs\":[{\"name\":\"interfaceID\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"pure\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"key\",\"type\":\"string\"},{\"name\":\"value\",\"type\":\"string\"}],\"name\":\"setText\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"contentTypes\",\"type\":\"uint256\"}],\"name\":\"ABI\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"},{\"name\":\"\",\"type\":\"bytes\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"x\",\"type\":\"bytes32\"},{\"name\":\"y\",\"type\":\"bytes32\"}],\"name\":\"setPubkey\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"hash\",\"type\":\"bytes\"}],\"name\":\"setContenthash\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"}],\"name\":\"addr\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"key\",\"type\":\"string\"}],\"name\":\"text\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"contentType\",\"type\":\"uint256\"},{\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"setABI\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"}],\"name\":\"name\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"name\",\"type\":\"string\"}],\"name\":\"setName\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"}],\"name\":\"contenthash\",\"outputs\":[{\"name\":\"\",\"type\":\"bytes\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"}],\"name\":\"pubkey\",\"outputs\":[{\"name\":\"x\",\"type\":\"bytes32\"},{\"name\":\"y\",\"type\":\"bytes32\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"addr\",\"type\":\"address\"}],\"name\":\"setAddr\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"name\":\"ensAddr\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"a\",\"type\":\"address\"}],\"name\":\"AddrChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"name\",\"type\":\"string\"}],\"name\":\"NameChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":true,\"name\":\"contentType\",\"type\":\"uint256\"}],\"name\":\"ABIChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"x\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"y\",\"type\":\"bytes32\"}],\"name\":\"PubkeyChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"indexedKey\",\"type\":\"string\"},{\"indexed\":false,\"name\":\"key\",\"type\":\"string\"}],\"name\":\"TextChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"hash\",\"type\":\"bytes\"}],\"name\":\"ContenthashChanged\",\"type\":\"event\"}]" // PublicResolverBin is the compiled bytecode used for deploying new contracts. -const PublicResolverBin = `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` +const PublicResolverBin = `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` // DeployPublicResolver deploys a new Ethereum contract, binding an instance of PublicResolver to it. func DeployPublicResolver(auth *bind.TransactOpts, backend bind.ContractBackend, ensAddr common.Address) (common.Address, *types.Transaction, *PublicResolver, error) { @@ -178,43 +190,37 @@ func (_PublicResolver *PublicResolverTransactorRaw) Transact(opts *bind.Transact // ABI is a free data retrieval call binding the contract method 0x2203ab56. // -// Solidity: function ABI(node bytes32, contentTypes uint256) constant returns(contentType uint256, data bytes) -func (_PublicResolver *PublicResolverCaller) ABI(opts *bind.CallOpts, node [32]byte, contentTypes *big.Int) (struct { - ContentType *big.Int - Data []byte -}, error) { - ret := new(struct { - ContentType *big.Int - Data []byte - }) - out := ret +// Solidity: function ABI(bytes32 node, uint256 contentTypes) constant returns(uint256, bytes) +func (_PublicResolver *PublicResolverCaller) ABI(opts *bind.CallOpts, node [32]byte, contentTypes *big.Int) (*big.Int, []byte, error) { + var ( + ret0 = new(*big.Int) + ret1 = new([]byte) + ) + out := &[]interface{}{ + ret0, + ret1, + } err := _PublicResolver.contract.Call(opts, out, "ABI", node, contentTypes) - return *ret, err + return *ret0, *ret1, err } // ABI is a free data retrieval call binding the contract method 0x2203ab56. // -// Solidity: function ABI(node bytes32, contentTypes uint256) constant returns(contentType uint256, data bytes) -func (_PublicResolver *PublicResolverSession) ABI(node [32]byte, contentTypes *big.Int) (struct { - ContentType *big.Int - Data []byte -}, error) { +// Solidity: function ABI(bytes32 node, uint256 contentTypes) constant returns(uint256, bytes) +func (_PublicResolver *PublicResolverSession) ABI(node [32]byte, contentTypes *big.Int) (*big.Int, []byte, error) { return _PublicResolver.Contract.ABI(&_PublicResolver.CallOpts, node, contentTypes) } // ABI is a free data retrieval call binding the contract method 0x2203ab56. // -// Solidity: function ABI(node bytes32, contentTypes uint256) constant returns(contentType uint256, data bytes) -func (_PublicResolver *PublicResolverCallerSession) ABI(node [32]byte, contentTypes *big.Int) (struct { - ContentType *big.Int - Data []byte -}, error) { +// Solidity: function ABI(bytes32 node, uint256 contentTypes) constant returns(uint256, bytes) +func (_PublicResolver *PublicResolverCallerSession) ABI(node [32]byte, contentTypes *big.Int) (*big.Int, []byte, error) { return _PublicResolver.Contract.ABI(&_PublicResolver.CallOpts, node, contentTypes) } // Addr is a free data retrieval call binding the contract method 0x3b3b57de. // -// Solidity: function addr(node bytes32) constant returns(ret address) +// Solidity: function addr(bytes32 node) constant returns(address) func (_PublicResolver *PublicResolverCaller) Addr(opts *bind.CallOpts, node [32]byte) (common.Address, error) { var ( ret0 = new(common.Address) @@ -226,47 +232,47 @@ func (_PublicResolver *PublicResolverCaller) Addr(opts *bind.CallOpts, node [32] // Addr is a free data retrieval call binding the contract method 0x3b3b57de. // -// Solidity: function addr(node bytes32) constant returns(ret address) +// Solidity: function addr(bytes32 node) constant returns(address) func (_PublicResolver *PublicResolverSession) Addr(node [32]byte) (common.Address, error) { return _PublicResolver.Contract.Addr(&_PublicResolver.CallOpts, node) } // Addr is a free data retrieval call binding the contract method 0x3b3b57de. // -// Solidity: function addr(node bytes32) constant returns(ret address) +// Solidity: function addr(bytes32 node) constant returns(address) func (_PublicResolver *PublicResolverCallerSession) Addr(node [32]byte) (common.Address, error) { return _PublicResolver.Contract.Addr(&_PublicResolver.CallOpts, node) } -// Content is a free data retrieval call binding the contract method 0x2dff6941. +// Contenthash is a free data retrieval call binding the contract method 0xbc1c58d1. // -// Solidity: function content(node bytes32) constant returns(ret bytes32) -func (_PublicResolver *PublicResolverCaller) Content(opts *bind.CallOpts, node [32]byte) ([32]byte, error) { +// Solidity: function contenthash(bytes32 node) constant returns(bytes) +func (_PublicResolver *PublicResolverCaller) Contenthash(opts *bind.CallOpts, node [32]byte) ([]byte, error) { var ( - ret0 = new([32]byte) + ret0 = new([]byte) ) out := ret0 - err := _PublicResolver.contract.Call(opts, out, "content", node) + err := _PublicResolver.contract.Call(opts, out, "contenthash", node) return *ret0, err } -// Content is a free data retrieval call binding the contract method 0x2dff6941. +// Contenthash is a free data retrieval call binding the contract method 0xbc1c58d1. // -// Solidity: function content(node bytes32) constant returns(ret bytes32) -func (_PublicResolver *PublicResolverSession) Content(node [32]byte) ([32]byte, error) { - return _PublicResolver.Contract.Content(&_PublicResolver.CallOpts, node) +// Solidity: function contenthash(bytes32 node) constant returns(bytes) +func (_PublicResolver *PublicResolverSession) Contenthash(node [32]byte) ([]byte, error) { + return _PublicResolver.Contract.Contenthash(&_PublicResolver.CallOpts, node) } -// Content is a free data retrieval call binding the contract method 0x2dff6941. +// Contenthash is a free data retrieval call binding the contract method 0xbc1c58d1. // -// Solidity: function content(node bytes32) constant returns(ret bytes32) -func (_PublicResolver *PublicResolverCallerSession) Content(node [32]byte) ([32]byte, error) { - return _PublicResolver.Contract.Content(&_PublicResolver.CallOpts, node) +// Solidity: function contenthash(bytes32 node) constant returns(bytes) +func (_PublicResolver *PublicResolverCallerSession) Contenthash(node [32]byte) ([]byte, error) { + return _PublicResolver.Contract.Contenthash(&_PublicResolver.CallOpts, node) } // Name is a free data retrieval call binding the contract method 0x691f3431. // -// Solidity: function name(node bytes32) constant returns(ret string) +// Solidity: function name(bytes32 node) constant returns(string) func (_PublicResolver *PublicResolverCaller) Name(opts *bind.CallOpts, node [32]byte) (string, error) { var ( ret0 = new(string) @@ -278,21 +284,21 @@ func (_PublicResolver *PublicResolverCaller) Name(opts *bind.CallOpts, node [32] // Name is a free data retrieval call binding the contract method 0x691f3431. // -// Solidity: function name(node bytes32) constant returns(ret string) +// Solidity: function name(bytes32 node) constant returns(string) func (_PublicResolver *PublicResolverSession) Name(node [32]byte) (string, error) { return _PublicResolver.Contract.Name(&_PublicResolver.CallOpts, node) } // Name is a free data retrieval call binding the contract method 0x691f3431. // -// Solidity: function name(node bytes32) constant returns(ret string) +// Solidity: function name(bytes32 node) constant returns(string) func (_PublicResolver *PublicResolverCallerSession) Name(node [32]byte) (string, error) { return _PublicResolver.Contract.Name(&_PublicResolver.CallOpts, node) } // Pubkey is a free data retrieval call binding the contract method 0xc8690233. // -// Solidity: function pubkey(node bytes32) constant returns(x bytes32, y bytes32) +// Solidity: function pubkey(bytes32 node) constant returns(bytes32 x, bytes32 y) func (_PublicResolver *PublicResolverCaller) Pubkey(opts *bind.CallOpts, node [32]byte) (struct { X [32]byte Y [32]byte @@ -308,7 +314,7 @@ func (_PublicResolver *PublicResolverCaller) Pubkey(opts *bind.CallOpts, node [3 // Pubkey is a free data retrieval call binding the contract method 0xc8690233. // -// Solidity: function pubkey(node bytes32) constant returns(x bytes32, y bytes32) +// Solidity: function pubkey(bytes32 node) constant returns(bytes32 x, bytes32 y) func (_PublicResolver *PublicResolverSession) Pubkey(node [32]byte) (struct { X [32]byte Y [32]byte @@ -318,7 +324,7 @@ func (_PublicResolver *PublicResolverSession) Pubkey(node [32]byte) (struct { // Pubkey is a free data retrieval call binding the contract method 0xc8690233. // -// Solidity: function pubkey(node bytes32) constant returns(x bytes32, y bytes32) +// Solidity: function pubkey(bytes32 node) constant returns(bytes32 x, bytes32 y) func (_PublicResolver *PublicResolverCallerSession) Pubkey(node [32]byte) (struct { X [32]byte Y [32]byte @@ -328,7 +334,7 @@ func (_PublicResolver *PublicResolverCallerSession) Pubkey(node [32]byte) (struc // SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7. // -// Solidity: function supportsInterface(interfaceID bytes4) constant returns(bool) +// Solidity: function supportsInterface(bytes4 interfaceID) constant returns(bool) func (_PublicResolver *PublicResolverCaller) SupportsInterface(opts *bind.CallOpts, interfaceID [4]byte) (bool, error) { var ( ret0 = new(bool) @@ -340,21 +346,21 @@ func (_PublicResolver *PublicResolverCaller) SupportsInterface(opts *bind.CallOp // SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7. // -// Solidity: function supportsInterface(interfaceID bytes4) constant returns(bool) +// Solidity: function supportsInterface(bytes4 interfaceID) constant returns(bool) func (_PublicResolver *PublicResolverSession) SupportsInterface(interfaceID [4]byte) (bool, error) { return _PublicResolver.Contract.SupportsInterface(&_PublicResolver.CallOpts, interfaceID) } // SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7. // -// Solidity: function supportsInterface(interfaceID bytes4) constant returns(bool) +// Solidity: function supportsInterface(bytes4 interfaceID) constant returns(bool) func (_PublicResolver *PublicResolverCallerSession) SupportsInterface(interfaceID [4]byte) (bool, error) { return _PublicResolver.Contract.SupportsInterface(&_PublicResolver.CallOpts, interfaceID) } // Text is a free data retrieval call binding the contract method 0x59d1d43c. // -// Solidity: function text(node bytes32, key string) constant returns(ret string) +// Solidity: function text(bytes32 node, string key) constant returns(string) func (_PublicResolver *PublicResolverCaller) Text(opts *bind.CallOpts, node [32]byte, key string) (string, error) { var ( ret0 = new(string) @@ -366,140 +372,140 @@ func (_PublicResolver *PublicResolverCaller) Text(opts *bind.CallOpts, node [32] // Text is a free data retrieval call binding the contract method 0x59d1d43c. // -// Solidity: function text(node bytes32, key string) constant returns(ret string) +// Solidity: function text(bytes32 node, string key) constant returns(string) func (_PublicResolver *PublicResolverSession) Text(node [32]byte, key string) (string, error) { return _PublicResolver.Contract.Text(&_PublicResolver.CallOpts, node, key) } // Text is a free data retrieval call binding the contract method 0x59d1d43c. // -// Solidity: function text(node bytes32, key string) constant returns(ret string) +// Solidity: function text(bytes32 node, string key) constant returns(string) func (_PublicResolver *PublicResolverCallerSession) Text(node [32]byte, key string) (string, error) { return _PublicResolver.Contract.Text(&_PublicResolver.CallOpts, node, key) } // SetABI is a paid mutator transaction binding the contract method 0x623195b0. // -// Solidity: function setABI(node bytes32, contentType uint256, data bytes) returns() +// Solidity: function setABI(bytes32 node, uint256 contentType, bytes data) returns() func (_PublicResolver *PublicResolverTransactor) SetABI(opts *bind.TransactOpts, node [32]byte, contentType *big.Int, data []byte) (*types.Transaction, error) { return _PublicResolver.contract.Transact(opts, "setABI", node, contentType, data) } // SetABI is a paid mutator transaction binding the contract method 0x623195b0. // -// Solidity: function setABI(node bytes32, contentType uint256, data bytes) returns() +// Solidity: function setABI(bytes32 node, uint256 contentType, bytes data) returns() func (_PublicResolver *PublicResolverSession) SetABI(node [32]byte, contentType *big.Int, data []byte) (*types.Transaction, error) { return _PublicResolver.Contract.SetABI(&_PublicResolver.TransactOpts, node, contentType, data) } // SetABI is a paid mutator transaction binding the contract method 0x623195b0. // -// Solidity: function setABI(node bytes32, contentType uint256, data bytes) returns() +// Solidity: function setABI(bytes32 node, uint256 contentType, bytes data) returns() func (_PublicResolver *PublicResolverTransactorSession) SetABI(node [32]byte, contentType *big.Int, data []byte) (*types.Transaction, error) { return _PublicResolver.Contract.SetABI(&_PublicResolver.TransactOpts, node, contentType, data) } // SetAddr is a paid mutator transaction binding the contract method 0xd5fa2b00. // -// Solidity: function setAddr(node bytes32, addr address) returns() +// Solidity: function setAddr(bytes32 node, address addr) returns() func (_PublicResolver *PublicResolverTransactor) SetAddr(opts *bind.TransactOpts, node [32]byte, addr common.Address) (*types.Transaction, error) { return _PublicResolver.contract.Transact(opts, "setAddr", node, addr) } // SetAddr is a paid mutator transaction binding the contract method 0xd5fa2b00. // -// Solidity: function setAddr(node bytes32, addr address) returns() +// Solidity: function setAddr(bytes32 node, address addr) returns() func (_PublicResolver *PublicResolverSession) SetAddr(node [32]byte, addr common.Address) (*types.Transaction, error) { return _PublicResolver.Contract.SetAddr(&_PublicResolver.TransactOpts, node, addr) } // SetAddr is a paid mutator transaction binding the contract method 0xd5fa2b00. // -// Solidity: function setAddr(node bytes32, addr address) returns() +// Solidity: function setAddr(bytes32 node, address addr) returns() func (_PublicResolver *PublicResolverTransactorSession) SetAddr(node [32]byte, addr common.Address) (*types.Transaction, error) { return _PublicResolver.Contract.SetAddr(&_PublicResolver.TransactOpts, node, addr) } -// SetContent is a paid mutator transaction binding the contract method 0xc3d014d6. +// SetContenthash is a paid mutator transaction binding the contract method 0x304e6ade. // -// Solidity: function setContent(node bytes32, hash bytes32) returns() -func (_PublicResolver *PublicResolverTransactor) SetContent(opts *bind.TransactOpts, node [32]byte, hash [32]byte) (*types.Transaction, error) { - return _PublicResolver.contract.Transact(opts, "setContent", node, hash) +// Solidity: function setContenthash(bytes32 node, bytes hash) returns() +func (_PublicResolver *PublicResolverTransactor) SetContenthash(opts *bind.TransactOpts, node [32]byte, hash []byte) (*types.Transaction, error) { + return _PublicResolver.contract.Transact(opts, "setContenthash", node, hash) } -// SetContent is a paid mutator transaction binding the contract method 0xc3d014d6. +// SetContenthash is a paid mutator transaction binding the contract method 0x304e6ade. // -// Solidity: function setContent(node bytes32, hash bytes32) returns() -func (_PublicResolver *PublicResolverSession) SetContent(node [32]byte, hash [32]byte) (*types.Transaction, error) { - return _PublicResolver.Contract.SetContent(&_PublicResolver.TransactOpts, node, hash) +// Solidity: function setContenthash(bytes32 node, bytes hash) returns() +func (_PublicResolver *PublicResolverSession) SetContenthash(node [32]byte, hash []byte) (*types.Transaction, error) { + return _PublicResolver.Contract.SetContenthash(&_PublicResolver.TransactOpts, node, hash) } -// SetContent is a paid mutator transaction binding the contract method 0xc3d014d6. +// SetContenthash is a paid mutator transaction binding the contract method 0x304e6ade. // -// Solidity: function setContent(node bytes32, hash bytes32) returns() -func (_PublicResolver *PublicResolverTransactorSession) SetContent(node [32]byte, hash [32]byte) (*types.Transaction, error) { - return _PublicResolver.Contract.SetContent(&_PublicResolver.TransactOpts, node, hash) +// Solidity: function setContenthash(bytes32 node, bytes hash) returns() +func (_PublicResolver *PublicResolverTransactorSession) SetContenthash(node [32]byte, hash []byte) (*types.Transaction, error) { + return _PublicResolver.Contract.SetContenthash(&_PublicResolver.TransactOpts, node, hash) } // SetName is a paid mutator transaction binding the contract method 0x77372213. // -// Solidity: function setName(node bytes32, name string) returns() +// Solidity: function setName(bytes32 node, string name) returns() func (_PublicResolver *PublicResolverTransactor) SetName(opts *bind.TransactOpts, node [32]byte, name string) (*types.Transaction, error) { return _PublicResolver.contract.Transact(opts, "setName", node, name) } // SetName is a paid mutator transaction binding the contract method 0x77372213. // -// Solidity: function setName(node bytes32, name string) returns() +// Solidity: function setName(bytes32 node, string name) returns() func (_PublicResolver *PublicResolverSession) SetName(node [32]byte, name string) (*types.Transaction, error) { return _PublicResolver.Contract.SetName(&_PublicResolver.TransactOpts, node, name) } // SetName is a paid mutator transaction binding the contract method 0x77372213. // -// Solidity: function setName(node bytes32, name string) returns() +// Solidity: function setName(bytes32 node, string name) returns() func (_PublicResolver *PublicResolverTransactorSession) SetName(node [32]byte, name string) (*types.Transaction, error) { return _PublicResolver.Contract.SetName(&_PublicResolver.TransactOpts, node, name) } // SetPubkey is a paid mutator transaction binding the contract method 0x29cd62ea. // -// Solidity: function setPubkey(node bytes32, x bytes32, y bytes32) returns() +// Solidity: function setPubkey(bytes32 node, bytes32 x, bytes32 y) returns() func (_PublicResolver *PublicResolverTransactor) SetPubkey(opts *bind.TransactOpts, node [32]byte, x [32]byte, y [32]byte) (*types.Transaction, error) { return _PublicResolver.contract.Transact(opts, "setPubkey", node, x, y) } // SetPubkey is a paid mutator transaction binding the contract method 0x29cd62ea. // -// Solidity: function setPubkey(node bytes32, x bytes32, y bytes32) returns() +// Solidity: function setPubkey(bytes32 node, bytes32 x, bytes32 y) returns() func (_PublicResolver *PublicResolverSession) SetPubkey(node [32]byte, x [32]byte, y [32]byte) (*types.Transaction, error) { return _PublicResolver.Contract.SetPubkey(&_PublicResolver.TransactOpts, node, x, y) } // SetPubkey is a paid mutator transaction binding the contract method 0x29cd62ea. // -// Solidity: function setPubkey(node bytes32, x bytes32, y bytes32) returns() +// Solidity: function setPubkey(bytes32 node, bytes32 x, bytes32 y) returns() func (_PublicResolver *PublicResolverTransactorSession) SetPubkey(node [32]byte, x [32]byte, y [32]byte) (*types.Transaction, error) { return _PublicResolver.Contract.SetPubkey(&_PublicResolver.TransactOpts, node, x, y) } // SetText is a paid mutator transaction binding the contract method 0x10f13a8c. // -// Solidity: function setText(node bytes32, key string, value string) returns() +// Solidity: function setText(bytes32 node, string key, string value) returns() func (_PublicResolver *PublicResolverTransactor) SetText(opts *bind.TransactOpts, node [32]byte, key string, value string) (*types.Transaction, error) { return _PublicResolver.contract.Transact(opts, "setText", node, key, value) } // SetText is a paid mutator transaction binding the contract method 0x10f13a8c. // -// Solidity: function setText(node bytes32, key string, value string) returns() +// Solidity: function setText(bytes32 node, string key, string value) returns() func (_PublicResolver *PublicResolverSession) SetText(node [32]byte, key string, value string) (*types.Transaction, error) { return _PublicResolver.Contract.SetText(&_PublicResolver.TransactOpts, node, key, value) } // SetText is a paid mutator transaction binding the contract method 0x10f13a8c. // -// Solidity: function setText(node bytes32, key string, value string) returns() +// Solidity: function setText(bytes32 node, string key, string value) returns() func (_PublicResolver *PublicResolverTransactorSession) SetText(node [32]byte, key string, value string) (*types.Transaction, error) { return _PublicResolver.Contract.SetText(&_PublicResolver.TransactOpts, node, key, value) } @@ -559,7 +565,7 @@ func (it *PublicResolverABIChangedIterator) Next() bool { } } -// Error retruned any retrieval or parsing error occurred during filtering. +// Error returns any retrieval or parsing error occurred during filtering. func (it *PublicResolverABIChangedIterator) Error() error { return it.fail } @@ -580,7 +586,7 @@ type PublicResolverABIChanged struct { // FilterABIChanged is a free log retrieval operation binding the contract event 0xaa121bbeef5f32f5961a2a28966e769023910fc9479059ee3495d4c1a696efe3. // -// Solidity: event ABIChanged(node indexed bytes32, contentType indexed uint256) +// Solidity: event ABIChanged(bytes32 indexed node, uint256 indexed contentType) func (_PublicResolver *PublicResolverFilterer) FilterABIChanged(opts *bind.FilterOpts, node [][32]byte, contentType []*big.Int) (*PublicResolverABIChangedIterator, error) { var nodeRule []interface{} @@ -601,7 +607,7 @@ func (_PublicResolver *PublicResolverFilterer) FilterABIChanged(opts *bind.Filte // WatchABIChanged is a free log subscription operation binding the contract event 0xaa121bbeef5f32f5961a2a28966e769023910fc9479059ee3495d4c1a696efe3. // -// Solidity: event ABIChanged(node indexed bytes32, contentType indexed uint256) +// Solidity: event ABIChanged(bytes32 indexed node, uint256 indexed contentType) func (_PublicResolver *PublicResolverFilterer) WatchABIChanged(opts *bind.WatchOpts, sink chan<- *PublicResolverABIChanged, node [][32]byte, contentType []*big.Int) (event.Subscription, error) { var nodeRule []interface{} @@ -700,7 +706,7 @@ func (it *PublicResolverAddrChangedIterator) Next() bool { } } -// Error retruned any retrieval or parsing error occurred during filtering. +// Error returns any retrieval or parsing error occurred during filtering. func (it *PublicResolverAddrChangedIterator) Error() error { return it.fail } @@ -721,7 +727,7 @@ type PublicResolverAddrChanged struct { // FilterAddrChanged is a free log retrieval operation binding the contract event 0x52d7d861f09ab3d26239d492e8968629f95e9e318cf0b73bfddc441522a15fd2. // -// Solidity: event AddrChanged(node indexed bytes32, a address) +// Solidity: event AddrChanged(bytes32 indexed node, address a) func (_PublicResolver *PublicResolverFilterer) FilterAddrChanged(opts *bind.FilterOpts, node [][32]byte) (*PublicResolverAddrChangedIterator, error) { var nodeRule []interface{} @@ -738,7 +744,7 @@ func (_PublicResolver *PublicResolverFilterer) FilterAddrChanged(opts *bind.Filt // WatchAddrChanged is a free log subscription operation binding the contract event 0x52d7d861f09ab3d26239d492e8968629f95e9e318cf0b73bfddc441522a15fd2. // -// Solidity: event AddrChanged(node indexed bytes32, a address) +// Solidity: event AddrChanged(bytes32 indexed node, address a) func (_PublicResolver *PublicResolverFilterer) WatchAddrChanged(opts *bind.WatchOpts, sink chan<- *PublicResolverAddrChanged, node [][32]byte) (event.Subscription, error) { var nodeRule []interface{} @@ -778,9 +784,9 @@ func (_PublicResolver *PublicResolverFilterer) WatchAddrChanged(opts *bind.Watch }), nil } -// PublicResolverContentChangedIterator is returned from FilterContentChanged and is used to iterate over the raw logs and unpacked data for ContentChanged events raised by the PublicResolver contract. -type PublicResolverContentChangedIterator struct { - Event *PublicResolverContentChanged // Event containing the contract specifics and raw log +// PublicResolverContenthashChangedIterator is returned from FilterContenthashChanged and is used to iterate over the raw logs and unpacked data for ContenthashChanged events raised by the PublicResolver contract. +type PublicResolverContenthashChangedIterator struct { + Event *PublicResolverContenthashChanged // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data @@ -794,7 +800,7 @@ type PublicResolverContentChangedIterator struct { // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. -func (it *PublicResolverContentChangedIterator) Next() bool { +func (it *PublicResolverContenthashChangedIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -803,7 +809,7 @@ func (it *PublicResolverContentChangedIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(PublicResolverContentChanged) + it.Event = new(PublicResolverContenthashChanged) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -818,7 +824,7 @@ func (it *PublicResolverContentChangedIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(PublicResolverContentChanged) + it.Event = new(PublicResolverContenthashChanged) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -833,53 +839,53 @@ func (it *PublicResolverContentChangedIterator) Next() bool { } } -// Error retruned any retrieval or parsing error occurred during filtering. -func (it *PublicResolverContentChangedIterator) Error() error { +// Error returns any retrieval or parsing error occurred during filtering. +func (it *PublicResolverContenthashChangedIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *PublicResolverContentChangedIterator) Close() error { +func (it *PublicResolverContenthashChangedIterator) Close() error { it.sub.Unsubscribe() return nil } -// PublicResolverContentChanged represents a ContentChanged event raised by the PublicResolver contract. -type PublicResolverContentChanged struct { +// PublicResolverContenthashChanged represents a ContenthashChanged event raised by the PublicResolver contract. +type PublicResolverContenthashChanged struct { Node [32]byte - Hash [32]byte + Hash []byte Raw types.Log // Blockchain specific contextual infos } -// FilterContentChanged is a free log retrieval operation binding the contract event 0x0424b6fe0d9c3bdbece0e7879dc241bb0c22e900be8b6c168b4ee08bd9bf83bc. +// FilterContenthashChanged is a free log retrieval operation binding the contract event 0xe379c1624ed7e714cc0937528a32359d69d5281337765313dba4e081b72d7578. // -// Solidity: event ContentChanged(node indexed bytes32, hash bytes32) -func (_PublicResolver *PublicResolverFilterer) FilterContentChanged(opts *bind.FilterOpts, node [][32]byte) (*PublicResolverContentChangedIterator, error) { +// Solidity: event ContenthashChanged(bytes32 indexed node, bytes hash) +func (_PublicResolver *PublicResolverFilterer) FilterContenthashChanged(opts *bind.FilterOpts, node [][32]byte) (*PublicResolverContenthashChangedIterator, error) { var nodeRule []interface{} for _, nodeItem := range node { nodeRule = append(nodeRule, nodeItem) } - logs, sub, err := _PublicResolver.contract.FilterLogs(opts, "ContentChanged", nodeRule) + logs, sub, err := _PublicResolver.contract.FilterLogs(opts, "ContenthashChanged", nodeRule) if err != nil { return nil, err } - return &PublicResolverContentChangedIterator{contract: _PublicResolver.contract, event: "ContentChanged", logs: logs, sub: sub}, nil + return &PublicResolverContenthashChangedIterator{contract: _PublicResolver.contract, event: "ContenthashChanged", logs: logs, sub: sub}, nil } -// WatchContentChanged is a free log subscription operation binding the contract event 0x0424b6fe0d9c3bdbece0e7879dc241bb0c22e900be8b6c168b4ee08bd9bf83bc. +// WatchContenthashChanged is a free log subscription operation binding the contract event 0xe379c1624ed7e714cc0937528a32359d69d5281337765313dba4e081b72d7578. // -// Solidity: event ContentChanged(node indexed bytes32, hash bytes32) -func (_PublicResolver *PublicResolverFilterer) WatchContentChanged(opts *bind.WatchOpts, sink chan<- *PublicResolverContentChanged, node [][32]byte) (event.Subscription, error) { +// Solidity: event ContenthashChanged(bytes32 indexed node, bytes hash) +func (_PublicResolver *PublicResolverFilterer) WatchContenthashChanged(opts *bind.WatchOpts, sink chan<- *PublicResolverContenthashChanged, node [][32]byte) (event.Subscription, error) { var nodeRule []interface{} for _, nodeItem := range node { nodeRule = append(nodeRule, nodeItem) } - logs, sub, err := _PublicResolver.contract.WatchLogs(opts, "ContentChanged", nodeRule) + logs, sub, err := _PublicResolver.contract.WatchLogs(opts, "ContenthashChanged", nodeRule) if err != nil { return nil, err } @@ -889,8 +895,8 @@ func (_PublicResolver *PublicResolverFilterer) WatchContentChanged(opts *bind.Wa select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(PublicResolverContentChanged) - if err := _PublicResolver.contract.UnpackLog(event, "ContentChanged", log); err != nil { + event := new(PublicResolverContenthashChanged) + if err := _PublicResolver.contract.UnpackLog(event, "ContenthashChanged", log); err != nil { return err } event.Raw = log @@ -966,7 +972,7 @@ func (it *PublicResolverNameChangedIterator) Next() bool { } } -// Error retruned any retrieval or parsing error occurred during filtering. +// Error returns any retrieval or parsing error occurred during filtering. func (it *PublicResolverNameChangedIterator) Error() error { return it.fail } @@ -987,7 +993,7 @@ type PublicResolverNameChanged struct { // FilterNameChanged is a free log retrieval operation binding the contract event 0xb7d29e911041e8d9b843369e890bcb72c9388692ba48b65ac54e7214c4c348f7. // -// Solidity: event NameChanged(node indexed bytes32, name string) +// Solidity: event NameChanged(bytes32 indexed node, string name) func (_PublicResolver *PublicResolverFilterer) FilterNameChanged(opts *bind.FilterOpts, node [][32]byte) (*PublicResolverNameChangedIterator, error) { var nodeRule []interface{} @@ -1004,7 +1010,7 @@ func (_PublicResolver *PublicResolverFilterer) FilterNameChanged(opts *bind.Filt // WatchNameChanged is a free log subscription operation binding the contract event 0xb7d29e911041e8d9b843369e890bcb72c9388692ba48b65ac54e7214c4c348f7. // -// Solidity: event NameChanged(node indexed bytes32, name string) +// Solidity: event NameChanged(bytes32 indexed node, string name) func (_PublicResolver *PublicResolverFilterer) WatchNameChanged(opts *bind.WatchOpts, sink chan<- *PublicResolverNameChanged, node [][32]byte) (event.Subscription, error) { var nodeRule []interface{} @@ -1099,7 +1105,7 @@ func (it *PublicResolverPubkeyChangedIterator) Next() bool { } } -// Error retruned any retrieval or parsing error occurred during filtering. +// Error returns any retrieval or parsing error occurred during filtering. func (it *PublicResolverPubkeyChangedIterator) Error() error { return it.fail } @@ -1121,7 +1127,7 @@ type PublicResolverPubkeyChanged struct { // FilterPubkeyChanged is a free log retrieval operation binding the contract event 0x1d6f5e03d3f63eb58751986629a5439baee5079ff04f345becb66e23eb154e46. // -// Solidity: event PubkeyChanged(node indexed bytes32, x bytes32, y bytes32) +// Solidity: event PubkeyChanged(bytes32 indexed node, bytes32 x, bytes32 y) func (_PublicResolver *PublicResolverFilterer) FilterPubkeyChanged(opts *bind.FilterOpts, node [][32]byte) (*PublicResolverPubkeyChangedIterator, error) { var nodeRule []interface{} @@ -1138,7 +1144,7 @@ func (_PublicResolver *PublicResolverFilterer) FilterPubkeyChanged(opts *bind.Fi // WatchPubkeyChanged is a free log subscription operation binding the contract event 0x1d6f5e03d3f63eb58751986629a5439baee5079ff04f345becb66e23eb154e46. // -// Solidity: event PubkeyChanged(node indexed bytes32, x bytes32, y bytes32) +// Solidity: event PubkeyChanged(bytes32 indexed node, bytes32 x, bytes32 y) func (_PublicResolver *PublicResolverFilterer) WatchPubkeyChanged(opts *bind.WatchOpts, sink chan<- *PublicResolverPubkeyChanged, node [][32]byte) (event.Subscription, error) { var nodeRule []interface{} @@ -1233,7 +1239,7 @@ func (it *PublicResolverTextChangedIterator) Next() bool { } } -// Error retruned any retrieval or parsing error occurred during filtering. +// Error returns any retrieval or parsing error occurred during filtering. func (it *PublicResolverTextChangedIterator) Error() error { return it.fail } @@ -1248,26 +1254,22 @@ func (it *PublicResolverTextChangedIterator) Close() error { // PublicResolverTextChanged represents a TextChanged event raised by the PublicResolver contract. type PublicResolverTextChanged struct { Node [32]byte - IndexedKey common.Hash + IndexedKey string Key string Raw types.Log // Blockchain specific contextual infos } // FilterTextChanged is a free log retrieval operation binding the contract event 0xd8c9334b1a9c2f9da342a0a2b32629c1a229b6445dad78947f674b44444a7550. // -// Solidity: event TextChanged(node indexed bytes32, indexedKey indexed string, key string) -func (_PublicResolver *PublicResolverFilterer) FilterTextChanged(opts *bind.FilterOpts, node [][32]byte, indexedKey []string) (*PublicResolverTextChangedIterator, error) { +// Solidity: event TextChanged(bytes32 indexed node, string indexedKey, string key) +func (_PublicResolver *PublicResolverFilterer) FilterTextChanged(opts *bind.FilterOpts, node [][32]byte) (*PublicResolverTextChangedIterator, error) { var nodeRule []interface{} for _, nodeItem := range node { nodeRule = append(nodeRule, nodeItem) } - var indexedKeyRule []interface{} - for _, indexedKeyItem := range indexedKey { - indexedKeyRule = append(indexedKeyRule, indexedKeyItem) - } - logs, sub, err := _PublicResolver.contract.FilterLogs(opts, "TextChanged", nodeRule, indexedKeyRule) + logs, sub, err := _PublicResolver.contract.FilterLogs(opts, "TextChanged", nodeRule) if err != nil { return nil, err } @@ -1276,19 +1278,15 @@ func (_PublicResolver *PublicResolverFilterer) FilterTextChanged(opts *bind.Filt // WatchTextChanged is a free log subscription operation binding the contract event 0xd8c9334b1a9c2f9da342a0a2b32629c1a229b6445dad78947f674b44444a7550. // -// Solidity: event TextChanged(node indexed bytes32, indexedKey indexed string, key string) -func (_PublicResolver *PublicResolverFilterer) WatchTextChanged(opts *bind.WatchOpts, sink chan<- *PublicResolverTextChanged, node [][32]byte, indexedKey []string) (event.Subscription, error) { +// Solidity: event TextChanged(bytes32 indexed node, string indexedKey, string key) +func (_PublicResolver *PublicResolverFilterer) WatchTextChanged(opts *bind.WatchOpts, sink chan<- *PublicResolverTextChanged, node [][32]byte) (event.Subscription, error) { var nodeRule []interface{} for _, nodeItem := range node { nodeRule = append(nodeRule, nodeItem) } - var indexedKeyRule []interface{} - for _, indexedKeyItem := range indexedKey { - indexedKeyRule = append(indexedKeyRule, indexedKeyItem) - } - logs, sub, err := _PublicResolver.contract.WatchLogs(opts, "TextChanged", nodeRule, indexedKeyRule) + logs, sub, err := _PublicResolver.contract.WatchLogs(opts, "TextChanged", nodeRule) if err != nil { return nil, err } diff --git a/contracts/ens/ens.go b/contracts/ens/ens.go index b1841ab17d..6fed172dcd 100644 --- a/contracts/ens/ens.go +++ b/contracts/ens/ens.go @@ -16,25 +16,35 @@ package ens -//go:generate abigen --sol contract/ENS.sol --exc contract/AbstractENS.sol:AbstractENS --pkg contract --out contract/ens.go -//go:generate abigen --sol contract/FIFSRegistrar.sol --exc contract/AbstractENS.sol:AbstractENS --pkg contract --out contract/fifsregistrar.go -//go:generate abigen --sol contract/PublicResolver.sol --exc contract/AbstractENS.sol:AbstractENS --pkg contract --out contract/publicresolver.go +//go:generate abigen --sol contract/ENS.sol --pkg contract --out contract/ens.go +//go:generate abigen --sol contract/ENSRegistry.sol --exc contract/ENS.sol:ENS --pkg contract --out contract/ensregistry.go +//go:generate abigen --sol contract/FIFSRegistrar.sol --exc contract/ENS.sol:ENS --pkg contract --out contract/fifsregistrar.go +//go:generate abigen --sol contract/PublicResolver.sol --exc contract/ENS.sol:ENS --pkg contract --out contract/publicresolver.go import ( + "encoding/binary" "strings" "github.com/ethereum/go-ethereum/accounts/abi/bind" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/contracts/ens/contract" + "github.com/ethereum/go-ethereum/contracts/ens/fallback_contract" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/crypto" ) var ( - MainNetAddress = common.HexToAddress("0x314159265dD8dbb310642f98f50C066173C1259b") - TestNetAddress = common.HexToAddress("0x112234455c3a32fd11230c42e7bccd4a84e02010") + MainNetAddress = common.HexToAddress("0x314159265dD8dbb310642f98f50C066173C1259b") + TestNetAddress = common.HexToAddress("0x112234455c3a32fd11230c42e7bccd4a84e02010") + contentHash_Interface_Id [4]byte ) +const contentHash_Interface_Id_Spec = 0xbc1c58d1 + +func init() { + binary.BigEndian.PutUint32(contentHash_Interface_Id[:], contentHash_Interface_Id_Spec) +} + // ENS is the swarm domain name registry and resolver type ENS struct { *contract.ENSSession @@ -60,7 +70,7 @@ func NewENS(transactOpts *bind.TransactOpts, contractAddr common.Address, contra // DeployENS deploys an instance of the ENS nameservice, with a 'first-in, first-served' root registrar. func DeployENS(transactOpts *bind.TransactOpts, contractBackend bind.ContractBackend) (common.Address, *ENS, error) { // Deploy the ENS registry - ensAddr, _, _, err := contract.DeployENS(transactOpts, contractBackend) + ensAddr, _, _, err := contract.DeployENSRegistry(transactOpts, contractBackend) if err != nil { return ensAddr, nil, err } @@ -110,6 +120,21 @@ func (ens *ENS) getResolver(node [32]byte) (*contract.PublicResolverSession, err }, nil } +func (ens *ENS) getFallbackResolver(node [32]byte) (*fallback_contract.PublicResolverSession, error) { + resolverAddr, err := ens.Resolver(node) + if err != nil { + return nil, err + } + resolver, err := fallback_contract.NewPublicResolver(resolverAddr, ens.contractBackend) + if err != nil { + return nil, err + } + return &fallback_contract.PublicResolverSession{ + Contract: resolver, + TransactOpts: ens.TransactOpts, + }, nil +} + func (ens *ENS) getRegistrar(node [32]byte) (*contract.FIFSRegistrarSession, error) { registrarAddr, err := ens.Owner(node) if err != nil { @@ -133,11 +158,33 @@ func (ens *ENS) Resolve(name string) (common.Hash, error) { if err != nil { return common.Hash{}, err } - ret, err := resolver.Content(node) + + // IMPORTANT: The old contract is deprecated. This code should be removed latest on June 1st 2019 + supported, err := resolver.SupportsInterface(contentHash_Interface_Id) if err != nil { return common.Hash{}, err } - return common.BytesToHash(ret[:]), nil + + if !supported { + resolver, err := ens.getFallbackResolver(node) + if err != nil { + return common.Hash{}, err + } + ret, err := resolver.Content(node) + if err != nil { + return common.Hash{}, err + } + return common.BytesToHash(ret[:]), nil + } + + // END DEPRECATED CODE + + contentHash, err := resolver.Contenthash(node) + if err != nil { + return common.Hash{}, err + } + + return extractContentHash(contentHash) } // Addr is a non-transactional call that returns the address associated with a name. @@ -181,15 +228,36 @@ func (ens *ENS) Register(name string) (*types.Transaction, error) { } // SetContentHash sets the content hash associated with a name. Only works if the caller -// owns the name, and the associated resolver implements a `setContent` function. -func (ens *ENS) SetContentHash(name string, hash common.Hash) (*types.Transaction, error) { +// owns the name, and the associated resolver implements a `setContenthash` function. +func (ens *ENS) SetContentHash(name string, hash []byte) (*types.Transaction, error) { node := EnsNode(name) resolver, err := ens.getResolver(node) if err != nil { return nil, err } + opts := ens.TransactOpts opts.GasLimit = 200000 - return resolver.Contract.SetContent(&opts, node, hash) + + // IMPORTANT: The old contract is deprecated. This code should be removed latest on June 1st 2019 + supported, err := resolver.SupportsInterface(contentHash_Interface_Id) + if err != nil { + return nil, err + } + + if !supported { + resolver, err := ens.getFallbackResolver(node) + if err != nil { + return nil, err + } + opts := ens.TransactOpts + opts.GasLimit = 200000 + var b [32]byte + copy(b[:], hash) + return resolver.Contract.SetContent(&opts, node, b) + } + + // END DEPRECATED CODE + return resolver.Contract.SetContenthash(&opts, node, hash) } diff --git a/contracts/ens/ens_test.go b/contracts/ens/ens_test.go index cd64fbf15f..c65df836ad 100644 --- a/contracts/ens/ens_test.go +++ b/contracts/ens/ens_test.go @@ -24,16 +24,18 @@ import ( "github.com/ethereum/go-ethereum/accounts/abi/bind/backends" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/contracts/ens/contract" + "github.com/ethereum/go-ethereum/contracts/ens/fallback_contract" "github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/crypto" ) var ( - key, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291") - name = "my name on ENS" - hash = crypto.Keccak256Hash([]byte("my content")) - addr = crypto.PubkeyToAddress(key.PublicKey) - testAddr = common.HexToAddress("0x1234123412341234123412341234123412341234") + key, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291") + name = "my name on ENS" + hash = crypto.Keccak256Hash([]byte("my content")) + fallbackHash = crypto.Keccak256Hash([]byte("my content hash")) + addr = crypto.PubkeyToAddress(key.PublicKey) + testAddr = common.HexToAddress("0x1234123412341234123412341234123412341234") ) func TestENS(t *testing.T) { @@ -57,24 +59,29 @@ func TestENS(t *testing.T) { if err != nil { t.Fatalf("can't deploy resolver: %v", err) } + if _, err := ens.SetResolver(EnsNode(name), resolverAddr); err != nil { t.Fatalf("can't set resolver: %v", err) } contractBackend.Commit() // Set the content hash for the name. - if _, err = ens.SetContentHash(name, hash); err != nil { + cid, err := EncodeSwarmHash(hash) + if err != nil { + t.Fatal(err) + } + if _, err = ens.SetContentHash(name, cid); err != nil { t.Fatalf("can't set content hash: %v", err) } contractBackend.Commit() // Try to resolve the name. - vhost, err := ens.Resolve(name) + resolvedHash, err := ens.Resolve(name) if err != nil { t.Fatalf("expected no error, got %v", err) } - if vhost != hash { - t.Fatalf("resolve error, expected %v, got %v", hash.Hex(), vhost.Hex()) + if resolvedHash.Hex() != hash.Hex() { + t.Fatalf("resolve error, expected %v, got %v", hash.Hex(), resolvedHash.Hex()) } // set the address for the name @@ -88,7 +95,32 @@ func TestENS(t *testing.T) { if err != nil { t.Fatalf("expected no error, got %v", err) } - if vhost != hash { + if testAddr.Hex() != recoveredAddr.Hex() { t.Fatalf("resolve error, expected %v, got %v", testAddr.Hex(), recoveredAddr.Hex()) } + + // deploy the fallback contract and see that the fallback mechanism works + fallbackResolverAddr, _, _, err := fallback_contract.DeployPublicResolver(transactOpts, contractBackend, ensAddr) + if err != nil { + t.Fatalf("can't deploy resolver: %v", err) + } + if _, err := ens.SetResolver(EnsNode(name), fallbackResolverAddr); err != nil { + t.Fatalf("can't set resolver: %v", err) + } + contractBackend.Commit() + + // Set the content hash for the name. + if _, err = ens.SetContentHash(name, fallbackHash.Bytes()); err != nil { + t.Fatalf("can't set content hash: %v", err) + } + contractBackend.Commit() + + // Try to resolve the name. + fallbackResolvedHash, err := ens.Resolve(name) + if err != nil { + t.Fatalf("expected no error, got %v", err) + } + if fallbackResolvedHash.Hex() != fallbackHash.Hex() { + t.Fatalf("resolve error, expected %v, got %v", hash.Hex(), resolvedHash.Hex()) + } } diff --git a/contracts/ens/fallback_contract/PublicResolver.sol b/contracts/ens/fallback_contract/PublicResolver.sol new file mode 100644 index 0000000000..9dcc95689e --- /dev/null +++ b/contracts/ens/fallback_contract/PublicResolver.sol @@ -0,0 +1,212 @@ +pragma solidity ^0.4.0; + +import './AbstractENS.sol'; + +/** + * A simple resolver anyone can use; only allows the owner of a node to set its + * address. + */ +contract PublicResolver { + bytes4 constant INTERFACE_META_ID = 0x01ffc9a7; + bytes4 constant ADDR_INTERFACE_ID = 0x3b3b57de; + bytes4 constant CONTENT_INTERFACE_ID = 0xd8389dc5; + bytes4 constant NAME_INTERFACE_ID = 0x691f3431; + bytes4 constant ABI_INTERFACE_ID = 0x2203ab56; + bytes4 constant PUBKEY_INTERFACE_ID = 0xc8690233; + bytes4 constant TEXT_INTERFACE_ID = 0x59d1d43c; + + event AddrChanged(bytes32 indexed node, address a); + event ContentChanged(bytes32 indexed node, bytes32 hash); + event NameChanged(bytes32 indexed node, string name); + event ABIChanged(bytes32 indexed node, uint256 indexed contentType); + event PubkeyChanged(bytes32 indexed node, bytes32 x, bytes32 y); + event TextChanged(bytes32 indexed node, string indexed indexedKey, string key); + + struct PublicKey { + bytes32 x; + bytes32 y; + } + + struct Record { + address addr; + bytes32 content; + string name; + PublicKey pubkey; + mapping(string=>string) text; + mapping(uint256=>bytes) abis; + } + + AbstractENS ens; + mapping(bytes32=>Record) records; + + modifier only_owner(bytes32 node) { + if (ens.owner(node) != msg.sender) throw; + _; + } + + /** + * Constructor. + * @param ensAddr The ENS registrar contract. + */ + function PublicResolver(AbstractENS ensAddr) { + ens = ensAddr; + } + + /** + * Returns true if the resolver implements the interface specified by the provided hash. + * @param interfaceID The ID of the interface to check for. + * @return True if the contract implements the requested interface. + */ + function supportsInterface(bytes4 interfaceID) constant returns (bool) { + return interfaceID == ADDR_INTERFACE_ID || + interfaceID == CONTENT_INTERFACE_ID || + interfaceID == NAME_INTERFACE_ID || + interfaceID == ABI_INTERFACE_ID || + interfaceID == PUBKEY_INTERFACE_ID || + interfaceID == TEXT_INTERFACE_ID || + interfaceID == INTERFACE_META_ID; + } + + /** + * Returns the address associated with an ENS node. + * @param node The ENS node to query. + * @return The associated address. + */ + function addr(bytes32 node) constant returns (address ret) { + ret = records[node].addr; + } + + /** + * Sets the address associated with an ENS node. + * May only be called by the owner of that node in the ENS registry. + * @param node The node to update. + * @param addr The address to set. + */ + function setAddr(bytes32 node, address addr) only_owner(node) { + records[node].addr = addr; + AddrChanged(node, addr); + } + + /** + * Returns the content hash associated with an ENS node. + * Note that this resource type is not standardized, and will likely change + * in future to a resource type based on multihash. + * @param node The ENS node to query. + * @return The associated content hash. + */ + function content(bytes32 node) constant returns (bytes32 ret) { + ret = records[node].content; + } + + /** + * Sets the content hash associated with an ENS node. + * May only be called by the owner of that node in the ENS registry. + * Note that this resource type is not standardized, and will likely change + * in future to a resource type based on multihash. + * @param node The node to update. + * @param hash The content hash to set + */ + function setContent(bytes32 node, bytes32 hash) only_owner(node) { + records[node].content = hash; + ContentChanged(node, hash); + } + + /** + * Returns the name associated with an ENS node, for reverse records. + * Defined in EIP181. + * @param node The ENS node to query. + * @return The associated name. + */ + function name(bytes32 node) constant returns (string ret) { + ret = records[node].name; + } + + /** + * Sets the name associated with an ENS node, for reverse records. + * May only be called by the owner of that node in the ENS registry. + * @param node The node to update. + * @param name The name to set. + */ + function setName(bytes32 node, string name) only_owner(node) { + records[node].name = name; + NameChanged(node, name); + } + + /** + * Returns the ABI associated with an ENS node. + * Defined in EIP205. + * @param node The ENS node to query + * @param contentTypes A bitwise OR of the ABI formats accepted by the caller. + * @return contentType The content type of the return value + * @return data The ABI data + */ + function ABI(bytes32 node, uint256 contentTypes) constant returns (uint256 contentType, bytes data) { + var record = records[node]; + for(contentType = 1; contentType <= contentTypes; contentType <<= 1) { + if ((contentType & contentTypes) != 0 && record.abis[contentType].length > 0) { + data = record.abis[contentType]; + return; + } + } + contentType = 0; + } + + /** + * Sets the ABI associated with an ENS node. + * Nodes may have one ABI of each content type. To remove an ABI, set it to + * the empty string. + * @param node The node to update. + * @param contentType The content type of the ABI + * @param data The ABI data. + */ + function setABI(bytes32 node, uint256 contentType, bytes data) only_owner(node) { + // Content types must be powers of 2 + if (((contentType - 1) & contentType) != 0) throw; + + records[node].abis[contentType] = data; + ABIChanged(node, contentType); + } + + /** + * Returns the SECP256k1 public key associated with an ENS node. + * Defined in EIP 619. + * @param node The ENS node to query + * @return x, y the X and Y coordinates of the curve point for the public key. + */ + function pubkey(bytes32 node) constant returns (bytes32 x, bytes32 y) { + return (records[node].pubkey.x, records[node].pubkey.y); + } + + /** + * Sets the SECP256k1 public key associated with an ENS node. + * @param node The ENS node to query + * @param x the X coordinate of the curve point for the public key. + * @param y the Y coordinate of the curve point for the public key. + */ + function setPubkey(bytes32 node, bytes32 x, bytes32 y) only_owner(node) { + records[node].pubkey = PublicKey(x, y); + PubkeyChanged(node, x, y); + } + + /** + * Returns the text data associated with an ENS node and key. + * @param node The ENS node to query. + * @param key The text data key to query. + * @return The associated text data. + */ + function text(bytes32 node, string key) constant returns (string ret) { + ret = records[node].text[key]; + } + + /** + * Sets the text data associated with an ENS node and key. + * May only be called by the owner of that node in the ENS registry. + * @param node The node to update. + * @param key The key to set. + * @param value The text data value to set. + */ + function setText(bytes32 node, string key, string value) only_owner(node) { + records[node].text[key] = value; + TextChanged(node, key, key); + } +} diff --git a/contracts/ens/fallback_contract/publicresolver.go b/contracts/ens/fallback_contract/publicresolver.go new file mode 100644 index 0000000000..a2a4be1c16 --- /dev/null +++ b/contracts/ens/fallback_contract/publicresolver.go @@ -0,0 +1,1321 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package fallback_contract + +import ( + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// PublicResolverABI is the input ABI used to generate the binding from. +const PublicResolverABI = "[{\"constant\":true,\"inputs\":[{\"name\":\"interfaceID\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"key\",\"type\":\"string\"},{\"name\":\"value\",\"type\":\"string\"}],\"name\":\"setText\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"contentTypes\",\"type\":\"uint256\"}],\"name\":\"ABI\",\"outputs\":[{\"name\":\"contentType\",\"type\":\"uint256\"},{\"name\":\"data\",\"type\":\"bytes\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"x\",\"type\":\"bytes32\"},{\"name\":\"y\",\"type\":\"bytes32\"}],\"name\":\"setPubkey\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"}],\"name\":\"content\",\"outputs\":[{\"name\":\"ret\",\"type\":\"bytes32\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"}],\"name\":\"addr\",\"outputs\":[{\"name\":\"ret\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"key\",\"type\":\"string\"}],\"name\":\"text\",\"outputs\":[{\"name\":\"ret\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"contentType\",\"type\":\"uint256\"},{\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"setABI\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"}],\"name\":\"name\",\"outputs\":[{\"name\":\"ret\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"name\",\"type\":\"string\"}],\"name\":\"setName\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"hash\",\"type\":\"bytes32\"}],\"name\":\"setContent\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"}],\"name\":\"pubkey\",\"outputs\":[{\"name\":\"x\",\"type\":\"bytes32\"},{\"name\":\"y\",\"type\":\"bytes32\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"addr\",\"type\":\"address\"}],\"name\":\"setAddr\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"name\":\"ensAddr\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"a\",\"type\":\"address\"}],\"name\":\"AddrChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"hash\",\"type\":\"bytes32\"}],\"name\":\"ContentChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"name\",\"type\":\"string\"}],\"name\":\"NameChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":true,\"name\":\"contentType\",\"type\":\"uint256\"}],\"name\":\"ABIChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"x\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"y\",\"type\":\"bytes32\"}],\"name\":\"PubkeyChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":true,\"name\":\"indexedKey\",\"type\":\"string\"},{\"indexed\":false,\"name\":\"key\",\"type\":\"string\"}],\"name\":\"TextChanged\",\"type\":\"event\"}]" + +// PublicResolverBin is the compiled bytecode used for deploying new contracts. +const PublicResolverBin = `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` + +// DeployPublicResolver deploys a new Ethereum contract, binding an instance of PublicResolver to it. +func DeployPublicResolver(auth *bind.TransactOpts, backend bind.ContractBackend, ensAddr common.Address) (common.Address, *types.Transaction, *PublicResolver, error) { + parsed, err := abi.JSON(strings.NewReader(PublicResolverABI)) + if err != nil { + return common.Address{}, nil, nil, err + } + address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(PublicResolverBin), backend, ensAddr) + if err != nil { + return common.Address{}, nil, nil, err + } + return address, tx, &PublicResolver{PublicResolverCaller: PublicResolverCaller{contract: contract}, PublicResolverTransactor: PublicResolverTransactor{contract: contract}, PublicResolverFilterer: PublicResolverFilterer{contract: contract}}, nil +} + +// PublicResolver is an auto generated Go binding around an Ethereum contract. +type PublicResolver struct { + PublicResolverCaller // Read-only binding to the contract + PublicResolverTransactor // Write-only binding to the contract + PublicResolverFilterer // Log filterer for contract events +} + +// PublicResolverCaller is an auto generated read-only Go binding around an Ethereum contract. +type PublicResolverCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// PublicResolverTransactor is an auto generated write-only Go binding around an Ethereum contract. +type PublicResolverTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// PublicResolverFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type PublicResolverFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// PublicResolverSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type PublicResolverSession struct { + Contract *PublicResolver // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// PublicResolverCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type PublicResolverCallerSession struct { + Contract *PublicResolverCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// PublicResolverTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type PublicResolverTransactorSession struct { + Contract *PublicResolverTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// PublicResolverRaw is an auto generated low-level Go binding around an Ethereum contract. +type PublicResolverRaw struct { + Contract *PublicResolver // Generic contract binding to access the raw methods on +} + +// PublicResolverCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type PublicResolverCallerRaw struct { + Contract *PublicResolverCaller // Generic read-only contract binding to access the raw methods on +} + +// PublicResolverTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type PublicResolverTransactorRaw struct { + Contract *PublicResolverTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewPublicResolver creates a new instance of PublicResolver, bound to a specific deployed contract. +func NewPublicResolver(address common.Address, backend bind.ContractBackend) (*PublicResolver, error) { + contract, err := bindPublicResolver(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &PublicResolver{PublicResolverCaller: PublicResolverCaller{contract: contract}, PublicResolverTransactor: PublicResolverTransactor{contract: contract}, PublicResolverFilterer: PublicResolverFilterer{contract: contract}}, nil +} + +// NewPublicResolverCaller creates a new read-only instance of PublicResolver, bound to a specific deployed contract. +func NewPublicResolverCaller(address common.Address, caller bind.ContractCaller) (*PublicResolverCaller, error) { + contract, err := bindPublicResolver(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &PublicResolverCaller{contract: contract}, nil +} + +// NewPublicResolverTransactor creates a new write-only instance of PublicResolver, bound to a specific deployed contract. +func NewPublicResolverTransactor(address common.Address, transactor bind.ContractTransactor) (*PublicResolverTransactor, error) { + contract, err := bindPublicResolver(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &PublicResolverTransactor{contract: contract}, nil +} + +// NewPublicResolverFilterer creates a new log filterer instance of PublicResolver, bound to a specific deployed contract. +func NewPublicResolverFilterer(address common.Address, filterer bind.ContractFilterer) (*PublicResolverFilterer, error) { + contract, err := bindPublicResolver(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &PublicResolverFilterer{contract: contract}, nil +} + +// bindPublicResolver binds a generic wrapper to an already deployed contract. +func bindPublicResolver(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := abi.JSON(strings.NewReader(PublicResolverABI)) + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_PublicResolver *PublicResolverRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { + return _PublicResolver.Contract.PublicResolverCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_PublicResolver *PublicResolverRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _PublicResolver.Contract.PublicResolverTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_PublicResolver *PublicResolverRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _PublicResolver.Contract.PublicResolverTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_PublicResolver *PublicResolverCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { + return _PublicResolver.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_PublicResolver *PublicResolverTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _PublicResolver.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_PublicResolver *PublicResolverTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _PublicResolver.Contract.contract.Transact(opts, method, params...) +} + +// ABI is a free data retrieval call binding the contract method 0x2203ab56. +// +// Solidity: function ABI(node bytes32, contentTypes uint256) constant returns(contentType uint256, data bytes) +func (_PublicResolver *PublicResolverCaller) ABI(opts *bind.CallOpts, node [32]byte, contentTypes *big.Int) (struct { + ContentType *big.Int + Data []byte +}, error) { + ret := new(struct { + ContentType *big.Int + Data []byte + }) + out := ret + err := _PublicResolver.contract.Call(opts, out, "ABI", node, contentTypes) + return *ret, err +} + +// ABI is a free data retrieval call binding the contract method 0x2203ab56. +// +// Solidity: function ABI(node bytes32, contentTypes uint256) constant returns(contentType uint256, data bytes) +func (_PublicResolver *PublicResolverSession) ABI(node [32]byte, contentTypes *big.Int) (struct { + ContentType *big.Int + Data []byte +}, error) { + return _PublicResolver.Contract.ABI(&_PublicResolver.CallOpts, node, contentTypes) +} + +// ABI is a free data retrieval call binding the contract method 0x2203ab56. +// +// Solidity: function ABI(node bytes32, contentTypes uint256) constant returns(contentType uint256, data bytes) +func (_PublicResolver *PublicResolverCallerSession) ABI(node [32]byte, contentTypes *big.Int) (struct { + ContentType *big.Int + Data []byte +}, error) { + return _PublicResolver.Contract.ABI(&_PublicResolver.CallOpts, node, contentTypes) +} + +// Addr is a free data retrieval call binding the contract method 0x3b3b57de. +// +// Solidity: function addr(node bytes32) constant returns(ret address) +func (_PublicResolver *PublicResolverCaller) Addr(opts *bind.CallOpts, node [32]byte) (common.Address, error) { + var ( + ret0 = new(common.Address) + ) + out := ret0 + err := _PublicResolver.contract.Call(opts, out, "addr", node) + return *ret0, err +} + +// Addr is a free data retrieval call binding the contract method 0x3b3b57de. +// +// Solidity: function addr(node bytes32) constant returns(ret address) +func (_PublicResolver *PublicResolverSession) Addr(node [32]byte) (common.Address, error) { + return _PublicResolver.Contract.Addr(&_PublicResolver.CallOpts, node) +} + +// Addr is a free data retrieval call binding the contract method 0x3b3b57de. +// +// Solidity: function addr(node bytes32) constant returns(ret address) +func (_PublicResolver *PublicResolverCallerSession) Addr(node [32]byte) (common.Address, error) { + return _PublicResolver.Contract.Addr(&_PublicResolver.CallOpts, node) +} + +// Content is a free data retrieval call binding the contract method 0x2dff6941. +// +// Solidity: function content(node bytes32) constant returns(ret bytes32) +func (_PublicResolver *PublicResolverCaller) Content(opts *bind.CallOpts, node [32]byte) ([32]byte, error) { + var ( + ret0 = new([32]byte) + ) + out := ret0 + err := _PublicResolver.contract.Call(opts, out, "content", node) + return *ret0, err +} + +// Content is a free data retrieval call binding the contract method 0x2dff6941. +// +// Solidity: function content(node bytes32) constant returns(ret bytes32) +func (_PublicResolver *PublicResolverSession) Content(node [32]byte) ([32]byte, error) { + return _PublicResolver.Contract.Content(&_PublicResolver.CallOpts, node) +} + +// Content is a free data retrieval call binding the contract method 0x2dff6941. +// +// Solidity: function content(node bytes32) constant returns(ret bytes32) +func (_PublicResolver *PublicResolverCallerSession) Content(node [32]byte) ([32]byte, error) { + return _PublicResolver.Contract.Content(&_PublicResolver.CallOpts, node) +} + +// Name is a free data retrieval call binding the contract method 0x691f3431. +// +// Solidity: function name(node bytes32) constant returns(ret string) +func (_PublicResolver *PublicResolverCaller) Name(opts *bind.CallOpts, node [32]byte) (string, error) { + var ( + ret0 = new(string) + ) + out := ret0 + err := _PublicResolver.contract.Call(opts, out, "name", node) + return *ret0, err +} + +// Name is a free data retrieval call binding the contract method 0x691f3431. +// +// Solidity: function name(node bytes32) constant returns(ret string) +func (_PublicResolver *PublicResolverSession) Name(node [32]byte) (string, error) { + return _PublicResolver.Contract.Name(&_PublicResolver.CallOpts, node) +} + +// Name is a free data retrieval call binding the contract method 0x691f3431. +// +// Solidity: function name(node bytes32) constant returns(ret string) +func (_PublicResolver *PublicResolverCallerSession) Name(node [32]byte) (string, error) { + return _PublicResolver.Contract.Name(&_PublicResolver.CallOpts, node) +} + +// Pubkey is a free data retrieval call binding the contract method 0xc8690233. +// +// Solidity: function pubkey(node bytes32) constant returns(x bytes32, y bytes32) +func (_PublicResolver *PublicResolverCaller) Pubkey(opts *bind.CallOpts, node [32]byte) (struct { + X [32]byte + Y [32]byte +}, error) { + ret := new(struct { + X [32]byte + Y [32]byte + }) + out := ret + err := _PublicResolver.contract.Call(opts, out, "pubkey", node) + return *ret, err +} + +// Pubkey is a free data retrieval call binding the contract method 0xc8690233. +// +// Solidity: function pubkey(node bytes32) constant returns(x bytes32, y bytes32) +func (_PublicResolver *PublicResolverSession) Pubkey(node [32]byte) (struct { + X [32]byte + Y [32]byte +}, error) { + return _PublicResolver.Contract.Pubkey(&_PublicResolver.CallOpts, node) +} + +// Pubkey is a free data retrieval call binding the contract method 0xc8690233. +// +// Solidity: function pubkey(node bytes32) constant returns(x bytes32, y bytes32) +func (_PublicResolver *PublicResolverCallerSession) Pubkey(node [32]byte) (struct { + X [32]byte + Y [32]byte +}, error) { + return _PublicResolver.Contract.Pubkey(&_PublicResolver.CallOpts, node) +} + +// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7. +// +// Solidity: function supportsInterface(interfaceID bytes4) constant returns(bool) +func (_PublicResolver *PublicResolverCaller) SupportsInterface(opts *bind.CallOpts, interfaceID [4]byte) (bool, error) { + var ( + ret0 = new(bool) + ) + out := ret0 + err := _PublicResolver.contract.Call(opts, out, "supportsInterface", interfaceID) + return *ret0, err +} + +// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7. +// +// Solidity: function supportsInterface(interfaceID bytes4) constant returns(bool) +func (_PublicResolver *PublicResolverSession) SupportsInterface(interfaceID [4]byte) (bool, error) { + return _PublicResolver.Contract.SupportsInterface(&_PublicResolver.CallOpts, interfaceID) +} + +// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7. +// +// Solidity: function supportsInterface(interfaceID bytes4) constant returns(bool) +func (_PublicResolver *PublicResolverCallerSession) SupportsInterface(interfaceID [4]byte) (bool, error) { + return _PublicResolver.Contract.SupportsInterface(&_PublicResolver.CallOpts, interfaceID) +} + +// Text is a free data retrieval call binding the contract method 0x59d1d43c. +// +// Solidity: function text(node bytes32, key string) constant returns(ret string) +func (_PublicResolver *PublicResolverCaller) Text(opts *bind.CallOpts, node [32]byte, key string) (string, error) { + var ( + ret0 = new(string) + ) + out := ret0 + err := _PublicResolver.contract.Call(opts, out, "text", node, key) + return *ret0, err +} + +// Text is a free data retrieval call binding the contract method 0x59d1d43c. +// +// Solidity: function text(node bytes32, key string) constant returns(ret string) +func (_PublicResolver *PublicResolverSession) Text(node [32]byte, key string) (string, error) { + return _PublicResolver.Contract.Text(&_PublicResolver.CallOpts, node, key) +} + +// Text is a free data retrieval call binding the contract method 0x59d1d43c. +// +// Solidity: function text(node bytes32, key string) constant returns(ret string) +func (_PublicResolver *PublicResolverCallerSession) Text(node [32]byte, key string) (string, error) { + return _PublicResolver.Contract.Text(&_PublicResolver.CallOpts, node, key) +} + +// SetABI is a paid mutator transaction binding the contract method 0x623195b0. +// +// Solidity: function setABI(node bytes32, contentType uint256, data bytes) returns() +func (_PublicResolver *PublicResolverTransactor) SetABI(opts *bind.TransactOpts, node [32]byte, contentType *big.Int, data []byte) (*types.Transaction, error) { + return _PublicResolver.contract.Transact(opts, "setABI", node, contentType, data) +} + +// SetABI is a paid mutator transaction binding the contract method 0x623195b0. +// +// Solidity: function setABI(node bytes32, contentType uint256, data bytes) returns() +func (_PublicResolver *PublicResolverSession) SetABI(node [32]byte, contentType *big.Int, data []byte) (*types.Transaction, error) { + return _PublicResolver.Contract.SetABI(&_PublicResolver.TransactOpts, node, contentType, data) +} + +// SetABI is a paid mutator transaction binding the contract method 0x623195b0. +// +// Solidity: function setABI(node bytes32, contentType uint256, data bytes) returns() +func (_PublicResolver *PublicResolverTransactorSession) SetABI(node [32]byte, contentType *big.Int, data []byte) (*types.Transaction, error) { + return _PublicResolver.Contract.SetABI(&_PublicResolver.TransactOpts, node, contentType, data) +} + +// SetAddr is a paid mutator transaction binding the contract method 0xd5fa2b00. +// +// Solidity: function setAddr(node bytes32, addr address) returns() +func (_PublicResolver *PublicResolverTransactor) SetAddr(opts *bind.TransactOpts, node [32]byte, addr common.Address) (*types.Transaction, error) { + return _PublicResolver.contract.Transact(opts, "setAddr", node, addr) +} + +// SetAddr is a paid mutator transaction binding the contract method 0xd5fa2b00. +// +// Solidity: function setAddr(node bytes32, addr address) returns() +func (_PublicResolver *PublicResolverSession) SetAddr(node [32]byte, addr common.Address) (*types.Transaction, error) { + return _PublicResolver.Contract.SetAddr(&_PublicResolver.TransactOpts, node, addr) +} + +// SetAddr is a paid mutator transaction binding the contract method 0xd5fa2b00. +// +// Solidity: function setAddr(node bytes32, addr address) returns() +func (_PublicResolver *PublicResolverTransactorSession) SetAddr(node [32]byte, addr common.Address) (*types.Transaction, error) { + return _PublicResolver.Contract.SetAddr(&_PublicResolver.TransactOpts, node, addr) +} + +// SetContent is a paid mutator transaction binding the contract method 0xc3d014d6. +// +// Solidity: function setContent(node bytes32, hash bytes32) returns() +func (_PublicResolver *PublicResolverTransactor) SetContent(opts *bind.TransactOpts, node [32]byte, hash [32]byte) (*types.Transaction, error) { + return _PublicResolver.contract.Transact(opts, "setContent", node, hash) +} + +// SetContent is a paid mutator transaction binding the contract method 0xc3d014d6. +// +// Solidity: function setContent(node bytes32, hash bytes32) returns() +func (_PublicResolver *PublicResolverSession) SetContent(node [32]byte, hash [32]byte) (*types.Transaction, error) { + return _PublicResolver.Contract.SetContent(&_PublicResolver.TransactOpts, node, hash) +} + +// SetContent is a paid mutator transaction binding the contract method 0xc3d014d6. +// +// Solidity: function setContent(node bytes32, hash bytes32) returns() +func (_PublicResolver *PublicResolverTransactorSession) SetContent(node [32]byte, hash [32]byte) (*types.Transaction, error) { + return _PublicResolver.Contract.SetContent(&_PublicResolver.TransactOpts, node, hash) +} + +// SetName is a paid mutator transaction binding the contract method 0x77372213. +// +// Solidity: function setName(node bytes32, name string) returns() +func (_PublicResolver *PublicResolverTransactor) SetName(opts *bind.TransactOpts, node [32]byte, name string) (*types.Transaction, error) { + return _PublicResolver.contract.Transact(opts, "setName", node, name) +} + +// SetName is a paid mutator transaction binding the contract method 0x77372213. +// +// Solidity: function setName(node bytes32, name string) returns() +func (_PublicResolver *PublicResolverSession) SetName(node [32]byte, name string) (*types.Transaction, error) { + return _PublicResolver.Contract.SetName(&_PublicResolver.TransactOpts, node, name) +} + +// SetName is a paid mutator transaction binding the contract method 0x77372213. +// +// Solidity: function setName(node bytes32, name string) returns() +func (_PublicResolver *PublicResolverTransactorSession) SetName(node [32]byte, name string) (*types.Transaction, error) { + return _PublicResolver.Contract.SetName(&_PublicResolver.TransactOpts, node, name) +} + +// SetPubkey is a paid mutator transaction binding the contract method 0x29cd62ea. +// +// Solidity: function setPubkey(node bytes32, x bytes32, y bytes32) returns() +func (_PublicResolver *PublicResolverTransactor) SetPubkey(opts *bind.TransactOpts, node [32]byte, x [32]byte, y [32]byte) (*types.Transaction, error) { + return _PublicResolver.contract.Transact(opts, "setPubkey", node, x, y) +} + +// SetPubkey is a paid mutator transaction binding the contract method 0x29cd62ea. +// +// Solidity: function setPubkey(node bytes32, x bytes32, y bytes32) returns() +func (_PublicResolver *PublicResolverSession) SetPubkey(node [32]byte, x [32]byte, y [32]byte) (*types.Transaction, error) { + return _PublicResolver.Contract.SetPubkey(&_PublicResolver.TransactOpts, node, x, y) +} + +// SetPubkey is a paid mutator transaction binding the contract method 0x29cd62ea. +// +// Solidity: function setPubkey(node bytes32, x bytes32, y bytes32) returns() +func (_PublicResolver *PublicResolverTransactorSession) SetPubkey(node [32]byte, x [32]byte, y [32]byte) (*types.Transaction, error) { + return _PublicResolver.Contract.SetPubkey(&_PublicResolver.TransactOpts, node, x, y) +} + +// SetText is a paid mutator transaction binding the contract method 0x10f13a8c. +// +// Solidity: function setText(node bytes32, key string, value string) returns() +func (_PublicResolver *PublicResolverTransactor) SetText(opts *bind.TransactOpts, node [32]byte, key string, value string) (*types.Transaction, error) { + return _PublicResolver.contract.Transact(opts, "setText", node, key, value) +} + +// SetText is a paid mutator transaction binding the contract method 0x10f13a8c. +// +// Solidity: function setText(node bytes32, key string, value string) returns() +func (_PublicResolver *PublicResolverSession) SetText(node [32]byte, key string, value string) (*types.Transaction, error) { + return _PublicResolver.Contract.SetText(&_PublicResolver.TransactOpts, node, key, value) +} + +// SetText is a paid mutator transaction binding the contract method 0x10f13a8c. +// +// Solidity: function setText(node bytes32, key string, value string) returns() +func (_PublicResolver *PublicResolverTransactorSession) SetText(node [32]byte, key string, value string) (*types.Transaction, error) { + return _PublicResolver.Contract.SetText(&_PublicResolver.TransactOpts, node, key, value) +} + +// PublicResolverABIChangedIterator is returned from FilterABIChanged and is used to iterate over the raw logs and unpacked data for ABIChanged events raised by the PublicResolver contract. +type PublicResolverABIChangedIterator struct { + Event *PublicResolverABIChanged // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PublicResolverABIChangedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PublicResolverABIChanged) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PublicResolverABIChanged) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error retruned any retrieval or parsing error occurred during filtering. +func (it *PublicResolverABIChangedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PublicResolverABIChangedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PublicResolverABIChanged represents a ABIChanged event raised by the PublicResolver contract. +type PublicResolverABIChanged struct { + Node [32]byte + ContentType *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterABIChanged is a free log retrieval operation binding the contract event 0xaa121bbeef5f32f5961a2a28966e769023910fc9479059ee3495d4c1a696efe3. +// +// Solidity: event ABIChanged(node indexed bytes32, contentType indexed uint256) +func (_PublicResolver *PublicResolverFilterer) FilterABIChanged(opts *bind.FilterOpts, node [][32]byte, contentType []*big.Int) (*PublicResolverABIChangedIterator, error) { + + var nodeRule []interface{} + for _, nodeItem := range node { + nodeRule = append(nodeRule, nodeItem) + } + var contentTypeRule []interface{} + for _, contentTypeItem := range contentType { + contentTypeRule = append(contentTypeRule, contentTypeItem) + } + + logs, sub, err := _PublicResolver.contract.FilterLogs(opts, "ABIChanged", nodeRule, contentTypeRule) + if err != nil { + return nil, err + } + return &PublicResolverABIChangedIterator{contract: _PublicResolver.contract, event: "ABIChanged", logs: logs, sub: sub}, nil +} + +// WatchABIChanged is a free log subscription operation binding the contract event 0xaa121bbeef5f32f5961a2a28966e769023910fc9479059ee3495d4c1a696efe3. +// +// Solidity: event ABIChanged(node indexed bytes32, contentType indexed uint256) +func (_PublicResolver *PublicResolverFilterer) WatchABIChanged(opts *bind.WatchOpts, sink chan<- *PublicResolverABIChanged, node [][32]byte, contentType []*big.Int) (event.Subscription, error) { + + var nodeRule []interface{} + for _, nodeItem := range node { + nodeRule = append(nodeRule, nodeItem) + } + var contentTypeRule []interface{} + for _, contentTypeItem := range contentType { + contentTypeRule = append(contentTypeRule, contentTypeItem) + } + + logs, sub, err := _PublicResolver.contract.WatchLogs(opts, "ABIChanged", nodeRule, contentTypeRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PublicResolverABIChanged) + if err := _PublicResolver.contract.UnpackLog(event, "ABIChanged", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// PublicResolverAddrChangedIterator is returned from FilterAddrChanged and is used to iterate over the raw logs and unpacked data for AddrChanged events raised by the PublicResolver contract. +type PublicResolverAddrChangedIterator struct { + Event *PublicResolverAddrChanged // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PublicResolverAddrChangedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PublicResolverAddrChanged) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PublicResolverAddrChanged) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error retruned any retrieval or parsing error occurred during filtering. +func (it *PublicResolverAddrChangedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PublicResolverAddrChangedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PublicResolverAddrChanged represents a AddrChanged event raised by the PublicResolver contract. +type PublicResolverAddrChanged struct { + Node [32]byte + A common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterAddrChanged is a free log retrieval operation binding the contract event 0x52d7d861f09ab3d26239d492e8968629f95e9e318cf0b73bfddc441522a15fd2. +// +// Solidity: event AddrChanged(node indexed bytes32, a address) +func (_PublicResolver *PublicResolverFilterer) FilterAddrChanged(opts *bind.FilterOpts, node [][32]byte) (*PublicResolverAddrChangedIterator, error) { + + var nodeRule []interface{} + for _, nodeItem := range node { + nodeRule = append(nodeRule, nodeItem) + } + + logs, sub, err := _PublicResolver.contract.FilterLogs(opts, "AddrChanged", nodeRule) + if err != nil { + return nil, err + } + return &PublicResolverAddrChangedIterator{contract: _PublicResolver.contract, event: "AddrChanged", logs: logs, sub: sub}, nil +} + +// WatchAddrChanged is a free log subscription operation binding the contract event 0x52d7d861f09ab3d26239d492e8968629f95e9e318cf0b73bfddc441522a15fd2. +// +// Solidity: event AddrChanged(node indexed bytes32, a address) +func (_PublicResolver *PublicResolverFilterer) WatchAddrChanged(opts *bind.WatchOpts, sink chan<- *PublicResolverAddrChanged, node [][32]byte) (event.Subscription, error) { + + var nodeRule []interface{} + for _, nodeItem := range node { + nodeRule = append(nodeRule, nodeItem) + } + + logs, sub, err := _PublicResolver.contract.WatchLogs(opts, "AddrChanged", nodeRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PublicResolverAddrChanged) + if err := _PublicResolver.contract.UnpackLog(event, "AddrChanged", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// PublicResolverContentChangedIterator is returned from FilterContentChanged and is used to iterate over the raw logs and unpacked data for ContentChanged events raised by the PublicResolver contract. +type PublicResolverContentChangedIterator struct { + Event *PublicResolverContentChanged // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PublicResolverContentChangedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PublicResolverContentChanged) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PublicResolverContentChanged) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error retruned any retrieval or parsing error occurred during filtering. +func (it *PublicResolverContentChangedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PublicResolverContentChangedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PublicResolverContentChanged represents a ContentChanged event raised by the PublicResolver contract. +type PublicResolverContentChanged struct { + Node [32]byte + Hash [32]byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterContentChanged is a free log retrieval operation binding the contract event 0x0424b6fe0d9c3bdbece0e7879dc241bb0c22e900be8b6c168b4ee08bd9bf83bc. +// +// Solidity: event ContentChanged(node indexed bytes32, hash bytes32) +func (_PublicResolver *PublicResolverFilterer) FilterContentChanged(opts *bind.FilterOpts, node [][32]byte) (*PublicResolverContentChangedIterator, error) { + + var nodeRule []interface{} + for _, nodeItem := range node { + nodeRule = append(nodeRule, nodeItem) + } + + logs, sub, err := _PublicResolver.contract.FilterLogs(opts, "ContentChanged", nodeRule) + if err != nil { + return nil, err + } + return &PublicResolverContentChangedIterator{contract: _PublicResolver.contract, event: "ContentChanged", logs: logs, sub: sub}, nil +} + +// WatchContentChanged is a free log subscription operation binding the contract event 0x0424b6fe0d9c3bdbece0e7879dc241bb0c22e900be8b6c168b4ee08bd9bf83bc. +// +// Solidity: event ContentChanged(node indexed bytes32, hash bytes32) +func (_PublicResolver *PublicResolverFilterer) WatchContentChanged(opts *bind.WatchOpts, sink chan<- *PublicResolverContentChanged, node [][32]byte) (event.Subscription, error) { + + var nodeRule []interface{} + for _, nodeItem := range node { + nodeRule = append(nodeRule, nodeItem) + } + + logs, sub, err := _PublicResolver.contract.WatchLogs(opts, "ContentChanged", nodeRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PublicResolverContentChanged) + if err := _PublicResolver.contract.UnpackLog(event, "ContentChanged", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// PublicResolverNameChangedIterator is returned from FilterNameChanged and is used to iterate over the raw logs and unpacked data for NameChanged events raised by the PublicResolver contract. +type PublicResolverNameChangedIterator struct { + Event *PublicResolverNameChanged // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PublicResolverNameChangedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PublicResolverNameChanged) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PublicResolverNameChanged) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error retruned any retrieval or parsing error occurred during filtering. +func (it *PublicResolverNameChangedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PublicResolverNameChangedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PublicResolverNameChanged represents a NameChanged event raised by the PublicResolver contract. +type PublicResolverNameChanged struct { + Node [32]byte + Name string + Raw types.Log // Blockchain specific contextual infos +} + +// FilterNameChanged is a free log retrieval operation binding the contract event 0xb7d29e911041e8d9b843369e890bcb72c9388692ba48b65ac54e7214c4c348f7. +// +// Solidity: event NameChanged(node indexed bytes32, name string) +func (_PublicResolver *PublicResolverFilterer) FilterNameChanged(opts *bind.FilterOpts, node [][32]byte) (*PublicResolverNameChangedIterator, error) { + + var nodeRule []interface{} + for _, nodeItem := range node { + nodeRule = append(nodeRule, nodeItem) + } + + logs, sub, err := _PublicResolver.contract.FilterLogs(opts, "NameChanged", nodeRule) + if err != nil { + return nil, err + } + return &PublicResolverNameChangedIterator{contract: _PublicResolver.contract, event: "NameChanged", logs: logs, sub: sub}, nil +} + +// WatchNameChanged is a free log subscription operation binding the contract event 0xb7d29e911041e8d9b843369e890bcb72c9388692ba48b65ac54e7214c4c348f7. +// +// Solidity: event NameChanged(node indexed bytes32, name string) +func (_PublicResolver *PublicResolverFilterer) WatchNameChanged(opts *bind.WatchOpts, sink chan<- *PublicResolverNameChanged, node [][32]byte) (event.Subscription, error) { + + var nodeRule []interface{} + for _, nodeItem := range node { + nodeRule = append(nodeRule, nodeItem) + } + + logs, sub, err := _PublicResolver.contract.WatchLogs(opts, "NameChanged", nodeRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PublicResolverNameChanged) + if err := _PublicResolver.contract.UnpackLog(event, "NameChanged", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// PublicResolverPubkeyChangedIterator is returned from FilterPubkeyChanged and is used to iterate over the raw logs and unpacked data for PubkeyChanged events raised by the PublicResolver contract. +type PublicResolverPubkeyChangedIterator struct { + Event *PublicResolverPubkeyChanged // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PublicResolverPubkeyChangedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PublicResolverPubkeyChanged) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PublicResolverPubkeyChanged) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error retruned any retrieval or parsing error occurred during filtering. +func (it *PublicResolverPubkeyChangedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PublicResolverPubkeyChangedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PublicResolverPubkeyChanged represents a PubkeyChanged event raised by the PublicResolver contract. +type PublicResolverPubkeyChanged struct { + Node [32]byte + X [32]byte + Y [32]byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterPubkeyChanged is a free log retrieval operation binding the contract event 0x1d6f5e03d3f63eb58751986629a5439baee5079ff04f345becb66e23eb154e46. +// +// Solidity: event PubkeyChanged(node indexed bytes32, x bytes32, y bytes32) +func (_PublicResolver *PublicResolverFilterer) FilterPubkeyChanged(opts *bind.FilterOpts, node [][32]byte) (*PublicResolverPubkeyChangedIterator, error) { + + var nodeRule []interface{} + for _, nodeItem := range node { + nodeRule = append(nodeRule, nodeItem) + } + + logs, sub, err := _PublicResolver.contract.FilterLogs(opts, "PubkeyChanged", nodeRule) + if err != nil { + return nil, err + } + return &PublicResolverPubkeyChangedIterator{contract: _PublicResolver.contract, event: "PubkeyChanged", logs: logs, sub: sub}, nil +} + +// WatchPubkeyChanged is a free log subscription operation binding the contract event 0x1d6f5e03d3f63eb58751986629a5439baee5079ff04f345becb66e23eb154e46. +// +// Solidity: event PubkeyChanged(node indexed bytes32, x bytes32, y bytes32) +func (_PublicResolver *PublicResolverFilterer) WatchPubkeyChanged(opts *bind.WatchOpts, sink chan<- *PublicResolverPubkeyChanged, node [][32]byte) (event.Subscription, error) { + + var nodeRule []interface{} + for _, nodeItem := range node { + nodeRule = append(nodeRule, nodeItem) + } + + logs, sub, err := _PublicResolver.contract.WatchLogs(opts, "PubkeyChanged", nodeRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PublicResolverPubkeyChanged) + if err := _PublicResolver.contract.UnpackLog(event, "PubkeyChanged", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// PublicResolverTextChangedIterator is returned from FilterTextChanged and is used to iterate over the raw logs and unpacked data for TextChanged events raised by the PublicResolver contract. +type PublicResolverTextChangedIterator struct { + Event *PublicResolverTextChanged // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PublicResolverTextChangedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PublicResolverTextChanged) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PublicResolverTextChanged) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error retruned any retrieval or parsing error occurred during filtering. +func (it *PublicResolverTextChangedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PublicResolverTextChangedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PublicResolverTextChanged represents a TextChanged event raised by the PublicResolver contract. +type PublicResolverTextChanged struct { + Node [32]byte + IndexedKey common.Hash + Key string + Raw types.Log // Blockchain specific contextual infos +} + +// FilterTextChanged is a free log retrieval operation binding the contract event 0xd8c9334b1a9c2f9da342a0a2b32629c1a229b6445dad78947f674b44444a7550. +// +// Solidity: event TextChanged(node indexed bytes32, indexedKey indexed string, key string) +func (_PublicResolver *PublicResolverFilterer) FilterTextChanged(opts *bind.FilterOpts, node [][32]byte, indexedKey []string) (*PublicResolverTextChangedIterator, error) { + + var nodeRule []interface{} + for _, nodeItem := range node { + nodeRule = append(nodeRule, nodeItem) + } + var indexedKeyRule []interface{} + for _, indexedKeyItem := range indexedKey { + indexedKeyRule = append(indexedKeyRule, indexedKeyItem) + } + + logs, sub, err := _PublicResolver.contract.FilterLogs(opts, "TextChanged", nodeRule, indexedKeyRule) + if err != nil { + return nil, err + } + return &PublicResolverTextChangedIterator{contract: _PublicResolver.contract, event: "TextChanged", logs: logs, sub: sub}, nil +} + +// WatchTextChanged is a free log subscription operation binding the contract event 0xd8c9334b1a9c2f9da342a0a2b32629c1a229b6445dad78947f674b44444a7550. +// +// Solidity: event TextChanged(node indexed bytes32, indexedKey indexed string, key string) +func (_PublicResolver *PublicResolverFilterer) WatchTextChanged(opts *bind.WatchOpts, sink chan<- *PublicResolverTextChanged, node [][32]byte, indexedKey []string) (event.Subscription, error) { + + var nodeRule []interface{} + for _, nodeItem := range node { + nodeRule = append(nodeRule, nodeItem) + } + var indexedKeyRule []interface{} + for _, indexedKeyItem := range indexedKey { + indexedKeyRule = append(indexedKeyRule, indexedKeyItem) + } + + logs, sub, err := _PublicResolver.contract.WatchLogs(opts, "TextChanged", nodeRule, indexedKeyRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PublicResolverTextChanged) + if err := _PublicResolver.contract.UnpackLog(event, "TextChanged", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} diff --git a/core/blockchain.go b/core/blockchain.go index c4481588f9..539f40d196 100644 --- a/core/blockchain.go +++ b/core/blockchain.go @@ -47,6 +47,16 @@ import ( ) var ( + accountReadTimer = metrics.NewRegisteredTimer("chain/account/reads", nil) + accountHashTimer = metrics.NewRegisteredTimer("chain/account/hashes", nil) + accountUpdateTimer = metrics.NewRegisteredTimer("chain/account/updates", nil) + accountCommitTimer = metrics.NewRegisteredTimer("chain/account/commits", nil) + + storageReadTimer = metrics.NewRegisteredTimer("chain/storage/reads", nil) + storageHashTimer = metrics.NewRegisteredTimer("chain/storage/hashes", nil) + storageUpdateTimer = metrics.NewRegisteredTimer("chain/storage/updates", nil) + storageCommitTimer = metrics.NewRegisteredTimer("chain/storage/commits", nil) + blockInsertTimer = metrics.NewRegisteredTimer("chain/inserts", nil) blockValidationTimer = metrics.NewRegisteredTimer("chain/validation", nil) blockExecutionTimer = metrics.NewRegisteredTimer("chain/execution", nil) @@ -1249,10 +1259,26 @@ func (bc *BlockChain) insertChain(chain types.Blocks, verifySeals bool) (int, [] if err != nil { return it.index, events, coalescedLogs, err } + + // Update the metrics subsystem with all the measurements + accountReadTimer.Update(state.AccountReads) + accountHashTimer.Update(state.AccountHashes) + accountUpdateTimer.Update(state.AccountUpdates) + accountCommitTimer.Update(state.AccountCommits) + + storageReadTimer.Update(state.StorageReads) + storageHashTimer.Update(state.StorageHashes) + storageUpdateTimer.Update(state.StorageUpdates) + storageCommitTimer.Update(state.StorageCommits) + + trieAccess := state.AccountReads + state.AccountHashes + state.AccountUpdates + state.AccountCommits + trieAccess += state.StorageReads + state.StorageHashes + state.StorageUpdates + state.StorageCommits + blockInsertTimer.UpdateSince(start) - blockExecutionTimer.Update(t1.Sub(t0)) + blockExecutionTimer.Update(t1.Sub(t0) - trieAccess) blockValidationTimer.Update(t2.Sub(t1)) blockWriteTimer.Update(t3.Sub(t2)) + switch status { case CanonStatTy: log.Debug("Inserted new block", "number", block.Number(), "hash", block.Hash(), @@ -1274,7 +1300,6 @@ func (bc *BlockChain) insertChain(chain types.Blocks, verifySeals bool) (int, [] "root", block.Root()) events = append(events, ChainSideEvent{block}) } - blockInsertTimer.UpdateSince(start) stats.processed++ stats.usedGas += usedGas diff --git a/core/state/state_object.go b/core/state/state_object.go index f41ab04092..7fbb45b3df 100644 --- a/core/state/state_object.go +++ b/core/state/state_object.go @@ -21,9 +21,11 @@ import ( "fmt" "io" "math/big" + "time" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/metrics" "github.com/ethereum/go-ethereum/rlp" ) @@ -177,6 +179,10 @@ func (self *stateObject) GetCommittedState(db Database, key common.Hash) common. if cached { return value } + // Track the amount of time wasted on reading the storge trie + if metrics.EnabledExpensive { + defer func(start time.Time) { self.db.StorageReads += time.Since(start) }(time.Now()) + } // Otherwise load the value from the database enc, err := self.getTrie(db).TryGet(key[:]) if err != nil { @@ -216,6 +222,11 @@ func (self *stateObject) setState(key, value common.Hash) { // updateTrie writes cached storage modifications into the object's storage trie. func (self *stateObject) updateTrie(db Database) Trie { + // Track the amount of time wasted on updating the storge trie + if metrics.EnabledExpensive { + defer func(start time.Time) { self.db.StorageUpdates += time.Since(start) }(time.Now()) + } + // Update all the dirty slots in the trie tr := self.getTrie(db) for key, value := range self.dirtyStorage { delete(self.dirtyStorage, key) @@ -240,6 +251,11 @@ func (self *stateObject) updateTrie(db Database) Trie { // UpdateRoot sets the trie root to the current root hash of func (self *stateObject) updateRoot(db Database) { self.updateTrie(db) + + // Track the amount of time wasted on hashing the storge trie + if metrics.EnabledExpensive { + defer func(start time.Time) { self.db.StorageHashes += time.Since(start) }(time.Now()) + } self.data.Root = self.trie.Hash() } @@ -250,6 +266,10 @@ func (self *stateObject) CommitTrie(db Database) error { if self.dbErr != nil { return self.dbErr } + // Track the amount of time wasted on committing the storge trie + if metrics.EnabledExpensive { + defer func(start time.Time) { self.db.StorageCommits += time.Since(start) }(time.Now()) + } root, err := self.trie.Commit(nil) if err == nil { self.data.Root = root diff --git a/core/state/statedb.go b/core/state/statedb.go index 4c00092f4e..0673de543f 100644 --- a/core/state/statedb.go +++ b/core/state/statedb.go @@ -22,11 +22,13 @@ import ( "fmt" "math/big" "sort" + "time" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/log" + "github.com/ethereum/go-ethereum/metrics" "github.com/ethereum/go-ethereum/rlp" "github.com/ethereum/go-ethereum/trie" ) @@ -86,6 +88,16 @@ type StateDB struct { journal *journal validRevisions []revision nextRevisionId int + + // Measurements gathered during execution for debugging purposes + AccountReads time.Duration + AccountHashes time.Duration + AccountUpdates time.Duration + AccountCommits time.Duration + StorageReads time.Duration + StorageHashes time.Duration + StorageUpdates time.Duration + StorageCommits time.Duration } // Create a new state from a given trie. @@ -386,36 +398,51 @@ func (self *StateDB) Suicide(addr common.Address) bool { // // updateStateObject writes the given object to the trie. -func (self *StateDB) updateStateObject(stateObject *stateObject) { +func (s *StateDB) updateStateObject(stateObject *stateObject) { + // Track the amount of time wasted on updating the account from the trie + if metrics.EnabledExpensive { + defer func(start time.Time) { s.AccountUpdates += time.Since(start) }(time.Now()) + } + // Encode the account and update the account trie addr := stateObject.Address() + data, err := rlp.EncodeToBytes(stateObject) if err != nil { panic(fmt.Errorf("can't encode object at %x: %v", addr[:], err)) } - self.setError(self.trie.TryUpdate(addr[:], data)) + s.setError(s.trie.TryUpdate(addr[:], data)) } // deleteStateObject removes the given object from the state trie. -func (self *StateDB) deleteStateObject(stateObject *stateObject) { +func (s *StateDB) deleteStateObject(stateObject *stateObject) { + // Track the amount of time wasted on deleting the account from the trie + if metrics.EnabledExpensive { + defer func(start time.Time) { s.AccountUpdates += time.Since(start) }(time.Now()) + } + // Delete the account from the trie stateObject.deleted = true + addr := stateObject.Address() - self.setError(self.trie.TryDelete(addr[:])) + s.setError(s.trie.TryDelete(addr[:])) } // Retrieve a state object given by the address. Returns nil if not found. -func (self *StateDB) getStateObject(addr common.Address) (stateObject *stateObject) { - // Prefer 'live' objects. - if obj := self.stateObjects[addr]; obj != nil { +func (s *StateDB) getStateObject(addr common.Address) (stateObject *stateObject) { + // Prefer live objects + if obj := s.stateObjects[addr]; obj != nil { if obj.deleted { return nil } return obj } - - // Load the object from the database. - enc, err := self.trie.TryGet(addr[:]) + // Track the amount of time wasted on loading the object from the database + if metrics.EnabledExpensive { + defer func(start time.Time) { s.AccountReads += time.Since(start) }(time.Now()) + } + // Load the object from the database + enc, err := s.trie.TryGet(addr[:]) if len(enc) == 0 { - self.setError(err) + s.setError(err) return nil } var data Account @@ -423,9 +450,9 @@ func (self *StateDB) getStateObject(addr common.Address) (stateObject *stateObje log.Error("Failed to decode state object", "addr", addr, "err", err) return nil } - // Insert into the live set. - obj := newObject(self, addr, data) - self.setStateObject(obj) + // Insert into the live set + obj := newObject(s, addr, data) + s.setStateObject(obj) return obj } @@ -600,6 +627,11 @@ func (s *StateDB) Finalise(deleteEmptyObjects bool) { // goes into transaction receipts. func (s *StateDB) IntermediateRoot(deleteEmptyObjects bool) common.Hash { s.Finalise(deleteEmptyObjects) + + // Track the amount of time wasted on hashing the account trie + if metrics.EnabledExpensive { + defer func(start time.Time) { s.AccountHashes += time.Since(start) }(time.Now()) + } return s.trie.Hash() } @@ -624,7 +656,7 @@ func (s *StateDB) Commit(deleteEmptyObjects bool) (root common.Hash, err error) for addr := range s.journal.dirties { s.stateObjectsDirty[addr] = struct{}{} } - // Commit objects to the trie. + // Commit objects to the trie, measuring the elapsed time for addr, stateObject := range s.stateObjects { _, isDirty := s.stateObjectsDirty[addr] switch { @@ -647,7 +679,10 @@ func (s *StateDB) Commit(deleteEmptyObjects bool) (root common.Hash, err error) } delete(s.stateObjectsDirty, addr) } - // Write trie changes. + // Write the account trie changes, measuing the amount of wasted time + if metrics.EnabledExpensive { + defer func(start time.Time) { s.AccountCommits += time.Since(start) }(time.Now()) + } root, err = s.trie.Commit(func(leaf []byte, parent common.Hash) error { var account Account if err := rlp.DecodeBytes(leaf, &account); err != nil { diff --git a/internal/build/util.go b/internal/build/util.go index b34371c2dd..319c0f2d3e 100644 --- a/internal/build/util.go +++ b/internal/build/util.go @@ -143,9 +143,9 @@ func CopyFile(dst, src string, mode os.FileMode) { // so that go commands executed by build use the same version of Go as the 'host' that runs // build code. e.g. // -// /usr/lib/go-1.12/bin/go run build/ci.go ... +// /usr/lib/go-1.12.1/bin/go run build/ci.go ... // -// runs using go 1.12 and invokes go 1.12 tools from the same GOROOT. This is also important +// runs using go 1.12.1 and invokes go 1.12.1 tools from the same GOROOT. This is also important // because runtime.Version checks on the host should match the tools that are run. func GoTool(tool string, args ...string) *exec.Cmd { args = append([]string{tool}, args...) diff --git a/les/handler.go b/les/handler.go index 50c32fb958..7c290b717d 100644 --- a/les/handler.go +++ b/les/handler.go @@ -329,6 +329,11 @@ func (pm *ProtocolManager) handle(p *peer) error { // handleMsg is invoked whenever an inbound message is received from a remote // peer. The remote connection is torn down upon returning any error. func (pm *ProtocolManager) handleMsg(p *peer) error { + select { + case err := <-p.errCh: + return err + default: + } // Read the next message from the remote peer, and ensure it's fully consumed msg, err := p.rw.ReadMsg() if err != nil { @@ -389,7 +394,10 @@ func (pm *ProtocolManager) handleMsg(p *peer) error { if reply != nil { p.queueSend(func() { if err := reply.send(bv); err != nil { - p.errCh <- err + select { + case p.errCh <- err: + default: + } } }) } diff --git a/les/peer.go b/les/peer.go index 8b506de629..0c15add9c6 100644 --- a/les/peer.go +++ b/les/peer.go @@ -98,15 +98,14 @@ type peer struct { } func newPeer(version int, network uint64, isTrusted bool, p *p2p.Peer, rw p2p.MsgReadWriter) *peer { - id := p.ID() - return &peer{ Peer: p, rw: rw, version: version, network: network, - id: fmt.Sprintf("%x", id), + id: fmt.Sprintf("%x", p.ID().Bytes()), isTrusted: isTrusted, + errCh: make(chan error, 1), } } diff --git a/les/server.go b/les/server.go index 270640f025..3716685e17 100644 --- a/les/server.go +++ b/les/server.go @@ -280,8 +280,8 @@ func (pm *ProtocolManager) blockLoop() { ) for _, p := range peers { + p := p switch p.announceType { - case announceTypeSimple: p.queueSend(func() { p.SendAnnounce(announce) }) case announceTypeSigned: @@ -290,7 +290,6 @@ func (pm *ProtocolManager) blockLoop() { signedAnnounce.sign(pm.server.privateKey) signed = true } - p.queueSend(func() { p.SendAnnounce(signedAnnounce) }) } } diff --git a/metrics/influxdb/influxdb.go b/metrics/influxdb/influxdb.go index c4ef927234..6619915fdb 100644 --- a/metrics/influxdb/influxdb.go +++ b/metrics/influxdb/influxdb.go @@ -91,6 +91,7 @@ func (r *reporter) makeClient() (err error) { URL: r.url, Username: r.username, Password: r.password, + Timeout: 10 * time.Second, }) return diff --git a/metrics/metrics.go b/metrics/metrics.go index 5910fb0734..8ae7aec435 100644 --- a/metrics/metrics.go +++ b/metrics/metrics.go @@ -15,24 +15,41 @@ import ( ) // Enabled is checked by the constructor functions for all of the -// standard metrics. If it is true, the metric returned is a stub. +// standard metrics. If it is true, the metric returned is a stub. // // This global kill-switch helps quantify the observer effect and makes // for less cluttered pprof profiles. var Enabled = false -// MetricsEnabledFlag is the CLI flag name to use to enable metrics collections. -const MetricsEnabledFlag = "metrics" -const DashboardEnabledFlag = "dashboard" +// EnabledExpensive is a soft-flag meant for external packages to check if costly +// metrics gathering is allowed or not. The goal is to separate standard metrics +// for health monitoring and debug metrics that might impact runtime performance. +var EnabledExpensive = false + +// enablerFlags is the CLI flag names to use to enable metrics collections. +var enablerFlags = []string{"metrics", "dashboard"} + +// expensiveEnablerFlags is the CLI flag names to use to enable metrics collections. +var expensiveEnablerFlags = []string{"metrics.expensive"} // Init enables or disables the metrics system. Since we need this to run before // any other code gets to create meters and timers, we'll actually do an ugly hack // and peek into the command line args for the metrics flag. func init() { for _, arg := range os.Args { - if flag := strings.TrimLeft(arg, "-"); flag == MetricsEnabledFlag || flag == DashboardEnabledFlag { - log.Info("Enabling metrics collection") - Enabled = true + flag := strings.TrimLeft(arg, "-") + + for _, enabler := range enablerFlags { + if !Enabled && flag == enabler { + log.Info("Enabling metrics collection") + Enabled = true + } + } + for _, enabler := range expensiveEnablerFlags { + if !EnabledExpensive && flag == enabler { + log.Info("Enabling expensive metrics collection") + EnabledExpensive = true + } } } } diff --git a/p2p/simulations/adapters/exec.go b/p2p/simulations/adapters/exec.go index bd8bcbc856..106b179e43 100644 --- a/p2p/simulations/adapters/exec.go +++ b/p2p/simulations/adapters/exec.go @@ -92,6 +92,10 @@ func (e *ExecAdapter) NewNode(config *NodeConfig) (Node, error) { return nil, fmt.Errorf("error creating node directory: %s", err) } + err := config.initDummyEnode() + if err != nil { + return nil, err + } // generate the config conf := &execNodeConfig{ Stack: node.DefaultConfig, @@ -407,6 +411,13 @@ func startExecNodeStack() (*node.Node, error) { if err := json.Unmarshal([]byte(confEnv), &conf); err != nil { return nil, fmt.Errorf("error decoding %s: %v", envNodeConfig, err) } + + // create enode record + nodeTcpConn, err := net.ResolveTCPAddr("tcp", conf.Stack.P2P.ListenAddr) + if nodeTcpConn.IP == nil { + nodeTcpConn.IP = net.IPv4(127, 0, 0, 1) + } + conf.Node.initEnode(nodeTcpConn.IP, nodeTcpConn.Port, nodeTcpConn.Port) conf.Stack.P2P.PrivateKey = conf.Node.PrivateKey conf.Stack.Logger = log.New("node.id", conf.Node.ID.String()) diff --git a/p2p/simulations/adapters/inproc.go b/p2p/simulations/adapters/inproc.go index 991573c2dc..c1cf23a175 100644 --- a/p2p/simulations/adapters/inproc.go +++ b/p2p/simulations/adapters/inproc.go @@ -28,7 +28,6 @@ import ( "github.com/ethereum/go-ethereum/node" "github.com/ethereum/go-ethereum/p2p" "github.com/ethereum/go-ethereum/p2p/enode" - "github.com/ethereum/go-ethereum/p2p/enr" "github.com/ethereum/go-ethereum/p2p/simulations/pipes" "github.com/ethereum/go-ethereum/rpc" ) @@ -93,23 +92,10 @@ func (s *SimAdapter) NewNode(config *NodeConfig) (Node, error) { } } - // dialer in simulations based on ENR records - // doesn't work unless we explicitly set localhost record - ip := enr.IP(net.IPv4(127, 0, 0, 1)) - config.Record.Set(&ip) - tcpPort := enr.TCP(0) - config.Record.Set(&tcpPort) - - err := enode.SignV4(&config.Record, config.PrivateKey) + err := config.initDummyEnode() if err != nil { - return nil, fmt.Errorf("unable to generate ENR: %v", err) + return nil, err } - nod, err := enode.New(enode.V4ID{}, &config.Record) - if err != nil { - return nil, fmt.Errorf("unable to create enode: %v", err) - } - log.Trace("simnode new", "record", config.Record) - config.node = nod n, err := node.New(&node.Config{ P2P: p2p.Config{ diff --git a/p2p/simulations/adapters/types.go b/p2p/simulations/adapters/types.go index e5e4d159cb..f65ce7b605 100644 --- a/p2p/simulations/adapters/types.go +++ b/p2p/simulations/adapters/types.go @@ -27,6 +27,7 @@ import ( "github.com/docker/docker/pkg/reexec" "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/node" "github.com/ethereum/go-ethereum/p2p" "github.com/ethereum/go-ethereum/p2p/enode" @@ -265,3 +266,30 @@ func RegisterServices(services Services) { os.Exit(0) } } + +// adds the host part to the configuration's ENR, signs it +// creates and the corresponding enode object to the configuration +func (n *NodeConfig) initEnode(ip net.IP, tcpport int, udpport int) error { + enrIp := enr.IP(ip) + n.Record.Set(&enrIp) + enrTcpPort := enr.TCP(tcpport) + n.Record.Set(&enrTcpPort) + enrUdpPort := enr.UDP(udpport) + n.Record.Set(&enrUdpPort) + + err := enode.SignV4(&n.Record, n.PrivateKey) + if err != nil { + return fmt.Errorf("unable to generate ENR: %v", err) + } + nod, err := enode.New(enode.V4ID{}, &n.Record) + if err != nil { + return fmt.Errorf("unable to create enode: %v", err) + } + log.Trace("simnode new", "record", n.Record) + n.node = nod + return nil +} + +func (n *NodeConfig) initDummyEnode() error { + return n.initEnode(net.IPv4(127, 0, 0, 1), 0, 0) +} diff --git a/swarm/api/config.go b/swarm/api/config.go index 1fa6c4fdff..0a7100c574 100644 --- a/swarm/api/config.go +++ b/swarm/api/config.go @@ -29,7 +29,6 @@ import ( "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/node" "github.com/ethereum/go-ethereum/p2p/enode" - "github.com/ethereum/go-ethereum/swarm/log" "github.com/ethereum/go-ethereum/swarm/network" "github.com/ethereum/go-ethereum/swarm/pss" "github.com/ethereum/go-ethereum/swarm/services/swap" @@ -58,7 +57,7 @@ type Config struct { Port string PublicKey string BzzKey string - NodeID string + Enode *enode.Node `toml:"-"` NetworkID uint64 SwapEnabled bool SyncEnabled bool @@ -104,33 +103,38 @@ func NewConfig() (c *Config) { //some config params need to be initialized after the complete //config building phase is completed (e.g. due to overriding flags) -func (c *Config) Init(prvKey *ecdsa.PrivateKey) { +func (c *Config) Init(prvKey *ecdsa.PrivateKey, nodeKey *ecdsa.PrivateKey) error { - address := crypto.PubkeyToAddress(prvKey.PublicKey) - c.Path = filepath.Join(c.Path, "bzz-"+common.Bytes2Hex(address.Bytes())) - err := os.MkdirAll(c.Path, os.ModePerm) + // create swarm dir and record key + err := c.createAndSetPath(c.Path, prvKey) if err != nil { - log.Error(fmt.Sprintf("Error creating root swarm data directory: %v", err)) - return + return fmt.Errorf("Error creating root swarm data directory: %v", err) + } + c.setKey(prvKey) + + // create the new enode record + // signed with the ephemeral node key + enodeParams := &network.EnodeParams{ + PrivateKey: prvKey, + EnodeKey: nodeKey, + Lightnode: c.LightNodeEnabled, + Bootnode: c.BootnodeMode, + } + c.Enode, err = network.NewEnode(enodeParams) + if err != nil { + return fmt.Errorf("Error creating enode: %v", err) } - pubkey := crypto.FromECDSAPub(&prvKey.PublicKey) - pubkeyhex := common.ToHex(pubkey) - keyhex := hexutil.Encode(network.PrivateKeyToBzzKey(prvKey)) - - c.PublicKey = pubkeyhex - c.BzzKey = keyhex - c.NodeID = enode.PubkeyToIDV4(&prvKey.PublicKey).String() - + // initialize components that depend on the swarm instance's private key if c.SwapEnabled { c.Swap.Init(c.Contract, prvKey) } - c.privateKey = prvKey c.LocalStoreParams.Init(c.Path) - c.LocalStoreParams.BaseKey = common.FromHex(keyhex) + c.LocalStoreParams.BaseKey = common.FromHex(c.BzzKey) c.Pss = c.Pss.WithPrivateKey(c.privateKey) + return nil } func (c *Config) ShiftPrivateKey() (privKey *ecdsa.PrivateKey) { @@ -140,3 +144,25 @@ func (c *Config) ShiftPrivateKey() (privKey *ecdsa.PrivateKey) { } return privKey } + +func (c *Config) setKey(prvKey *ecdsa.PrivateKey) { + bzzkeybytes := network.PrivateKeyToBzzKey(prvKey) + pubkey := crypto.FromECDSAPub(&prvKey.PublicKey) + pubkeyhex := hexutil.Encode(pubkey) + keyhex := hexutil.Encode(bzzkeybytes) + + c.privateKey = prvKey + c.PublicKey = pubkeyhex + c.BzzKey = keyhex +} + +func (c *Config) createAndSetPath(datadirPath string, prvKey *ecdsa.PrivateKey) error { + address := crypto.PubkeyToAddress(prvKey.PublicKey) + bzzdirPath := filepath.Join(datadirPath, "bzz-"+common.Bytes2Hex(address.Bytes())) + err := os.MkdirAll(bzzdirPath, os.ModePerm) + if err != nil { + return err + } + c.Path = bzzdirPath + return nil +} diff --git a/swarm/api/config_test.go b/swarm/api/config_test.go index bd7e1d8705..a55da6f7b9 100644 --- a/swarm/api/config_test.go +++ b/swarm/api/config_test.go @@ -27,11 +27,16 @@ import ( func TestConfig(t *testing.T) { var hexprvkey = "65138b2aa745041b372153550584587da326ab440576b2a1191dd95cee30039c" + var hexnodekey = "75138b2aa745041b372153550584587da326ab440576b2a1191dd95cee30039c" prvkey, err := crypto.HexToECDSA(hexprvkey) if err != nil { t.Fatalf("failed to load private key: %v", err) } + nodekey, err := crypto.HexToECDSA(hexnodekey) + if err != nil { + t.Fatalf("failed to load private key: %v", err) + } one := NewConfig() two := NewConfig() @@ -41,7 +46,10 @@ func TestConfig(t *testing.T) { t.Fatal("Two default configs are not equal") } - one.Init(prvkey) + err = one.Init(prvkey, nodekey) + if err != nil { + t.Fatal(err) + } //the init function should set the following fields if one.BzzKey == "" { diff --git a/swarm/network/fetcher.go b/swarm/network/fetcher.go index f7deead3d1..5c0dfefce5 100644 --- a/swarm/network/fetcher.go +++ b/swarm/network/fetcher.go @@ -204,24 +204,24 @@ func (f *Fetcher) run(peers *sync.Map) { // incoming request case hopCount = <-f.requestC: - log.Trace("new request", "request addr", f.addr) // 2) chunk is requested, set requested flag // launch a request iff none been launched yet doRequest = !requested + log.Trace("new request", "request addr", f.addr, "doRequest", doRequest) requested = true // peer we requested from is gone. fall back to another // and remove the peer from the peers map case id := <-gone: - log.Trace("peer gone", "peer id", id.String(), "request addr", f.addr) peers.Delete(id.String()) doRequest = requested + log.Trace("peer gone", "peer id", id.String(), "request addr", f.addr, "doRequest", doRequest) // search timeout: too much time passed since the last request, // extend the search to a new peer if we can find one case <-waitC: - log.Trace("search timed out: requesting", "request addr", f.addr) doRequest = requested + log.Trace("search timed out: requesting", "request addr", f.addr, "doRequest", doRequest) // all Fetcher context closed, can quit case <-f.ctx.Done(): @@ -288,6 +288,7 @@ func (f *Fetcher) doRequest(gone chan *enode.ID, peersToSkip *sync.Map, sources for i = 0; i < len(sources); i++ { req.Source = sources[i] var err error + log.Trace("fetcher.doRequest", "request addr", f.addr, "peer", req.Source.String()) sourceID, quit, err = f.protoRequestFunc(f.ctx, req) if err == nil { // remove the peer from known sources diff --git a/swarm/network/network.go b/swarm/network/network.go index 1f91089417..c5c7e9b2fa 100644 --- a/swarm/network/network.go +++ b/swarm/network/network.go @@ -7,6 +7,7 @@ import ( "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/p2p/enode" + "github.com/ethereum/go-ethereum/p2p/enr" ) // BzzAddr implements the PeerAddr interface @@ -68,3 +69,37 @@ func PrivateKeyToBzzKey(prvKey *ecdsa.PrivateKey) []byte { pubkeyBytes := crypto.FromECDSAPub(&prvKey.PublicKey) return crypto.Keccak256Hash(pubkeyBytes).Bytes() } + +type EnodeParams struct { + PrivateKey *ecdsa.PrivateKey + EnodeKey *ecdsa.PrivateKey + Lightnode bool + Bootnode bool +} + +func NewEnodeRecord(params *EnodeParams) (*enr.Record, error) { + + if params.PrivateKey == nil { + return nil, fmt.Errorf("all param private keys must be defined") + } + + bzzkeybytes := PrivateKeyToBzzKey(params.PrivateKey) + + var record enr.Record + record.Set(NewENRAddrEntry(bzzkeybytes)) + record.Set(ENRLightNodeEntry(params.Lightnode)) + record.Set(ENRBootNodeEntry(params.Bootnode)) + return &record, nil +} + +func NewEnode(params *EnodeParams) (*enode.Node, error) { + record, err := NewEnodeRecord(params) + if err != nil { + return nil, err + } + err = enode.SignV4(record, params.EnodeKey) + if err != nil { + return nil, fmt.Errorf("ENR create fail: %v", err) + } + return enode.New(enode.V4ID{}, record) +} diff --git a/swarm/network/priorityqueue/priorityqueue.go b/swarm/network/priorityqueue/priorityqueue.go index 5385026054..056e85ec13 100644 --- a/swarm/network/priorityqueue/priorityqueue.go +++ b/swarm/network/priorityqueue/priorityqueue.go @@ -28,8 +28,9 @@ package priorityqueue import ( "context" "errors" + "time" - "github.com/ethereum/go-ethereum/log" + "github.com/ethereum/go-ethereum/metrics" ) var ( @@ -69,13 +70,16 @@ READ: case <-ctx.Done(): return case x := <-q: - log.Trace("priority.queue f(x)", "p", p, "len(Queues[p])", len(pq.Queues[p])) - f(x) + val := x.(struct { + v interface{} + t time.Time + }) + f(val.v) + metrics.GetOrRegisterResettingTimer("pq.run", nil).UpdateSince(val.t) p = top default: if p > 0 { p-- - log.Trace("priority.queue p > 0", "p", p) continue READ } p = top @@ -83,7 +87,6 @@ READ: case <-ctx.Done(): return case <-pq.wakeup: - log.Trace("priority.queue wakeup", "p", p) } } } @@ -95,9 +98,15 @@ func (pq *PriorityQueue) Push(x interface{}, p int) error { if p < 0 || p >= len(pq.Queues) { return errBadPriority } - log.Trace("priority.queue push", "p", p, "len(Queues[p])", len(pq.Queues[p])) + val := struct { + v interface{} + t time.Time + }{ + x, + time.Now(), + } select { - case pq.Queues[p] <- x: + case pq.Queues[p] <- val: default: return ErrContention } diff --git a/swarm/network/simulation/kademlia.go b/swarm/network/simulation/kademlia.go index 4b880aa0ce..00e870a070 100644 --- a/swarm/network/simulation/kademlia.go +++ b/swarm/network/simulation/kademlia.go @@ -103,7 +103,7 @@ func (s *Simulation) kademlias() (ks map[enode.ID]*network.Kademlia) { // in the snapshot are registered in the kademlia. // It differs from WaitTillHealthy, which waits only until all the kademlias are // healthy (it might happen even before all the connections are established). -func (s *Simulation) WaitTillSnapshotRecreated(ctx context.Context, snap simulations.Snapshot) error { +func (s *Simulation) WaitTillSnapshotRecreated(ctx context.Context, snap *simulations.Snapshot) error { expected := getSnapshotConnections(snap.Conns) ticker := time.NewTicker(150 * time.Millisecond) defer ticker.Stop() diff --git a/swarm/network/simulation/kademlia_test.go b/swarm/network/simulation/kademlia_test.go index 9cbc39da5b..0ac1e78039 100644 --- a/swarm/network/simulation/kademlia_test.go +++ b/swarm/network/simulation/kademlia_test.go @@ -182,7 +182,7 @@ func TestWaitTillSnapshotRecreated(t *testing.T) { if err != nil { t.Fatal(err) } - err = controlSim.WaitTillSnapshotRecreated(ctx, *snap) + err = controlSim.WaitTillSnapshotRecreated(ctx, snap) if err != nil { t.Fatal(err) } diff --git a/swarm/network/simulation/node.go b/swarm/network/simulation/node.go index 1ab9ddfd0d..46c2bb8660 100644 --- a/swarm/network/simulation/node.go +++ b/swarm/network/simulation/node.go @@ -17,20 +17,28 @@ package simulation import ( + "bytes" + "context" + "crypto/ecdsa" "encoding/json" "errors" "io/ioutil" "math/rand" "os" + "sync" "time" - "github.com/ethereum/go-ethereum/log" + "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/p2p/enode" "github.com/ethereum/go-ethereum/p2p/simulations" "github.com/ethereum/go-ethereum/p2p/simulations/adapters" "github.com/ethereum/go-ethereum/swarm/network" ) +var ( + BucketKeyBzzPrivateKey BucketKey = "bzzprivkey" +) + // NodeIDs returns NodeIDs for all nodes in the network. func (s *Simulation) NodeIDs() (ids []enode.ID) { nodes := s.Net.GetNodes() @@ -102,22 +110,26 @@ func (s *Simulation) AddNode(opts ...AddNodeOption) (id enode.ID, err error) { // most importantly the bzz overlay address // // for now we have no way of setting bootnodes or lightnodes in sims - // so we just set them as false + // so we just let them be set to false // they should perhaps be possible to override them with AddNodeOption - bzzKey := network.PrivateKeyToBzzKey(conf.PrivateKey) - bzzAddr := network.NewENRAddrEntry(bzzKey) + bzzPrivateKey, err := BzzPrivateKeyFromConfig(conf) + if err != nil { + return enode.ID{}, err + } - var lightnode network.ENRLightNodeEntry - var bootnode network.ENRBootNodeEntry - conf.Record.Set(bzzAddr) - conf.Record.Set(&lightnode) - conf.Record.Set(&bootnode) + enodeParams := &network.EnodeParams{ + PrivateKey: bzzPrivateKey, + } + record, err := network.NewEnodeRecord(enodeParams) + conf.Record = *record // Add the bzz address to the node config node, err := s.Net.NewNodeWithConfig(conf) if err != nil { return id, err } + s.buckets[node.ID()] = new(sync.Map) + s.SetNodeItem(node.ID(), BucketKeyBzzPrivateKey, bzzPrivateKey) return node.ID(), s.Net.Start(node.ID()) } @@ -217,30 +229,24 @@ func (s *Simulation) AddNodesAndConnectStar(count int, opts ...AddNodeOption) (i // UploadSnapshot uploads a snapshot to the simulation // This method tries to open the json file provided, applies the config to all nodes // and then loads the snapshot into the Simulation network -func (s *Simulation) UploadSnapshot(snapshotFile string, opts ...AddNodeOption) error { +func (s *Simulation) UploadSnapshot(ctx context.Context, snapshotFile string, opts ...AddNodeOption) error { f, err := os.Open(snapshotFile) if err != nil { return err } - defer func() { - err := f.Close() - if err != nil { - log.Error("Error closing snapshot file", "err", err) - } - }() + defer f.Close() + jsonbyte, err := ioutil.ReadAll(f) if err != nil { return err } var snap simulations.Snapshot - err = json.Unmarshal(jsonbyte, &snap) - if err != nil { + if err := json.Unmarshal(jsonbyte, &snap); err != nil { return err } //the snapshot probably has the property EnableMsgEvents not set - //just in case, set it to true! - //(we need this to wait for messages before uploading) + //set it to true (we need this to wait for messages before uploading) for i := range snap.Nodes { snap.Nodes[i].Node.Config.EnableMsgEvents = true snap.Nodes[i].Node.Config.Services = s.serviceNames @@ -249,15 +255,10 @@ func (s *Simulation) UploadSnapshot(snapshotFile string, opts ...AddNodeOption) } } - log.Info("Waiting for p2p connections to be established...") - - //now we can load the snapshot - err = s.Net.Load(&snap) - if err != nil { + if err := s.Net.Load(&snap); err != nil { return err } - log.Info("Snapshot loaded") - return nil + return s.WaitTillSnapshotRecreated(ctx, &snap) } // StartNode starts a node by NodeID. @@ -326,3 +327,15 @@ func (s *Simulation) StopRandomNodes(count int) (ids []enode.ID, err error) { func init() { rand.Seed(time.Now().UnixNano()) } + +// derive a private key for swarm for the node key +// returns the private key used to generate the bzz key +func BzzPrivateKeyFromConfig(conf *adapters.NodeConfig) (*ecdsa.PrivateKey, error) { + // pad the seed key some arbitrary data as ecdsa.GenerateKey takes 40 bytes seed data + privKeyBuf := append(crypto.FromECDSA(conf.PrivateKey), []byte{0x62, 0x7a, 0x7a, 0x62, 0x7a, 0x7a, 0x62, 0x7a}...) + bzzPrivateKey, err := ecdsa.GenerateKey(crypto.S256(), bytes.NewReader(privKeyBuf)) + if err != nil { + return nil, err + } + return bzzPrivateKey, nil +} diff --git a/swarm/network/simulation/node_test.go b/swarm/network/simulation/node_test.go index bae5afb260..e1e20a0f13 100644 --- a/swarm/network/simulation/node_test.go +++ b/swarm/network/simulation/node_test.go @@ -289,6 +289,7 @@ func TestUploadSnapshot(t *testing.T) { HiveParams: hp, } kad := network.NewKademlia(addr.Over(), network.NewKadParams()) + b.Store(BucketKeyKademlia, kad) return network.NewBzz(config, kad, nil, nil, nil), nil, nil }, }) @@ -296,12 +297,13 @@ func TestUploadSnapshot(t *testing.T) { nodeCount := 16 log.Debug("Uploading snapshot") - err := s.UploadSnapshot(fmt.Sprintf("../stream/testing/snapshot_%d.json", nodeCount)) + ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second) + defer cancel() + err := s.UploadSnapshot(ctx, fmt.Sprintf("../stream/testing/snapshot_%d.json", nodeCount)) if err != nil { t.Fatalf("Error uploading snapshot to simulation network: %v", err) } - ctx := context.Background() log.Debug("Starting simulation...") s.Run(ctx, func(ctx context.Context, sim *Simulation) error { log.Debug("Checking") diff --git a/swarm/network/simulation/simulation.go b/swarm/network/simulation/simulation.go index e18d19a67c..5787cafdae 100644 --- a/swarm/network/simulation/simulation.go +++ b/swarm/network/simulation/simulation.go @@ -85,13 +85,16 @@ func New(services map[string]ServiceFunc) (s *Simulation) { name, serviceFunc := name, serviceFunc s.serviceNames = append(s.serviceNames, name) adapterServices[name] = func(ctx *adapters.ServiceContext) (node.Service, error) { - b := new(sync.Map) + s.mu.Lock() + defer s.mu.Unlock() + b, ok := s.buckets[ctx.Config.ID] + if !ok { + b = new(sync.Map) + } service, cleanup, err := serviceFunc(ctx, b) if err != nil { return nil, err } - s.mu.Lock() - defer s.mu.Unlock() if cleanup != nil { s.cleanupFuncs = append(s.cleanupFuncs, cleanup) } diff --git a/swarm/network/simulations/discovery/discovery_test.go b/swarm/network/simulations/discovery/discovery_test.go index 1ad9ac2e9a..99a0c77224 100644 --- a/swarm/network/simulations/discovery/discovery_test.go +++ b/swarm/network/simulations/discovery/discovery_test.go @@ -131,7 +131,6 @@ func BenchmarkDiscovery_128_4(b *testing.B) { benchmarkDiscovery(b, 128, 4) } func BenchmarkDiscovery_256_4(b *testing.B) { benchmarkDiscovery(b, 256, 4) } func TestDiscoverySimulationExecAdapter(t *testing.T) { - t.Skip("This is left broken pending ENR preparations for swarm binary. Execadapter is not currently in use, so a short pause won't hurt") testDiscoverySimulationExecAdapter(t, *nodeCount, *initCount) } diff --git a/swarm/network/stream/delivery.go b/swarm/network/stream/delivery.go index 01ae7f9435..bc4f1f665f 100644 --- a/swarm/network/stream/delivery.go +++ b/swarm/network/stream/delivery.go @@ -185,6 +185,7 @@ func (d *Delivery) handleRetrieveRequestMsg(ctx context.Context, sp *Peer, req * if err != nil { log.Warn("ERROR in handleRetrieveRequestMsg", "err", err) } + osp.LogFields(olog.Bool("delivered", true)) return } osp.LogFields(olog.Bool("skipCheck", false)) @@ -216,6 +217,10 @@ type ChunkDeliveryMsgSyncing ChunkDeliveryMsg // chunk delivery msg is response to retrieverequest msg func (d *Delivery) handleChunkDeliveryMsg(ctx context.Context, sp *Peer, req *ChunkDeliveryMsg) error { + var osp opentracing.Span + ctx, osp = spancontext.StartSpan( + ctx, + "handle.chunk.delivery") processReceivedChunksCount.Inc(1) @@ -223,13 +228,18 @@ func (d *Delivery) handleChunkDeliveryMsg(ctx context.Context, sp *Peer, req *Ch spanId := fmt.Sprintf("stream.send.request.%v.%v", sp.ID(), req.Addr) span := tracing.ShiftSpanByKey(spanId) + log.Trace("handle.chunk.delivery", "ref", req.Addr, "from peer", sp.ID()) + go func() { + defer osp.Finish() + if span != nil { span.LogFields(olog.String("finish", "from handleChunkDeliveryMsg")) defer span.Finish() } req.peer = sp + log.Trace("handle.chunk.delivery", "put", req.Addr) err := d.chunkStore.Put(ctx, storage.NewChunk(req.Addr, req.SData)) if err != nil { if err == storage.ErrChunkInvalid { @@ -239,6 +249,7 @@ func (d *Delivery) handleChunkDeliveryMsg(ctx context.Context, sp *Peer, req *Ch req.peer.Drop(err) } } + log.Trace("handle.chunk.delivery", "done put", req.Addr, "err", err) }() return nil } @@ -284,6 +295,7 @@ func (d *Delivery) RequestFromPeers(ctx context.Context, req *network.Request) ( // this span will finish only when delivery is handled (or times out) ctx = context.WithValue(ctx, tracing.StoreLabelId, "stream.send.request") ctx = context.WithValue(ctx, tracing.StoreLabelMeta, fmt.Sprintf("%v.%v", sp.ID(), req.Addr)) + log.Trace("request.from.peers", "peer", sp.ID(), "ref", req.Addr) err := sp.SendPriority(ctx, &RetrieveRequestMsg{ Addr: req.Addr, SkipCheck: req.SkipCheck, diff --git a/swarm/network/stream/snapshot_retrieval_test.go b/swarm/network/stream/snapshot_retrieval_test.go index 2fdf8e9e37..2957999f80 100644 --- a/swarm/network/stream/snapshot_retrieval_test.go +++ b/swarm/network/stream/snapshot_retrieval_test.go @@ -22,8 +22,6 @@ import ( "testing" "time" - "github.com/ethereum/go-ethereum/swarm/testutil" - "github.com/ethereum/go-ethereum/node" "github.com/ethereum/go-ethereum/p2p/enode" "github.com/ethereum/go-ethereum/p2p/simulations/adapters" @@ -31,6 +29,7 @@ import ( "github.com/ethereum/go-ethereum/swarm/network/simulation" "github.com/ethereum/go-ethereum/swarm/state" "github.com/ethereum/go-ethereum/swarm/storage" + "github.com/ethereum/go-ethereum/swarm/testutil" ) //constants for random file generation @@ -155,14 +154,15 @@ func runFileRetrievalTest(nodeCount int) error { //array where the generated chunk hashes will be stored conf.hashes = make([]storage.Address, 0) - err := sim.UploadSnapshot(fmt.Sprintf("testing/snapshot_%d.json", nodeCount)) + ctx, cancelSimRun := context.WithTimeout(context.Background(), 3*time.Minute) + defer cancelSimRun() + + filename := fmt.Sprintf("testing/snapshot_%d.json", nodeCount) + err := sim.UploadSnapshot(ctx, filename) if err != nil { return err } - ctx, cancelSimRun := context.WithTimeout(context.Background(), 3*time.Minute) - defer cancelSimRun() - log.Info("Starting simulation") result := sim.Run(ctx, func(ctx context.Context, sim *simulation.Simulation) error { @@ -188,9 +188,6 @@ func runFileRetrievalTest(nodeCount int) error { if err != nil { return err } - if _, err := sim.WaitTillHealthy(ctx); err != nil { - return err - } log.Info("network healthy, start file checks") @@ -253,12 +250,15 @@ func runRetrievalTest(t *testing.T, chunkCount int, nodeCount int) error { //array where the generated chunk hashes will be stored conf.hashes = make([]storage.Address, 0) - err := sim.UploadSnapshot(fmt.Sprintf("testing/snapshot_%d.json", nodeCount)) + ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute) + defer cancel() + + filename := fmt.Sprintf("testing/snapshot_%d.json", nodeCount) + err := sim.UploadSnapshot(ctx, filename) if err != nil { return err } - ctx := context.Background() result := sim.Run(ctx, func(ctx context.Context, sim *simulation.Simulation) error { nodeIDs := sim.UpNodeIDs() for _, n := range nodeIDs { @@ -283,9 +283,6 @@ func runRetrievalTest(t *testing.T, chunkCount int, nodeCount int) error { if err != nil { return err } - if _, err := sim.WaitTillHealthy(ctx); err != nil { - return err - } // File retrieval check is repeated until all uploaded files are retrieved from all nodes // or until the timeout is reached. diff --git a/swarm/network/stream/snapshot_sync_test.go b/swarm/network/stream/snapshot_sync_test.go index 9737ec0a54..ce1e69db25 100644 --- a/swarm/network/stream/snapshot_sync_test.go +++ b/swarm/network/stream/snapshot_sync_test.go @@ -147,20 +147,16 @@ func testSyncingViaGlobalSync(t *testing.T, chunkCount int, nodeCount int) { //array where the generated chunk hashes will be stored conf.hashes = make([]storage.Address, 0) - err := sim.UploadSnapshot(fmt.Sprintf("testing/snapshot_%d.json", nodeCount)) + ctx, cancelSimRun := context.WithTimeout(context.Background(), 3*time.Minute) + defer cancelSimRun() + + filename := fmt.Sprintf("testing/snapshot_%d.json", nodeCount) + err := sim.UploadSnapshot(ctx, filename) if err != nil { t.Fatal(err) } - ctx, cancelSimRun := context.WithTimeout(context.Background(), 2*time.Minute) - defer cancelSimRun() - - if _, err := sim.WaitTillHealthy(ctx); err != nil { - t.Fatal(err) - } - result := runSim(conf, ctx, sim, chunkCount) - if result.Error != nil { t.Fatal(result.Error) } diff --git a/swarm/network/stream/stream.go b/swarm/network/stream/stream.go index c7c489152a..1038e52d0a 100644 --- a/swarm/network/stream/stream.go +++ b/swarm/network/stream/stream.go @@ -910,7 +910,7 @@ func (r *Registry) APIs() []rpc.API { Namespace: "stream", Version: "3.0", Service: r.api, - Public: true, + Public: false, }, } } diff --git a/swarm/network/stream/streamer_test.go b/swarm/network/stream/streamer_test.go index 83719af8a9..bdd3087bbc 100644 --- a/swarm/network/stream/streamer_test.go +++ b/swarm/network/stream/streamer_test.go @@ -1257,9 +1257,10 @@ func TestGetSubscriptionsRPC(t *testing.T) { simulation.NewPeerEventsFilter().ReceivedMessages().Protocol("stream").MsgCode(subscribeMsgCode), ) - // upload a snapshot - err := sim.UploadSnapshot(fmt.Sprintf("testing/snapshot_%d.json", nodeCount)) - if err != nil { + ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute) + defer cancel() + filename := fmt.Sprintf("testing/snapshot_%d.json", nodeCount) + if err := sim.UploadSnapshot(ctx, filename); err != nil { t.Fatal(err) } diff --git a/swarm/network_test.go b/swarm/network_test.go index 3221b852b6..97bdd07b14 100644 --- a/swarm/network_test.go +++ b/swarm/network_test.go @@ -311,8 +311,12 @@ func testSwarmNetwork(t *testing.T, o *testSwarmNetworkOptions, steps ...testSwa if err != nil { return nil, cleanup, err } + nodekey, err := crypto.GenerateKey() + if err != nil { + return nil, cleanup, err + } - config.Init(privkey) + config.Init(privkey, nodekey) config.DeliverySkipCheck = o.SkipCheck config.Port = "" diff --git a/swarm/pss/prox_test.go b/swarm/pss/prox_test.go index 1c8538d50b..bc32e612d3 100644 --- a/swarm/pss/prox_test.go +++ b/swarm/pss/prox_test.go @@ -2,12 +2,10 @@ package pss import ( "context" + "crypto/ecdsa" "encoding/binary" - "encoding/json" "errors" "fmt" - "io/ioutil" - "os" "strconv" "strings" "sync" @@ -20,7 +18,6 @@ import ( "github.com/ethereum/go-ethereum/node" "github.com/ethereum/go-ethereum/p2p" "github.com/ethereum/go-ethereum/p2p/enode" - "github.com/ethereum/go-ethereum/p2p/simulations" "github.com/ethereum/go-ethereum/p2p/simulations/adapters" "github.com/ethereum/go-ethereum/rpc" "github.com/ethereum/go-ethereum/swarm/network" @@ -92,7 +89,7 @@ func (d *testData) setDone() { d.handlerDone = true } -func getCmdParams(t *testing.T) (int, int) { +func getCmdParams(t *testing.T) (int, int, time.Duration) { args := strings.Split(t.Name(), "/") msgCount, err := strconv.ParseInt(args[2], 10, 16) if err != nil { @@ -102,25 +99,12 @@ func getCmdParams(t *testing.T) (int, int) { if err != nil { t.Fatal(err) } - return int(msgCount), int(nodeCount) -} - -func readSnapshot(t *testing.T, nodeCount int) simulations.Snapshot { - f, err := os.Open(fmt.Sprintf("testdata/snapshot_%d.json", nodeCount)) + timeoutStr := fmt.Sprintf("%ss", args[3]) + timeoutDur, err := time.ParseDuration(timeoutStr) if err != nil { t.Fatal(err) } - defer f.Close() - jsonbyte, err := ioutil.ReadAll(f) - if err != nil { - t.Fatal(err) - } - var snap simulations.Snapshot - err = json.Unmarshal(jsonbyte, &snap) - if err != nil { - t.Fatal(err) - } - return snap + return int(msgCount), int(nodeCount), timeoutDur } func newTestData() *testData { @@ -139,11 +123,27 @@ func newTestData() *testData { } } -func (d *testData) init(msgCount int) { +func (d *testData) getKademlia(nodeId *enode.ID) (*network.Kademlia, error) { + kadif, ok := d.sim.NodeItem(*nodeId, simulation.BucketKeyKademlia) + if !ok { + return nil, fmt.Errorf("no kademlia entry for %v", nodeId) + } + kad, ok := kadif.(*network.Kademlia) + if !ok { + return nil, fmt.Errorf("invalid kademlia entry for %v", nodeId) + } + return kad, nil +} + +func (d *testData) init(msgCount int) error { log.Debug("TestProxNetwork start") for _, nodeId := range d.sim.NodeIDs() { - d.nodeAddrs[nodeId] = nodeIDToAddr(nodeId) + kad, err := d.getKademlia(&nodeId) + if err != nil { + return err + } + d.nodeAddrs[nodeId] = kad.BaseAddr() } for i := 0; i < int(msgCount); i++ { @@ -191,6 +191,7 @@ func (d *testData) init(msgCount int) { log.Debug("nn for msg", "targets", len(d.recipients[i]), "msgidx", i, "msg", common.Bytes2Hex(msgAddr[:8]), "sender", d.senders[i], "senderpo", smallestPo) } log.Debug("msgs to receive", "count", d.requiredMessages) + return nil } // Here we test specific functionality of the pss, setting the prox property of @@ -212,7 +213,7 @@ func (d *testData) init(msgCount int) { // nodes Y and Z will be considered required recipients of the msg, // whereas nodes X, Y and Z will be allowed recipients. func TestProxNetwork(t *testing.T) { - t.Run("16/16", testProxNetwork) + t.Run("16/16/15", testProxNetwork) } // params in run name: nodes/msgs @@ -220,33 +221,32 @@ func TestProxNetworkLong(t *testing.T) { if !*longrunning { t.Skip("run with --longrunning flag to run extensive network tests") } - t.Run("8/100", testProxNetwork) - t.Run("16/100", testProxNetwork) - t.Run("32/100", testProxNetwork) - t.Run("64/100", testProxNetwork) - t.Run("128/100", testProxNetwork) + t.Run("8/100/30", testProxNetwork) + t.Run("16/100/30", testProxNetwork) + t.Run("32/100/60", testProxNetwork) + t.Run("64/100/60", testProxNetwork) + t.Run("128/100/120", testProxNetwork) } func testProxNetwork(t *testing.T) { tstdata := newTestData() - msgCount, nodeCount := getCmdParams(t) + msgCount, nodeCount, timeout := getCmdParams(t) handlerContextFuncs := make(map[Topic]handlerContextFunc) handlerContextFuncs[topic] = nodeMsgHandler services := newProxServices(tstdata, true, handlerContextFuncs, tstdata.kademlias) tstdata.sim = simulation.New(services) defer tstdata.sim.Close() - err := tstdata.sim.UploadSnapshot(fmt.Sprintf("testdata/snapshot_%d.json", nodeCount)) + ctx, cancel := context.WithTimeout(context.Background(), timeout) + defer cancel() + filename := fmt.Sprintf("testdata/snapshot_%d.json", nodeCount) + err := tstdata.sim.UploadSnapshot(ctx, filename) if err != nil { t.Fatal(err) } - ctx, cancel := context.WithTimeout(context.Background(), time.Second*120) - defer cancel() - snap := readSnapshot(t, nodeCount) - err = tstdata.sim.WaitTillSnapshotRecreated(ctx, snap) + err = tstdata.init(msgCount) // initialize the test data if err != nil { - t.Fatalf("failed to recreate snapshot: %s", err) + t.Fatal(err) } - tstdata.init(msgCount) // initialize the test data wrapper := func(c context.Context, _ *simulation.Simulation) error { return testRoutine(tstdata, c) } @@ -256,7 +256,7 @@ func testProxNetwork(t *testing.T) { // however, it might just mean that not all possible messages are received // now we must check if all required messages are received cnt := tstdata.getMsgCount() - log.Debug("TestProxNetwork finnished", "rcv", cnt) + log.Debug("TestProxNetwork finished", "rcv", cnt) if cnt < tstdata.requiredMessages { t.Fatal(result.Error) } @@ -380,7 +380,7 @@ func nodeMsgHandler(tstdata *testData, config *adapters.NodeConfig) *handler { // replaces pss_test.go when those tests are rewritten to the new swarm/network/simulation package func newProxServices(tstdata *testData, allowRaw bool, handlerContextFuncs map[Topic]handlerContextFunc, kademlias map[enode.ID]*network.Kademlia) map[string]simulation.ServiceFunc { stateStore := state.NewInmemoryStore() - kademlia := func(id enode.ID) *network.Kademlia { + kademlia := func(id enode.ID, bzzkey []byte) *network.Kademlia { if k, ok := kademlias[id]; ok { return k } @@ -390,17 +390,24 @@ func newProxServices(tstdata *testData, allowRaw bool, handlerContextFuncs map[T params.MaxRetries = 1000 params.RetryExponent = 2 params.RetryInterval = 1000000 - kademlias[id] = network.NewKademlia(id[:], params) + kademlias[id] = network.NewKademlia(bzzkey, params) return kademlias[id] } return map[string]simulation.ServiceFunc{ "bzz": func(ctx *adapters.ServiceContext, b *sync.Map) (node.Service, func(), error) { + var err error + var bzzPrivateKey *ecdsa.PrivateKey // normally translation of enode id to swarm address is concealed by the network package // however, we need to keep track of it in the test driver as well. // if the translation in the network package changes, that can cause these tests to unpredictably fail // therefore we keep a local copy of the translation here addr := network.NewAddr(ctx.Config.Node()) - addr.OAddr = nodeIDToAddr(ctx.Config.Node().ID()) + bzzPrivateKey, err = simulation.BzzPrivateKeyFromConfig(ctx.Config) + if err != nil { + return nil, nil, err + } + addr.OAddr = network.PrivateKeyToBzzKey(bzzPrivateKey) + b.Store(simulation.BucketKeyBzzPrivateKey, bzzPrivateKey) hp := network.NewHiveParams() hp.Discovery = false config := &network.BzzConfig{ @@ -408,7 +415,7 @@ func newProxServices(tstdata *testData, allowRaw bool, handlerContextFuncs map[T UnderlayAddr: addr.Under(), HiveParams: hp, } - return network.NewBzz(config, kademlia(ctx.Config.ID), stateStore, nil, nil), nil, nil + return network.NewBzz(config, kademlia(ctx.Config.ID, addr.OAddr), stateStore, nil, nil), nil, nil }, "pss": func(ctx *adapters.ServiceContext, b *sync.Map) (node.Service, func(), error) { // execadapter does not exec init() @@ -421,12 +428,16 @@ func newProxServices(tstdata *testData, allowRaw bool, handlerContextFuncs map[T privkey, err := w.GetPrivateKey(keys) pssp := NewPssParams().WithPrivateKey(privkey) pssp.AllowRaw = allowRaw - pskad := kademlia(ctx.Config.ID) + bzzPrivateKey, err := simulation.BzzPrivateKeyFromConfig(ctx.Config) + if err != nil { + return nil, nil, err + } + bzzKey := network.PrivateKeyToBzzKey(bzzPrivateKey) + pskad := kademlia(ctx.Config.ID, bzzKey) ps, err := NewPss(pskad, pssp) if err != nil { return nil, nil, err } - b.Store(simulation.BucketKeyKademlia, pskad) // register the handlers we've been passed var deregisters []func() @@ -448,6 +459,8 @@ func newProxServices(tstdata *testData, allowRaw bool, handlerContextFuncs map[T Public: false, }) + b.Store(simulation.BucketKeyKademlia, pskad) + // return Pss and cleanups return ps, func() { // run the handler deregister functions in reverse order @@ -458,8 +471,3 @@ func newProxServices(tstdata *testData, allowRaw bool, handlerContextFuncs map[T }, } } - -// makes sure we create the addresses the same way in driver and service setup -func nodeIDToAddr(id enode.ID) []byte { - return id.Bytes() -} diff --git a/swarm/storage/chunker.go b/swarm/storage/chunker.go index 5b36b477e0..b2f0f5633c 100644 --- a/swarm/storage/chunker.go +++ b/swarm/storage/chunker.go @@ -536,7 +536,6 @@ func (r *LazyChunkReader) join(ctx context.Context, b []byte, off int64, eoff in chunkData, err := r.getter.Get(ctx, Reference(childAddress)) if err != nil { metrics.GetOrRegisterResettingTimer("lcr.getter.get.err", nil).UpdateSince(startTime) - log.Debug("lazychunkreader.join", "key", fmt.Sprintf("%x", childAddress), "err", err) select { case errC <- fmt.Errorf("chunk %v-%v not found; key: %s", off, off+treeSize, fmt.Sprintf("%x", childAddress)): case <-quitC: @@ -561,12 +560,12 @@ func (r *LazyChunkReader) join(ctx context.Context, b []byte, off int64, eoff in // Read keeps a cursor so cannot be called simulateously, see ReadAt func (r *LazyChunkReader) Read(b []byte) (read int, err error) { - log.Debug("lazychunkreader.read", "key", r.addr) + log.Trace("lazychunkreader.read", "key", r.addr) metrics.GetOrRegisterCounter("lazychunkreader.read", nil).Inc(1) read, err = r.ReadAt(b, r.off) if err != nil && err != io.EOF { - log.Debug("lazychunkreader.readat", "read", read, "err", err) + log.Trace("lazychunkreader.readat", "read", read, "err", err) metrics.GetOrRegisterCounter("lazychunkreader.read.err", nil).Inc(1) } diff --git a/swarm/storage/netstore.go b/swarm/storage/netstore.go index e3845489e5..7741b8f7bd 100644 --- a/swarm/storage/netstore.go +++ b/swarm/storage/netstore.go @@ -87,7 +87,9 @@ func (n *NetStore) Put(ctx context.Context, ch Chunk) error { // if chunk is now put in the store, check if there was an active fetcher and call deliver on it // (this delivers the chunk to requestors via the fetcher) + log.Trace("n.getFetcher", "ref", ch.Address()) if f := n.getFetcher(ch.Address()); f != nil { + log.Trace("n.getFetcher deliver", "ref", ch.Address()) f.deliver(ctx, ch) } return nil @@ -341,5 +343,6 @@ func (f *fetcher) deliver(ctx context.Context, ch Chunk) { f.chunk = ch // closing the deliveredC channel will terminate ongoing requests close(f.deliveredC) + log.Trace("n.getFetcher close deliveredC", "ref", ch.Address()) }) } diff --git a/swarm/swarm.go b/swarm/swarm.go index b4b08c5c54..61813e23fc 100644 --- a/swarm/swarm.go +++ b/swarm/swarm.go @@ -36,7 +36,6 @@ import ( "github.com/ethereum/go-ethereum/ethclient" "github.com/ethereum/go-ethereum/metrics" "github.com/ethereum/go-ethereum/p2p" - "github.com/ethereum/go-ethereum/p2p/enode" "github.com/ethereum/go-ethereum/p2p/protocols" "github.com/ethereum/go-ethereum/params" "github.com/ethereum/go-ethereum/rpc" @@ -171,10 +170,7 @@ func NewSwarm(config *api.Config, mockStore *mock.NodeStore) (self *Swarm, err e self.accountingMetrics = protocols.SetupAccountingMetrics(10*time.Second, filepath.Join(config.Path, "metrics.db")) } - var nodeID enode.ID - if err := nodeID.UnmarshalText([]byte(config.NodeID)); err != nil { - return nil, err - } + nodeID := config.Enode.ID() syncing := stream.SyncingAutoSubscribe if !config.SyncEnabled || config.LightNodeEnabled { @@ -522,6 +518,8 @@ func (s *Swarm) APIs() []rpc.API { apis = append(apis, s.bzz.APIs()...) + apis = append(apis, s.streamer.APIs()...) + if s.ps != nil { apis = append(apis, s.ps.APIs()...) } diff --git a/swarm/swarm_test.go b/swarm/swarm_test.go index d85eb91185..2a5b28513a 100644 --- a/swarm/swarm_test.go +++ b/swarm/swarm_test.go @@ -170,8 +170,12 @@ func TestNewSwarm(t *testing.T) { if err != nil { t.Fatal(err) } + nodekey, err := crypto.GenerateKey() + if err != nil { + t.Fatal(err) + } - config.Init(privkey) + config.Init(privkey, nodekey) if tc.configure != nil { tc.configure(config) @@ -307,8 +311,12 @@ func TestLocalStoreAndRetrieve(t *testing.T) { if err != nil { t.Fatal(err) } + nodekey, err := crypto.GenerateKey() + if err != nil { + t.Fatal(err) + } - config.Init(privkey) + config.Init(privkey, nodekey) swarm, err := NewSwarm(config, nil) if err != nil { diff --git a/trie/database.go b/trie/database.go index c853dfe516..6df1a7f79b 100644 --- a/trie/database.go +++ b/trie/database.go @@ -17,6 +17,7 @@ package trie import ( + "encoding/binary" "fmt" "io" "sync" @@ -257,6 +258,19 @@ func expandNode(hash hashNode, n node) node { } } +// trienodeHasher is a struct to be used with BigCache, which uses a Hasher to +// determine which shard to place an entry into. It's not a cryptographic hash, +// just to provide a bit of anti-collision (default is FNV64a). +// +// Since trie keys are already hashes, we can just use the key directly to +// map shard id. +type trienodeHasher struct{} + +// Sum64 implements the bigcache.Hasher interface. +func (t trienodeHasher) Sum64(key string) uint64 { + return binary.BigEndian.Uint64([]byte(key)) +} + // NewDatabase creates a new trie database to store ephemeral trie content before // its written out to disk or garbage collected. No read cache is created, so all // data retrievals will hit the underlying disk database. @@ -276,6 +290,7 @@ func NewDatabaseWithCache(diskdb ethdb.KeyValueStore, cache int) *Database { MaxEntriesInWindow: cache * 1024, MaxEntrySize: 512, HardMaxCacheSize: cache, + Hasher: trienodeHasher{}, }) } return &Database{ diff --git a/vendor/github.com/opentracing/opentracing-go/CHANGELOG.md b/vendor/github.com/opentracing/opentracing-go/CHANGELOG.md index 1fc9fdf7f3..ecfb7e3b79 100644 --- a/vendor/github.com/opentracing/opentracing-go/CHANGELOG.md +++ b/vendor/github.com/opentracing/opentracing-go/CHANGELOG.md @@ -10,5 +10,5 @@ Changes by Version 1.0.0 (2016-09-26) ------------------- -- This release implements OpenTracing Specification 1.0 (http://opentracing.io/spec) +- This release implements OpenTracing Specification 1.0 (https://opentracing.io/spec) diff --git a/vendor/github.com/opentracing/opentracing-go/Makefile b/vendor/github.com/opentracing/opentracing-go/Makefile index d49a5c0d44..62abb63f58 100644 --- a/vendor/github.com/opentracing/opentracing-go/Makefile +++ b/vendor/github.com/opentracing/opentracing-go/Makefile @@ -1,26 +1,15 @@ -PACKAGES := . ./mocktracer/... ./ext/... - .DEFAULT_GOAL := test-and-lint -.PHONE: test-and-lint - +.PHONY: test-and-lint test-and-lint: test lint .PHONY: test test: go test -v -cover -race ./... +.PHONY: cover cover: - @rm -rf cover-all.out - $(foreach pkg, $(PACKAGES), $(MAKE) cover-pkg PKG=$(pkg) || true;) - @grep mode: cover.out > coverage.out - @cat cover-all.out >> coverage.out - go tool cover -html=coverage.out -o cover.html - @rm -rf cover.out cover-all.out coverage.out - -cover-pkg: - go test -coverprofile cover.out $(PKG) - @grep -v mode: cover.out >> cover-all.out + go test -v -coverprofile=coverage.txt -covermode=atomic -race ./... .PHONY: lint lint: @@ -29,4 +18,3 @@ lint: @# Run again with magic to exit non-zero if golint outputs anything. @! (golint ./... | read dummy) go vet ./... - diff --git a/vendor/github.com/opentracing/opentracing-go/README.md b/vendor/github.com/opentracing/opentracing-go/README.md index 007ee237c8..6ef1d7c9d2 100644 --- a/vendor/github.com/opentracing/opentracing-go/README.md +++ b/vendor/github.com/opentracing/opentracing-go/README.md @@ -8,8 +8,8 @@ This package is a Go platform API for OpenTracing. ## Required Reading In order to understand the Go platform API, one must first be familiar with the -[OpenTracing project](http://opentracing.io) and -[terminology](http://opentracing.io/documentation/pages/spec.html) more specifically. +[OpenTracing project](https://opentracing.io) and +[terminology](https://opentracing.io/specification/) more specifically. ## API overview for those adding instrumentation diff --git a/vendor/github.com/opentracing/opentracing-go/globaltracer.go b/vendor/github.com/opentracing/opentracing-go/globaltracer.go index 8c8e793ff2..4f7066a925 100644 --- a/vendor/github.com/opentracing/opentracing-go/globaltracer.go +++ b/vendor/github.com/opentracing/opentracing-go/globaltracer.go @@ -1,7 +1,12 @@ package opentracing +type registeredTracer struct { + tracer Tracer + isRegistered bool +} + var ( - globalTracer Tracer = NoopTracer{} + globalTracer = registeredTracer{NoopTracer{}, false} ) // SetGlobalTracer sets the [singleton] opentracing.Tracer returned by @@ -11,22 +16,27 @@ var ( // Prior to calling `SetGlobalTracer`, any Spans started via the `StartSpan` // (etc) globals are noops. func SetGlobalTracer(tracer Tracer) { - globalTracer = tracer + globalTracer = registeredTracer{tracer, true} } // GlobalTracer returns the global singleton `Tracer` implementation. // Before `SetGlobalTracer()` is called, the `GlobalTracer()` is a noop // implementation that drops all data handed to it. func GlobalTracer() Tracer { - return globalTracer + return globalTracer.tracer } // StartSpan defers to `Tracer.StartSpan`. See `GlobalTracer()`. func StartSpan(operationName string, opts ...StartSpanOption) Span { - return globalTracer.StartSpan(operationName, opts...) + return globalTracer.tracer.StartSpan(operationName, opts...) } // InitGlobalTracer is deprecated. Please use SetGlobalTracer. func InitGlobalTracer(tracer Tracer) { SetGlobalTracer(tracer) } + +// IsGlobalTracerRegistered returns a `bool` to indicate if a tracer has been globally registered +func IsGlobalTracerRegistered() bool { + return globalTracer.isRegistered +} diff --git a/vendor/github.com/opentracing/opentracing-go/propagation.go b/vendor/github.com/opentracing/opentracing-go/propagation.go index 0dd466a373..b0c275eb05 100644 --- a/vendor/github.com/opentracing/opentracing-go/propagation.go +++ b/vendor/github.com/opentracing/opentracing-go/propagation.go @@ -160,7 +160,7 @@ type HTTPHeadersCarrier http.Header // Set conforms to the TextMapWriter interface. func (c HTTPHeadersCarrier) Set(key, val string) { h := http.Header(c) - h.Add(key, val) + h.Set(key, val) } // ForeachKey conforms to the TextMapReader interface. diff --git a/vendor/vendor.json b/vendor/vendor.json index c2c7d7c3dd..e965b4d7f0 100644 --- a/vendor/vendor.json +++ b/vendor/vendor.json @@ -352,10 +352,10 @@ "revisionTime": "2017-01-28T05:05:32Z" }, { - "checksumSHA1": "wIcN7tZiF441h08RHAm4NV8cYO4=", + "checksumSHA1": "a/DHmc9bdsYlZZcwp6i3xhvV7Pk=", "path": "github.com/opentracing/opentracing-go", - "revision": "bd9c3193394760d98b2fa6ebb2291f0cd1d06a7d", - "revisionTime": "2018-06-06T20:41:48Z" + "revision": "25a84ff92183e2f8ac018ba1db54f8a07b3c0e04", + "revisionTime": "2019-02-18T02:30:34Z" }, { "checksumSHA1": "uhDxBvLEqRAMZKgpTZ8MFuLIIM8=",