contracts, swarm: implement EIP-1577 (#19285)

* contracts/ens: update public resolver solidity code

* contracts/ens: update public resolver, update go bindings

* update build

* fix ens.sol

* contracts/ens: change contract interface

* contracts/ens: implement public resolver changes

* contracts/ens: added ENSRegistry contract

* contracts/ens: reinstate old contract code

* contracts/ens: update README.md

* contracts/ens: added test coverage for fallback contract

* contracts/ens: added support for fallback contract

* contracts/ens: removed unused contract code

* contracts/ens: add todo and decode multicodec stub

* add encode

* vendor: add ipfs cid libraries

* contracts/ens: cid sanity tests

* contracts/ens: more cid sanity checks

* contracts/ens: wip integration

* wip

* Revert "vendor: add ipfs cid libraries"

This reverts commit 29d9b6b294.

* contracts/ens: removed multiformats dependencies

* contracts/ens: added decode tests

* contracts/ens: added eip spec test, minor changes to exiting tests

* contracts/ens: moved cid decoding to own file

* contracts/ens: added unit test to encode hash to content hash

* contracts/ens: removed unused code

* contracts/ens: fix ens tests to use cid decode and encode

* contracts/ens: adjust swarm multicodecs after pr merge

* contracts/ens: fix linter error

* constracts/ens: address PR comments

* cmd, contracts: make peoples lives easier

* contracts/ens: fix linter error

* contracts/ens: address PR comments

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 <http://www.gnu.org/licenses/>.
+
+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")
+	}
+}