pss_standalone.go

package main

import (
	"bytes"
	"crypto/ecdsa"
	"fmt"
	"math/rand"
	"net"
	"time"

	"github.com/ethereum/go-ethereum/common"
	"github.com/ethereum/go-ethereum/crypto"
	"github.com/ethereum/go-ethereum/node"
	"github.com/ethereum/go-ethereum/p2p"
	"github.com/ethereum/go-ethereum/p2p/discover"
	"github.com/ethereum/go-ethereum/p2p/protocols"
	"github.com/ethereum/go-ethereum/swarm/network"
	"github.com/ethereum/go-ethereum/swarm/pss"
)

func newPeer(i int) peer {
	key, err := crypto.GenerateKey()
	must(err)
	id := discover.PubkeyID(&key.PublicKey)
	addr := network.NewAddrFromNodeIDAndPort(id, net.IP{0, 0, 0, 0}, uint16(30303+i))
	// no clue what all of it means, i copy pasted it
	kadparams := network.NewKadParams()
	kadparams.MinProxBinSize = 2
	kadparams.MaxBinSize = 3
	kadparams.MinBinSize = 1
	kadparams.MaxRetries = 1000
	kadparams.RetryExponent = 2
	kadparams.RetryInterval = 1000000
	kad := network.NewKademlia(addr.Over(), kadparams)

	pssparams := pss.NewPssParams().WithPrivateKey(key)
	pssparams.AllowRaw = true

	cfg := &node.Config{
		Name: fmt.Sprintf("node-%d", i),
		P2P: p2p.Config{
			PrivateKey:  key,
			NoDiscovery: true,
			MaxPeers:    10,
			ListenAddr:  fmt.Sprintf("0.0.0.0:%d", 30303+i),
		},
	}
	stack, err := node.New(cfg)
	must(err)
	pssS, err := pss.NewPss(kad, pssparams)
	must(err)
	must(stack.Register(func(n *node.ServiceContext) (node.Service, error) {
		return pssS, nil
	}))
	must(stack.Start())
	return peer{
		key:    key,
		pss:    pssS,
		server: stack.Server(),
		kad:    kad,
		oaddr:  addr,
	}
}

type peer struct {
	key    *ecdsa.PrivateKey
	pss    *pss.Pss
	server *p2p.Server
	kad    network.Overlay
	oaddr  *network.BzzAddr
}

func enable(s, t peer) {
	must(s.kad.Register([]network.OverlayAddr{t.oaddr}))
	for _, p := range s.server.Peers() {
		if bytes.Equal(p.ID().Bytes(), t.oaddr.ID().Bytes()) {
			s.kad.On(network.NewBzzTestPeer(protocols.NewPeer(p, nil, nil), t.oaddr))
		}
	}
}

func main() {
	topic := pss.Topic{0x01, 0x02}
	symkey := make([]byte, 32)
	rand.Read(symkey)
	p1 := newPeer(1)
	p2 := newPeer(2)
	p3 := newPeer(3)
	p4 := newPeer(4)
	p1.server.AddPeer(p2.server.Self())
	p2.server.AddPeer(p3.server.Self())
	p2.server.AddPeer(p4.server.Self())
	p4.server.AddPeer(p1.server.Self())
	time.Sleep(time.Second) // wait connections are added
	enable(p1, p2)
	enable(p2, p3)
	enable(p2, p4)
	enable(p4, p1)
	symkeyid, err := p1.pss.SetSymmetricKey(symkey, topic, &pss.PssAddress{}, true)
	must(err)
	must(p1.pss.SetPeerPublicKey(&p3.key.PublicKey, topic, &pss.PssAddress{}))
	for _, p := range []peer{p2, p3, p4} {
		p.pss.SetSymmetricKey(symkey, topic, &pss.PssAddress{}, true)
	}
	for i, p := range []peer{p1, p2, p3, p4} {
		go func(p peer, j int) {
			p.pss.Register(&topic, func(msg []byte, p *p2p.Peer, asymmetric bool, keyid string) error {
				fmt.Printf("p%d received: %s\n", j, msg)
				return nil
			})
		}(p, i+1)
	}
	must(p1.pss.SendAsym(common.ToHex(crypto.FromECDSAPub(&p3.key.PublicKey)), topic, []byte("hello asym")))
	must(p1.pss.SendSym(symkeyid, topic, []byte("hello symmetric")))
	must(p1.pss.SendRaw(pss.PssAddress(p4.oaddr.Address()), topic, []byte("hello")))
	time.Sleep(3 * time.Second)
}

func must(err error) {
	if err != nil {
		panic(err)
	}
}