diff --git a/aw.go b/aw.go
index 3e44561..067f097 100644
--- a/aw.go
+++ b/aw.go
@@ -40,7 +40,7 @@ func New() *Builder {
 	// By default, the content resolver is nil, meaning content will only be
 	// stored in-memory.
 	builder.dht = dht.New(
-		id.NewSignatory(&builder.handshaker.PrivKey.PublicKey),
+		id.NewSignatory((*id.PubKey)(&builder.handshaker.PrivKey.PublicKey)),
 		builder.contentResolver,
 	)
 	return builder
@@ -49,7 +49,7 @@ func New() *Builder {
 func (builder *Builder) WithPrivKey(privKey *id.PrivKey) *Builder {
 	builder.handshaker.PrivKey = privKey
 	builder.dht = dht.New(
-		id.NewSignatory(&builder.handshaker.PrivKey.PublicKey),
+		id.NewSignatory((*id.PubKey)(&builder.handshaker.PrivKey.PublicKey)),
 		builder.contentResolver,
 	)
 	if err := builder.peer.Addr.Sign(builder.handshaker.PrivKey); err != nil {
@@ -61,7 +61,7 @@ func (builder *Builder) WithPrivKey(privKey *id.PrivKey) *Builder {
 func (builder *Builder) WithContentResolver(contentResolver dht.ContentResolver) *Builder {
 	builder.contentResolver = contentResolver
 	builder.dht = dht.New(
-		id.NewSignatory(&builder.handshaker.PrivKey.PublicKey),
+		id.NewSignatory((*id.PubKey)(&builder.handshaker.PrivKey.PublicKey)),
 		builder.contentResolver,
 	)
 	return builder
diff --git a/dht/dht_test.go b/dht/dht_test.go
index de9a75b..c9ca34b 100644
--- a/dht/dht_test.go
+++ b/dht/dht_test.go
@@ -32,7 +32,7 @@ var _ = Describe("DHT", func() {
 					ok := table.InsertAddr(addr)
 					Expect(ok).To(BeTrue())
 
-					signatory := id.NewSignatory(&privKey.PublicKey)
+					signatory := id.NewSignatory((*id.PubKey)(&privKey.PublicKey))
 					newAddr, ok := table.Addr(signatory)
 					Expect(ok).To(BeTrue())
 					Expect(newAddr).To(Equal(addr))
@@ -116,7 +116,7 @@ var _ = Describe("DHT", func() {
 
 					// Try to delete the address prior to inserting to make sure
 					// it does not panic.
-					signatory := id.NewSignatory(&privKey.PublicKey)
+					signatory := id.NewSignatory((*id.PubKey)(&privKey.PublicKey))
 					table.DeleteAddr(signatory)
 
 					// Insert the address.
@@ -238,7 +238,7 @@ var _ = Describe("DHT", func() {
 		Context("when initialising a DHT without a content resolver", func() {
 			It("should panic", func() {
 				privKey := id.NewPrivKey()
-				identity := id.NewSignatory(&privKey.PublicKey)
+				identity := id.NewSignatory((*id.PubKey)(&privKey.PublicKey))
 				Expect(func() { dht.New(identity, nil) }).To(Panic())
 			})
 		})
@@ -250,7 +250,7 @@ var _ = Describe("DHT", func() {
 				contentCh := make(chan id.Hash)
 
 				privKey := id.NewPrivKey()
-				identity := id.NewSignatory(&privKey.PublicKey)
+				identity := id.NewSignatory((*id.PubKey)(&privKey.PublicKey))
 				resolver := dhtutil.NewChannelResolver(insertCh, deleteCh, contentCh)
 				table := dht.New(identity, resolver)
 
@@ -369,7 +369,7 @@ var _ = Describe("DHT", func() {
 				signatories := make([]id.Signatory, numSignatories)
 				for i := 0; i < numSignatories; i++ {
 					privKey := id.NewPrivKey()
-					signatories[i] = id.NewSignatory(&privKey.PublicKey)
+					signatories[i] = id.NewSignatory((*id.PubKey)(&privKey.PublicKey))
 				}
 
 				hash := table.AddSubnet(signatories)
@@ -391,7 +391,7 @@ var _ = Describe("DHT", func() {
 				signatories := make([]id.Signatory, numSignatories)
 				for i := 0; i < numSignatories; i++ {
 					privKey := id.NewPrivKey()
-					signatories[i] = id.NewSignatory(&privKey.PublicKey)
+					signatories[i] = id.NewSignatory((*id.PubKey)(&privKey.PublicKey))
 				}
 
 				hash := table.AddSubnet(signatories)
@@ -420,7 +420,7 @@ var _ = Describe("DHT", func() {
 
 func initDHT() (dht.DHT, id.Signatory) {
 	privKey := id.NewPrivKey()
-	identity := id.NewSignatory(&privKey.PublicKey)
+	identity := id.NewSignatory((*id.PubKey)(&privKey.PublicKey))
 	resolver := dht.NewDoubleCacheContentResolver(dht.DefaultDoubleCacheContentResolverOptions(), nil)
 	return dht.New(identity, resolver), identity
 }
diff --git a/go.mod b/go.mod
index 55ecaf4..b8e624e 100644
--- a/go.mod
+++ b/go.mod
@@ -4,10 +4,10 @@ go 1.12
 
 require (
 	github.com/ethereum/go-ethereum v1.9.10
-	github.com/onsi/ginkgo v1.11.0
-	github.com/onsi/gomega v1.8.1
-	github.com/renproject/id v0.3.3
-	github.com/renproject/surge v1.1.3
+	github.com/onsi/ginkgo v1.12.3
+	github.com/onsi/gomega v1.10.1
+	github.com/renproject/id v0.4.2
+	github.com/renproject/surge v1.2.5
 	github.com/sirupsen/logrus v1.4.2
 	go.uber.org/zap v1.15.0
 	golang.org/x/time v0.0.0-20190308202827-9d24e82272b4
diff --git a/go.sum b/go.sum
index e31e569..4dc60c2 100644
--- a/go.sum
+++ b/go.sum
@@ -87,6 +87,8 @@ github.com/fatih/color v1.3.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5Kwzbycv
 github.com/fjl/memsize v0.0.0-20180418122429-ca190fb6ffbc/go.mod h1:VvhXpOYNQvB+uIk2RvXzuaQtkQJzzIx6lSBe1xv7hi0=
 github.com/fsnotify/fsnotify v1.4.7 h1:IXs+QLmnXW2CcXuY+8Mzv/fWEsPGWxqefPtCP5CnV9I=
 github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
+github.com/fsnotify/fsnotify v1.4.9 h1:hsms1Qyu0jgnwNXIxa+/V/PDsU6CfLf6CNO8H7IWoS4=
+github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ=
 github.com/garyburd/redigo v1.6.0/go.mod h1:NR3MbYisc3/PwhQ00EMzDiPmrwpPxAn5GI05/YaO1SY=
 github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff/go.mod h1:x7DCsMOv1taUwEWCzT4cmDeAkigA5/QCwUodaVOe8Ww=
 github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
@@ -105,12 +107,19 @@ github.com/golang/protobuf v1.3.2-0.20190517061210-b285ee9cfc6c h1:zqAKixg3cTcIa
 github.com/golang/protobuf v1.3.2-0.20190517061210-b285ee9cfc6c/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 github.com/golang/protobuf v1.3.2 h1:6nsPYzhq5kReh6QImI3k5qWzO4PEbvbIW2cwSfR/6xs=
 github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
+github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
+github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs=
+github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
+github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
+github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
 github.com/golang/snappy v0.0.1 h1:Qgr9rKW7uDUkrbSmQeiDsGa8SjGyCOGtuasMWwvp2P4=
 github.com/golang/snappy v0.0.1/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
 github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
 github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
 github.com/google/go-cmp v0.3.1 h1:Xye71clBPdm5HgqGwUkwhbynsUJZhDbS20FvLhQ2izg=
 github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
 github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI=
 github.com/gorilla/websocket v1.4.1-0.20190629185528-ae1634f6a989/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ=
@@ -166,6 +175,8 @@ github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3Rllmb
 github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
 github.com/naoina/go-stringutil v0.1.0/go.mod h1:XJ2SJL9jCtBh+P9q5btrd/Ylo8XwT/h1USek5+NqSA0=
 github.com/naoina/toml v0.1.2-0.20170918210437-9fafd6967416/go.mod h1:NBIhNtsFMo3G2szEBne+bO4gS192HuIYRqfvOWb4i1E=
+github.com/nxadm/tail v1.4.4 h1:DQuhQpB1tVlglWS2hLQ5OV6B5r8aGxSrPc5Qo6uTN78=
+github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A=
 github.com/oklog/ulid v1.3.1/go.mod h1:CirwcVhetQ6Lv90oh/F+FBtV6XMibvdAFo93nm5qn4U=
 github.com/olekukonko/tablewriter v0.0.1/go.mod h1:vsDQFd/mU46D+Z4whnwzcISnGGzXWMclvtLoiIKAKIo=
 github.com/olekukonko/tablewriter v0.0.2-0.20190409134802-7e037d187b0c/go.mod h1:vsDQFd/mU46D+Z4whnwzcISnGGzXWMclvtLoiIKAKIo=
@@ -176,11 +187,17 @@ github.com/onsi/ginkgo v1.9.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+W
 github.com/onsi/ginkgo v1.10.1/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
 github.com/onsi/ginkgo v1.11.0 h1:JAKSXpt1YjtLA7YpPiqO9ss6sNXEsPfSGdwN0UHqzrw=
 github.com/onsi/ginkgo v1.11.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
+github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk=
+github.com/onsi/ginkgo v1.12.3 h1:+RYp9QczoWz9zfUyLP/5SLXQVhfr6gZOoKGfQqHuLZQ=
+github.com/onsi/ginkgo v1.12.3/go.mod h1:iSB4RoI2tjJc9BBv4NKIKWKya62Rps+oPG/Lv9klQyY=
 github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
 github.com/onsi/gomega v1.5.0/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
 github.com/onsi/gomega v1.7.0/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
+github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY=
 github.com/onsi/gomega v1.8.1 h1:C5Dqfs/LeauYDX0jJXIe2SWmwCbGzx9yF8C8xy3Lh34=
 github.com/onsi/gomega v1.8.1/go.mod h1:Ho0h+IUsWyvy1OpqCwxlQ/21gkhVunqlU8fDGcoTdcA=
+github.com/onsi/gomega v1.10.1 h1:o0+MgICZLuZ7xjH7Vx6zS/zcu93/BEp1VwkIW1mEXCE=
+github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo=
 github.com/openconfig/gnmi v0.0.0-20190823184014-89b2bf29312c/go.mod h1:t+O9It+LKzfOAhKTT5O0ehDix+MTqbtT0T9t+7zzOvc=
 github.com/openconfig/reference v0.0.0-20190727015836-8dfd928c9696/go.mod h1:ym2A+zigScwkSEb/cVQB0/ZMpU3rqiH6X7WRRsxgOGw=
 github.com/opentracing/opentracing-go v1.1.0/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o=
@@ -222,6 +239,8 @@ github.com/renproject/id v0.3.1 h1:92CbN8sQTlMIXid69fOJXEkES67uJDORkobRvqoVvJs=
 github.com/renproject/id v0.3.1/go.mod h1:xEoepH7Jze4l+gJxzSh9yRt634XyiM1j9si+WS2Emsc=
 github.com/renproject/id v0.3.3 h1:IiJR1mJ8PvAds+zRz1gxukbWKJJrYQSUnNdihOsaGAY=
 github.com/renproject/id v0.3.3/go.mod h1:BmNHJVfkLsDcvQFHAAPxhhv2KUvWhT4xXFo1Phmp8Kw=
+github.com/renproject/id v0.4.2 h1:XseNDPPCJtsZjIWR7Qgf+zxy0Gt5xsLrfwpQxJt5wFQ=
+github.com/renproject/id v0.4.2/go.mod h1:bCzV4zZkyWetf0GvhJxMT9HQNnGUwzQpImtXOUXqq0k=
 github.com/renproject/kv v1.1.2 h1:P18yHdDVJTEZ9yeyx6o82ICY1m6f+VdtAt/ouZez+AU=
 github.com/renproject/kv v1.1.2/go.mod h1:78bvdAtYiYxCoT9ihVhl8qdmjl7s9fST/FkRLnZ6rXY=
 github.com/renproject/phi v0.1.0 h1:ZOn7QeDribk/uV46OhQWcTLxyuLg7P+xR1Hfl5cOQuI=
@@ -233,6 +252,11 @@ github.com/renproject/surge v1.1.2 h1:Yy3pTlRyaMJGLfn64JHgCnWs3cWbRJjE+aFxZXRGfW
 github.com/renproject/surge v1.1.2/go.mod h1:UnnFYpLSD0T9MzCcyHjbNdmxiQsDVyBDCuqcbhcaLCY=
 github.com/renproject/surge v1.1.3 h1:nCN3yWUbIbSDWyMaU6aCIidCE15yEcZb8Bcuziog/wU=
 github.com/renproject/surge v1.1.3/go.mod h1:UnnFYpLSD0T9MzCcyHjbNdmxiQsDVyBDCuqcbhcaLCY=
+github.com/renproject/surge v1.2.2/go.mod h1:jNVsKCM3/2PAllkc2cx7g2saG9NrHRX5x20I/TDMXOs=
+github.com/renproject/surge v1.2.4 h1:TnlbFQEbcyHbdnZx/PGOaexxaNRP2/l6hSzbs5jnJw0=
+github.com/renproject/surge v1.2.4/go.mod h1:jNVsKCM3/2PAllkc2cx7g2saG9NrHRX5x20I/TDMXOs=
+github.com/renproject/surge v1.2.5 h1:P2qKZxWiKrC8hw7in/hXVtic+dGkhd1M0H/1Lj+fJnw=
+github.com/renproject/surge v1.2.5/go.mod h1:jNVsKCM3/2PAllkc2cx7g2saG9NrHRX5x20I/TDMXOs=
 github.com/rjeczalik/notify v0.9.1/go.mod h1:rKwnCoCGeuQnwBtTSPL9Dad03Vh2n40ePRrjvIXnJho=
 github.com/robertkrimen/otto v0.0.0-20170205013659-6a77b7cbc37d/go.mod h1:xvqspoSXJTIpemEonrMDFq6XzwHYYgToXWj5eRX1OtY=
 github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
@@ -313,6 +337,8 @@ golang.org/x/net v0.0.0-20190813141303-74dc4d7220e7 h1:fHDIZ2oxGnUZRN6WgWFCbYBjH
 golang.org/x/net v0.0.0-20190813141303-74dc4d7220e7/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20190912160710-24e19bdeb0f2 h1:4dVFTC832rPn4pomLSz1vA+are2+dU19w1H8OngV7nc=
 golang.org/x/net v0.0.0-20190912160710-24e19bdeb0f2/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200520004742-59133d7f0dd7 h1:AeiKBIuRw3UomYXSbLy0Mc2dDLfdtbT/IVn4keq83P0=
+golang.org/x/net v0.0.0-20200520004742-59133d7f0dd7/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
 golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
@@ -333,8 +359,14 @@ golang.org/x/sys v0.0.0-20190712062909-fae7ac547cb7/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20190801041406-cbf593c0f2f3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190813064441-fde4db37ae7a h1:aYOabOQFp6Vj6W1F80affTUvO9UxmJRx8K0gsfABByQ=
 golang.org/x/sys v0.0.0-20190813064441-fde4db37ae7a/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190904154756-749cb33beabd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190912141932-bc967efca4b8 h1:41hwlulw1prEMBxLQSlMSux1zxJf07B3WPsdjJlKZxE=
 golang.org/x/sys v0.0.0-20190912141932-bc967efca4b8/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200519105757-fe76b779f299 h1:DYfZAGf2WMFjMxbgTjaC+2HC7NkNAQs+6Q8b9WEB/F4=
+golang.org/x/sys v0.0.0-20200519105757-fe76b779f299/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs=
 golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
@@ -349,9 +381,17 @@ golang.org/x/tools v0.0.0-20191029041327-9cc4af7d6b2c/go.mod h1:b+2E5dAYhXwXZwtn
 golang.org/x/tools v0.0.0-20191029190741-b9c20aec41a5/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7 h1:9zdDQZ7Thm29KFXgAX/+yaf3eVbP7djjWp/dXAppNCc=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
 google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
 google.golang.org/grpc v1.23.1/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
+google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
+google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
+google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
+google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE=
+google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
+google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
 gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
 gopkg.in/bsm/ratelimit.v1 v1.0.0-20160220154919-db14e161995a/go.mod h1:KF9sEfUPAXdG8Oev9e99iLGnl2uJMjc5B+4y3O7x610=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
@@ -376,6 +416,8 @@ gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.4 h1:/eiJrUcujPVeJ3xlSWaiNi3uSVmDGBK1pDHUHAnao1I=
 gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.3.0 h1:clyUAQHOM3G0M3f5vQj7LuJrETvjVot3Z5el9nffUtU=
+gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gotest.tools v2.2.0+incompatible/go.mod h1:DsYFclhRJ6vuDpmuTbkuFWG+y2sxOXAzmJt81HFBacw=
 honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg=
diff --git a/gossip/gossip.go b/gossip/gossip.go
index 1d932a4..6b5c74c 100644
--- a/gossip/gossip.go
+++ b/gossip/gossip.go
@@ -186,7 +186,7 @@ func (g *Gossiper) DidReceivePush(version wire.Version, data []byte, from id.Sig
 	//
 
 	pushV1 := wire.PushV1{}
-	if err := surge.FromBinary(data, &pushV1); err != nil {
+	if err := surge.FromBinary(&pushV1, data); err != nil {
 		return wire.Message{}, fmt.Errorf("unmarshaling push: %v", err)
 	}
 
@@ -230,7 +230,7 @@ func (g *Gossiper) DidReceivePushAck(version wire.Version, data []byte, from id.
 	//
 
 	pushAckV1 := wire.PushAckV1{}
-	if err := surge.FromBinary(data, &pushAckV1); err != nil {
+	if err := surge.FromBinary(&pushAckV1, data); err != nil {
 		g.opts.Logger.Fatalf("unmarshaling push ack: %v", err)
 	}
 
@@ -251,7 +251,7 @@ func (g *Gossiper) DidReceivePull(version wire.Version, data []byte, from id.Sig
 	//
 
 	pullV1 := wire.PullV1{}
-	if err := surge.FromBinary(data, &pullV1); err != nil {
+	if err := surge.FromBinary(&pullV1, data); err != nil {
 		return wire.Message{}, fmt.Errorf("unmarshaling pull: %v", err)
 	}
 
@@ -295,7 +295,7 @@ func (g *Gossiper) DidReceivePullAck(version wire.Version, data []byte, from id.
 		return nil
 	}
 	pullAckV1 := wire.PullAckV1{}
-	if err := surge.FromBinary(data, &pullAckV1); err != nil {
+	if err := surge.FromBinary(&pullAckV1, data); err != nil {
 		return fmt.Errorf("unmarshaling pull ack: %v", err)
 	}
 
diff --git a/gossip/gossip_test.go b/gossip/gossip_test.go
index 6928b19..2f5970e 100644
--- a/gossip/gossip_test.go
+++ b/gossip/gossip_test.go
@@ -171,7 +171,7 @@ var _ = Describe("Gossip", func() {
 					subnet := nodes[syncIndex].dht.AddSubnet(signatories)
 
 					// Sync data from the subnet and ensure it is the same.
-					innerCtx, innerCancel := context.WithTimeout(ctx, 100*time.Millisecond)
+					innerCtx, innerCancel := context.WithTimeout(ctx, time.Second)
 					defer innerCancel()
 
 					newData, err := nodes[syncIndex].gossiper.Sync(innerCtx, subnet, hash, dataType)
@@ -205,7 +205,7 @@ var _ = Describe("Gossip", func() {
 
 					// Sync data with an unknown hash from the subnet and ensure
 					// it returns an error.
-					innerCtx, innerCancel := context.WithTimeout(ctx, 100*time.Millisecond)
+					innerCtx, innerCancel := context.WithTimeout(ctx, time.Second)
 					defer innerCancel()
 
 					_, err := nodes[syncIndex].gossiper.Sync(innerCtx, subnet, hash, dataType)
@@ -237,7 +237,7 @@ var _ = Describe("Gossip", func() {
 				}
 
 				// Sync data from the default subnet and ensure it is the same.
-				innerCtx, innerCancel := context.WithTimeout(ctx, 100*time.Millisecond)
+				innerCtx, innerCancel := context.WithTimeout(ctx, time.Second)
 				defer innerCancel()
 
 				newData, err := nodes[syncIndex].gossiper.Sync(innerCtx, gossip.DefaultSubnet, hash, dataType)
@@ -280,7 +280,7 @@ var _ = Describe("Gossip", func() {
 				}
 
 				// Sync data from the subnet and ensure it is the same.
-				innerCtx, innerCancel := context.WithTimeout(ctx, 100*time.Millisecond)
+				innerCtx, innerCancel := context.WithTimeout(ctx, time.Second)
 				defer innerCancel()
 
 				wg := new(sync.WaitGroup)
@@ -318,7 +318,7 @@ func initNodes(ctx context.Context, n uint, alpha int) []node {
 	nodes := make([]node, n)
 	for i := range nodes {
 		privKey := id.NewPrivKey()
-		signatory := id.NewSignatory(&privKey.PublicKey)
+		signatory := id.NewSignatory((*id.PubKey)(&privKey.PublicKey))
 		host := "0.0.0.0"
 		port := uint16(3000 + rand.Int()%3000)
 
diff --git a/handshake/ecdsa.go b/handshake/ecdsa.go
index 91ec673..bb4875d 100644
--- a/handshake/ecdsa.go
+++ b/handshake/ecdsa.go
@@ -77,7 +77,7 @@ func (handshaker *ecdsaHandshaker) Handshake(ctx context.Context, conn net.Conn)
 		return nil, fmt.Errorf("reading and decrypting server key: %v", err)
 	}
 
-	return NewGCMSession(xor(clientKey[:], serverKey), id.NewSignatory(serverPubKey))
+	return NewGCMSession(xor(clientKey[:], serverKey), id.NewSignatory((*id.PubKey)(serverPubKey)))
 }
 
 func (handshaker *ecdsaHandshaker) AcceptHandshake(ctx context.Context, conn net.Conn) (Session, error) {
@@ -119,7 +119,7 @@ func (handshaker *ecdsaHandshaker) AcceptHandshake(ctx context.Context, conn net
 		return nil, fmt.Errorf("writing server key: %v", err)
 	}
 
-	return NewGCMSession(xor(clientKey, serverKey[:]), id.NewSignatory(clientPubKey))
+	return NewGCMSession(xor(clientKey, serverKey[:]), id.NewSignatory((*id.PubKey)(clientPubKey)))
 }
 
 func encryptAndWriteKey(w io.Writer, localKey []byte, pubKey *ecdsa.PublicKey) error {
@@ -127,15 +127,15 @@ func encryptAndWriteKey(w io.Writer, localKey []byte, pubKey *ecdsa.PublicKey) e
 	if err != nil {
 		return fmt.Errorf("encrypting key: %v", err)
 	}
-	if _, err := surge.Marshal(w, encryptedKey, surge.MaxBytes); err != nil {
+	if _, err := w.Write(encryptedKey); err != nil {
 		return fmt.Errorf("writing key: %v", err)
 	}
 	return nil
 }
 
 func readAndDecryptKey(r io.Reader, privKey *id.PrivKey) ([]byte, error) {
-	encryptedKey := []byte{}
-	if _, err := surge.Unmarshal(r, &encryptedKey, surge.MaxBytes); err != nil {
+	encryptedKey := make([]byte, 145)
+	if _, err := r.Read(encryptedKey); err != nil {
 		return nil, fmt.Errorf("reading key: %v", err)
 	}
 	eciesPrivKey := ecies.ImportECDSA((*ecdsa.PrivateKey)(privKey))
@@ -148,41 +148,43 @@ func readAndDecryptKey(r io.Reader, privKey *id.PrivKey) ([]byte, error) {
 
 func writePubKeyWithSignature(w io.Writer, pubKey *ecdsa.PublicKey, signer *id.PrivKey) error {
 	compressedPubKey := crypto.CompressPubkey(pubKey)
-	if _, err := surge.Marshal(w, compressedPubKey, surge.MaxBytes); err != nil {
-		return fmt.Errorf("marshaling pubkey: %v", err)
+	if _, err := w.Write(compressedPubKey); err != nil {
+		return fmt.Errorf("writing pubkey: %v", err)
 	}
-	signatory := id.NewSignatory(pubKey)
+	signatory := id.NewSignatory((*id.PubKey)(pubKey))
 	rawSignature, err := crypto.Sign(signatory[:], (*ecdsa.PrivateKey)(signer))
 	if err != nil {
 		return fmt.Errorf("signing pubkey: %v", err)
 	}
-	signature := id.Signature{}
-	copy(signature[:], rawSignature)
-	if _, err := surge.Marshal(w, signature, surge.MaxBytes); err != nil {
-		return fmt.Errorf("marshaling signature: %v", err)
+	if _, err := w.Write(rawSignature); err != nil {
+		return fmt.Errorf("writing signature: %v", err)
 	}
 	return nil
 }
 
 func readPubKeyWithSignature(r io.Reader) (*ecdsa.PublicKey, id.Signatory, error) {
-	compressedPubKey := []byte{}
-	if _, err := surge.Unmarshal(r, &compressedPubKey, surge.MaxBytes); err != nil {
-		return nil, id.Signatory{}, fmt.Errorf("unmarshaling pubkey: %v", err)
+	compressedPubKey := make([]byte, 33)
+	if _, err := r.Read(compressedPubKey); err != nil {
+		return nil, id.Signatory{}, fmt.Errorf("reading pubkey: %v", err)
 	}
 	pubKey, err := crypto.DecompressPubkey(compressedPubKey)
 	if err != nil {
 		return nil, id.Signatory{}, fmt.Errorf("decompressing pubkey: %v", err)
 	}
-	signatory := id.NewSignatory(pubKey)
+	signatory := id.NewSignatory((*id.PubKey)(pubKey))
+	signatureBytes := make([]byte, 65)
+	if _, err := r.Read(signatureBytes); err != nil {
+		return nil, id.Signatory{}, fmt.Errorf("reading signature: %v", err)
+	}
 	signature := id.Signature{}
-	if _, err := surge.Unmarshal(r, &signature, surge.MaxBytes); err != nil {
+	if err := surge.FromBinary(&signature, signatureBytes); err != nil {
 		return nil, id.Signatory{}, fmt.Errorf("unmarshaling signature: %v", err)
 	}
 	verifiedPubKey, err := crypto.SigToPub(signatory[:], signature[:])
 	if err != nil {
 		return nil, id.Signatory{}, fmt.Errorf("verifying pubkey: %v", err)
 	}
-	if !id.NewSignatory(verifiedPubKey).Equal(&signatory) {
+	if !id.NewSignatory((*id.PubKey)(verifiedPubKey)).Equal(&signatory) {
 		return nil, id.Signatory{}, fmt.Errorf("verifying signatory: %v", err)
 	}
 	return pubKey, signatory, nil
diff --git a/handshake/ecdsa_test.go b/handshake/ecdsa_test.go
index bf52e1b..8e82254 100644
--- a/handshake/ecdsa_test.go
+++ b/handshake/ecdsa_test.go
@@ -113,13 +113,13 @@ var _ = Describe("ECDSA handshake", func() {
 			// Client privkey and signatory
 			//
 			clientPrivKey := id.NewPrivKey()
-			clientSignatory := id.NewSignatory(&clientPrivKey.PublicKey)
+			clientSignatory := id.NewSignatory((*id.PubKey)(&clientPrivKey.PublicKey))
 
 			//
 			// Server privkey and signatory
 			//
 			serverPrivKey := id.NewPrivKey()
-			serverSignatory := id.NewSignatory(&serverPrivKey.PublicKey)
+			serverSignatory := id.NewSignatory((*id.PubKey)(&serverPrivKey.PublicKey))
 
 			//
 			// Server connection
@@ -183,13 +183,13 @@ var _ = Describe("ECDSA handshake", func() {
 			// Client privkey and signatory
 			//
 			clientPrivKey := id.NewPrivKey()
-			clientSignatory := id.NewSignatory(&clientPrivKey.PublicKey)
+			clientSignatory := id.NewSignatory((*id.PubKey)(&clientPrivKey.PublicKey))
 
 			//
 			// Server privkey and signatory
 			//
 			serverPrivKey := id.NewPrivKey()
-			serverSignatory := id.NewSignatory(&serverPrivKey.PublicKey)
+			serverSignatory := id.NewSignatory((*id.PubKey)(&serverPrivKey.PublicKey))
 
 			//
 			// Server connection
@@ -197,7 +197,7 @@ var _ = Describe("ECDSA handshake", func() {
 			port := uint16(3000 + rand.Int()%3000)
 			listener, err := net.Listen("tcp", fmt.Sprintf("127.0.0.1:%v", port))
 			Expect(err).ToNot(HaveOccurred())
-			
+
 			go func() {
 				defer GinkgoRecover()
 				defer listener.Close()
diff --git a/handshake/insecure.go b/handshake/insecure.go
index 8d12038..82c391e 100644
--- a/handshake/insecure.go
+++ b/handshake/insecure.go
@@ -31,9 +31,13 @@ func (handshaker *insecureHandshaker) Handshake(ctx context.Context, conn net.Co
 	//
 
 	conn.SetWriteDeadline(time.Now().Add(handshaker.opts.Timeout / 2))
-	if _, err := id.NewSignatory(&handshaker.opts.PrivKey.PublicKey).Marshal(conn, surge.MaxBytes); err != nil {
+	identityBytes, err := surge.ToBinary(id.NewSignatory((*id.PubKey)(&handshaker.opts.PrivKey.PublicKey)))
+	if err != nil {
 		return nil, fmt.Errorf("marshaling identity: %v", err)
 	}
+	if _, err := conn.Write(identityBytes); err != nil {
+		return nil, fmt.Errorf("writing identity: %v", err)
+	}
 
 	//
 	// Read remote server identity.
@@ -41,7 +45,10 @@ func (handshaker *insecureHandshaker) Handshake(ctx context.Context, conn net.Co
 
 	serverSignatory := id.Signatory{}
 	conn.SetReadDeadline(time.Now().Add(handshaker.opts.Timeout / 2))
-	if _, err := serverSignatory.Unmarshal(conn, surge.MaxBytes); err != nil {
+	if _, err := conn.Read(identityBytes); err != nil {
+		return nil, fmt.Errorf("reading server identity: %v", err)
+	}
+	if err := surge.FromBinary(&serverSignatory, identityBytes); err != nil {
 		return nil, fmt.Errorf("unmarshaling server identity: %v", err)
 	}
 	if handshaker.opts.Filter != nil && !handshaker.opts.Filter.Filter(serverSignatory) {
@@ -62,11 +69,15 @@ func (handshaker *insecureHandshaker) AcceptHandshake(ctx context.Context, conn
 
 	clientSignatory := id.Signatory{}
 	conn.SetReadDeadline(time.Now().Add(handshaker.opts.Timeout / 2))
-	if _, err := clientSignatory.Unmarshal(conn, surge.MaxBytes); err != nil {
+	identityBytes := make([]byte, 32)
+	if _, err := conn.Read(identityBytes); err != nil {
+		return nil, fmt.Errorf("reading client identity: %v", err)
+	}
+	if err := surge.FromBinary(&clientSignatory, identityBytes); err != nil {
 		return nil, fmt.Errorf("unmarshaling client identity: %v", err)
 	}
 	if handshaker.opts.Filter != nil && !handshaker.opts.Filter.Filter(clientSignatory) {
-		return nil, fmt.Errorf("filtering: bad server")
+		return nil, fmt.Errorf("filtering: bad client")
 	}
 
 	//
@@ -74,9 +85,13 @@ func (handshaker *insecureHandshaker) AcceptHandshake(ctx context.Context, conn
 	//
 
 	conn.SetWriteDeadline(time.Now().Add(handshaker.opts.Timeout / 2))
-	if _, err := id.NewSignatory(&handshaker.opts.PrivKey.PublicKey).Marshal(conn, surge.MaxBytes); err != nil {
+	identityBytes, err := surge.ToBinary(id.NewSignatory((*id.PubKey)(&handshaker.opts.PrivKey.PublicKey)))
+	if err != nil {
 		return nil, fmt.Errorf("marshaling identity: %v", err)
 	}
+	if _, err := conn.Write(identityBytes); err != nil {
+		return nil, fmt.Errorf("writing identity: %v", err)
+	}
 
 	return insecureSession{remoteSignatory: clientSignatory}, nil
 }
diff --git a/handshake/insecure_test.go b/handshake/insecure_test.go
index 25e6328..f5be281 100644
--- a/handshake/insecure_test.go
+++ b/handshake/insecure_test.go
@@ -113,13 +113,13 @@ var _ = Describe("Insecure handshake", func() {
 			// Client signatory
 			//
 			clientPrivKey := id.NewPrivKey()
-			clientSignatory := id.NewSignatory(&clientPrivKey.PublicKey)
+			clientSignatory := id.NewSignatory((*id.PubKey)(&clientPrivKey.PublicKey))
 
 			//
 			// Server signatory
 			//
 			serverPrivKey := id.NewPrivKey()
-			serverSignatory := id.NewSignatory(&serverPrivKey.PublicKey)
+			serverSignatory := id.NewSignatory((*id.PubKey)(&serverPrivKey.PublicKey))
 
 			//
 			// Server connection
@@ -175,13 +175,13 @@ var _ = Describe("Insecure handshake", func() {
 			// Client signatory
 			//
 			clientPrivKey := id.NewPrivKey()
-			clientSignatory := id.NewSignatory(&clientPrivKey.PublicKey)
+			clientSignatory := id.NewSignatory((*id.PubKey)(&clientPrivKey.PublicKey))
 
 			//
 			// Server signatory
 			//
 			serverPrivKey := id.NewPrivKey()
-			serverSignatory := id.NewSignatory(&serverPrivKey.PublicKey)
+			serverSignatory := id.NewSignatory((*id.PubKey)(&serverPrivKey.PublicKey))
 
 			//
 			// Server connection
diff --git a/peer/peer.go b/peer/peer.go
index 76c4221..292f2a3 100644
--- a/peer/peer.go
+++ b/peer/peer.go
@@ -75,7 +75,7 @@ func (peer *Peer) Run(ctx context.Context) {
 
 // Identity returns the signatory of the peer.
 func (peer *Peer) Identity() id.Signatory {
-	return id.NewSignatory(&peer.privKey.PublicKey)
+	return id.NewSignatory((*id.PubKey)(&peer.privKey.PublicKey))
 }
 
 // Addr returns the network address of this peer.
@@ -159,7 +159,7 @@ func (peer *Peer) DidReceivePing(version wire.Version, data []byte, from id.Sign
 	}
 
 	remoteAddr := wire.Address{}
-	if err := surge.FromBinary(data, &remoteAddr); err != nil {
+	if err := surge.FromBinary(&remoteAddr, data); err != nil {
 		return wire.Message{}, fmt.Errorf("unsupported remote address: %v", err)
 	}
 
@@ -202,7 +202,7 @@ func (peer *Peer) DidReceivePingAck(version wire.Version, data []byte, from id.S
 	// Unmarshal the remote addresses returned to us in the PingAck response,
 	// and limit the number of addreses to prevent spam.
 	pingAckV1 := wire.PingAckV1{}
-	if err := surge.FromBinary(data, &pingAckV1); err != nil {
+	if err := surge.FromBinary(&pingAckV1, data); err != nil {
 		return fmt.Errorf("unsupported remote address: %v", err)
 	}
 	if len(pingAckV1.Addrs) > peer.opts.Alpha {
diff --git a/tcp/client.go b/tcp/client.go
index 55178d6..093bfcf 100644
--- a/tcp/client.go
+++ b/tcp/client.go
@@ -279,13 +279,14 @@ func (client *Client) run(ctx context.Context, deadline *time.Timer, addr string
 		bufio.NewWriterSize(conn, surge.MaxBytes),
 	)
 
+	buf := make([]byte, surge.MaxBytes)
 	if lastMessage != nil {
 		// Failing to write a message should not result in the
 		// connection/channel being killed, and should not result in all pending
 		// messages being lost. Therefore, we consume the error, and return a
 		// nil-error.
 		client.opts.Logger.Info("resending last message sent")
-		if err := client.write(session, rw, *lastMessage); err != nil {
+		if err := client.write(session, rw, *lastMessage, buf); err != nil {
 			client.opts.Logger.Error("writing", zap.Error(err))
 			return lastMessage, nil
 		}
@@ -330,7 +331,7 @@ func (client *Client) run(ctx context.Context, deadline *time.Timer, addr string
 			// connection/channel being killed, and should not result in all pending
 			// messages being lost. Therefore, we consume the error, and return a
 			// nil-error.
-			if err := client.write(session, rw, msg); err != nil {
+			if err := client.write(session, rw, msg, buf); err != nil {
 				client.opts.Logger.Error("writing", zap.Error(err))
 				return &msg, nil
 			}
@@ -338,7 +339,7 @@ func (client *Client) run(ctx context.Context, deadline *time.Timer, addr string
 	}
 }
 
-func (client *Client) write(session handshake.Session, rw *bufio.ReadWriter, msg wire.Message) error {
+func (client *Client) write(session handshake.Session, rw *bufio.ReadWriter, msg wire.Message, buf []byte) error {
 	var err error
 
 	//
@@ -351,9 +352,13 @@ func (client *Client) write(session handshake.Session, rw *bufio.ReadWriter, msg
 		return fmt.Errorf("encrypting message: %v", err)
 	}
 	// Write the encrypted message to the connection.
-	if _, err := msg.Marshal(rw, surge.MaxBytes); err != nil {
+	msgBytes, err := surge.ToBinary(msg)
+	if err != nil {
 		return fmt.Errorf("marshaling message: %v", err)
 	}
+	if _, err := rw.Write(msgBytes); err != nil {
+		return fmt.Errorf("writing message: %v", err)
+	}
 	if err := rw.Flush(); err != nil {
 		return fmt.Errorf("flushing message: %v", err)
 	}
@@ -363,10 +368,14 @@ func (client *Client) write(session handshake.Session, rw *bufio.ReadWriter, msg
 	//
 
 	// Read an encrypted response from the connection.
+	if _, err := rw.Read(buf); err != nil {
+		return fmt.Errorf("reading response: %v", err)
+	}
 	response := wire.Message{}
-	if _, err := response.Unmarshal(rw, surge.MaxBytes); err != nil {
+	if err := surge.FromBinary(&response, buf); err != nil {
 		return fmt.Errorf("unmarshaling response: %v", err)
 	}
+	buf = buf[:0]
 	// Check that the response version is supported.
 	switch response.Version {
 	case wire.V1:
diff --git a/tcp/server.go b/tcp/server.go
index 9677e37..a5675fb 100644
--- a/tcp/server.go
+++ b/tcp/server.go
@@ -4,7 +4,6 @@ import (
 	"bufio"
 	"context"
 	"fmt"
-	"io"
 	"net"
 	"sync"
 	"sync/atomic"
@@ -251,6 +250,7 @@ func (server *Server) handle(ctx context.Context, conn net.Conn) {
 	// Read messages from the client until the time-to-live expires, or an error
 	// is encountered when trying to read.
 	server.opts.Logger.Info("handling", zap.String("remote", remoteAddr))
+	buf := make([]byte, surge.MaxBytes)
 	bufReader := bufio.NewReaderSize(conn, surge.MaxBytes)
 	bufWriter := bufio.NewWriterSize(conn, surge.MaxBytes)
 	for {
@@ -262,12 +262,12 @@ func (server *Server) handle(ctx context.Context, conn net.Conn) {
 		}
 
 		// Read message from connection.
+		if _, err := bufReader.Read(buf); err != nil {
+			server.opts.Logger.Error("bad message", zap.Error(err))
+			return
+		}
 		msg := wire.Message{}
-		if _, err := msg.Unmarshal(bufReader, surge.MaxBytes); err != nil {
-			if err != io.EOF {
-				server.opts.Logger.Error("bad message", zap.Error(err))
-				return
-			}
+		if err := surge.FromBinary(&msg, buf); err != nil {
 			server.opts.Logger.Info("closing connection", zap.String("remote", conn.RemoteAddr().String()))
 			return
 		}
@@ -334,7 +334,12 @@ func (server *Server) handle(ctx context.Context, conn net.Conn) {
 			server.opts.Logger.Error("bad response: %v", zap.Error(err))
 			return
 		}
-		if _, err := response.Marshal(bufWriter, surge.MaxBytes); err != nil {
+		responseBytes, err := surge.ToBinary(response)
+		if err != nil {
+			server.opts.Logger.Info("closing connection", zap.String("remote", conn.RemoteAddr().String()))
+			return
+		}
+		if _, err := bufWriter.Write(responseBytes); err != nil {
 			server.opts.Logger.Error("bad response", zap.Error(err))
 			return
 		}
diff --git a/wire/addr.go b/wire/addr.go
index 7267f72..6e647da 100644
--- a/wire/addr.go
+++ b/wire/addr.go
@@ -1,11 +1,9 @@
 package wire
 
 import (
-	"bytes"
 	"crypto/ecdsa"
 	"crypto/sha256"
 	"fmt"
-	"io"
 
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/renproject/id"
@@ -21,29 +19,33 @@ const (
 	WebSocket         = uint8(3)
 )
 
-// NewAddressHash returns the Hash of an Address for signing by the peer.
+// NewAddressHash returns the Hash of an Address for signing by the peer. An
+// error is returned when the arguments too large and cannot be marshaled into
+// bytes without exceeding memory allocation restrictions.
 func NewAddressHash(protocol uint8, value string, nonce uint64) (id.Hash, error) {
-	buf := new(bytes.Buffer)
-	buf.Grow(surge.SizeHint(protocol) + surge.SizeHint(value) + surge.SizeHint(nonce))
+	buf := make([]byte, surge.SizeHintU8+surge.SizeHintString(value)+surge.SizeHintU64)
 	return NewAddressHashWithBuffer(protocol, value, nonce, buf)
 }
 
-// NewAddressHashWithBuffer returns the Hash of an Address for signing by the
-// peer. It uses a Buffer for all marshaling, and expected the caller to Reset
-// the Buffer before/after calling this function.
-func NewAddressHashWithBuffer(protocol uint8, value string, nonce uint64, buf *bytes.Buffer) (id.Hash, error) {
-	buf.Reset()
-	m, err := surge.Marshal(buf, protocol, surge.MaxBytes)
-	if err != nil {
-		return id.Hash{}, fmt.Errorf("marshaling protocol: %v", err)
-	}
-	if m, err = surge.Marshal(buf, value, m); err != nil {
-		return id.Hash{}, fmt.Errorf("marshaling value: %v", err)
-	}
-	if m, err = surge.Marshal(buf, nonce, m); err != nil {
-		return id.Hash{}, fmt.Errorf("marshaling nonce: %v", err)
-	}
-	return id.Hash(sha256.Sum256(buf.Bytes())), nil
+// NewAddressHashWithBuffer writes the Hash of an Address into a bytes buffer
+// for signing by the peer. An error is returned when the arguments are too
+// large and cannot be marshaled into bytes without exceeding memory allocation
+// restrictions. This function is useful when doing a lot of hashing, because it
+// allows for buffer re-use.
+func NewAddressHashWithBuffer(protocol uint8, value string, nonce uint64, data []byte) (id.Hash, error) {
+	var err error
+	buf := data
+	rem := surge.MaxBytes
+	if buf, rem, err = surge.MarshalU8(protocol, buf, rem); err != nil {
+		return id.Hash{}, err
+	}
+	if buf, rem, err = surge.MarshalString(value, buf, rem); err != nil {
+		return id.Hash{}, err
+	}
+	if buf, rem, err = surge.MarshalU64(nonce, buf, rem); err != nil {
+		return id.Hash{}, err
+	}
+	return id.Hash(sha256.Sum256(buf)), nil
 }
 
 // An Address is a verifiable and expirable network address associated with a
@@ -71,65 +73,54 @@ func NewUnsignedAddress(protocol uint8, value string, nonce uint64) Address {
 // SizeHint returns the number of bytes needed to represent this Address in
 // binary.
 func (addr Address) SizeHint() int {
-	return surge.SizeHint(addr.Protocol) +
-		surge.SizeHint(addr.Value) +
-		surge.SizeHint(addr.Nonce) +
-		surge.SizeHint(addr.Signature)
+	return surge.SizeHintU8 +
+		surge.SizeHintString(addr.Value) +
+		surge.SizeHintU64 +
+		addr.Signature.SizeHint()
 }
 
 // Marshal this Address into binary.
-func (addr Address) Marshal(w io.Writer, m int) (int, error) {
-	m, err := surge.Marshal(w, addr.Protocol, m)
-	if err != nil {
-		return m, fmt.Errorf("marsahling timestamp: %v", err)
+func (addr Address) Marshal(buf []byte, rem int) ([]byte, int, error) {
+	var err error
+	if buf, rem, err = surge.MarshalU8(addr.Protocol, buf, rem); err != nil {
+		return buf, rem, err
 	}
-	m, err = surge.Marshal(w, addr.Value, m)
-	if err != nil {
-		return m, fmt.Errorf("marsahling protocol: %v", err)
+	if buf, rem, err = surge.MarshalString(addr.Value, buf, rem); err != nil {
+		return buf, rem, err
 	}
-	m, err = surge.Marshal(w, addr.Nonce, m)
-	if err != nil {
-		return m, fmt.Errorf("marsahling value: %v", err)
-	}
-	m, err = surge.Marshal(w, addr.Signature, m)
-	if err != nil {
-		return m, fmt.Errorf("marsahling signature: %v", err)
+	if buf, rem, err = surge.MarshalU64(addr.Nonce, buf, rem); err != nil {
+		return buf, rem, err
 	}
-	return m, nil
+	return addr.Signature.Marshal(buf, rem)
 }
 
 // Unmarshal from binary into this Address.
-func (addr *Address) Unmarshal(r io.Reader, m int) (int, error) {
-	m, err := surge.Unmarshal(r, &addr.Protocol, m)
-	if err != nil {
-		return m, fmt.Errorf("unmarsahling timestamp: %v", err)
-	}
-	m, err = surge.Unmarshal(r, &addr.Value, m)
+func (addr *Address) Unmarshal(buf []byte, rem int) ([]byte, int, error) {
+	var err error
+	buf, rem, err = surge.UnmarshalU8(&addr.Protocol, buf, rem)
 	if err != nil {
-		return m, fmt.Errorf("unmarsahling protocol: %v", err)
+		return buf, rem, err
 	}
-	m, err = surge.Unmarshal(r, &addr.Nonce, m)
+	buf, rem, err = surge.UnmarshalString(&addr.Value, buf, rem)
 	if err != nil {
-		return m, fmt.Errorf("unmarsahling value: %v", err)
+		return buf, rem, err
 	}
-	m, err = surge.Unmarshal(r, &addr.Signature, m)
+	buf, rem, err = surge.UnmarshalU64(&addr.Nonce, buf, rem)
 	if err != nil {
-		return m, fmt.Errorf("unmarsahling signature: %v", err)
+		return buf, rem, err
 	}
-	return m, nil
+	return addr.Signature.Unmarshal(buf, rem)
 }
 
 // Sign this Address and set its Signature.
 func (addr *Address) Sign(privKey *id.PrivKey) error {
-	buf := new(bytes.Buffer)
-	buf.Grow(surge.SizeHint(addr.Nonce) + surge.SizeHint(addr.Protocol) + surge.SizeHint(addr.Value))
+	buf := make([]byte, surge.SizeHintU8+surge.SizeHintString(addr.Value)+surge.SizeHintU64)
 	return addr.SignWithBuffer(privKey, buf)
 }
 
 // SignWithBuffer will Sign the Address and set its Signature. It uses a Buffer
-// for all marshaling, and expected the caller to Reset the Buffer before/after
-// calling this method.
-func (addr *Address) SignWithBuffer(privKey *id.PrivKey, buf *bytes.Buffer) error {
+// for all marshaling to allow for buffer re-use.
+func (addr *Address) SignWithBuffer(privKey *id.PrivKey, buf []byte) error {
 	hash, err := NewAddressHashWithBuffer(addr.Protocol, addr.Value, addr.Nonce, buf)
 	if err != nil {
 		return fmt.Errorf("hashing address: %v", err)
@@ -146,15 +137,13 @@ func (addr *Address) SignWithBuffer(privKey *id.PrivKey, buf *bytes.Buffer) erro
 
 // Verify that the Address was signed by a specific Signatory.
 func (addr *Address) Verify(signatory id.Signatory) error {
-	buf := new(bytes.Buffer)
-	buf.Grow(surge.SizeHint(addr.Nonce) + surge.SizeHint(addr.Protocol) + surge.SizeHint(addr.Value))
+	buf := make([]byte, surge.SizeHintU8+surge.SizeHintString(addr.Value)+surge.SizeHintU64)
 	return addr.VerifyWithBuffer(signatory, buf)
 }
 
 // VerifyWithBuffer will verify that the Address was signed by a specific
-// Signatory. It uses a Buffer for all marshaling, and expected the caller to
-// Reset the Buffer before/after calling this method.
-func (addr *Address) VerifyWithBuffer(signatory id.Signatory, buf *bytes.Buffer) error {
+// Signatory. It uses a Buffer for all marshaling to allow for buffer re-use.
+func (addr *Address) VerifyWithBuffer(signatory id.Signatory, buf []byte) error {
 	hash, err := NewAddressHashWithBuffer(addr.Protocol, addr.Value, addr.Nonce, buf)
 	if err != nil {
 		return fmt.Errorf("hashing address: %v", err)
@@ -163,7 +152,7 @@ func (addr *Address) VerifyWithBuffer(signatory id.Signatory, buf *bytes.Buffer)
 	if err != nil {
 		return fmt.Errorf("identifying address signature: %v", err)
 	}
-	verifiedSignatory := id.NewSignatory(verifiedPubKey)
+	verifiedSignatory := id.NewSignatory((*id.PubKey)(verifiedPubKey))
 	if !signatory.Equal(&verifiedSignatory) {
 		return fmt.Errorf("verifying address signatory: expected=%v, got=%v", signatory, verifiedSignatory)
 	}
@@ -173,16 +162,14 @@ func (addr *Address) VerifyWithBuffer(signatory id.Signatory, buf *bytes.Buffer)
 // Signatory returns the Signatory from the Address, based on the Signature. If
 // the Address is unsigned, then the empty Signatory is returned.
 func (addr *Address) Signatory() (id.Signatory, error) {
-	buf := new(bytes.Buffer)
-	buf.Grow(surge.SizeHint(addr.Nonce) + surge.SizeHint(addr.Protocol) + surge.SizeHint(addr.Value))
+	buf := make([]byte, surge.SizeHintU8+surge.SizeHintString(addr.Value)+surge.SizeHintU64)
 	return addr.SignatoryWithBuffer(buf)
 }
 
 // SignatoryWithBuffer returns the Signatory from the Address, based on the
 // Signature. If the Address is unsigned, then the empty Signatory is returned.
-// It uses a Buffer for all marshaling, and expected the caller to Reset the
-// Buffer before/after calling this method.
-func (addr *Address) SignatoryWithBuffer(buf *bytes.Buffer) (id.Signatory, error) {
+// It uses a Buffer for all marshaling to allow for buffer re-use.
+func (addr *Address) SignatoryWithBuffer(buf []byte) (id.Signatory, error) {
 	// Check whether or not the Address is unsigned.
 	if addr.Signature.Equal(&id.Signature{}) {
 		return id.Signatory{}, nil
@@ -197,7 +184,7 @@ func (addr *Address) SignatoryWithBuffer(buf *bytes.Buffer) (id.Signatory, error
 	if err != nil {
 		return id.Signatory{}, fmt.Errorf("identifying address signature: %v", err)
 	}
-	return id.NewSignatory(pubKey), nil
+	return id.NewSignatory((*id.PubKey)(pubKey)), nil
 }
 
 // String returns a human-readable representation of the Address. The string
diff --git a/wire/addr_test.go b/wire/addr_test.go
index 8465e00..25f1be6 100644
--- a/wire/addr_test.go
+++ b/wire/addr_test.go
@@ -22,7 +22,7 @@ var _ = Describe("Address", func() {
 				data, err := surge.ToBinary(addr)
 				Expect(err).ToNot(HaveOccurred())
 				unmarshaledAddr := wire.Address{}
-				err = surge.FromBinary(data, &unmarshaledAddr)
+				err = surge.FromBinary(&unmarshaledAddr, data)
 				Expect(err).ToNot(HaveOccurred())
 				Expect(addr.Equal(&unmarshaledAddr)).To(BeTrue())
 				return true
diff --git a/wire/msg.go b/wire/msg.go
index 690d61f..abaa6ba 100644
--- a/wire/msg.go
+++ b/wire/msg.go
@@ -2,7 +2,6 @@ package wire
 
 import (
 	"bytes"
-	"fmt"
 	"io"
 
 	"github.com/renproject/id"
@@ -69,46 +68,30 @@ func (msg Message) Equal(other *Message) bool {
 	return msg.Version == other.Version && msg.Type == other.Type && bytes.Equal(msg.Data, other.Data)
 }
 
-// SizeHint returns the number of bytes required to represent this Message in
-// binary.
-func (msg Message) SizeHint() int {
-	return surge.SizeHint(msg.Version) +
-		surge.SizeHint(msg.Type) +
-		surge.SizeHint(msg.Data)
-}
-
 // Marshal this Message into binary.
-func (msg Message) Marshal(w io.Writer, m int) (int, error) {
-	m, err := surge.Marshal(w, uint8(msg.Version), m)
-	if err != nil {
-		return m, fmt.Errorf("marshaling version: %v", err)
+func (msg Message) Marshal(buf []byte, rem int) ([]byte, int, error) {
+	var err error
+	if buf, rem, err = surge.MarshalU8(uint8(msg.Version), buf, rem); err != nil {
+		return buf, rem, err
 	}
-	m, err = surge.Marshal(w, uint8(msg.Type), m)
-	if err != nil {
-		return m, fmt.Errorf("marshaling variant: %v", err)
+	if buf, rem, err = surge.MarshalU8(uint8(msg.Type), buf, rem); err != nil {
+		return buf, rem, err
 	}
-	m, err = surge.Marshal(w, msg.Data, m)
-	if err != nil {
-		return m, fmt.Errorf("marshaling data: %v", err)
-	}
-	return m, nil
+	return surge.MarshalBytes(msg.Data, buf, rem)
 }
 
 // Unmarshal from binary into this Message.
-func (msg *Message) Unmarshal(r io.Reader, m int) (int, error) {
-	m, err := surge.Unmarshal(r, (*uint8)(&msg.Version), m)
-	if err != nil {
-		return m, fmt.Errorf("unmarshaling version: %v", err)
-	}
-	m, err = surge.Unmarshal(r, (*uint8)(&msg.Type), m)
+func (msg *Message) Unmarshal(buf []byte, rem int) ([]byte, int, error) {
+	var err error
+	buf, rem, err = surge.UnmarshalU8((*uint8)(&msg.Version), buf, rem)
 	if err != nil {
-		return m, fmt.Errorf("unmarshaling variant: %v", err)
+		return buf, rem, err
 	}
-	m, err = surge.Unmarshal(r, &msg.Data, m)
+	buf, rem, err = surge.UnmarshalU8((*uint8)(&msg.Type), buf, rem)
 	if err != nil {
-		return m, fmt.Errorf("unmarshaling data: %v", err)
+		return buf, rem, err
 	}
-	return m, nil
+	return surge.UnmarshalBytes(&msg.Data, buf, rem)
 }
 
 type PingV1 struct {
@@ -118,15 +101,15 @@ type PingV1 struct {
 }
 
 func (ping PingV1) SizeHint() int {
-	return surge.SizeHint(ping.Addr)
+	return ping.Addr.SizeHint()
 }
 
-func (ping PingV1) Marshal(w io.Writer, m int) (int, error) {
-	return surge.Marshal(w, ping.Addr, m)
+func (ping PingV1) Marshal(buf []byte, rem int) ([]byte, int, error) {
+	return ping.Addr.Marshal(buf, rem)
 }
 
-func (ping *PingV1) Unmarshal(r io.Reader, m int) (int, error) {
-	return surge.Unmarshal(r, &ping.Addr, m)
+func (ping *PingV1) Unmarshal(buf []byte, rem int) ([]byte, int, error) {
+	return ping.Addr.Unmarshal(buf, rem)
 }
 
 type PingAckV1 struct {
@@ -137,12 +120,12 @@ func (pingAck PingAckV1) SizeHint() int {
 	return surge.SizeHint(pingAck.Addrs)
 }
 
-func (pingAck PingAckV1) Marshal(w io.Writer, m int) (int, error) {
-	return surge.Marshal(w, pingAck.Addrs, m)
+func (pingAck PingAckV1) Marshal(buf []byte, rem int) ([]byte, int, error) {
+	return surge.Marshal(pingAck.Addrs, buf, rem)
 }
 
-func (pingAck *PingAckV1) Unmarshal(r io.Reader, m int) (int, error) {
-	return surge.Unmarshal(r, &pingAck.Addrs, m)
+func (pingAck *PingAckV1) Unmarshal(buf []byte, rem int) ([]byte, int, error) {
+	return surge.Unmarshal(&pingAck.Addrs, buf, rem)
 }
 
 type PushV1 struct {
@@ -152,39 +135,31 @@ type PushV1 struct {
 }
 
 func (push PushV1) SizeHint() int {
-	return surge.SizeHint(push.Subnet) + surge.SizeHint(push.ContentHash)
+	return push.Subnet.SizeHint() + push.ContentHash.SizeHint() + surge.SizeHintU8
 }
 
-func (push PushV1) Marshal(w io.Writer, m int) (int, error) {
-	m, err := surge.Marshal(w, push.Subnet, m)
-	if err != nil {
-		return m, err
+func (push PushV1) Marshal(buf []byte, rem int) ([]byte, int, error) {
+	var err error
+	if buf, rem, err = push.Subnet.Marshal(buf, rem); err != nil {
+		return buf, rem, err
 	}
-	m, err = surge.Marshal(w, push.ContentHash, m)
-	if err != nil {
-		return m, err
-	}
-	m, err = surge.Marshal(w, push.ContentType, m)
-	if err != nil {
-		return m, err
+	if buf, rem, err = push.ContentHash.Marshal(buf, rem); err != nil {
+		return buf, rem, err
 	}
-	return m, nil
+	return surge.MarshalU8(push.ContentType, buf, rem)
 }
 
-func (push *PushV1) Unmarshal(r io.Reader, m int) (int, error) {
-	m, err := surge.Unmarshal(r, &push.Subnet, m)
-	if err != nil {
-		return m, err
-	}
-	m, err = surge.Unmarshal(r, &push.ContentHash, m)
+func (push *PushV1) Unmarshal(buf []byte, rem int) ([]byte, int, error) {
+	var err error
+	buf, rem, err = push.Subnet.Unmarshal(buf, rem)
 	if err != nil {
-		return m, err
+		return buf, rem, err
 	}
-	m, err = surge.Unmarshal(r, &push.ContentType, m)
+	buf, rem, err = push.ContentHash.Unmarshal(buf, rem)
 	if err != nil {
-		return m, err
+		return buf, rem, err
 	}
-	return m, nil
+	return surge.UnmarshalU8(&push.ContentType, buf, rem)
 }
 
 type PushAckV1 struct {
@@ -209,39 +184,31 @@ type PullV1 struct {
 }
 
 func (pull PullV1) SizeHint() int {
-	return surge.SizeHint(pull.Subnet) + surge.SizeHint(pull.ContentHash)
+	return pull.Subnet.SizeHint() + pull.ContentHash.SizeHint() + surge.SizeHintU8
 }
 
-func (pull PullV1) Marshal(w io.Writer, m int) (int, error) {
-	m, err := surge.Marshal(w, pull.Subnet, m)
-	if err != nil {
-		return m, err
+func (pull PullV1) Marshal(buf []byte, rem int) ([]byte, int, error) {
+	var err error
+	if buf, rem, err = pull.Subnet.Marshal(buf, rem); err != nil {
+		return buf, rem, err
 	}
-	m, err = surge.Marshal(w, pull.ContentHash, m)
-	if err != nil {
-		return m, err
+	if buf, rem, err = pull.ContentHash.Marshal(buf, rem); err != nil {
+		return buf, rem, err
 	}
-	m, err = surge.Marshal(w, pull.ContentType, m)
-	if err != nil {
-		return m, err
-	}
-	return m, nil
+	return surge.MarshalU8(pull.ContentType, buf, rem)
 }
 
-func (pull *PullV1) Unmarshal(r io.Reader, m int) (int, error) {
-	m, err := surge.Unmarshal(r, &pull.Subnet, m)
+func (pull *PullV1) Unmarshal(buf []byte, rem int) ([]byte, int, error) {
+	var err error
+	buf, rem, err = pull.Subnet.Unmarshal(buf, rem)
 	if err != nil {
-		return m, err
+		return buf, rem, err
 	}
-	m, err = surge.Unmarshal(r, &pull.ContentHash, m)
+	buf, rem, err = pull.ContentHash.Unmarshal(buf, rem)
 	if err != nil {
-		return m, err
+		return buf, rem, err
 	}
-	m, err = surge.Unmarshal(r, &pull.ContentType, m)
-	if err != nil {
-		return m, err
-	}
-	return m, nil
+	return surge.UnmarshalU8(&pull.ContentType, buf, rem)
 }
 
 type PullAckV1 struct {
@@ -252,45 +219,39 @@ type PullAckV1 struct {
 }
 
 func (pullAck PullAckV1) SizeHint() int {
-	return surge.SizeHint(pullAck.Subnet) + surge.SizeHint(pullAck.ContentHash) + surge.SizeHint(pullAck.Content)
+	return pullAck.Subnet.SizeHint() +
+		pullAck.ContentHash.SizeHint() +
+		surge.SizeHintU8 +
+		surge.SizeHintBytes(pullAck.Content)
 }
 
-func (pullAck PullAckV1) Marshal(w io.Writer, m int) (int, error) {
-	m, err := surge.Marshal(w, pullAck.Subnet, m)
-	if err != nil {
-		return m, err
+func (pullAck PullAckV1) Marshal(buf []byte, rem int) ([]byte, int, error) {
+	var err error
+	if buf, rem, err = pullAck.Subnet.Marshal(buf, rem); err != nil {
+		return buf, rem, err
 	}
-	m, err = surge.Marshal(w, pullAck.ContentHash, m)
-	if err != nil {
-		return m, err
-	}
-	m, err = surge.Marshal(w, pullAck.ContentType, m)
-	if err != nil {
-		return m, err
+	if buf, rem, err = pullAck.ContentHash.Marshal(buf, rem); err != nil {
+		return buf, rem, err
 	}
-	m, err = surge.Marshal(w, pullAck.Content, m)
-	if err != nil {
-		return m, err
+	if buf, rem, err = surge.MarshalU8(pullAck.ContentType, buf, rem); err != nil {
+		return buf, rem, err
 	}
-	return m, nil
+	return surge.MarshalBytes(pullAck.Content, buf, rem)
 }
 
-func (pullAck *PullAckV1) Unmarshal(r io.Reader, m int) (int, error) {
-	m, err := surge.Unmarshal(r, &pullAck.Subnet, m)
-	if err != nil {
-		return m, err
-	}
-	m, err = surge.Unmarshal(r, &pullAck.ContentHash, m)
+func (pullAck *PullAckV1) Unmarshal(buf []byte, rem int) ([]byte, int, error) {
+	var err error
+	buf, rem, err = pullAck.Subnet.Unmarshal(buf, rem)
 	if err != nil {
-		return m, err
+		return buf, rem, err
 	}
-	m, err = surge.Unmarshal(r, &pullAck.ContentType, m)
+	buf, rem, err = pullAck.ContentHash.Unmarshal(buf, rem)
 	if err != nil {
-		return m, err
+		return buf, rem, err
 	}
-	m, err = surge.Unmarshal(r, &pullAck.Content, m)
+	buf, rem, err = surge.UnmarshalU8(&pullAck.ContentType, buf, rem)
 	if err != nil {
-		return m, err
+		return buf, rem, err
 	}
-	return m, nil
+	return surge.UnmarshalBytes(&pullAck.Content, buf, rem)
 }
diff --git a/wire/msg_test.go b/wire/msg_test.go
index ac8c6be..d195350 100644
--- a/wire/msg_test.go
+++ b/wire/msg_test.go
@@ -22,7 +22,7 @@ var _ = Describe("Message", func() {
 				data, err := surge.ToBinary(msg)
 				Expect(err).ToNot(HaveOccurred())
 				unmarshaledMsg := wire.Message{}
-				err = surge.FromBinary(data, &unmarshaledMsg)
+				err = surge.FromBinary(&unmarshaledMsg, data)
 				Expect(err).ToNot(HaveOccurred())
 				Expect(msg.Equal(&unmarshaledMsg)).To(BeTrue())
 				return true