replace key with the new public_key make node_addr more self-contained (own error type)

Makefile

···
 	EXT=so; \
 	if [ "$(BUILDOS)" = "darwin" ]; then EXT=dylib; fi; \
 	uniffi-bindgen-go --out-dir pkg/iroh/generated --library ./target/debug/libiroh_streamplace.$$EXT \
-	&& cp ./target/debug/libiroh_streamplace.$$EXT $(BUILDDIR)/rust/iroh-streamplace/libiroh_streamplace.$$EXT \
-	&& cp ./target/debug/libiroh_streamplace.$$EXT $(BUILDDIR)/lib/libiroh_streamplace.$$EXT
+	&& mkdir -p $(BUILDDIR)/rust/iroh-streamplace/ \
+	&& mkdir -p $(BUILDDIR)/lib/ \
+	&& cp ./target/debug/libiroh_streamplace.$$EXT $(BUILDDIR)/rust/iroh-streamplace/ \
+	&& cp ./target/debug/libiroh_streamplace.$$EXT $(BUILDDIR)/lib/
 
 .PHONY: dev-test
 dev-test:

pkg/iroh/generated/iroh_streamplace/iroh_streamplace.go

···
 import (
 	"bytes"
 	"encoding/binary"
+	"errors"
 	"fmt"
 	"io"
 	"math"
···
 	"runtime/cgo"
 	"sync"
 	"sync/atomic"
+	"time"
 	"unsafe"
 )
 
···
 func init() {
 
 	FfiConverterDataHandlerINSTANCE.register()
+	FfiConverterDataHandlerOldINSTANCE.register()
 	FfiConverterGoSignerINSTANCE.register()
 	uniffiCheckChecksums()
 }
···
 	}
 	{
 		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
+			return C.uniffi_iroh_streamplace_checksum_func_subscribe_item_debug()
+		})
+		if checksum != 8233 {
+			// If this happens try cleaning and rebuilding your project
+			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_func_subscribe_item_debug: UniFFI API checksum mismatch")
+		}
+	}
+	{
+		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
 			return C.uniffi_iroh_streamplace_checksum_method_datahandler_handle_data()
 		})
 		if checksum != 27893 {
···
 	}
 	{
 		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
+			return C.uniffi_iroh_streamplace_checksum_method_datahandlerold_handle_data()
+		})
+		if checksum != 20343 {
+			// If this happens try cleaning and rebuilding your project
+			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_datahandlerold_handle_data: UniFFI API checksum mismatch")
+		}
+	}
+	{
+		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
+			return C.uniffi_iroh_streamplace_checksum_method_db_iter_with_opts()
+		})
+		if checksum != 3815 {
+			// If this happens try cleaning and rebuilding your project
+			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_db_iter_with_opts: UniFFI API checksum mismatch")
+		}
+	}
+	{
+		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
+			return C.uniffi_iroh_streamplace_checksum_method_db_subscribe()
+		})
+		if checksum != 415 {
+			// If this happens try cleaning and rebuilding your project
+			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_db_subscribe: UniFFI API checksum mismatch")
+		}
+	}
+	{
+		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
+			return C.uniffi_iroh_streamplace_checksum_method_db_subscribe_with_opts()
+		})
+		if checksum != 17612 {
+			// If this happens try cleaning and rebuilding your project
+			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_db_subscribe_with_opts: UniFFI API checksum mismatch")
+		}
+	}
+	{
+		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
+			return C.uniffi_iroh_streamplace_checksum_method_db_write()
+		})
+		if checksum != 5247 {
+			// If this happens try cleaning and rebuilding your project
+			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_db_write: UniFFI API checksum mismatch")
+		}
+	}
+	{
+		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
 			return C.uniffi_iroh_streamplace_checksum_method_endpoint_node_addr()
 		})
 		if checksum != 17254 {
···
 	}
 	{
 		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
+			return C.uniffi_iroh_streamplace_checksum_method_filter_global()
+		})
+		if checksum != 47323 {
+			// If this happens try cleaning and rebuilding your project
+			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_filter_global: UniFFI API checksum mismatch")
+		}
+	}
+	{
+		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
+			return C.uniffi_iroh_streamplace_checksum_method_filter_scope()
+		})
+		if checksum != 23022 {
+			// If this happens try cleaning and rebuilding your project
+			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_filter_scope: UniFFI API checksum mismatch")
+		}
+	}
+	{
+		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
+			return C.uniffi_iroh_streamplace_checksum_method_filter_scopes()
+		})
+		if checksum != 39037 {
+			// If this happens try cleaning and rebuilding your project
+			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_filter_scopes: UniFFI API checksum mismatch")
+		}
+	}
+	{
+		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
+			return C.uniffi_iroh_streamplace_checksum_method_filter_stream()
+		})
+		if checksum != 37766 {
+			// If this happens try cleaning and rebuilding your project
+			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_filter_stream: UniFFI API checksum mismatch")
+		}
+	}
+	{
+		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
+			return C.uniffi_iroh_streamplace_checksum_method_filter_time_from()
+		})
+		if checksum != 62275 {
+			// If this happens try cleaning and rebuilding your project
+			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_filter_time_from: UniFFI API checksum mismatch")
+		}
+	}
+	{
+		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
+			return C.uniffi_iroh_streamplace_checksum_method_filter_time_range()
+		})
+		if checksum != 2045 {
+			// If this happens try cleaning and rebuilding your project
+			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_filter_time_range: UniFFI API checksum mismatch")
+		}
+	}
+	{
+		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
+			return C.uniffi_iroh_streamplace_checksum_method_filter_timestamps()
+		})
+		if checksum != 27584 {
+			// If this happens try cleaning and rebuilding your project
+			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_filter_timestamps: UniFFI API checksum mismatch")
+		}
+	}
+	{
+		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
 			return C.uniffi_iroh_streamplace_checksum_method_gosigner_sign()
 		})
 		if checksum != 50597 {
···
 	}
 	{
 		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
+			return C.uniffi_iroh_streamplace_checksum_method_node_db()
+		})
+		if checksum != 39096 {
+			// If this happens try cleaning and rebuilding your project
+			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_node_db: UniFFI API checksum mismatch")
+		}
+	}
+	{
+		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
+			return C.uniffi_iroh_streamplace_checksum_method_node_join_peers()
+		})
+		if checksum != 56647 {
+			// If this happens try cleaning and rebuilding your project
+			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_node_join_peers: UniFFI API checksum mismatch")
+		}
+	}
+	{
+		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
+			return C.uniffi_iroh_streamplace_checksum_method_node_node_id()
+		})
+		if checksum != 55009 {
+			// If this happens try cleaning and rebuilding your project
+			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_node_node_id: UniFFI API checksum mismatch")
+		}
+	}
+	{
+		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
+			return C.uniffi_iroh_streamplace_checksum_method_node_node_scope()
+		})
+		if checksum != 16912 {
+			// If this happens try cleaning and rebuilding your project
+			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_node_node_scope: UniFFI API checksum mismatch")
+		}
+	}
+	{
+		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
+			return C.uniffi_iroh_streamplace_checksum_method_node_send_segment()
+		})
+		if checksum != 18989 {
+			// If this happens try cleaning and rebuilding your project
+			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_node_send_segment: UniFFI API checksum mismatch")
+		}
+	}
+	{
+		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
+			return C.uniffi_iroh_streamplace_checksum_method_node_subscribe()
+		})
+		if checksum != 17951 {
+			// If this happens try cleaning and rebuilding your project
+			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_node_subscribe: UniFFI API checksum mismatch")
+		}
+	}
+	{
+		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
+			return C.uniffi_iroh_streamplace_checksum_method_node_ticket()
+		})
+		if checksum != 37020 {
+			// If this happens try cleaning and rebuilding your project
+			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_node_ticket: UniFFI API checksum mismatch")
+		}
+	}
+	{
+		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
+			return C.uniffi_iroh_streamplace_checksum_method_node_unsubscribe()
+		})
+		if checksum != 35396 {
+			// If this happens try cleaning and rebuilding your project
+			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_node_unsubscribe: UniFFI API checksum mismatch")
+		}
+	}
+	{
+		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
 			return C.uniffi_iroh_streamplace_checksum_method_nodeaddr_direct_addresses()
 		})
 		if checksum != 17536 {
···
 		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
 			return C.uniffi_iroh_streamplace_checksum_method_nodeaddr_node_id()
 		})
-		if checksum != 35476 {
+		if checksum != 22953 {
 			// If this happens try cleaning and rebuilding your project
 			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_nodeaddr_node_id: UniFFI API checksum mismatch")
 		}
···
 		if checksum != 18967 {
 			// If this happens try cleaning and rebuilding your project
 			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_nodeaddr_relay_url: UniFFI API checksum mismatch")
+		}
+	}
+	{
+		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
+			return C.uniffi_iroh_streamplace_checksum_method_publickey_as_vec()
+		})
+		if checksum != 32346 {
+			// If this happens try cleaning and rebuilding your project
+			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_publickey_as_vec: UniFFI API checksum mismatch")
 		}
 	}
 	{
···
 	}
 	{
 		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
-			return C.uniffi_iroh_streamplace_checksum_method_publickey_to_bytes()
+			return C.uniffi_iroh_streamplace_checksum_method_publickeyold_equal()
 		})
-		if checksum != 8223 {
+		if checksum != 35079 {
 			// If this happens try cleaning and rebuilding your project
-			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_publickey_to_bytes: UniFFI API checksum mismatch")
+			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_publickeyold_equal: UniFFI API checksum mismatch")
+		}
+	}
+	{
+		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
+			return C.uniffi_iroh_streamplace_checksum_method_publickeyold_fmt_short()
+		})
+		if checksum != 26426 {
+			// If this happens try cleaning and rebuilding your project
+			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_publickeyold_fmt_short: UniFFI API checksum mismatch")
+		}
+	}
+	{
+		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
+			return C.uniffi_iroh_streamplace_checksum_method_publickeyold_to_bytes()
+		})
+		if checksum != 41746 {
+			// If this happens try cleaning and rebuilding your project
+			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_publickeyold_to_bytes: UniFFI API checksum mismatch")
 		}
 	}
 	{
···
 		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
 			return C.uniffi_iroh_streamplace_checksum_method_receiver_subscribe()
 		})
-		if checksum != 24145 {
+		if checksum != 46188 {
 			// If this happens try cleaning and rebuilding your project
 			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_receiver_subscribe: UniFFI API checksum mismatch")
 		}
···
 		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
 			return C.uniffi_iroh_streamplace_checksum_method_receiver_unsubscribe()
 		})
-		if checksum != 21760 {
+		if checksum != 7879 {
 			// If this happens try cleaning and rebuilding your project
 			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_receiver_unsubscribe: UniFFI API checksum mismatch")
 		}
···
 	}
 	{
 		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
+			return C.uniffi_iroh_streamplace_checksum_method_subscriberesponse_next_raw()
+		})
+		if checksum != 55650 {
+			// If this happens try cleaning and rebuilding your project
+			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_subscriberesponse_next_raw: UniFFI API checksum mismatch")
+		}
+	}
+	{
+		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
+			return C.uniffi_iroh_streamplace_checksum_method_writescope_put()
+		})
+		if checksum != 50543 {
+			// If this happens try cleaning and rebuilding your project
+			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_writescope_put: UniFFI API checksum mismatch")
+		}
+	}
+	{
+		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
 			return C.uniffi_iroh_streamplace_checksum_constructor_endpoint_new()
 		})
 		if checksum != 60672 {
···
 	}
 	{
 		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
+			return C.uniffi_iroh_streamplace_checksum_constructor_filter_new()
+		})
+		if checksum != 5241 {
+			// If this happens try cleaning and rebuilding your project
+			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_constructor_filter_new: UniFFI API checksum mismatch")
+		}
+	}
+	{
+		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
+			return C.uniffi_iroh_streamplace_checksum_constructor_node_forwarder()
+		})
+		if checksum != 7334 {
+			// If this happens try cleaning and rebuilding your project
+			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_constructor_node_forwarder: UniFFI API checksum mismatch")
+		}
+	}
+	{
+		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
+			return C.uniffi_iroh_streamplace_checksum_constructor_node_receiver()
+		})
+		if checksum != 33844 {
+			// If this happens try cleaning and rebuilding your project
+			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_constructor_node_receiver: UniFFI API checksum mismatch")
+		}
+	}
+	{
+		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
+			return C.uniffi_iroh_streamplace_checksum_constructor_node_sender()
+		})
+		if checksum != 44785 {
+			// If this happens try cleaning and rebuilding your project
+			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_constructor_node_sender: UniFFI API checksum mismatch")
+		}
+	}
+	{
+		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
 			return C.uniffi_iroh_streamplace_checksum_constructor_nodeaddr_new()
 		})
-		if checksum != 28044 {
+		if checksum != 56594 {
 			// If this happens try cleaning and rebuilding your project
 			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_constructor_nodeaddr_new: UniFFI API checksum mismatch")
 		}
···
 		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
 			return C.uniffi_iroh_streamplace_checksum_constructor_publickey_from_bytes()
 		})
-		if checksum != 54187 {
+		if checksum != 57602 {
 			// If this happens try cleaning and rebuilding your project
 			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_constructor_publickey_from_bytes: UniFFI API checksum mismatch")
 		}
···
 		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
 			return C.uniffi_iroh_streamplace_checksum_constructor_publickey_from_string()
 		})
-		if checksum != 62773 {
+		if checksum != 45922 {
 			// If this happens try cleaning and rebuilding your project
 			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_constructor_publickey_from_string: UniFFI API checksum mismatch")
 		}
 	}
 	{
 		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
+			return C.uniffi_iroh_streamplace_checksum_constructor_publickeyold_from_bytes()
+		})
+		if checksum != 40751 {
+			// If this happens try cleaning and rebuilding your project
+			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_constructor_publickeyold_from_bytes: UniFFI API checksum mismatch")
+		}
+	}
+	{
+		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
+			return C.uniffi_iroh_streamplace_checksum_constructor_publickeyold_from_string()
+		})
+		if checksum != 54251 {
+			// If this happens try cleaning and rebuilding your project
+			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_constructor_publickeyold_from_string: UniFFI API checksum mismatch")
+		}
+	}
+	{
+		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
 			return C.uniffi_iroh_streamplace_checksum_constructor_receiver_new()
 		})
-		if checksum != 35153 {
+		if checksum != 18072 {
 			// If this happens try cleaning and rebuilding your project
 			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_constructor_receiver_new: UniFFI API checksum mismatch")
 		}
···
 	}
 }
 
+type FfiConverterUint64 struct{}
+
+var FfiConverterUint64INSTANCE = FfiConverterUint64{}
+
+func (FfiConverterUint64) Lower(value uint64) C.uint64_t {
+	return C.uint64_t(value)
+}
+
+func (FfiConverterUint64) Write(writer io.Writer, value uint64) {
+	writeUint64(writer, value)
+}
+
+func (FfiConverterUint64) Lift(value C.uint64_t) uint64 {
+	return uint64(value)
+}
+
+func (FfiConverterUint64) Read(reader io.Reader) uint64 {
+	return readUint64(reader)
+}
+
+type FfiDestroyerUint64 struct{}
+
+func (FfiDestroyerUint64) Destroy(_ uint64) {}
+
 type FfiConverterBool struct{}
 
 var FfiConverterBoolINSTANCE = FfiConverterBool{}
···
 	length := readInt32(reader)
 	buffer := make([]byte, length)
 	read_length, err := reader.Read(buffer)
-	if err != nil {
+	if err != nil && err != io.EOF {
 		panic(err)
 	}
 	if read_length != int(length) {
···
 	length := readInt32(reader)
 	buffer := make([]byte, length)
 	read_length, err := reader.Read(buffer)
-	if err != nil {
+	if err != nil && err != io.EOF {
 		panic(err)
 	}
 	if read_length != int(length) {
···
 
 func (FfiDestroyerBytes) Destroy(_ []byte) {}
 
+// FfiConverterDuration converts between uniffi duration and Go duration.
+type FfiConverterDuration struct{}
+
+var FfiConverterDurationINSTANCE = FfiConverterDuration{}
+
+func (c FfiConverterDuration) Lift(rb RustBufferI) time.Duration {
+	return LiftFromRustBuffer[time.Duration](c, rb)
+}
+
+func (c FfiConverterDuration) Read(reader io.Reader) time.Duration {
+	sec := readUint64(reader)
+	nsec := readUint32(reader)
+	return time.Duration(sec*1_000_000_000 + uint64(nsec))
+}
+
+func (c FfiConverterDuration) Lower(value time.Duration) C.RustBuffer {
+	return LowerIntoRustBuffer[time.Duration](c, value)
+}
+
+func (c FfiConverterDuration) Write(writer io.Writer, value time.Duration) {
+	if value.Nanoseconds() < 0 {
+		// Rust does not support negative durations:
+		// https://www.reddit.com/r/rust/comments/ljl55u/why_rusts_duration_not_supporting_negative_values/
+		// This panic is very bad, because it depends on user input, and in Go user input related
+		// error are supposed to be returned as errors, and not cause panics. However, with the
+		// current architecture, its not possible to return an error from here, so panic is used as
+		// the only other option to signal an error.
+		panic("negative duration is not allowed")
+	}
+
+	writeUint64(writer, uint64(value)/1_000_000_000)
+	writeUint32(writer, uint32(uint64(value)%1_000_000_000))
+}
+
+type FfiDestroyerDuration struct{}
+
+func (FfiDestroyerDuration) Destroy(_ time.Duration) {}
+
 // Below is an implementation of synchronization requirements outlined in the link.
 // https://github.com/mozilla/uniffi-rs/blob/0dc031132d9493ca812c3af6e7dd60ad2ea95bf0/uniffi_bindgen/src/bindings/kotlin/templates/ObjectRuntime.kt#L31
 
···
 	})
 }
 
+// DataHandler trait that is exported to go for receiving data callbacks.
 type DataHandler interface {
 	HandleData(topic string, data []byte)
 }
+
+// DataHandler trait that is exported to go for receiving data callbacks.
 type DataHandlerImpl struct {
 	ffiObject FfiObject
 }
···
 func (_self *DataHandlerImpl) HandleData(topic string, data []byte) {
 	_pointer := _self.ffiObject.incrementPointer("DataHandler")
 	defer _self.ffiObject.decrementPointer()
-	uniffiRustCallAsync[struct{}](
+	uniffiRustCallAsync[error](
 		nil,
 		// completeFn
 		func(handle C.uint64_t, status *C.RustCallStatus) struct{} {
···
 	C.uniffi_iroh_streamplace_fn_init_callback_vtable_datahandler(&UniffiVTableCallbackInterfaceDataHandlerINSTANCE)
 }
 
+type DataHandlerOld interface {
+	HandleData(topic string, data []byte)
+}
+type DataHandlerOldImpl struct {
+	ffiObject FfiObject
+}
+
+func (_self *DataHandlerOldImpl) HandleData(topic string, data []byte) {
+	_pointer := _self.ffiObject.incrementPointer("DataHandlerOld")
+	defer _self.ffiObject.decrementPointer()
+	uniffiRustCallAsync[error](
+		nil,
+		// completeFn
+		func(handle C.uint64_t, status *C.RustCallStatus) struct{} {
+			C.ffi_iroh_streamplace_rust_future_complete_void(handle, status)
+			return struct{}{}
+		},
+		// liftFn
+		func(_ struct{}) struct{} { return struct{}{} },
+		C.uniffi_iroh_streamplace_fn_method_datahandlerold_handle_data(
+			_pointer, FfiConverterStringINSTANCE.Lower(topic), FfiConverterBytesINSTANCE.Lower(data)),
+		// pollFn
+		func(handle C.uint64_t, continuation C.UniffiRustFutureContinuationCallback, data C.uint64_t) {
+			C.ffi_iroh_streamplace_rust_future_poll_void(handle, continuation, data)
+		},
+		// freeFn
+		func(handle C.uint64_t) {
+			C.ffi_iroh_streamplace_rust_future_free_void(handle)
+		},
+	)
+
+}
+func (object *DataHandlerOldImpl) Destroy() {
+	runtime.SetFinalizer(object, nil)
+	object.ffiObject.destroy()
+}
+
+type FfiConverterDataHandlerOld struct {
+	handleMap *concurrentHandleMap[DataHandlerOld]
+}
+
+var FfiConverterDataHandlerOldINSTANCE = FfiConverterDataHandlerOld{
+	handleMap: newConcurrentHandleMap[DataHandlerOld](),
+}
+
+func (c FfiConverterDataHandlerOld) Lift(pointer unsafe.Pointer) DataHandlerOld {
+	result := &DataHandlerOldImpl{
+		newFfiObject(
+			pointer,
+			func(pointer unsafe.Pointer, status *C.RustCallStatus) unsafe.Pointer {
+				return C.uniffi_iroh_streamplace_fn_clone_datahandlerold(pointer, status)
+			},
+			func(pointer unsafe.Pointer, status *C.RustCallStatus) {
+				C.uniffi_iroh_streamplace_fn_free_datahandlerold(pointer, status)
+			},
+		),
+	}
+	runtime.SetFinalizer(result, (*DataHandlerOldImpl).Destroy)
+	return result
+}
+
+func (c FfiConverterDataHandlerOld) Read(reader io.Reader) DataHandlerOld {
+	return c.Lift(unsafe.Pointer(uintptr(readUint64(reader))))
+}
+
+func (c FfiConverterDataHandlerOld) Lower(value DataHandlerOld) unsafe.Pointer {
+	// TODO: this is bad - all synchronization from ObjectRuntime.go is discarded here,
+	// because the pointer will be decremented immediately after this function returns,
+	// and someone will be left holding onto a non-locked pointer.
+	pointer := unsafe.Pointer(uintptr(c.handleMap.insert(value)))
+	return pointer
+
+}
+
+func (c FfiConverterDataHandlerOld) Write(writer io.Writer, value DataHandlerOld) {
+	writeUint64(writer, uint64(uintptr(c.Lower(value))))
+}
+
+type FfiDestroyerDataHandlerOld struct{}
+
+func (_ FfiDestroyerDataHandlerOld) Destroy(value DataHandlerOld) {
+	if val, ok := value.(*DataHandlerOldImpl); ok {
+		val.Destroy()
+	} else {
+		panic("Expected *DataHandlerOldImpl")
+	}
+}
+
+//export iroh_streamplace_cgo_dispatchCallbackInterfaceDataHandlerOldMethod0
+func iroh_streamplace_cgo_dispatchCallbackInterfaceDataHandlerOldMethod0(uniffiHandle C.uint64_t, topic C.RustBuffer, data C.RustBuffer, uniffiFutureCallback C.UniffiForeignFutureCompleteVoid, uniffiCallbackData C.uint64_t, uniffiOutReturn *C.UniffiForeignFuture) {
+	handle := uint64(uniffiHandle)
+	uniffiObj, ok := FfiConverterDataHandlerOldINSTANCE.handleMap.tryGet(handle)
+	if !ok {
+		panic(fmt.Errorf("no callback in handle map: %d", handle))
+	}
+
+	result := make(chan C.UniffiForeignFutureStructVoid, 1)
+	cancel := make(chan struct{}, 1)
+	guardHandle := cgo.NewHandle(cancel)
+	*uniffiOutReturn = C.UniffiForeignFuture{
+		handle: C.uint64_t(guardHandle),
+		free:   C.UniffiForeignFutureFree(C.iroh_streamplace_uniffiFreeGorutine),
+	}
+
+	// Wait for compleation or cancel
+	go func() {
+		select {
+		case <-cancel:
+		case res := <-result:
+			C.call_UniffiForeignFutureCompleteVoid(uniffiFutureCallback, uniffiCallbackData, res)
+		}
+	}()
+
+	// Eval callback asynchroniously
+	go func() {
+		asyncResult := &C.UniffiForeignFutureStructVoid{}
+		defer func() {
+			result <- *asyncResult
+		}()
+
+		uniffiObj.HandleData(
+			FfiConverterStringINSTANCE.Lift(GoRustBuffer{
+				inner: topic,
+			}),
+			FfiConverterBytesINSTANCE.Lift(GoRustBuffer{
+				inner: data,
+			}),
+		)
+
+	}()
+}
+
+var UniffiVTableCallbackInterfaceDataHandlerOldINSTANCE = C.UniffiVTableCallbackInterfaceDataHandlerOld{
+	handleData: (C.UniffiCallbackInterfaceDataHandlerOldMethod0)(C.iroh_streamplace_cgo_dispatchCallbackInterfaceDataHandlerOldMethod0),
+
+	uniffiFree: (C.UniffiCallbackInterfaceFree)(C.iroh_streamplace_cgo_dispatchCallbackInterfaceDataHandlerOldFree),
+}
+
+//export iroh_streamplace_cgo_dispatchCallbackInterfaceDataHandlerOldFree
+func iroh_streamplace_cgo_dispatchCallbackInterfaceDataHandlerOldFree(handle C.uint64_t) {
+	FfiConverterDataHandlerOldINSTANCE.handleMap.remove(uint64(handle))
+}
+
+func (c FfiConverterDataHandlerOld) register() {
+	C.uniffi_iroh_streamplace_fn_init_callback_vtable_datahandlerold(&UniffiVTableCallbackInterfaceDataHandlerOldINSTANCE)
+}
+
+// Iroh-streamplace specific metadata database.
+type DbInterface interface {
+	IterWithOpts(filter *Filter) ([]Entry, error)
+	Subscribe(filter *Filter) *SubscribeResponse
+	// Subscribe with options.
+	SubscribeWithOpts(opts SubscribeOpts) *SubscribeResponse
+	Write(secret []byte) (*WriteScope, error)
+}
+
+// Iroh-streamplace specific metadata database.
+type Db struct {
+	ffiObject FfiObject
+}
+
+func (_self *Db) IterWithOpts(filter *Filter) ([]Entry, error) {
+	_pointer := _self.ffiObject.incrementPointer("*Db")
+	defer _self.ffiObject.decrementPointer()
+	res, err := uniffiRustCallAsync[SubscribeNextError](
+		FfiConverterSubscribeNextErrorINSTANCE,
+		// completeFn
+		func(handle C.uint64_t, status *C.RustCallStatus) RustBufferI {
+			res := C.ffi_iroh_streamplace_rust_future_complete_rust_buffer(handle, status)
+			return GoRustBuffer{
+				inner: res,
+			}
+		},
+		// liftFn
+		func(ffi RustBufferI) []Entry {
+			return FfiConverterSequenceEntryINSTANCE.Lift(ffi)
+		},
+		C.uniffi_iroh_streamplace_fn_method_db_iter_with_opts(
+			_pointer, FfiConverterFilterINSTANCE.Lower(filter)),
+		// pollFn
+		func(handle C.uint64_t, continuation C.UniffiRustFutureContinuationCallback, data C.uint64_t) {
+			C.ffi_iroh_streamplace_rust_future_poll_rust_buffer(handle, continuation, data)
+		},
+		// freeFn
+		func(handle C.uint64_t) {
+			C.ffi_iroh_streamplace_rust_future_free_rust_buffer(handle)
+		},
+	)
+
+	return res, err
+}
+
+func (_self *Db) Subscribe(filter *Filter) *SubscribeResponse {
+	_pointer := _self.ffiObject.incrementPointer("*Db")
+	defer _self.ffiObject.decrementPointer()
+	return FfiConverterSubscribeResponseINSTANCE.Lift(rustCall(func(_uniffiStatus *C.RustCallStatus) unsafe.Pointer {
+		return C.uniffi_iroh_streamplace_fn_method_db_subscribe(
+			_pointer, FfiConverterFilterINSTANCE.Lower(filter), _uniffiStatus)
+	}))
+}
+
+// Subscribe with options.
+func (_self *Db) SubscribeWithOpts(opts SubscribeOpts) *SubscribeResponse {
+	_pointer := _self.ffiObject.incrementPointer("*Db")
+	defer _self.ffiObject.decrementPointer()
+	return FfiConverterSubscribeResponseINSTANCE.Lift(rustCall(func(_uniffiStatus *C.RustCallStatus) unsafe.Pointer {
+		return C.uniffi_iroh_streamplace_fn_method_db_subscribe_with_opts(
+			_pointer, FfiConverterSubscribeOptsINSTANCE.Lower(opts), _uniffiStatus)
+	}))
+}
+
+func (_self *Db) Write(secret []byte) (*WriteScope, error) {
+	_pointer := _self.ffiObject.incrementPointer("*Db")
+	defer _self.ffiObject.decrementPointer()
+	_uniffiRV, _uniffiErr := rustCallWithError[WriteError](FfiConverterWriteError{}, func(_uniffiStatus *C.RustCallStatus) unsafe.Pointer {
+		return C.uniffi_iroh_streamplace_fn_method_db_write(
+			_pointer, FfiConverterBytesINSTANCE.Lower(secret), _uniffiStatus)
+	})
+	if _uniffiErr != nil {
+		var _uniffiDefaultValue *WriteScope
+		return _uniffiDefaultValue, _uniffiErr
+	} else {
+		return FfiConverterWriteScopeINSTANCE.Lift(_uniffiRV), nil
+	}
+}
+func (object *Db) Destroy() {
+	runtime.SetFinalizer(object, nil)
+	object.ffiObject.destroy()
+}
+
+type FfiConverterDb struct{}
+
+var FfiConverterDbINSTANCE = FfiConverterDb{}
+
+func (c FfiConverterDb) Lift(pointer unsafe.Pointer) *Db {
+	result := &Db{
+		newFfiObject(
+			pointer,
+			func(pointer unsafe.Pointer, status *C.RustCallStatus) unsafe.Pointer {
+				return C.uniffi_iroh_streamplace_fn_clone_db(pointer, status)
+			},
+			func(pointer unsafe.Pointer, status *C.RustCallStatus) {
+				C.uniffi_iroh_streamplace_fn_free_db(pointer, status)
+			},
+		),
+	}
+	runtime.SetFinalizer(result, (*Db).Destroy)
+	return result
+}
+
+func (c FfiConverterDb) Read(reader io.Reader) *Db {
+	return c.Lift(unsafe.Pointer(uintptr(readUint64(reader))))
+}
+
+func (c FfiConverterDb) Lower(value *Db) unsafe.Pointer {
+	// TODO: this is bad - all synchronization from ObjectRuntime.go is discarded here,
+	// because the pointer will be decremented immediately after this function returns,
+	// and someone will be left holding onto a non-locked pointer.
+	pointer := value.ffiObject.incrementPointer("*Db")
+	defer value.ffiObject.decrementPointer()
+	return pointer
+
+}
+
+func (c FfiConverterDb) Write(writer io.Writer, value *Db) {
+	writeUint64(writer, uint64(uintptr(c.Lower(value))))
+}
+
+type FfiDestroyerDb struct{}
+
+func (_ FfiDestroyerDb) Destroy(value *Db) {
+	value.Destroy()
+}
+
 type EndpointInterface interface {
 	NodeAddr() *NodeAddr
 }
···
 }
 
 // Create a new endpoint.
-func NewEndpoint() (*Endpoint, *Error) {
+func NewEndpoint() (*Endpoint, error) {
 	res, err := uniffiRustCallAsync[Error](
 		FfiConverterErrorINSTANCE,
 		// completeFn
···
 func (_self *Endpoint) NodeAddr() *NodeAddr {
 	_pointer := _self.ffiObject.incrementPointer("*Endpoint")
 	defer _self.ffiObject.decrementPointer()
-	res, _ := uniffiRustCallAsync[struct{}](
+	res, _ := uniffiRustCallAsync[error](
 		nil,
 		// completeFn
 		func(handle C.uint64_t, status *C.RustCallStatus) unsafe.Pointer {
···
 	value.Destroy()
 }
 
+// A filter for subscriptions and iteration.
+type FilterInterface interface {
+	// Restrict to the global namespace, no per stream data.
+	Global() *Filter
+	// Restrict to a single scope.
+	Scope(scope *PublicKey) *Filter
+	// Restrict to a set of scopes.
+	Scopes(scopes []*PublicKey) *Filter
+	// Restrict to one specific stream, no global data.
+	Stream(stream []byte) *Filter
+	// Restrict to a time range starting at min, unbounded at the top.
+	TimeFrom(min uint64) *Filter
+	// Restrict to a time range given in nanoseconds since unix epoch.
+	TimeRange(min uint64, max uint64) *Filter
+	// Restrict to a time range.
+	Timestamps(min TimeBound, max TimeBound) *Filter
+}
+
+// A filter for subscriptions and iteration.
+type Filter struct {
+	ffiObject FfiObject
+}
+
+// Creates a new filter that matches everything.
+func NewFilter() *Filter {
+	return FfiConverterFilterINSTANCE.Lift(rustCall(func(_uniffiStatus *C.RustCallStatus) unsafe.Pointer {
+		return C.uniffi_iroh_streamplace_fn_constructor_filter_new(_uniffiStatus)
+	}))
+}
+
+// Restrict to the global namespace, no per stream data.
+func (_self *Filter) Global() *Filter {
+	_pointer := _self.ffiObject.incrementPointer("*Filter")
+	defer _self.ffiObject.decrementPointer()
+	return FfiConverterFilterINSTANCE.Lift(rustCall(func(_uniffiStatus *C.RustCallStatus) unsafe.Pointer {
+		return C.uniffi_iroh_streamplace_fn_method_filter_global(
+			_pointer, _uniffiStatus)
+	}))
+}
+
+// Restrict to a single scope.
+func (_self *Filter) Scope(scope *PublicKey) *Filter {
+	_pointer := _self.ffiObject.incrementPointer("*Filter")
+	defer _self.ffiObject.decrementPointer()
+	return FfiConverterFilterINSTANCE.Lift(rustCall(func(_uniffiStatus *C.RustCallStatus) unsafe.Pointer {
+		return C.uniffi_iroh_streamplace_fn_method_filter_scope(
+			_pointer, FfiConverterPublicKeyINSTANCE.Lower(scope), _uniffiStatus)
+	}))
+}
+
+// Restrict to a set of scopes.
+func (_self *Filter) Scopes(scopes []*PublicKey) *Filter {
+	_pointer := _self.ffiObject.incrementPointer("*Filter")
+	defer _self.ffiObject.decrementPointer()
+	return FfiConverterFilterINSTANCE.Lift(rustCall(func(_uniffiStatus *C.RustCallStatus) unsafe.Pointer {
+		return C.uniffi_iroh_streamplace_fn_method_filter_scopes(
+			_pointer, FfiConverterSequencePublicKeyINSTANCE.Lower(scopes), _uniffiStatus)
+	}))
+}
+
+// Restrict to one specific stream, no global data.
+func (_self *Filter) Stream(stream []byte) *Filter {
+	_pointer := _self.ffiObject.incrementPointer("*Filter")
+	defer _self.ffiObject.decrementPointer()
+	return FfiConverterFilterINSTANCE.Lift(rustCall(func(_uniffiStatus *C.RustCallStatus) unsafe.Pointer {
+		return C.uniffi_iroh_streamplace_fn_method_filter_stream(
+			_pointer, FfiConverterBytesINSTANCE.Lower(stream), _uniffiStatus)
+	}))
+}
+
+// Restrict to a time range starting at min, unbounded at the top.
+func (_self *Filter) TimeFrom(min uint64) *Filter {
+	_pointer := _self.ffiObject.incrementPointer("*Filter")
+	defer _self.ffiObject.decrementPointer()
+	return FfiConverterFilterINSTANCE.Lift(rustCall(func(_uniffiStatus *C.RustCallStatus) unsafe.Pointer {
+		return C.uniffi_iroh_streamplace_fn_method_filter_time_from(
+			_pointer, FfiConverterUint64INSTANCE.Lower(min), _uniffiStatus)
+	}))
+}
+
+// Restrict to a time range given in nanoseconds since unix epoch.
+func (_self *Filter) TimeRange(min uint64, max uint64) *Filter {
+	_pointer := _self.ffiObject.incrementPointer("*Filter")
+	defer _self.ffiObject.decrementPointer()
+	return FfiConverterFilterINSTANCE.Lift(rustCall(func(_uniffiStatus *C.RustCallStatus) unsafe.Pointer {
+		return C.uniffi_iroh_streamplace_fn_method_filter_time_range(
+			_pointer, FfiConverterUint64INSTANCE.Lower(min), FfiConverterUint64INSTANCE.Lower(max), _uniffiStatus)
+	}))
+}
+
+// Restrict to a time range.
+func (_self *Filter) Timestamps(min TimeBound, max TimeBound) *Filter {
+	_pointer := _self.ffiObject.incrementPointer("*Filter")
+	defer _self.ffiObject.decrementPointer()
+	return FfiConverterFilterINSTANCE.Lift(rustCall(func(_uniffiStatus *C.RustCallStatus) unsafe.Pointer {
+		return C.uniffi_iroh_streamplace_fn_method_filter_timestamps(
+			_pointer, FfiConverterTimeBoundINSTANCE.Lower(min), FfiConverterTimeBoundINSTANCE.Lower(max), _uniffiStatus)
+	}))
+}
+func (object *Filter) Destroy() {
+	runtime.SetFinalizer(object, nil)
+	object.ffiObject.destroy()
+}
+
+type FfiConverterFilter struct{}
+
+var FfiConverterFilterINSTANCE = FfiConverterFilter{}
+
+func (c FfiConverterFilter) Lift(pointer unsafe.Pointer) *Filter {
+	result := &Filter{
+		newFfiObject(
+			pointer,
+			func(pointer unsafe.Pointer, status *C.RustCallStatus) unsafe.Pointer {
+				return C.uniffi_iroh_streamplace_fn_clone_filter(pointer, status)
+			},
+			func(pointer unsafe.Pointer, status *C.RustCallStatus) {
+				C.uniffi_iroh_streamplace_fn_free_filter(pointer, status)
+			},
+		),
+	}
+	runtime.SetFinalizer(result, (*Filter).Destroy)
+	return result
+}
+
+func (c FfiConverterFilter) Read(reader io.Reader) *Filter {
+	return c.Lift(unsafe.Pointer(uintptr(readUint64(reader))))
+}
+
+func (c FfiConverterFilter) Lower(value *Filter) unsafe.Pointer {
+	// TODO: this is bad - all synchronization from ObjectRuntime.go is discarded here,
+	// because the pointer will be decremented immediately after this function returns,
+	// and someone will be left holding onto a non-locked pointer.
+	pointer := value.ffiObject.incrementPointer("*Filter")
+	defer value.ffiObject.decrementPointer()
+	return pointer
+
+}
+
+func (c FfiConverterFilter) Write(writer io.Writer, value *Filter) {
+	writeUint64(writer, uint64(uintptr(c.Lower(value))))
+}
+
+type FfiDestroyerFilter struct{}
+
+func (_ FfiDestroyerFilter) Destroy(value *Filter) {
+	value.Destroy()
+}
+
 type GoSigner interface {
-	Sign(data []byte) ([]byte, *SpError)
+	Sign(data []byte) ([]byte, error)
 }
 type GoSignerImpl struct {
 	ffiObject FfiObject
 }
 
-func (_self *GoSignerImpl) Sign(data []byte) ([]byte, *SpError) {
+func (_self *GoSignerImpl) Sign(data []byte) ([]byte, error) {
 	_pointer := _self.ffiObject.incrementPointer("GoSigner")
 	defer _self.ffiObject.decrementPointer()
 	_uniffiRV, _uniffiErr := rustCallWithError[SpError](FfiConverterSpError{}, func(_uniffiStatus *C.RustCallStatus) RustBufferI {
···
 		var _uniffiDefaultValue []byte
 		return _uniffiDefaultValue, _uniffiErr
 	} else {
-		return FfiConverterBytesINSTANCE.Lift(_uniffiRV), _uniffiErr
+		return FfiConverterBytesINSTANCE.Lift(_uniffiRV), nil
 	}
 }
 func (object *GoSignerImpl) Destroy() {
···
 		)
 
 	if err != nil {
-		// The only way to bypass an unexpected error is to bypass pointer to an empty
-		// instance of the error
-		if err.err == nil {
+		var actualError *SpError
+		if errors.As(err, &actualError) {
+			*callStatus = C.RustCallStatus{
+				code:     C.int8_t(uniffiCallbackResultError),
+				errorBuf: FfiConverterSpErrorINSTANCE.Lower(actualError),
+			}
+		} else {
 			*callStatus = C.RustCallStatus{
 				code: C.int8_t(uniffiCallbackUnexpectedResultError),
 			}
-			return
-		}
-
-		*callStatus = C.RustCallStatus{
-			code:     C.int8_t(uniffiCallbackResultError),
-			errorBuf: FfiConverterSpErrorINSTANCE.Lower(err),
 		}
 		return
 	}
···
 	C.uniffi_iroh_streamplace_fn_init_callback_vtable_gosigner(&UniffiVTableCallbackInterfaceGoSignerINSTANCE)
 }
 
+// Iroh-streamplace node that can send, forward or receive stream segments.
+type NodeInterface interface {
+	// Get a handle to the db to watch for changes locally or globally.
+	Db() *Db
+	// Join peers by their node tickets.
+	JoinPeers(peers []string) error
+	// Get this node's node ID.
+	NodeId() (*PublicKey, error)
+	// Get a handle to the write scope for this node.
+	//
+	// This is equivalent to calling `db.write(...)` with the secret key used to create the node.
+	NodeScope() *WriteScope
+	// Send a segment to all subscribers of the given stream.
+	SendSegment(key string, data []byte) error
+	// Subscribe to updates for a given stream from a remote node.
+	Subscribe(key string, remoteId *PublicKey) error
+	// Get this node's ticket.
+	Ticket() (string, error)
+	// Unsubscribe from updates for a given stream from a remote node.
+	Unsubscribe(key string, remoteId *PublicKey) error
+}
+
+// Iroh-streamplace node that can send, forward or receive stream segments.
+type Node struct {
+	ffiObject FfiObject
+}
+
+func NodeForwarder(config Config) (*Node, error) {
+	res, err := uniffiRustCallAsync[CreateError](
+		FfiConverterCreateErrorINSTANCE,
+		// completeFn
+		func(handle C.uint64_t, status *C.RustCallStatus) unsafe.Pointer {
+			res := C.ffi_iroh_streamplace_rust_future_complete_pointer(handle, status)
+			return res
+		},
+		// liftFn
+		func(ffi unsafe.Pointer) *Node {
+			return FfiConverterNodeINSTANCE.Lift(ffi)
+		},
+		C.uniffi_iroh_streamplace_fn_constructor_node_forwarder(FfiConverterConfigINSTANCE.Lower(config)),
+		// pollFn
+		func(handle C.uint64_t, continuation C.UniffiRustFutureContinuationCallback, data C.uint64_t) {
+			C.ffi_iroh_streamplace_rust_future_poll_pointer(handle, continuation, data)
+		},
+		// freeFn
+		func(handle C.uint64_t) {
+			C.ffi_iroh_streamplace_rust_future_free_pointer(handle)
+		},
+	)
+
+	return res, err
+}
+
+func NodeReceiver(config Config, handler DataHandler) (*Node, error) {
+	res, err := uniffiRustCallAsync[CreateError](
+		FfiConverterCreateErrorINSTANCE,
+		// completeFn
+		func(handle C.uint64_t, status *C.RustCallStatus) unsafe.Pointer {
+			res := C.ffi_iroh_streamplace_rust_future_complete_pointer(handle, status)
+			return res
+		},
+		// liftFn
+		func(ffi unsafe.Pointer) *Node {
+			return FfiConverterNodeINSTANCE.Lift(ffi)
+		},
+		C.uniffi_iroh_streamplace_fn_constructor_node_receiver(FfiConverterConfigINSTANCE.Lower(config), FfiConverterDataHandlerINSTANCE.Lower(handler)),
+		// pollFn
+		func(handle C.uint64_t, continuation C.UniffiRustFutureContinuationCallback, data C.uint64_t) {
+			C.ffi_iroh_streamplace_rust_future_poll_pointer(handle, continuation, data)
+		},
+		// freeFn
+		func(handle C.uint64_t) {
+			C.ffi_iroh_streamplace_rust_future_free_pointer(handle)
+		},
+	)
+
+	return res, err
+}
+
+// Create a new streamplace client node.
+func NodeSender(config Config) (*Node, error) {
+	res, err := uniffiRustCallAsync[CreateError](
+		FfiConverterCreateErrorINSTANCE,
+		// completeFn
+		func(handle C.uint64_t, status *C.RustCallStatus) unsafe.Pointer {
+			res := C.ffi_iroh_streamplace_rust_future_complete_pointer(handle, status)
+			return res
+		},
+		// liftFn
+		func(ffi unsafe.Pointer) *Node {
+			return FfiConverterNodeINSTANCE.Lift(ffi)
+		},
+		C.uniffi_iroh_streamplace_fn_constructor_node_sender(FfiConverterConfigINSTANCE.Lower(config)),
+		// pollFn
+		func(handle C.uint64_t, continuation C.UniffiRustFutureContinuationCallback, data C.uint64_t) {
+			C.ffi_iroh_streamplace_rust_future_poll_pointer(handle, continuation, data)
+		},
+		// freeFn
+		func(handle C.uint64_t) {
+			C.ffi_iroh_streamplace_rust_future_free_pointer(handle)
+		},
+	)
+
+	return res, err
+}
+
+// Get a handle to the db to watch for changes locally or globally.
+func (_self *Node) Db() *Db {
+	_pointer := _self.ffiObject.incrementPointer("*Node")
+	defer _self.ffiObject.decrementPointer()
+	return FfiConverterDbINSTANCE.Lift(rustCall(func(_uniffiStatus *C.RustCallStatus) unsafe.Pointer {
+		return C.uniffi_iroh_streamplace_fn_method_node_db(
+			_pointer, _uniffiStatus)
+	}))
+}
+
+// Join peers by their node tickets.
+func (_self *Node) JoinPeers(peers []string) error {
+	_pointer := _self.ffiObject.incrementPointer("*Node")
+	defer _self.ffiObject.decrementPointer()
+	_, err := uniffiRustCallAsync[JoinPeersError](
+		FfiConverterJoinPeersErrorINSTANCE,
+		// completeFn
+		func(handle C.uint64_t, status *C.RustCallStatus) struct{} {
+			C.ffi_iroh_streamplace_rust_future_complete_void(handle, status)
+			return struct{}{}
+		},
+		// liftFn
+		func(_ struct{}) struct{} { return struct{}{} },
+		C.uniffi_iroh_streamplace_fn_method_node_join_peers(
+			_pointer, FfiConverterSequenceStringINSTANCE.Lower(peers)),
+		// pollFn
+		func(handle C.uint64_t, continuation C.UniffiRustFutureContinuationCallback, data C.uint64_t) {
+			C.ffi_iroh_streamplace_rust_future_poll_void(handle, continuation, data)
+		},
+		// freeFn
+		func(handle C.uint64_t) {
+			C.ffi_iroh_streamplace_rust_future_free_void(handle)
+		},
+	)
+
+	return err
+}
+
+// Get this node's node ID.
+func (_self *Node) NodeId() (*PublicKey, error) {
+	_pointer := _self.ffiObject.incrementPointer("*Node")
+	defer _self.ffiObject.decrementPointer()
+	res, err := uniffiRustCallAsync[PutError](
+		FfiConverterPutErrorINSTANCE,
+		// completeFn
+		func(handle C.uint64_t, status *C.RustCallStatus) unsafe.Pointer {
+			res := C.ffi_iroh_streamplace_rust_future_complete_pointer(handle, status)
+			return res
+		},
+		// liftFn
+		func(ffi unsafe.Pointer) *PublicKey {
+			return FfiConverterPublicKeyINSTANCE.Lift(ffi)
+		},
+		C.uniffi_iroh_streamplace_fn_method_node_node_id(
+			_pointer),
+		// pollFn
+		func(handle C.uint64_t, continuation C.UniffiRustFutureContinuationCallback, data C.uint64_t) {
+			C.ffi_iroh_streamplace_rust_future_poll_pointer(handle, continuation, data)
+		},
+		// freeFn
+		func(handle C.uint64_t) {
+			C.ffi_iroh_streamplace_rust_future_free_pointer(handle)
+		},
+	)
+
+	return res, err
+}
+
+// Get a handle to the write scope for this node.
+//
+// This is equivalent to calling `db.write(...)` with the secret key used to create the node.
+func (_self *Node) NodeScope() *WriteScope {
+	_pointer := _self.ffiObject.incrementPointer("*Node")
+	defer _self.ffiObject.decrementPointer()
+	return FfiConverterWriteScopeINSTANCE.Lift(rustCall(func(_uniffiStatus *C.RustCallStatus) unsafe.Pointer {
+		return C.uniffi_iroh_streamplace_fn_method_node_node_scope(
+			_pointer, _uniffiStatus)
+	}))
+}
+
+// Send a segment to all subscribers of the given stream.
+func (_self *Node) SendSegment(key string, data []byte) error {
+	_pointer := _self.ffiObject.incrementPointer("*Node")
+	defer _self.ffiObject.decrementPointer()
+	_, err := uniffiRustCallAsync[PutError](
+		FfiConverterPutErrorINSTANCE,
+		// completeFn
+		func(handle C.uint64_t, status *C.RustCallStatus) struct{} {
+			C.ffi_iroh_streamplace_rust_future_complete_void(handle, status)
+			return struct{}{}
+		},
+		// liftFn
+		func(_ struct{}) struct{} { return struct{}{} },
+		C.uniffi_iroh_streamplace_fn_method_node_send_segment(
+			_pointer, FfiConverterStringINSTANCE.Lower(key), FfiConverterBytesINSTANCE.Lower(data)),
+		// pollFn
+		func(handle C.uint64_t, continuation C.UniffiRustFutureContinuationCallback, data C.uint64_t) {
+			C.ffi_iroh_streamplace_rust_future_poll_void(handle, continuation, data)
+		},
+		// freeFn
+		func(handle C.uint64_t) {
+			C.ffi_iroh_streamplace_rust_future_free_void(handle)
+		},
+	)
+
+	return err
+}
+
+// Subscribe to updates for a given stream from a remote node.
+func (_self *Node) Subscribe(key string, remoteId *PublicKey) error {
+	_pointer := _self.ffiObject.incrementPointer("*Node")
+	defer _self.ffiObject.decrementPointer()
+	_, err := uniffiRustCallAsync[PutError](
+		FfiConverterPutErrorINSTANCE,
+		// completeFn
+		func(handle C.uint64_t, status *C.RustCallStatus) struct{} {
+			C.ffi_iroh_streamplace_rust_future_complete_void(handle, status)
+			return struct{}{}
+		},
+		// liftFn
+		func(_ struct{}) struct{} { return struct{}{} },
+		C.uniffi_iroh_streamplace_fn_method_node_subscribe(
+			_pointer, FfiConverterStringINSTANCE.Lower(key), FfiConverterPublicKeyINSTANCE.Lower(remoteId)),
+		// pollFn
+		func(handle C.uint64_t, continuation C.UniffiRustFutureContinuationCallback, data C.uint64_t) {
+			C.ffi_iroh_streamplace_rust_future_poll_void(handle, continuation, data)
+		},
+		// freeFn
+		func(handle C.uint64_t) {
+			C.ffi_iroh_streamplace_rust_future_free_void(handle)
+		},
+	)
+
+	return err
+}
+
+// Get this node's ticket.
+func (_self *Node) Ticket() (string, error) {
+	_pointer := _self.ffiObject.incrementPointer("*Node")
+	defer _self.ffiObject.decrementPointer()
+	res, err := uniffiRustCallAsync[PutError](
+		FfiConverterPutErrorINSTANCE,
+		// completeFn
+		func(handle C.uint64_t, status *C.RustCallStatus) RustBufferI {
+			res := C.ffi_iroh_streamplace_rust_future_complete_rust_buffer(handle, status)
+			return GoRustBuffer{
+				inner: res,
+			}
+		},
+		// liftFn
+		func(ffi RustBufferI) string {
+			return FfiConverterStringINSTANCE.Lift(ffi)
+		},
+		C.uniffi_iroh_streamplace_fn_method_node_ticket(
+			_pointer),
+		// pollFn
+		func(handle C.uint64_t, continuation C.UniffiRustFutureContinuationCallback, data C.uint64_t) {
+			C.ffi_iroh_streamplace_rust_future_poll_rust_buffer(handle, continuation, data)
+		},
+		// freeFn
+		func(handle C.uint64_t) {
+			C.ffi_iroh_streamplace_rust_future_free_rust_buffer(handle)
+		},
+	)
+
+	return res, err
+}
+
+// Unsubscribe from updates for a given stream from a remote node.
+func (_self *Node) Unsubscribe(key string, remoteId *PublicKey) error {
+	_pointer := _self.ffiObject.incrementPointer("*Node")
+	defer _self.ffiObject.decrementPointer()
+	_, err := uniffiRustCallAsync[PutError](
+		FfiConverterPutErrorINSTANCE,
+		// completeFn
+		func(handle C.uint64_t, status *C.RustCallStatus) struct{} {
+			C.ffi_iroh_streamplace_rust_future_complete_void(handle, status)
+			return struct{}{}
+		},
+		// liftFn
+		func(_ struct{}) struct{} { return struct{}{} },
+		C.uniffi_iroh_streamplace_fn_method_node_unsubscribe(
+			_pointer, FfiConverterStringINSTANCE.Lower(key), FfiConverterPublicKeyINSTANCE.Lower(remoteId)),
+		// pollFn
+		func(handle C.uint64_t, continuation C.UniffiRustFutureContinuationCallback, data C.uint64_t) {
+			C.ffi_iroh_streamplace_rust_future_poll_void(handle, continuation, data)
+		},
+		// freeFn
+		func(handle C.uint64_t) {
+			C.ffi_iroh_streamplace_rust_future_free_void(handle)
+		},
+	)
+
+	return err
+}
+func (object *Node) Destroy() {
+	runtime.SetFinalizer(object, nil)
+	object.ffiObject.destroy()
+}
+
+type FfiConverterNode struct{}
+
+var FfiConverterNodeINSTANCE = FfiConverterNode{}
+
+func (c FfiConverterNode) Lift(pointer unsafe.Pointer) *Node {
+	result := &Node{
+		newFfiObject(
+			pointer,
+			func(pointer unsafe.Pointer, status *C.RustCallStatus) unsafe.Pointer {
+				return C.uniffi_iroh_streamplace_fn_clone_node(pointer, status)
+			},
+			func(pointer unsafe.Pointer, status *C.RustCallStatus) {
+				C.uniffi_iroh_streamplace_fn_free_node(pointer, status)
+			},
+		),
+	}
+	runtime.SetFinalizer(result, (*Node).Destroy)
+	return result
+}
+
+func (c FfiConverterNode) Read(reader io.Reader) *Node {
+	return c.Lift(unsafe.Pointer(uintptr(readUint64(reader))))
+}
+
+func (c FfiConverterNode) Lower(value *Node) unsafe.Pointer {
+	// TODO: this is bad - all synchronization from ObjectRuntime.go is discarded here,
+	// because the pointer will be decremented immediately after this function returns,
+	// and someone will be left holding onto a non-locked pointer.
+	pointer := value.ffiObject.incrementPointer("*Node")
+	defer value.ffiObject.decrementPointer()
+	return pointer
+
+}
+
+func (c FfiConverterNode) Write(writer io.Writer, value *Node) {
+	writeUint64(writer, uint64(uintptr(c.Lower(value))))
+}
+
+type FfiDestroyerNode struct{}
+
+func (_ FfiDestroyerNode) Destroy(value *Node) {
+	value.Destroy()
+}
+
 // A peer and it's addressing information.
 type NodeAddrInterface interface {
 	// Get the direct addresses of this peer.
 	DirectAddresses() []string
 	// Returns true if both NodeAddr's have the same values
 	Equal(other *NodeAddr) bool
-	NodeId() *PublicKey
+	NodeId() *PublicKeyOld
 	// Get the home relay URL for this peer
 	RelayUrl() *string
 }
···
 }
 
 // Create a new [`NodeAddr`] with empty [`AddrInfo`].
-func NewNodeAddr(nodeId *PublicKey, derpUrl *string, addresses []string) *NodeAddr {
+func NewNodeAddr(nodeId *PublicKeyOld, derpUrl *string, addresses []string) *NodeAddr {
 	return FfiConverterNodeAddrINSTANCE.Lift(rustCall(func(_uniffiStatus *C.RustCallStatus) unsafe.Pointer {
-		return C.uniffi_iroh_streamplace_fn_constructor_nodeaddr_new(FfiConverterPublicKeyINSTANCE.Lower(nodeId), FfiConverterOptionalStringINSTANCE.Lower(derpUrl), FfiConverterSequenceStringINSTANCE.Lower(addresses), _uniffiStatus)
+		return C.uniffi_iroh_streamplace_fn_constructor_nodeaddr_new(FfiConverterPublicKeyOldINSTANCE.Lower(nodeId), FfiConverterOptionalStringINSTANCE.Lower(derpUrl), FfiConverterSequenceStringINSTANCE.Lower(addresses), _uniffiStatus)
 	}))
 }
 
···
 	}))
 }
 
-func (_self *NodeAddr) NodeId() *PublicKey {
+func (_self *NodeAddr) NodeId() *PublicKeyOld {
 	_pointer := _self.ffiObject.incrementPointer("*NodeAddr")
 	defer _self.ffiObject.decrementPointer()
-	return FfiConverterPublicKeyINSTANCE.Lift(rustCall(func(_uniffiStatus *C.RustCallStatus) unsafe.Pointer {
+	return FfiConverterPublicKeyOldINSTANCE.Lift(rustCall(func(_uniffiStatus *C.RustCallStatus) unsafe.Pointer {
 		return C.uniffi_iroh_streamplace_fn_method_nodeaddr_node_id(
 			_pointer, _uniffiStatus)
 	}))
···
 // The key itself is just a 32 byte array, but a key has associated crypto
 // information that is cached for performance reasons.
 type PublicKeyInterface interface {
+	// Express the PublicKey as a byte array
+	AsVec() []byte
 	// Returns true if the PublicKeys are equal
 	Equal(other *PublicKey) bool
 	// Convert to a base32 string limited to the first 10 bytes for a friendly string
 	// representation of the key.
 	FmtShort() string
-	// Express the PublicKey as a byte array
-	ToBytes() []byte
 }
 
 // A public key.
···
 }
 
 // Make a PublicKey from byte array
-func PublicKeyFromBytes(bytes []byte) (*PublicKey, *Error) {
-	_uniffiRV, _uniffiErr := rustCallWithError[Error](FfiConverterError{}, func(_uniffiStatus *C.RustCallStatus) unsafe.Pointer {
+func PublicKeyFromBytes(bytes []byte) (*PublicKey, error) {
+	_uniffiRV, _uniffiErr := rustCallWithError[PublicKeyError](FfiConverterPublicKeyError{}, func(_uniffiStatus *C.RustCallStatus) unsafe.Pointer {
 		return C.uniffi_iroh_streamplace_fn_constructor_publickey_from_bytes(FfiConverterBytesINSTANCE.Lower(bytes), _uniffiStatus)
 	})
 	if _uniffiErr != nil {
 		var _uniffiDefaultValue *PublicKey
 		return _uniffiDefaultValue, _uniffiErr
 	} else {
-		return FfiConverterPublicKeyINSTANCE.Lift(_uniffiRV), _uniffiErr
+		return FfiConverterPublicKeyINSTANCE.Lift(_uniffiRV), nil
 	}
 }
 
 // Make a PublicKey from base32 string
-func PublicKeyFromString(s string) (*PublicKey, *Error) {
-	_uniffiRV, _uniffiErr := rustCallWithError[Error](FfiConverterError{}, func(_uniffiStatus *C.RustCallStatus) unsafe.Pointer {
+func PublicKeyFromString(s string) (*PublicKey, error) {
+	_uniffiRV, _uniffiErr := rustCallWithError[PublicKeyError](FfiConverterPublicKeyError{}, func(_uniffiStatus *C.RustCallStatus) unsafe.Pointer {
 		return C.uniffi_iroh_streamplace_fn_constructor_publickey_from_string(FfiConverterStringINSTANCE.Lower(s), _uniffiStatus)
 	})
 	if _uniffiErr != nil {
 		var _uniffiDefaultValue *PublicKey
 		return _uniffiDefaultValue, _uniffiErr
 	} else {
-		return FfiConverterPublicKeyINSTANCE.Lift(_uniffiRV), _uniffiErr
+		return FfiConverterPublicKeyINSTANCE.Lift(_uniffiRV), nil
 	}
 }
 
+// Express the PublicKey as a byte array
+func (_self *PublicKey) AsVec() []byte {
+	_pointer := _self.ffiObject.incrementPointer("*PublicKey")
+	defer _self.ffiObject.decrementPointer()
+	return FfiConverterBytesINSTANCE.Lift(rustCall(func(_uniffiStatus *C.RustCallStatus) RustBufferI {
+		return GoRustBuffer{
+			inner: C.uniffi_iroh_streamplace_fn_method_publickey_as_vec(
+				_pointer, _uniffiStatus),
+		}
+	}))
+}
+
 // Returns true if the PublicKeys are equal
 func (_self *PublicKey) Equal(other *PublicKey) bool {
 	_pointer := _self.ffiObject.incrementPointer("*PublicKey")
···
 	return FfiConverterStringINSTANCE.Lift(rustCall(func(_uniffiStatus *C.RustCallStatus) RustBufferI {
 		return GoRustBuffer{
 			inner: C.uniffi_iroh_streamplace_fn_method_publickey_fmt_short(
-				_pointer, _uniffiStatus),
-		}
-	}))
-}
-
-// Express the PublicKey as a byte array
-func (_self *PublicKey) ToBytes() []byte {
-	_pointer := _self.ffiObject.incrementPointer("*PublicKey")
-	defer _self.ffiObject.decrementPointer()
-	return FfiConverterBytesINSTANCE.Lift(rustCall(func(_uniffiStatus *C.RustCallStatus) RustBufferI {
-		return GoRustBuffer{
-			inner: C.uniffi_iroh_streamplace_fn_method_publickey_to_bytes(
 				_pointer, _uniffiStatus),
 		}
 	}))
···
 	value.Destroy()
 }
 
+// A public key.
+//
+// The key itself is just a 32 byte array, but a key has associated crypto
+// information that is cached for performance reasons.
+type PublicKeyOldInterface interface {
+	// Returns true if the PublicKeys are equal
+	Equal(other *PublicKeyOld) bool
+	// Convert to a base32 string limited to the first 10 bytes for a friendly string
+	// representation of the key.
+	FmtShort() string
+	// Express the PublicKey as a byte array
+	ToBytes() []byte
+}
+
+// A public key.
+//
+// The key itself is just a 32 byte array, but a key has associated crypto
+// information that is cached for performance reasons.
+type PublicKeyOld struct {
+	ffiObject FfiObject
+}
+
+// Make a PublicKey from byte array
+func PublicKeyOldFromBytes(bytes []byte) (*PublicKeyOld, error) {
+	_uniffiRV, _uniffiErr := rustCallWithError[Error](FfiConverterError{}, func(_uniffiStatus *C.RustCallStatus) unsafe.Pointer {
+		return C.uniffi_iroh_streamplace_fn_constructor_publickeyold_from_bytes(FfiConverterBytesINSTANCE.Lower(bytes), _uniffiStatus)
+	})
+	if _uniffiErr != nil {
+		var _uniffiDefaultValue *PublicKeyOld
+		return _uniffiDefaultValue, _uniffiErr
+	} else {
+		return FfiConverterPublicKeyOldINSTANCE.Lift(_uniffiRV), nil
+	}
+}
+
+// Make a PublicKey from base32 string
+func PublicKeyOldFromString(s string) (*PublicKeyOld, error) {
+	_uniffiRV, _uniffiErr := rustCallWithError[Error](FfiConverterError{}, func(_uniffiStatus *C.RustCallStatus) unsafe.Pointer {
+		return C.uniffi_iroh_streamplace_fn_constructor_publickeyold_from_string(FfiConverterStringINSTANCE.Lower(s), _uniffiStatus)
+	})
+	if _uniffiErr != nil {
+		var _uniffiDefaultValue *PublicKeyOld
+		return _uniffiDefaultValue, _uniffiErr
+	} else {
+		return FfiConverterPublicKeyOldINSTANCE.Lift(_uniffiRV), nil
+	}
+}
+
+// Returns true if the PublicKeys are equal
+func (_self *PublicKeyOld) Equal(other *PublicKeyOld) bool {
+	_pointer := _self.ffiObject.incrementPointer("*PublicKeyOld")
+	defer _self.ffiObject.decrementPointer()
+	return FfiConverterBoolINSTANCE.Lift(rustCall(func(_uniffiStatus *C.RustCallStatus) C.int8_t {
+		return C.uniffi_iroh_streamplace_fn_method_publickeyold_equal(
+			_pointer, FfiConverterPublicKeyOldINSTANCE.Lower(other), _uniffiStatus)
+	}))
+}
+
+// Convert to a base32 string limited to the first 10 bytes for a friendly string
+// representation of the key.
+func (_self *PublicKeyOld) FmtShort() string {
+	_pointer := _self.ffiObject.incrementPointer("*PublicKeyOld")
+	defer _self.ffiObject.decrementPointer()
+	return FfiConverterStringINSTANCE.Lift(rustCall(func(_uniffiStatus *C.RustCallStatus) RustBufferI {
+		return GoRustBuffer{
+			inner: C.uniffi_iroh_streamplace_fn_method_publickeyold_fmt_short(
+				_pointer, _uniffiStatus),
+		}
+	}))
+}
+
+// Express the PublicKey as a byte array
+func (_self *PublicKeyOld) ToBytes() []byte {
+	_pointer := _self.ffiObject.incrementPointer("*PublicKeyOld")
+	defer _self.ffiObject.decrementPointer()
+	return FfiConverterBytesINSTANCE.Lift(rustCall(func(_uniffiStatus *C.RustCallStatus) RustBufferI {
+		return GoRustBuffer{
+			inner: C.uniffi_iroh_streamplace_fn_method_publickeyold_to_bytes(
+				_pointer, _uniffiStatus),
+		}
+	}))
+}
+
+func (_self *PublicKeyOld) String() string {
+	_pointer := _self.ffiObject.incrementPointer("*PublicKeyOld")
+	defer _self.ffiObject.decrementPointer()
+	return FfiConverterStringINSTANCE.Lift(rustCall(func(_uniffiStatus *C.RustCallStatus) RustBufferI {
+		return GoRustBuffer{
+			inner: C.uniffi_iroh_streamplace_fn_method_publickeyold_uniffi_trait_display(
+				_pointer, _uniffiStatus),
+		}
+	}))
+}
+
+func (object *PublicKeyOld) Destroy() {
+	runtime.SetFinalizer(object, nil)
+	object.ffiObject.destroy()
+}
+
+type FfiConverterPublicKeyOld struct{}
+
+var FfiConverterPublicKeyOldINSTANCE = FfiConverterPublicKeyOld{}
+
+func (c FfiConverterPublicKeyOld) Lift(pointer unsafe.Pointer) *PublicKeyOld {
+	result := &PublicKeyOld{
+		newFfiObject(
+			pointer,
+			func(pointer unsafe.Pointer, status *C.RustCallStatus) unsafe.Pointer {
+				return C.uniffi_iroh_streamplace_fn_clone_publickeyold(pointer, status)
+			},
+			func(pointer unsafe.Pointer, status *C.RustCallStatus) {
+				C.uniffi_iroh_streamplace_fn_free_publickeyold(pointer, status)
+			},
+		),
+	}
+	runtime.SetFinalizer(result, (*PublicKeyOld).Destroy)
+	return result
+}
+
+func (c FfiConverterPublicKeyOld) Read(reader io.Reader) *PublicKeyOld {
+	return c.Lift(unsafe.Pointer(uintptr(readUint64(reader))))
+}
+
+func (c FfiConverterPublicKeyOld) Lower(value *PublicKeyOld) unsafe.Pointer {
+	// TODO: this is bad - all synchronization from ObjectRuntime.go is discarded here,
+	// because the pointer will be decremented immediately after this function returns,
+	// and someone will be left holding onto a non-locked pointer.
+	pointer := value.ffiObject.incrementPointer("*PublicKeyOld")
+	defer value.ffiObject.decrementPointer()
+	return pointer
+
+}
+
+func (c FfiConverterPublicKeyOld) Write(writer io.Writer, value *PublicKeyOld) {
+	writeUint64(writer, uint64(uintptr(c.Lower(value))))
+}
+
+type FfiDestroyerPublicKeyOld struct{}
+
+func (_ FfiDestroyerPublicKeyOld) Destroy(value *PublicKeyOld) {
+	value.Destroy()
+}
+
 type ReceiverInterface interface {
 	NodeAddr() *NodeAddr
 	// Subscribe to the given topic on the remote.
-	Subscribe(remoteId *PublicKey, topic string) *Error
+	Subscribe(remoteId *PublicKeyOld, topic string) error
 	// Unsubscribe from this topic on the remote.
-	Unsubscribe(remoteId *PublicKey, topic string) *Error
+	Unsubscribe(remoteId *PublicKeyOld, topic string) error
 }
 type Receiver struct {
 	ffiObject FfiObject
 }
 
 // Create a new receiver.
-func NewReceiver(endpoint *Endpoint, handler DataHandler) (*Receiver, *Error) {
+func NewReceiver(endpoint *Endpoint, handler DataHandlerOld) (*Receiver, error) {
 	res, err := uniffiRustCallAsync[Error](
 		FfiConverterErrorINSTANCE,
 		// completeFn
···
 		func(ffi unsafe.Pointer) *Receiver {
 			return FfiConverterReceiverINSTANCE.Lift(ffi)
 		},
-		C.uniffi_iroh_streamplace_fn_constructor_receiver_new(FfiConverterEndpointINSTANCE.Lower(endpoint), FfiConverterDataHandlerINSTANCE.Lower(handler)),
+		C.uniffi_iroh_streamplace_fn_constructor_receiver_new(FfiConverterEndpointINSTANCE.Lower(endpoint), FfiConverterDataHandlerOldINSTANCE.Lower(handler)),
 		// pollFn
 		func(handle C.uint64_t, continuation C.UniffiRustFutureContinuationCallback, data C.uint64_t) {
 			C.ffi_iroh_streamplace_rust_future_poll_pointer(handle, continuation, data)
···
 func (_self *Receiver) NodeAddr() *NodeAddr {
 	_pointer := _self.ffiObject.incrementPointer("*Receiver")
 	defer _self.ffiObject.decrementPointer()
-	res, _ := uniffiRustCallAsync[struct{}](
+	res, _ := uniffiRustCallAsync[error](
 		nil,
 		// completeFn
 		func(handle C.uint64_t, status *C.RustCallStatus) unsafe.Pointer {
···
 }
 
 // Subscribe to the given topic on the remote.
-func (_self *Receiver) Subscribe(remoteId *PublicKey, topic string) *Error {
+func (_self *Receiver) Subscribe(remoteId *PublicKeyOld, topic string) error {
 	_pointer := _self.ffiObject.incrementPointer("*Receiver")
 	defer _self.ffiObject.decrementPointer()
 	_, err := uniffiRustCallAsync[Error](
···
 		// liftFn
 		func(_ struct{}) struct{} { return struct{}{} },
 		C.uniffi_iroh_streamplace_fn_method_receiver_subscribe(
-			_pointer, FfiConverterPublicKeyINSTANCE.Lower(remoteId), FfiConverterStringINSTANCE.Lower(topic)),
+			_pointer, FfiConverterPublicKeyOldINSTANCE.Lower(remoteId), FfiConverterStringINSTANCE.Lower(topic)),
 		// pollFn
 		func(handle C.uint64_t, continuation C.UniffiRustFutureContinuationCallback, data C.uint64_t) {
 			C.ffi_iroh_streamplace_rust_future_poll_void(handle, continuation, data)
···
 }
 
 // Unsubscribe from this topic on the remote.
-func (_self *Receiver) Unsubscribe(remoteId *PublicKey, topic string) *Error {
+func (_self *Receiver) Unsubscribe(remoteId *PublicKeyOld, topic string) error {
 	_pointer := _self.ffiObject.incrementPointer("*Receiver")
 	defer _self.ffiObject.decrementPointer()
 	_, err := uniffiRustCallAsync[Error](
···
 		// liftFn
 		func(_ struct{}) struct{} { return struct{}{} },
 		C.uniffi_iroh_streamplace_fn_method_receiver_unsubscribe(
-			_pointer, FfiConverterPublicKeyINSTANCE.Lower(remoteId), FfiConverterStringINSTANCE.Lower(topic)),
+			_pointer, FfiConverterPublicKeyOldINSTANCE.Lower(remoteId), FfiConverterStringINSTANCE.Lower(topic)),
 		// pollFn
 		func(handle C.uint64_t, continuation C.UniffiRustFutureContinuationCallback, data C.uint64_t) {
 			C.ffi_iroh_streamplace_rust_future_poll_void(handle, continuation, data)
···
 type SenderInterface interface {
 	NodeAddr() *NodeAddr
 	// Sends the given data to all subscribers that have subscribed to this `key`.
-	Send(key string, data []byte) *Error
+	Send(key string, data []byte) error
 }
 type Sender struct {
 	ffiObject FfiObject
 }
 
 // Create a new sender.
-func NewSender(endpoint *Endpoint) (*Sender, *Error) {
+func NewSender(endpoint *Endpoint) (*Sender, error) {
 	res, err := uniffiRustCallAsync[Error](
 		FfiConverterErrorINSTANCE,
 		// completeFn
···
 func (_self *Sender) NodeAddr() *NodeAddr {
 	_pointer := _self.ffiObject.incrementPointer("*Sender")
 	defer _self.ffiObject.decrementPointer()
-	res, _ := uniffiRustCallAsync[struct{}](
+	res, _ := uniffiRustCallAsync[error](
 		nil,
 		// completeFn
 		func(handle C.uint64_t, status *C.RustCallStatus) unsafe.Pointer {
···
 }
 
 // Sends the given data to all subscribers that have subscribed to this `key`.
-func (_self *Sender) Send(key string, data []byte) *Error {
+func (_self *Sender) Send(key string, data []byte) error {
 	_pointer := _self.ffiObject.incrementPointer("*Sender")
 	defer _self.ffiObject.decrementPointer()
 	_, err := uniffiRustCallAsync[Error](
···
 	value.Destroy()
 }
 
+// A response to a subscribe request.
+//
+// This can be used as a stream of [`SubscribeItem`]s.
+type SubscribeResponseInterface interface {
+	NextRaw() (*SubscribeItem, error)
+}
+
+// A response to a subscribe request.
+//
+// This can be used as a stream of [`SubscribeItem`]s.
+type SubscribeResponse struct {
+	ffiObject FfiObject
+}
+
+func (_self *SubscribeResponse) NextRaw() (*SubscribeItem, error) {
+	_pointer := _self.ffiObject.incrementPointer("*SubscribeResponse")
+	defer _self.ffiObject.decrementPointer()
+	res, err := uniffiRustCallAsync[SubscribeNextError](
+		FfiConverterSubscribeNextErrorINSTANCE,
+		// completeFn
+		func(handle C.uint64_t, status *C.RustCallStatus) RustBufferI {
+			res := C.ffi_iroh_streamplace_rust_future_complete_rust_buffer(handle, status)
+			return GoRustBuffer{
+				inner: res,
+			}
+		},
+		// liftFn
+		func(ffi RustBufferI) *SubscribeItem {
+			return FfiConverterOptionalSubscribeItemINSTANCE.Lift(ffi)
+		},
+		C.uniffi_iroh_streamplace_fn_method_subscriberesponse_next_raw(
+			_pointer),
+		// pollFn
+		func(handle C.uint64_t, continuation C.UniffiRustFutureContinuationCallback, data C.uint64_t) {
+			C.ffi_iroh_streamplace_rust_future_poll_rust_buffer(handle, continuation, data)
+		},
+		// freeFn
+		func(handle C.uint64_t) {
+			C.ffi_iroh_streamplace_rust_future_free_rust_buffer(handle)
+		},
+	)
+
+	return res, err
+}
+
+func (_self *SubscribeResponse) DebugString() string {
+	_pointer := _self.ffiObject.incrementPointer("*SubscribeResponse")
+	defer _self.ffiObject.decrementPointer()
+	return FfiConverterStringINSTANCE.Lift(rustCall(func(_uniffiStatus *C.RustCallStatus) RustBufferI {
+		return GoRustBuffer{
+			inner: C.uniffi_iroh_streamplace_fn_method_subscriberesponse_uniffi_trait_debug(
+				_pointer, _uniffiStatus),
+		}
+	}))
+}
+
+func (object *SubscribeResponse) Destroy() {
+	runtime.SetFinalizer(object, nil)
+	object.ffiObject.destroy()
+}
+
+type FfiConverterSubscribeResponse struct{}
+
+var FfiConverterSubscribeResponseINSTANCE = FfiConverterSubscribeResponse{}
+
+func (c FfiConverterSubscribeResponse) Lift(pointer unsafe.Pointer) *SubscribeResponse {
+	result := &SubscribeResponse{
+		newFfiObject(
+			pointer,
+			func(pointer unsafe.Pointer, status *C.RustCallStatus) unsafe.Pointer {
+				return C.uniffi_iroh_streamplace_fn_clone_subscriberesponse(pointer, status)
+			},
+			func(pointer unsafe.Pointer, status *C.RustCallStatus) {
+				C.uniffi_iroh_streamplace_fn_free_subscriberesponse(pointer, status)
+			},
+		),
+	}
+	runtime.SetFinalizer(result, (*SubscribeResponse).Destroy)
+	return result
+}
+
+func (c FfiConverterSubscribeResponse) Read(reader io.Reader) *SubscribeResponse {
+	return c.Lift(unsafe.Pointer(uintptr(readUint64(reader))))
+}
+
+func (c FfiConverterSubscribeResponse) Lower(value *SubscribeResponse) unsafe.Pointer {
+	// TODO: this is bad - all synchronization from ObjectRuntime.go is discarded here,
+	// because the pointer will be decremented immediately after this function returns,
+	// and someone will be left holding onto a non-locked pointer.
+	pointer := value.ffiObject.incrementPointer("*SubscribeResponse")
+	defer value.ffiObject.decrementPointer()
+	return pointer
+
+}
+
+func (c FfiConverterSubscribeResponse) Write(writer io.Writer, value *SubscribeResponse) {
+	writeUint64(writer, uint64(uintptr(c.Lower(value))))
+}
+
+type FfiDestroyerSubscribeResponse struct{}
+
+func (_ FfiDestroyerSubscribeResponse) Destroy(value *SubscribeResponse) {
+	value.Destroy()
+}
+
+// A write scope that can be used to put values into the database.
+//
+// The default write scope is available from the [`Node::node_scope`] method.
+type WriteScopeInterface interface {
+	Put(stream *[]byte, key []byte, value []byte) error
+}
+
+// A write scope that can be used to put values into the database.
+//
+// The default write scope is available from the [`Node::node_scope`] method.
+type WriteScope struct {
+	ffiObject FfiObject
+}
+
+func (_self *WriteScope) Put(stream *[]byte, key []byte, value []byte) error {
+	_pointer := _self.ffiObject.incrementPointer("*WriteScope")
+	defer _self.ffiObject.decrementPointer()
+	_, err := uniffiRustCallAsync[PutError](
+		FfiConverterPutErrorINSTANCE,
+		// completeFn
+		func(handle C.uint64_t, status *C.RustCallStatus) struct{} {
+			C.ffi_iroh_streamplace_rust_future_complete_void(handle, status)
+			return struct{}{}
+		},
+		// liftFn
+		func(_ struct{}) struct{} { return struct{}{} },
+		C.uniffi_iroh_streamplace_fn_method_writescope_put(
+			_pointer, FfiConverterOptionalBytesINSTANCE.Lower(stream), FfiConverterBytesINSTANCE.Lower(key), FfiConverterBytesINSTANCE.Lower(value)),
+		// pollFn
+		func(handle C.uint64_t, continuation C.UniffiRustFutureContinuationCallback, data C.uint64_t) {
+			C.ffi_iroh_streamplace_rust_future_poll_void(handle, continuation, data)
+		},
+		// freeFn
+		func(handle C.uint64_t) {
+			C.ffi_iroh_streamplace_rust_future_free_void(handle)
+		},
+	)
+
+	return err
+}
+func (object *WriteScope) Destroy() {
+	runtime.SetFinalizer(object, nil)
+	object.ffiObject.destroy()
+}
+
+type FfiConverterWriteScope struct{}
+
+var FfiConverterWriteScopeINSTANCE = FfiConverterWriteScope{}
+
+func (c FfiConverterWriteScope) Lift(pointer unsafe.Pointer) *WriteScope {
+	result := &WriteScope{
+		newFfiObject(
+			pointer,
+			func(pointer unsafe.Pointer, status *C.RustCallStatus) unsafe.Pointer {
+				return C.uniffi_iroh_streamplace_fn_clone_writescope(pointer, status)
+			},
+			func(pointer unsafe.Pointer, status *C.RustCallStatus) {
+				C.uniffi_iroh_streamplace_fn_free_writescope(pointer, status)
+			},
+		),
+	}
+	runtime.SetFinalizer(result, (*WriteScope).Destroy)
+	return result
+}
+
+func (c FfiConverterWriteScope) Read(reader io.Reader) *WriteScope {
+	return c.Lift(unsafe.Pointer(uintptr(readUint64(reader))))
+}
+
+func (c FfiConverterWriteScope) Lower(value *WriteScope) unsafe.Pointer {
+	// TODO: this is bad - all synchronization from ObjectRuntime.go is discarded here,
+	// because the pointer will be decremented immediately after this function returns,
+	// and someone will be left holding onto a non-locked pointer.
+	pointer := value.ffiObject.incrementPointer("*WriteScope")
+	defer value.ffiObject.decrementPointer()
+	return pointer
+
+}
+
+func (c FfiConverterWriteScope) Write(writer io.Writer, value *WriteScope) {
+	writeUint64(writer, uint64(uintptr(c.Lower(value))))
+}
+
+type FfiDestroyerWriteScope struct{}
+
+func (_ FfiDestroyerWriteScope) Destroy(value *WriteScope) {
+	value.Destroy()
+}
+
+// Configuration for an iroh-streamplace node.
+type Config struct {
+	// An Ed25519 secret key as a 32 byte array.
+	Key []byte
+	// The gossip topic to use. Must be 32 bytes.
+	//
+	// You can use e.g. a BLAKE3 hash of a topic string here. This can be used
+	// as a cheap way to have a shared secret - nodes that do not know the topic
+	// cannot connect to the swarm.
+	Topic []byte
+	// Maximum duration to wait for sending a stream piece to a peer.
+	MaxSendDuration time.Duration
+	// Disable using relays, for tests.
+	DisableRelay bool
+}
+
+func (r *Config) Destroy() {
+	FfiDestroyerBytes{}.Destroy(r.Key)
+	FfiDestroyerBytes{}.Destroy(r.Topic)
+	FfiDestroyerDuration{}.Destroy(r.MaxSendDuration)
+	FfiDestroyerBool{}.Destroy(r.DisableRelay)
+}
+
+type FfiConverterConfig struct{}
+
+var FfiConverterConfigINSTANCE = FfiConverterConfig{}
+
+func (c FfiConverterConfig) Lift(rb RustBufferI) Config {
+	return LiftFromRustBuffer[Config](c, rb)
+}
+
+func (c FfiConverterConfig) Read(reader io.Reader) Config {
+	return Config{
+		FfiConverterBytesINSTANCE.Read(reader),
+		FfiConverterBytesINSTANCE.Read(reader),
+		FfiConverterDurationINSTANCE.Read(reader),
+		FfiConverterBoolINSTANCE.Read(reader),
+	}
+}
+
+func (c FfiConverterConfig) Lower(value Config) C.RustBuffer {
+	return LowerIntoRustBuffer[Config](c, value)
+}
+
+func (c FfiConverterConfig) Write(writer io.Writer, value Config) {
+	FfiConverterBytesINSTANCE.Write(writer, value.Key)
+	FfiConverterBytesINSTANCE.Write(writer, value.Topic)
+	FfiConverterDurationINSTANCE.Write(writer, value.MaxSendDuration)
+	FfiConverterBoolINSTANCE.Write(writer, value.DisableRelay)
+}
+
+type FfiDestroyerConfig struct{}
+
+func (_ FfiDestroyerConfig) Destroy(value Config) {
+	value.Destroy()
+}
+
+// An entry returned from the database.
+type Entry struct {
+	Scope     *PublicKey
+	Stream    *[]byte
+	Key       []byte
+	Value     []byte
+	Timestamp uint64
+}
+
+func (r *Entry) Destroy() {
+	FfiDestroyerPublicKey{}.Destroy(r.Scope)
+	FfiDestroyerOptionalBytes{}.Destroy(r.Stream)
+	FfiDestroyerBytes{}.Destroy(r.Key)
+	FfiDestroyerBytes{}.Destroy(r.Value)
+	FfiDestroyerUint64{}.Destroy(r.Timestamp)
+}
+
+type FfiConverterEntry struct{}
+
+var FfiConverterEntryINSTANCE = FfiConverterEntry{}
+
+func (c FfiConverterEntry) Lift(rb RustBufferI) Entry {
+	return LiftFromRustBuffer[Entry](c, rb)
+}
+
+func (c FfiConverterEntry) Read(reader io.Reader) Entry {
+	return Entry{
+		FfiConverterPublicKeyINSTANCE.Read(reader),
+		FfiConverterOptionalBytesINSTANCE.Read(reader),
+		FfiConverterBytesINSTANCE.Read(reader),
+		FfiConverterBytesINSTANCE.Read(reader),
+		FfiConverterUint64INSTANCE.Read(reader),
+	}
+}
+
+func (c FfiConverterEntry) Lower(value Entry) C.RustBuffer {
+	return LowerIntoRustBuffer[Entry](c, value)
+}
+
+func (c FfiConverterEntry) Write(writer io.Writer, value Entry) {
+	FfiConverterPublicKeyINSTANCE.Write(writer, value.Scope)
+	FfiConverterOptionalBytesINSTANCE.Write(writer, value.Stream)
+	FfiConverterBytesINSTANCE.Write(writer, value.Key)
+	FfiConverterBytesINSTANCE.Write(writer, value.Value)
+	FfiConverterUint64INSTANCE.Write(writer, value.Timestamp)
+}
+
+type FfiDestroyerEntry struct{}
+
+func (_ FfiDestroyerEntry) Destroy(value Entry) {
+	value.Destroy()
+}
+
+// Options for subscribing.
+//
+// `filter` specifies what to subscribe to.
+// `mode` specifies whether to get current items, new items, or both.
+type SubscribeOpts struct {
+	Filter *Filter
+	Mode   SubscribeMode
+}
+
+func (r *SubscribeOpts) Destroy() {
+	FfiDestroyerFilter{}.Destroy(r.Filter)
+	FfiDestroyerSubscribeMode{}.Destroy(r.Mode)
+}
+
+type FfiConverterSubscribeOpts struct{}
+
+var FfiConverterSubscribeOptsINSTANCE = FfiConverterSubscribeOpts{}
+
+func (c FfiConverterSubscribeOpts) Lift(rb RustBufferI) SubscribeOpts {
+	return LiftFromRustBuffer[SubscribeOpts](c, rb)
+}
+
+func (c FfiConverterSubscribeOpts) Read(reader io.Reader) SubscribeOpts {
+	return SubscribeOpts{
+		FfiConverterFilterINSTANCE.Read(reader),
+		FfiConverterSubscribeModeINSTANCE.Read(reader),
+	}
+}
+
+func (c FfiConverterSubscribeOpts) Lower(value SubscribeOpts) C.RustBuffer {
+	return LowerIntoRustBuffer[SubscribeOpts](c, value)
+}
+
+func (c FfiConverterSubscribeOpts) Write(writer io.Writer, value SubscribeOpts) {
+	FfiConverterFilterINSTANCE.Write(writer, value.Filter)
+	FfiConverterSubscribeModeINSTANCE.Write(writer, value.Mode)
+}
+
+type FfiDestroyerSubscribeOpts struct{}
+
+func (_ FfiDestroyerSubscribeOpts) Destroy(value SubscribeOpts) {
+	value.Destroy()
+}
+
+// Error creating a new database node.
+type CreateError struct {
+	err error
+}
+
+// Convience method to turn *CreateError into error
+// Avoiding treating nil pointer as non nil error interface
+func (err *CreateError) AsError() error {
+	if err == nil {
+		return nil
+	} else {
+		return err
+	}
+}
+
+func (err CreateError) Error() string {
+	return fmt.Sprintf("CreateError: %s", err.err.Error())
+}
+
+func (err CreateError) Unwrap() error {
+	return err.err
+}
+
+// Err* are used for checking error type with `errors.Is`
+var ErrCreateErrorPrivateKey = fmt.Errorf("CreateErrorPrivateKey")
+var ErrCreateErrorTopic = fmt.Errorf("CreateErrorTopic")
+var ErrCreateErrorBind = fmt.Errorf("CreateErrorBind")
+var ErrCreateErrorSubscribe = fmt.Errorf("CreateErrorSubscribe")
+
+// Variant structs
+// The provided private key is invalid (not 32 bytes).
+type CreateErrorPrivateKey struct {
+	Size uint64
+}
+
+// The provided private key is invalid (not 32 bytes).
+func NewCreateErrorPrivateKey(
+	size uint64,
+) *CreateError {
+	return &CreateError{err: &CreateErrorPrivateKey{
+		Size: size}}
+}
+
+func (e CreateErrorPrivateKey) destroy() {
+	FfiDestroyerUint64{}.Destroy(e.Size)
+}
+
+func (err CreateErrorPrivateKey) Error() string {
+	return fmt.Sprint("PrivateKey",
+		": ",
+
+		"Size=",
+		err.Size,
+	)
+}
+
+func (self CreateErrorPrivateKey) Is(target error) bool {
+	return target == ErrCreateErrorPrivateKey
+}
+
+// The provided gossip topic is invalid (not 32 bytes).
+type CreateErrorTopic struct {
+	Size uint64
+}
+
+// The provided gossip topic is invalid (not 32 bytes).
+func NewCreateErrorTopic(
+	size uint64,
+) *CreateError {
+	return &CreateError{err: &CreateErrorTopic{
+		Size: size}}
+}
+
+func (e CreateErrorTopic) destroy() {
+	FfiDestroyerUint64{}.Destroy(e.Size)
+}
+
+func (err CreateErrorTopic) Error() string {
+	return fmt.Sprint("Topic",
+		": ",
+
+		"Size=",
+		err.Size,
+	)
+}
+
+func (self CreateErrorTopic) Is(target error) bool {
+	return target == ErrCreateErrorTopic
+}
+
+// Failed to bind the iroh endpoint.
+type CreateErrorBind struct {
+	Message string
+}
+
+// Failed to bind the iroh endpoint.
+func NewCreateErrorBind(
+	message string,
+) *CreateError {
+	return &CreateError{err: &CreateErrorBind{
+		Message: message}}
+}
+
+func (e CreateErrorBind) destroy() {
+	FfiDestroyerString{}.Destroy(e.Message)
+}
+
+func (err CreateErrorBind) Error() string {
+	return fmt.Sprint("Bind",
+		": ",
+
+		"Message=",
+		err.Message,
+	)
+}
+
+func (self CreateErrorBind) Is(target error) bool {
+	return target == ErrCreateErrorBind
+}
+
+// Failed to subscribe to the gossip topic.
+type CreateErrorSubscribe struct {
+	Message string
+}
+
+// Failed to subscribe to the gossip topic.
+func NewCreateErrorSubscribe(
+	message string,
+) *CreateError {
+	return &CreateError{err: &CreateErrorSubscribe{
+		Message: message}}
+}
+
+func (e CreateErrorSubscribe) destroy() {
+	FfiDestroyerString{}.Destroy(e.Message)
+}
+
+func (err CreateErrorSubscribe) Error() string {
+	return fmt.Sprint("Subscribe",
+		": ",
+
+		"Message=",
+		err.Message,
+	)
+}
+
+func (self CreateErrorSubscribe) Is(target error) bool {
+	return target == ErrCreateErrorSubscribe
+}
+
+type FfiConverterCreateError struct{}
+
+var FfiConverterCreateErrorINSTANCE = FfiConverterCreateError{}
+
+func (c FfiConverterCreateError) Lift(eb RustBufferI) *CreateError {
+	return LiftFromRustBuffer[*CreateError](c, eb)
+}
+
+func (c FfiConverterCreateError) Lower(value *CreateError) C.RustBuffer {
+	return LowerIntoRustBuffer[*CreateError](c, value)
+}
+
+func (c FfiConverterCreateError) Read(reader io.Reader) *CreateError {
+	errorID := readUint32(reader)
+
+	switch errorID {
+	case 1:
+		return &CreateError{&CreateErrorPrivateKey{
+			Size: FfiConverterUint64INSTANCE.Read(reader),
+		}}
+	case 2:
+		return &CreateError{&CreateErrorTopic{
+			Size: FfiConverterUint64INSTANCE.Read(reader),
+		}}
+	case 3:
+		return &CreateError{&CreateErrorBind{
+			Message: FfiConverterStringINSTANCE.Read(reader),
+		}}
+	case 4:
+		return &CreateError{&CreateErrorSubscribe{
+			Message: FfiConverterStringINSTANCE.Read(reader),
+		}}
+	default:
+		panic(fmt.Sprintf("Unknown error code %d in FfiConverterCreateError.Read()", errorID))
+	}
+}
+
+func (c FfiConverterCreateError) Write(writer io.Writer, value *CreateError) {
+	switch variantValue := value.err.(type) {
+	case *CreateErrorPrivateKey:
+		writeInt32(writer, 1)
+		FfiConverterUint64INSTANCE.Write(writer, variantValue.Size)
+	case *CreateErrorTopic:
+		writeInt32(writer, 2)
+		FfiConverterUint64INSTANCE.Write(writer, variantValue.Size)
+	case *CreateErrorBind:
+		writeInt32(writer, 3)
+		FfiConverterStringINSTANCE.Write(writer, variantValue.Message)
+	case *CreateErrorSubscribe:
+		writeInt32(writer, 4)
+		FfiConverterStringINSTANCE.Write(writer, variantValue.Message)
+	default:
+		_ = variantValue
+		panic(fmt.Sprintf("invalid error value `%v` in FfiConverterCreateError.Write", value))
+	}
+}
+
+type FfiDestroyerCreateError struct{}
+
+func (_ FfiDestroyerCreateError) Destroy(value *CreateError) {
+	switch variantValue := value.err.(type) {
+	case CreateErrorPrivateKey:
+		variantValue.destroy()
+	case CreateErrorTopic:
+		variantValue.destroy()
+	case CreateErrorBind:
+		variantValue.destroy()
+	case CreateErrorSubscribe:
+		variantValue.destroy()
+	default:
+		_ = variantValue
+		panic(fmt.Sprintf("invalid error value `%v` in FfiDestroyerCreateError.Destroy", value))
+	}
+}
+
 // An Error.
 type Error struct {
 	err error
···
 	}
 }
 
+// Error joining peers.
+type JoinPeersError struct {
+	err error
+}
+
+// Convience method to turn *JoinPeersError into error
+// Avoiding treating nil pointer as non nil error interface
+func (err *JoinPeersError) AsError() error {
+	if err == nil {
+		return nil
+	} else {
+		return err
+	}
+}
+
+func (err JoinPeersError) Error() string {
+	return fmt.Sprintf("JoinPeersError: %s", err.err.Error())
+}
+
+func (err JoinPeersError) Unwrap() error {
+	return err.err
+}
+
+// Err* are used for checking error type with `errors.Is`
+var ErrJoinPeersErrorTicket = fmt.Errorf("JoinPeersErrorTicket")
+var ErrJoinPeersErrorIrpc = fmt.Errorf("JoinPeersErrorIrpc")
+
+// Variant structs
+// Failed to parse a provided iroh node ticket.
+type JoinPeersErrorTicket struct {
+	Message string
+}
+
+// Failed to parse a provided iroh node ticket.
+func NewJoinPeersErrorTicket(
+	message string,
+) *JoinPeersError {
+	return &JoinPeersError{err: &JoinPeersErrorTicket{
+		Message: message}}
+}
+
+func (e JoinPeersErrorTicket) destroy() {
+	FfiDestroyerString{}.Destroy(e.Message)
+}
+
+func (err JoinPeersErrorTicket) Error() string {
+	return fmt.Sprint("Ticket",
+		": ",
+
+		"Message=",
+		err.Message,
+	)
+}
+
+func (self JoinPeersErrorTicket) Is(target error) bool {
+	return target == ErrJoinPeersErrorTicket
+}
+
+// Error during the join peers operation.
+type JoinPeersErrorIrpc struct {
+	Message string
+}
+
+// Error during the join peers operation.
+func NewJoinPeersErrorIrpc(
+	message string,
+) *JoinPeersError {
+	return &JoinPeersError{err: &JoinPeersErrorIrpc{
+		Message: message}}
+}
+
+func (e JoinPeersErrorIrpc) destroy() {
+	FfiDestroyerString{}.Destroy(e.Message)
+}
+
+func (err JoinPeersErrorIrpc) Error() string {
+	return fmt.Sprint("Irpc",
+		": ",
+
+		"Message=",
+		err.Message,
+	)
+}
+
+func (self JoinPeersErrorIrpc) Is(target error) bool {
+	return target == ErrJoinPeersErrorIrpc
+}
+
+type FfiConverterJoinPeersError struct{}
+
+var FfiConverterJoinPeersErrorINSTANCE = FfiConverterJoinPeersError{}
+
+func (c FfiConverterJoinPeersError) Lift(eb RustBufferI) *JoinPeersError {
+	return LiftFromRustBuffer[*JoinPeersError](c, eb)
+}
+
+func (c FfiConverterJoinPeersError) Lower(value *JoinPeersError) C.RustBuffer {
+	return LowerIntoRustBuffer[*JoinPeersError](c, value)
+}
+
+func (c FfiConverterJoinPeersError) Read(reader io.Reader) *JoinPeersError {
+	errorID := readUint32(reader)
+
+	switch errorID {
+	case 1:
+		return &JoinPeersError{&JoinPeersErrorTicket{
+			Message: FfiConverterStringINSTANCE.Read(reader),
+		}}
+	case 2:
+		return &JoinPeersError{&JoinPeersErrorIrpc{
+			Message: FfiConverterStringINSTANCE.Read(reader),
+		}}
+	default:
+		panic(fmt.Sprintf("Unknown error code %d in FfiConverterJoinPeersError.Read()", errorID))
+	}
+}
+
+func (c FfiConverterJoinPeersError) Write(writer io.Writer, value *JoinPeersError) {
+	switch variantValue := value.err.(type) {
+	case *JoinPeersErrorTicket:
+		writeInt32(writer, 1)
+		FfiConverterStringINSTANCE.Write(writer, variantValue.Message)
+	case *JoinPeersErrorIrpc:
+		writeInt32(writer, 2)
+		FfiConverterStringINSTANCE.Write(writer, variantValue.Message)
+	default:
+		_ = variantValue
+		panic(fmt.Sprintf("invalid error value `%v` in FfiConverterJoinPeersError.Write", value))
+	}
+}
+
+type FfiDestroyerJoinPeersError struct{}
+
+func (_ FfiDestroyerJoinPeersError) Destroy(value *JoinPeersError) {
+	switch variantValue := value.err.(type) {
+	case JoinPeersErrorTicket:
+		variantValue.destroy()
+	case JoinPeersErrorIrpc:
+		variantValue.destroy()
+	default:
+		_ = variantValue
+		panic(fmt.Sprintf("invalid error value `%v` in FfiDestroyerJoinPeersError.Destroy", value))
+	}
+}
+
+type PublicKeyError struct {
+	err error
+}
+
+// Convience method to turn *PublicKeyError into error
+// Avoiding treating nil pointer as non nil error interface
+func (err *PublicKeyError) AsError() error {
+	if err == nil {
+		return nil
+	} else {
+		return err
+	}
+}
+
+func (err PublicKeyError) Error() string {
+	return fmt.Sprintf("PublicKeyError: %s", err.err.Error())
+}
+
+func (err PublicKeyError) Unwrap() error {
+	return err.err
+}
+
+// Err* are used for checking error type with `errors.Is`
+var ErrPublicKeyErrorLength = fmt.Errorf("PublicKeyErrorLength")
+var ErrPublicKeyErrorInvalid = fmt.Errorf("PublicKeyErrorInvalid")
+
+// Variant structs
+type PublicKeyErrorLength struct {
+	Size uint64
+}
+
+func NewPublicKeyErrorLength(
+	size uint64,
+) *PublicKeyError {
+	return &PublicKeyError{err: &PublicKeyErrorLength{
+		Size: size}}
+}
+
+func (e PublicKeyErrorLength) destroy() {
+	FfiDestroyerUint64{}.Destroy(e.Size)
+}
+
+func (err PublicKeyErrorLength) Error() string {
+	return fmt.Sprint("Length",
+		": ",
+
+		"Size=",
+		err.Size,
+	)
+}
+
+func (self PublicKeyErrorLength) Is(target error) bool {
+	return target == ErrPublicKeyErrorLength
+}
+
+type PublicKeyErrorInvalid struct {
+	Message string
+}
+
+func NewPublicKeyErrorInvalid(
+	message string,
+) *PublicKeyError {
+	return &PublicKeyError{err: &PublicKeyErrorInvalid{
+		Message: message}}
+}
+
+func (e PublicKeyErrorInvalid) destroy() {
+	FfiDestroyerString{}.Destroy(e.Message)
+}
+
+func (err PublicKeyErrorInvalid) Error() string {
+	return fmt.Sprint("Invalid",
+		": ",
+
+		"Message=",
+		err.Message,
+	)
+}
+
+func (self PublicKeyErrorInvalid) Is(target error) bool {
+	return target == ErrPublicKeyErrorInvalid
+}
+
+type FfiConverterPublicKeyError struct{}
+
+var FfiConverterPublicKeyErrorINSTANCE = FfiConverterPublicKeyError{}
+
+func (c FfiConverterPublicKeyError) Lift(eb RustBufferI) *PublicKeyError {
+	return LiftFromRustBuffer[*PublicKeyError](c, eb)
+}
+
+func (c FfiConverterPublicKeyError) Lower(value *PublicKeyError) C.RustBuffer {
+	return LowerIntoRustBuffer[*PublicKeyError](c, value)
+}
+
+func (c FfiConverterPublicKeyError) Read(reader io.Reader) *PublicKeyError {
+	errorID := readUint32(reader)
+
+	switch errorID {
+	case 1:
+		return &PublicKeyError{&PublicKeyErrorLength{
+			Size: FfiConverterUint64INSTANCE.Read(reader),
+		}}
+	case 2:
+		return &PublicKeyError{&PublicKeyErrorInvalid{
+			Message: FfiConverterStringINSTANCE.Read(reader),
+		}}
+	default:
+		panic(fmt.Sprintf("Unknown error code %d in FfiConverterPublicKeyError.Read()", errorID))
+	}
+}
+
+func (c FfiConverterPublicKeyError) Write(writer io.Writer, value *PublicKeyError) {
+	switch variantValue := value.err.(type) {
+	case *PublicKeyErrorLength:
+		writeInt32(writer, 1)
+		FfiConverterUint64INSTANCE.Write(writer, variantValue.Size)
+	case *PublicKeyErrorInvalid:
+		writeInt32(writer, 2)
+		FfiConverterStringINSTANCE.Write(writer, variantValue.Message)
+	default:
+		_ = variantValue
+		panic(fmt.Sprintf("invalid error value `%v` in FfiConverterPublicKeyError.Write", value))
+	}
+}
+
+type FfiDestroyerPublicKeyError struct{}
+
+func (_ FfiDestroyerPublicKeyError) Destroy(value *PublicKeyError) {
+	switch variantValue := value.err.(type) {
+	case PublicKeyErrorLength:
+		variantValue.destroy()
+	case PublicKeyErrorInvalid:
+		variantValue.destroy()
+	default:
+		_ = variantValue
+		panic(fmt.Sprintf("invalid error value `%v` in FfiDestroyerPublicKeyError.Destroy", value))
+	}
+}
+
+// Error putting a value into the database.
+type PutError struct {
+	err error
+}
+
+// Convience method to turn *PutError into error
+// Avoiding treating nil pointer as non nil error interface
+func (err *PutError) AsError() error {
+	if err == nil {
+		return nil
+	} else {
+		return err
+	}
+}
+
+func (err PutError) Error() string {
+	return fmt.Sprintf("PutError: %s", err.err.Error())
+}
+
+func (err PutError) Unwrap() error {
+	return err.err
+}
+
+// Err* are used for checking error type with `errors.Is`
+var ErrPutErrorIrpc = fmt.Errorf("PutErrorIrpc")
+
+// Variant structs
+// Error during the put operation.
+type PutErrorIrpc struct {
+	Message string
+}
+
+// Error during the put operation.
+func NewPutErrorIrpc(
+	message string,
+) *PutError {
+	return &PutError{err: &PutErrorIrpc{
+		Message: message}}
+}
+
+func (e PutErrorIrpc) destroy() {
+	FfiDestroyerString{}.Destroy(e.Message)
+}
+
+func (err PutErrorIrpc) Error() string {
+	return fmt.Sprint("Irpc",
+		": ",
+
+		"Message=",
+		err.Message,
+	)
+}
+
+func (self PutErrorIrpc) Is(target error) bool {
+	return target == ErrPutErrorIrpc
+}
+
+type FfiConverterPutError struct{}
+
+var FfiConverterPutErrorINSTANCE = FfiConverterPutError{}
+
+func (c FfiConverterPutError) Lift(eb RustBufferI) *PutError {
+	return LiftFromRustBuffer[*PutError](c, eb)
+}
+
+func (c FfiConverterPutError) Lower(value *PutError) C.RustBuffer {
+	return LowerIntoRustBuffer[*PutError](c, value)
+}
+
+func (c FfiConverterPutError) Read(reader io.Reader) *PutError {
+	errorID := readUint32(reader)
+
+	switch errorID {
+	case 1:
+		return &PutError{&PutErrorIrpc{
+			Message: FfiConverterStringINSTANCE.Read(reader),
+		}}
+	default:
+		panic(fmt.Sprintf("Unknown error code %d in FfiConverterPutError.Read()", errorID))
+	}
+}
+
+func (c FfiConverterPutError) Write(writer io.Writer, value *PutError) {
+	switch variantValue := value.err.(type) {
+	case *PutErrorIrpc:
+		writeInt32(writer, 1)
+		FfiConverterStringINSTANCE.Write(writer, variantValue.Message)
+	default:
+		_ = variantValue
+		panic(fmt.Sprintf("invalid error value `%v` in FfiConverterPutError.Write", value))
+	}
+}
+
+type FfiDestroyerPutError struct{}
+
+func (_ FfiDestroyerPutError) Destroy(value *PutError) {
+	switch variantValue := value.err.(type) {
+	case PutErrorIrpc:
+		variantValue.destroy()
+	default:
+		_ = variantValue
+		panic(fmt.Sprintf("invalid error value `%v` in FfiDestroyerPutError.Destroy", value))
+	}
+}
+
 type SpError struct {
 	err error
 }
···
 	}
 }
 
+type StreamFilter interface {
+	Destroy()
+}
+type StreamFilterAll struct {
+}
+
+func (e StreamFilterAll) Destroy() {
+}
+
+type StreamFilterGlobal struct {
+}
+
+func (e StreamFilterGlobal) Destroy() {
+}
+
+type StreamFilterStream struct {
+	Field0 []byte
+}
+
+func (e StreamFilterStream) Destroy() {
+	FfiDestroyerBytes{}.Destroy(e.Field0)
+}
+
+type FfiConverterStreamFilter struct{}
+
+var FfiConverterStreamFilterINSTANCE = FfiConverterStreamFilter{}
+
+func (c FfiConverterStreamFilter) Lift(rb RustBufferI) StreamFilter {
+	return LiftFromRustBuffer[StreamFilter](c, rb)
+}
+
+func (c FfiConverterStreamFilter) Lower(value StreamFilter) C.RustBuffer {
+	return LowerIntoRustBuffer[StreamFilter](c, value)
+}
+func (FfiConverterStreamFilter) Read(reader io.Reader) StreamFilter {
+	id := readInt32(reader)
+	switch id {
+	case 1:
+		return StreamFilterAll{}
+	case 2:
+		return StreamFilterGlobal{}
+	case 3:
+		return StreamFilterStream{
+			FfiConverterBytesINSTANCE.Read(reader),
+		}
+	default:
+		panic(fmt.Sprintf("invalid enum value %v in FfiConverterStreamFilter.Read()", id))
+	}
+}
+
+func (FfiConverterStreamFilter) Write(writer io.Writer, value StreamFilter) {
+	switch variant_value := value.(type) {
+	case StreamFilterAll:
+		writeInt32(writer, 1)
+	case StreamFilterGlobal:
+		writeInt32(writer, 2)
+	case StreamFilterStream:
+		writeInt32(writer, 3)
+		FfiConverterBytesINSTANCE.Write(writer, variant_value.Field0)
+	default:
+		_ = variant_value
+		panic(fmt.Sprintf("invalid enum value `%v` in FfiConverterStreamFilter.Write", value))
+	}
+}
+
+type FfiDestroyerStreamFilter struct{}
+
+func (_ FfiDestroyerStreamFilter) Destroy(value StreamFilter) {
+	value.Destroy()
+}
+
+// An item returned from a subscription.
+type SubscribeItem interface {
+	Destroy()
+}
+type SubscribeItemEntry struct {
+	Scope     *PublicKey
+	Stream    *[]byte
+	Key       []byte
+	Value     []byte
+	Timestamp uint64
+}
+
+func (e SubscribeItemEntry) Destroy() {
+	FfiDestroyerPublicKey{}.Destroy(e.Scope)
+	FfiDestroyerOptionalBytes{}.Destroy(e.Stream)
+	FfiDestroyerBytes{}.Destroy(e.Key)
+	FfiDestroyerBytes{}.Destroy(e.Value)
+	FfiDestroyerUint64{}.Destroy(e.Timestamp)
+}
+
+type SubscribeItemCurrentDone struct {
+}
+
+func (e SubscribeItemCurrentDone) Destroy() {
+}
+
+type SubscribeItemExpired struct {
+	Scope     *PublicKey
+	Stream    *[]byte
+	Key       []byte
+	Timestamp uint64
+}
+
+func (e SubscribeItemExpired) Destroy() {
+	FfiDestroyerPublicKey{}.Destroy(e.Scope)
+	FfiDestroyerOptionalBytes{}.Destroy(e.Stream)
+	FfiDestroyerBytes{}.Destroy(e.Key)
+	FfiDestroyerUint64{}.Destroy(e.Timestamp)
+}
+
+type SubscribeItemOther struct {
+}
+
+func (e SubscribeItemOther) Destroy() {
+}
+
+type FfiConverterSubscribeItem struct{}
+
+var FfiConverterSubscribeItemINSTANCE = FfiConverterSubscribeItem{}
+
+func (c FfiConverterSubscribeItem) Lift(rb RustBufferI) SubscribeItem {
+	return LiftFromRustBuffer[SubscribeItem](c, rb)
+}
+
+func (c FfiConverterSubscribeItem) Lower(value SubscribeItem) C.RustBuffer {
+	return LowerIntoRustBuffer[SubscribeItem](c, value)
+}
+func (FfiConverterSubscribeItem) Read(reader io.Reader) SubscribeItem {
+	id := readInt32(reader)
+	switch id {
+	case 1:
+		return SubscribeItemEntry{
+			FfiConverterPublicKeyINSTANCE.Read(reader),
+			FfiConverterOptionalBytesINSTANCE.Read(reader),
+			FfiConverterBytesINSTANCE.Read(reader),
+			FfiConverterBytesINSTANCE.Read(reader),
+			FfiConverterUint64INSTANCE.Read(reader),
+		}
+	case 2:
+		return SubscribeItemCurrentDone{}
+	case 3:
+		return SubscribeItemExpired{
+			FfiConverterPublicKeyINSTANCE.Read(reader),
+			FfiConverterOptionalBytesINSTANCE.Read(reader),
+			FfiConverterBytesINSTANCE.Read(reader),
+			FfiConverterUint64INSTANCE.Read(reader),
+		}
+	case 4:
+		return SubscribeItemOther{}
+	default:
+		panic(fmt.Sprintf("invalid enum value %v in FfiConverterSubscribeItem.Read()", id))
+	}
+}
+
+func (FfiConverterSubscribeItem) Write(writer io.Writer, value SubscribeItem) {
+	switch variant_value := value.(type) {
+	case SubscribeItemEntry:
+		writeInt32(writer, 1)
+		FfiConverterPublicKeyINSTANCE.Write(writer, variant_value.Scope)
+		FfiConverterOptionalBytesINSTANCE.Write(writer, variant_value.Stream)
+		FfiConverterBytesINSTANCE.Write(writer, variant_value.Key)
+		FfiConverterBytesINSTANCE.Write(writer, variant_value.Value)
+		FfiConverterUint64INSTANCE.Write(writer, variant_value.Timestamp)
+	case SubscribeItemCurrentDone:
+		writeInt32(writer, 2)
+	case SubscribeItemExpired:
+		writeInt32(writer, 3)
+		FfiConverterPublicKeyINSTANCE.Write(writer, variant_value.Scope)
+		FfiConverterOptionalBytesINSTANCE.Write(writer, variant_value.Stream)
+		FfiConverterBytesINSTANCE.Write(writer, variant_value.Key)
+		FfiConverterUint64INSTANCE.Write(writer, variant_value.Timestamp)
+	case SubscribeItemOther:
+		writeInt32(writer, 4)
+	default:
+		_ = variant_value
+		panic(fmt.Sprintf("invalid enum value `%v` in FfiConverterSubscribeItem.Write", value))
+	}
+}
+
+type FfiDestroyerSubscribeItem struct{}
+
+func (_ FfiDestroyerSubscribeItem) Destroy(value SubscribeItem) {
+	value.Destroy()
+}
+
+// Subscription mode for key-value subscriptions.
+type SubscribeMode uint
+
+const (
+	SubscribeModeCurrent SubscribeMode = 1
+	SubscribeModeFuture  SubscribeMode = 2
+	SubscribeModeBoth    SubscribeMode = 3
+)
+
+type FfiConverterSubscribeMode struct{}
+
+var FfiConverterSubscribeModeINSTANCE = FfiConverterSubscribeMode{}
+
+func (c FfiConverterSubscribeMode) Lift(rb RustBufferI) SubscribeMode {
+	return LiftFromRustBuffer[SubscribeMode](c, rb)
+}
+
+func (c FfiConverterSubscribeMode) Lower(value SubscribeMode) C.RustBuffer {
+	return LowerIntoRustBuffer[SubscribeMode](c, value)
+}
+func (FfiConverterSubscribeMode) Read(reader io.Reader) SubscribeMode {
+	id := readInt32(reader)
+	return SubscribeMode(id)
+}
+
+func (FfiConverterSubscribeMode) Write(writer io.Writer, value SubscribeMode) {
+	writeInt32(writer, int32(value))
+}
+
+type FfiDestroyerSubscribeMode struct{}
+
+func (_ FfiDestroyerSubscribeMode) Destroy(value SubscribeMode) {
+}
+
+// Error getting the next item from a subscription.
+type SubscribeNextError struct {
+	err error
+}
+
+// Convience method to turn *SubscribeNextError into error
+// Avoiding treating nil pointer as non nil error interface
+func (err *SubscribeNextError) AsError() error {
+	if err == nil {
+		return nil
+	} else {
+		return err
+	}
+}
+
+func (err SubscribeNextError) Error() string {
+	return fmt.Sprintf("SubscribeNextError: %s", err.err.Error())
+}
+
+func (err SubscribeNextError) Unwrap() error {
+	return err.err
+}
+
+// Err* are used for checking error type with `errors.Is`
+var ErrSubscribeNextErrorIrpc = fmt.Errorf("SubscribeNextErrorIrpc")
+
+// Variant structs
+// Error during the subscribe next operation.
+type SubscribeNextErrorIrpc struct {
+	Message string
+}
+
+// Error during the subscribe next operation.
+func NewSubscribeNextErrorIrpc(
+	message string,
+) *SubscribeNextError {
+	return &SubscribeNextError{err: &SubscribeNextErrorIrpc{
+		Message: message}}
+}
+
+func (e SubscribeNextErrorIrpc) destroy() {
+	FfiDestroyerString{}.Destroy(e.Message)
+}
+
+func (err SubscribeNextErrorIrpc) Error() string {
+	return fmt.Sprint("Irpc",
+		": ",
+
+		"Message=",
+		err.Message,
+	)
+}
+
+func (self SubscribeNextErrorIrpc) Is(target error) bool {
+	return target == ErrSubscribeNextErrorIrpc
+}
+
+type FfiConverterSubscribeNextError struct{}
+
+var FfiConverterSubscribeNextErrorINSTANCE = FfiConverterSubscribeNextError{}
+
+func (c FfiConverterSubscribeNextError) Lift(eb RustBufferI) *SubscribeNextError {
+	return LiftFromRustBuffer[*SubscribeNextError](c, eb)
+}
+
+func (c FfiConverterSubscribeNextError) Lower(value *SubscribeNextError) C.RustBuffer {
+	return LowerIntoRustBuffer[*SubscribeNextError](c, value)
+}
+
+func (c FfiConverterSubscribeNextError) Read(reader io.Reader) *SubscribeNextError {
+	errorID := readUint32(reader)
+
+	switch errorID {
+	case 1:
+		return &SubscribeNextError{&SubscribeNextErrorIrpc{
+			Message: FfiConverterStringINSTANCE.Read(reader),
+		}}
+	default:
+		panic(fmt.Sprintf("Unknown error code %d in FfiConverterSubscribeNextError.Read()", errorID))
+	}
+}
+
+func (c FfiConverterSubscribeNextError) Write(writer io.Writer, value *SubscribeNextError) {
+	switch variantValue := value.err.(type) {
+	case *SubscribeNextErrorIrpc:
+		writeInt32(writer, 1)
+		FfiConverterStringINSTANCE.Write(writer, variantValue.Message)
+	default:
+		_ = variantValue
+		panic(fmt.Sprintf("invalid error value `%v` in FfiConverterSubscribeNextError.Write", value))
+	}
+}
+
+type FfiDestroyerSubscribeNextError struct{}
+
+func (_ FfiDestroyerSubscribeNextError) Destroy(value *SubscribeNextError) {
+	switch variantValue := value.err.(type) {
+	case SubscribeNextErrorIrpc:
+		variantValue.destroy()
+	default:
+		_ = variantValue
+		panic(fmt.Sprintf("invalid error value `%v` in FfiDestroyerSubscribeNextError.Destroy", value))
+	}
+}
+
+// A bound on time for filtering.
+type TimeBound interface {
+	Destroy()
+}
+type TimeBoundUnbounded struct {
+}
+
+func (e TimeBoundUnbounded) Destroy() {
+}
+
+type TimeBoundIncluded struct {
+	Field0 uint64
+}
+
+func (e TimeBoundIncluded) Destroy() {
+	FfiDestroyerUint64{}.Destroy(e.Field0)
+}
+
+type TimeBoundExcluded struct {
+	Field0 uint64
+}
+
+func (e TimeBoundExcluded) Destroy() {
+	FfiDestroyerUint64{}.Destroy(e.Field0)
+}
+
+type FfiConverterTimeBound struct{}
+
+var FfiConverterTimeBoundINSTANCE = FfiConverterTimeBound{}
+
+func (c FfiConverterTimeBound) Lift(rb RustBufferI) TimeBound {
+	return LiftFromRustBuffer[TimeBound](c, rb)
+}
+
+func (c FfiConverterTimeBound) Lower(value TimeBound) C.RustBuffer {
+	return LowerIntoRustBuffer[TimeBound](c, value)
+}
+func (FfiConverterTimeBound) Read(reader io.Reader) TimeBound {
+	id := readInt32(reader)
+	switch id {
+	case 1:
+		return TimeBoundUnbounded{}
+	case 2:
+		return TimeBoundIncluded{
+			FfiConverterUint64INSTANCE.Read(reader),
+		}
+	case 3:
+		return TimeBoundExcluded{
+			FfiConverterUint64INSTANCE.Read(reader),
+		}
+	default:
+		panic(fmt.Sprintf("invalid enum value %v in FfiConverterTimeBound.Read()", id))
+	}
+}
+
+func (FfiConverterTimeBound) Write(writer io.Writer, value TimeBound) {
+	switch variant_value := value.(type) {
+	case TimeBoundUnbounded:
+		writeInt32(writer, 1)
+	case TimeBoundIncluded:
+		writeInt32(writer, 2)
+		FfiConverterUint64INSTANCE.Write(writer, variant_value.Field0)
+	case TimeBoundExcluded:
+		writeInt32(writer, 3)
+		FfiConverterUint64INSTANCE.Write(writer, variant_value.Field0)
+	default:
+		_ = variant_value
+		panic(fmt.Sprintf("invalid enum value `%v` in FfiConverterTimeBound.Write", value))
+	}
+}
+
+type FfiDestroyerTimeBound struct{}
+
+func (_ FfiDestroyerTimeBound) Destroy(value TimeBound) {
+	value.Destroy()
+}
+
+// Error getting the next item from a subscription.
+type WriteError struct {
+	err error
+}
+
+// Convience method to turn *WriteError into error
+// Avoiding treating nil pointer as non nil error interface
+func (err *WriteError) AsError() error {
+	if err == nil {
+		return nil
+	} else {
+		return err
+	}
+}
+
+func (err WriteError) Error() string {
+	return fmt.Sprintf("WriteError: %s", err.err.Error())
+}
+
+func (err WriteError) Unwrap() error {
+	return err.err
+}
+
+// Err* are used for checking error type with `errors.Is`
+var ErrWriteErrorPrivateKeySize = fmt.Errorf("WriteErrorPrivateKeySize")
+
+// Variant structs
+// The provided private key is invalid (not 32 bytes).
+type WriteErrorPrivateKeySize struct {
+	Size uint64
+}
+
+// The provided private key is invalid (not 32 bytes).
+func NewWriteErrorPrivateKeySize(
+	size uint64,
+) *WriteError {
+	return &WriteError{err: &WriteErrorPrivateKeySize{
+		Size: size}}
+}
+
+func (e WriteErrorPrivateKeySize) destroy() {
+	FfiDestroyerUint64{}.Destroy(e.Size)
+}
+
+func (err WriteErrorPrivateKeySize) Error() string {
+	return fmt.Sprint("PrivateKeySize",
+		": ",
+
+		"Size=",
+		err.Size,
+	)
+}
+
+func (self WriteErrorPrivateKeySize) Is(target error) bool {
+	return target == ErrWriteErrorPrivateKeySize
+}
+
+type FfiConverterWriteError struct{}
+
+var FfiConverterWriteErrorINSTANCE = FfiConverterWriteError{}
+
+func (c FfiConverterWriteError) Lift(eb RustBufferI) *WriteError {
+	return LiftFromRustBuffer[*WriteError](c, eb)
+}
+
+func (c FfiConverterWriteError) Lower(value *WriteError) C.RustBuffer {
+	return LowerIntoRustBuffer[*WriteError](c, value)
+}
+
+func (c FfiConverterWriteError) Read(reader io.Reader) *WriteError {
+	errorID := readUint32(reader)
+
+	switch errorID {
+	case 1:
+		return &WriteError{&WriteErrorPrivateKeySize{
+			Size: FfiConverterUint64INSTANCE.Read(reader),
+		}}
+	default:
+		panic(fmt.Sprintf("Unknown error code %d in FfiConverterWriteError.Read()", errorID))
+	}
+}
+
+func (c FfiConverterWriteError) Write(writer io.Writer, value *WriteError) {
+	switch variantValue := value.err.(type) {
+	case *WriteErrorPrivateKeySize:
+		writeInt32(writer, 1)
+		FfiConverterUint64INSTANCE.Write(writer, variantValue.Size)
+	default:
+		_ = variantValue
+		panic(fmt.Sprintf("invalid error value `%v` in FfiConverterWriteError.Write", value))
+	}
+}
+
+type FfiDestroyerWriteError struct{}
+
+func (_ FfiDestroyerWriteError) Destroy(value *WriteError) {
+	switch variantValue := value.err.(type) {
+	case WriteErrorPrivateKeySize:
+		variantValue.destroy()
+	default:
+		_ = variantValue
+		panic(fmt.Sprintf("invalid error value `%v` in FfiDestroyerWriteError.Destroy", value))
+	}
+}
+
 type FfiConverterOptionalString struct{}
 
 var FfiConverterOptionalStringINSTANCE = FfiConverterOptionalString{}
···
 	}
 }
 
+type FfiConverterOptionalBytes struct{}
+
+var FfiConverterOptionalBytesINSTANCE = FfiConverterOptionalBytes{}
+
+func (c FfiConverterOptionalBytes) Lift(rb RustBufferI) *[]byte {
+	return LiftFromRustBuffer[*[]byte](c, rb)
+}
+
+func (_ FfiConverterOptionalBytes) Read(reader io.Reader) *[]byte {
+	if readInt8(reader) == 0 {
+		return nil
+	}
+	temp := FfiConverterBytesINSTANCE.Read(reader)
+	return &temp
+}
+
+func (c FfiConverterOptionalBytes) Lower(value *[]byte) C.RustBuffer {
+	return LowerIntoRustBuffer[*[]byte](c, value)
+}
+
+func (_ FfiConverterOptionalBytes) Write(writer io.Writer, value *[]byte) {
+	if value == nil {
+		writeInt8(writer, 0)
+	} else {
+		writeInt8(writer, 1)
+		FfiConverterBytesINSTANCE.Write(writer, *value)
+	}
+}
+
+type FfiDestroyerOptionalBytes struct{}
+
+func (_ FfiDestroyerOptionalBytes) Destroy(value *[]byte) {
+	if value != nil {
+		FfiDestroyerBytes{}.Destroy(*value)
+	}
+}
+
+type FfiConverterOptionalSubscribeItem struct{}
+
+var FfiConverterOptionalSubscribeItemINSTANCE = FfiConverterOptionalSubscribeItem{}
+
+func (c FfiConverterOptionalSubscribeItem) Lift(rb RustBufferI) *SubscribeItem {
+	return LiftFromRustBuffer[*SubscribeItem](c, rb)
+}
+
+func (_ FfiConverterOptionalSubscribeItem) Read(reader io.Reader) *SubscribeItem {
+	if readInt8(reader) == 0 {
+		return nil
+	}
+	temp := FfiConverterSubscribeItemINSTANCE.Read(reader)
+	return &temp
+}
+
+func (c FfiConverterOptionalSubscribeItem) Lower(value *SubscribeItem) C.RustBuffer {
+	return LowerIntoRustBuffer[*SubscribeItem](c, value)
+}
+
+func (_ FfiConverterOptionalSubscribeItem) Write(writer io.Writer, value *SubscribeItem) {
+	if value == nil {
+		writeInt8(writer, 0)
+	} else {
+		writeInt8(writer, 1)
+		FfiConverterSubscribeItemINSTANCE.Write(writer, *value)
+	}
+}
+
+type FfiDestroyerOptionalSubscribeItem struct{}
+
+func (_ FfiDestroyerOptionalSubscribeItem) Destroy(value *SubscribeItem) {
+	if value != nil {
+		FfiDestroyerSubscribeItem{}.Destroy(*value)
+	}
+}
+
 type FfiConverterSequenceString struct{}
 
 var FfiConverterSequenceStringINSTANCE = FfiConverterSequenceString{}
···
 	}
 }
 
+type FfiConverterSequencePublicKey struct{}
+
+var FfiConverterSequencePublicKeyINSTANCE = FfiConverterSequencePublicKey{}
+
+func (c FfiConverterSequencePublicKey) Lift(rb RustBufferI) []*PublicKey {
+	return LiftFromRustBuffer[[]*PublicKey](c, rb)
+}
+
+func (c FfiConverterSequencePublicKey) Read(reader io.Reader) []*PublicKey {
+	length := readInt32(reader)
+	if length == 0 {
+		return nil
+	}
+	result := make([]*PublicKey, 0, length)
+	for i := int32(0); i < length; i++ {
+		result = append(result, FfiConverterPublicKeyINSTANCE.Read(reader))
+	}
+	return result
+}
+
+func (c FfiConverterSequencePublicKey) Lower(value []*PublicKey) C.RustBuffer {
+	return LowerIntoRustBuffer[[]*PublicKey](c, value)
+}
+
+func (c FfiConverterSequencePublicKey) Write(writer io.Writer, value []*PublicKey) {
+	if len(value) > math.MaxInt32 {
+		panic("[]*PublicKey is too large to fit into Int32")
+	}
+
+	writeInt32(writer, int32(len(value)))
+	for _, item := range value {
+		FfiConverterPublicKeyINSTANCE.Write(writer, item)
+	}
+}
+
+type FfiDestroyerSequencePublicKey struct{}
+
+func (FfiDestroyerSequencePublicKey) Destroy(sequence []*PublicKey) {
+	for _, value := range sequence {
+		FfiDestroyerPublicKey{}.Destroy(value)
+	}
+}
+
+type FfiConverterSequenceEntry struct{}
+
+var FfiConverterSequenceEntryINSTANCE = FfiConverterSequenceEntry{}
+
+func (c FfiConverterSequenceEntry) Lift(rb RustBufferI) []Entry {
+	return LiftFromRustBuffer[[]Entry](c, rb)
+}
+
+func (c FfiConverterSequenceEntry) Read(reader io.Reader) []Entry {
+	length := readInt32(reader)
+	if length == 0 {
+		return nil
+	}
+	result := make([]Entry, 0, length)
+	for i := int32(0); i < length; i++ {
+		result = append(result, FfiConverterEntryINSTANCE.Read(reader))
+	}
+	return result
+}
+
+func (c FfiConverterSequenceEntry) Lower(value []Entry) C.RustBuffer {
+	return LowerIntoRustBuffer[[]Entry](c, value)
+}
+
+func (c FfiConverterSequenceEntry) Write(writer io.Writer, value []Entry) {
+	if len(value) > math.MaxInt32 {
+		panic("[]Entry is too large to fit into Int32")
+	}
+
+	writeInt32(writer, int32(len(value)))
+	for _, item := range value {
+		FfiConverterEntryINSTANCE.Write(writer, item)
+	}
+}
+
+type FfiDestroyerSequenceEntry struct{}
+
+func (FfiDestroyerSequenceEntry) Destroy(sequence []Entry) {
+	for _, value := range sequence {
+		FfiDestroyerEntry{}.Destroy(value)
+	}
+}
+
 const (
 	uniffiRustFuturePollReady      int8 = 0
 	uniffiRustFuturePollMaybeReady int8 = 1
···
 	guard <- struct{}{}
 }
 
-func GetManifestAndCert(data []byte) (string, *SpError) {
+func GetManifestAndCert(data []byte) (string, error) {
 	_uniffiRV, _uniffiErr := rustCallWithError[SpError](FfiConverterSpError{}, func(_uniffiStatus *C.RustCallStatus) RustBufferI {
 		return GoRustBuffer{
 			inner: C.uniffi_iroh_streamplace_fn_func_get_manifest_and_cert(FfiConverterBytesINSTANCE.Lower(data), _uniffiStatus),
···
 		var _uniffiDefaultValue string
 		return _uniffiDefaultValue, _uniffiErr
 	} else {
-		return FfiConverterStringINSTANCE.Lift(_uniffiRV), _uniffiErr
+		return FfiConverterStringINSTANCE.Lift(_uniffiRV), nil
 	}
 }
 
-func Sign(manifest string, data []byte, certs []byte, gosigner GoSigner) ([]byte, *SpError) {
+func Sign(manifest string, data []byte, certs []byte, gosigner GoSigner) ([]byte, error) {
 	_uniffiRV, _uniffiErr := rustCallWithError[SpError](FfiConverterSpError{}, func(_uniffiStatus *C.RustCallStatus) RustBufferI {
 		return GoRustBuffer{
 			inner: C.uniffi_iroh_streamplace_fn_func_sign(FfiConverterStringINSTANCE.Lower(manifest), FfiConverterBytesINSTANCE.Lower(data), FfiConverterBytesINSTANCE.Lower(certs), FfiConverterGoSignerINSTANCE.Lower(gosigner), _uniffiStatus),
···
 		var _uniffiDefaultValue []byte
 		return _uniffiDefaultValue, _uniffiErr
 	} else {
-		return FfiConverterBytesINSTANCE.Lift(_uniffiRV), _uniffiErr
+		return FfiConverterBytesINSTANCE.Lift(_uniffiRV), nil
 	}
 }
+
+func SubscribeItemDebug(item SubscribeItem) string {
+	return FfiConverterStringINSTANCE.Lift(rustCall(func(_uniffiStatus *C.RustCallStatus) RustBufferI {
+		return GoRustBuffer{
+			inner: C.uniffi_iroh_streamplace_fn_func_subscribe_item_debug(FfiConverterSubscribeItemINSTANCE.Lower(item), _uniffiStatus),
+		}
+	}))
+}

pkg/iroh/generated/iroh_streamplace/iroh_streamplace.h

···
 
 
 #endif
+#ifndef UNIFFI_FFIDEF_CALLBACK_INTERFACE_DATA_HANDLER_OLD_METHOD0
+#define UNIFFI_FFIDEF_CALLBACK_INTERFACE_DATA_HANDLER_OLD_METHOD0
+typedef void (*UniffiCallbackInterfaceDataHandlerOldMethod0)(uint64_t uniffi_handle, RustBuffer topic, RustBuffer data, UniffiForeignFutureCompleteVoid uniffi_future_callback, uint64_t uniffi_callback_data, UniffiForeignFuture* uniffi_out_return);
+
+// Making function static works arround:
+// https://github.com/golang/go/issues/11263
+static void call_UniffiCallbackInterfaceDataHandlerOldMethod0(
+				UniffiCallbackInterfaceDataHandlerOldMethod0 cb, uint64_t uniffi_handle, RustBuffer topic, RustBuffer data, UniffiForeignFutureCompleteVoid uniffi_future_callback, uint64_t uniffi_callback_data, UniffiForeignFuture* uniffi_out_return)
+{
+	return cb(uniffi_handle, topic, data, uniffi_future_callback, uniffi_callback_data, uniffi_out_return);
+}
+
+
+#endif
 #ifndef UNIFFI_FFIDEF_CALLBACK_INTERFACE_GO_SIGNER_METHOD0
 #define UNIFFI_FFIDEF_CALLBACK_INTERFACE_GO_SIGNER_METHOD0
 typedef void (*UniffiCallbackInterfaceGoSignerMethod0)(uint64_t uniffi_handle, RustBuffer data, RustBuffer* uniffi_out_return, RustCallStatus* callStatus );
···
 } UniffiVTableCallbackInterfaceDataHandler;
 
 #endif
+#ifndef UNIFFI_FFIDEF_V_TABLE_CALLBACK_INTERFACE_DATA_HANDLER_OLD
+#define UNIFFI_FFIDEF_V_TABLE_CALLBACK_INTERFACE_DATA_HANDLER_OLD
+typedef struct UniffiVTableCallbackInterfaceDataHandlerOld {
+    UniffiCallbackInterfaceDataHandlerOldMethod0 handleData;
+    UniffiCallbackInterfaceFree uniffiFree;
+} UniffiVTableCallbackInterfaceDataHandlerOld;
+
+#endif
 #ifndef UNIFFI_FFIDEF_V_TABLE_CALLBACK_INTERFACE_GO_SIGNER
 #define UNIFFI_FFIDEF_V_TABLE_CALLBACK_INTERFACE_GO_SIGNER
 typedef struct UniffiVTableCallbackInterfaceGoSigner {
···
 uint64_t uniffi_iroh_streamplace_fn_method_datahandler_handle_data(void* ptr, RustBuffer topic, RustBuffer data
 );
 #endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_CLONE_DATAHANDLEROLD
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_CLONE_DATAHANDLEROLD
+void* uniffi_iroh_streamplace_fn_clone_datahandlerold(void* ptr, RustCallStatus *out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_FREE_DATAHANDLEROLD
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_FREE_DATAHANDLEROLD
+void uniffi_iroh_streamplace_fn_free_datahandlerold(void* ptr, RustCallStatus *out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_INIT_CALLBACK_VTABLE_DATAHANDLEROLD
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_INIT_CALLBACK_VTABLE_DATAHANDLEROLD
+void uniffi_iroh_streamplace_fn_init_callback_vtable_datahandlerold(UniffiVTableCallbackInterfaceDataHandlerOld* vtable
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_DATAHANDLEROLD_HANDLE_DATA
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_DATAHANDLEROLD_HANDLE_DATA
+uint64_t uniffi_iroh_streamplace_fn_method_datahandlerold_handle_data(void* ptr, RustBuffer topic, RustBuffer data
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_CLONE_DB
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_CLONE_DB
+void* uniffi_iroh_streamplace_fn_clone_db(void* ptr, RustCallStatus *out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_FREE_DB
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_FREE_DB
+void uniffi_iroh_streamplace_fn_free_db(void* ptr, RustCallStatus *out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_DB_ITER_WITH_OPTS
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_DB_ITER_WITH_OPTS
+uint64_t uniffi_iroh_streamplace_fn_method_db_iter_with_opts(void* ptr, void* filter
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_DB_SUBSCRIBE
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_DB_SUBSCRIBE
+void* uniffi_iroh_streamplace_fn_method_db_subscribe(void* ptr, void* filter, RustCallStatus *out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_DB_SUBSCRIBE_WITH_OPTS
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_DB_SUBSCRIBE_WITH_OPTS
+void* uniffi_iroh_streamplace_fn_method_db_subscribe_with_opts(void* ptr, RustBuffer opts, RustCallStatus *out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_DB_WRITE
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_DB_WRITE
+void* uniffi_iroh_streamplace_fn_method_db_write(void* ptr, RustBuffer secret, RustCallStatus *out_status
+);
+#endif
 #ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_CLONE_ENDPOINT
 #define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_CLONE_ENDPOINT
 void* uniffi_iroh_streamplace_fn_clone_endpoint(void* ptr, RustCallStatus *out_status
···
 uint64_t uniffi_iroh_streamplace_fn_method_endpoint_node_addr(void* ptr
 );
 #endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_CLONE_FILTER
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_CLONE_FILTER
+void* uniffi_iroh_streamplace_fn_clone_filter(void* ptr, RustCallStatus *out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_FREE_FILTER
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_FREE_FILTER
+void uniffi_iroh_streamplace_fn_free_filter(void* ptr, RustCallStatus *out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_CONSTRUCTOR_FILTER_NEW
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_CONSTRUCTOR_FILTER_NEW
+void* uniffi_iroh_streamplace_fn_constructor_filter_new(RustCallStatus *out_status
+    
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_FILTER_GLOBAL
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_FILTER_GLOBAL
+void* uniffi_iroh_streamplace_fn_method_filter_global(void* ptr, RustCallStatus *out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_FILTER_SCOPE
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_FILTER_SCOPE
+void* uniffi_iroh_streamplace_fn_method_filter_scope(void* ptr, void* scope, RustCallStatus *out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_FILTER_SCOPES
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_FILTER_SCOPES
+void* uniffi_iroh_streamplace_fn_method_filter_scopes(void* ptr, RustBuffer scopes, RustCallStatus *out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_FILTER_STREAM
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_FILTER_STREAM
+void* uniffi_iroh_streamplace_fn_method_filter_stream(void* ptr, RustBuffer stream, RustCallStatus *out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_FILTER_TIME_FROM
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_FILTER_TIME_FROM
+void* uniffi_iroh_streamplace_fn_method_filter_time_from(void* ptr, uint64_t min, RustCallStatus *out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_FILTER_TIME_RANGE
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_FILTER_TIME_RANGE
+void* uniffi_iroh_streamplace_fn_method_filter_time_range(void* ptr, uint64_t min, uint64_t max, RustCallStatus *out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_FILTER_TIMESTAMPS
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_FILTER_TIMESTAMPS
+void* uniffi_iroh_streamplace_fn_method_filter_timestamps(void* ptr, RustBuffer min, RustBuffer max, RustCallStatus *out_status
+);
+#endif
 #ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_CLONE_GOSIGNER
 #define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_CLONE_GOSIGNER
 void* uniffi_iroh_streamplace_fn_clone_gosigner(void* ptr, RustCallStatus *out_status
···
 RustBuffer uniffi_iroh_streamplace_fn_method_gosigner_sign(void* ptr, RustBuffer data, RustCallStatus *out_status
 );
 #endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_CLONE_NODE
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_CLONE_NODE
+void* uniffi_iroh_streamplace_fn_clone_node(void* ptr, RustCallStatus *out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_FREE_NODE
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_FREE_NODE
+void uniffi_iroh_streamplace_fn_free_node(void* ptr, RustCallStatus *out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_CONSTRUCTOR_NODE_FORWARDER
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_CONSTRUCTOR_NODE_FORWARDER
+uint64_t uniffi_iroh_streamplace_fn_constructor_node_forwarder(RustBuffer config
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_CONSTRUCTOR_NODE_RECEIVER
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_CONSTRUCTOR_NODE_RECEIVER
+uint64_t uniffi_iroh_streamplace_fn_constructor_node_receiver(RustBuffer config, void* handler
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_CONSTRUCTOR_NODE_SENDER
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_CONSTRUCTOR_NODE_SENDER
+uint64_t uniffi_iroh_streamplace_fn_constructor_node_sender(RustBuffer config
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_NODE_DB
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_NODE_DB
+void* uniffi_iroh_streamplace_fn_method_node_db(void* ptr, RustCallStatus *out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_NODE_JOIN_PEERS
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_NODE_JOIN_PEERS
+uint64_t uniffi_iroh_streamplace_fn_method_node_join_peers(void* ptr, RustBuffer peers
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_NODE_NODE_ID
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_NODE_NODE_ID
+uint64_t uniffi_iroh_streamplace_fn_method_node_node_id(void* ptr
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_NODE_NODE_SCOPE
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_NODE_NODE_SCOPE
+void* uniffi_iroh_streamplace_fn_method_node_node_scope(void* ptr, RustCallStatus *out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_NODE_SEND_SEGMENT
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_NODE_SEND_SEGMENT
+uint64_t uniffi_iroh_streamplace_fn_method_node_send_segment(void* ptr, RustBuffer key, RustBuffer data
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_NODE_SUBSCRIBE
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_NODE_SUBSCRIBE
+uint64_t uniffi_iroh_streamplace_fn_method_node_subscribe(void* ptr, RustBuffer key, void* remote_id
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_NODE_TICKET
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_NODE_TICKET
+uint64_t uniffi_iroh_streamplace_fn_method_node_ticket(void* ptr
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_NODE_UNSUBSCRIBE
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_NODE_UNSUBSCRIBE
+uint64_t uniffi_iroh_streamplace_fn_method_node_unsubscribe(void* ptr, RustBuffer key, void* remote_id
+);
+#endif
 #ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_CLONE_NODEADDR
 #define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_CLONE_NODEADDR
 void* uniffi_iroh_streamplace_fn_clone_nodeaddr(void* ptr, RustCallStatus *out_status
···
 void* uniffi_iroh_streamplace_fn_constructor_publickey_from_string(RustBuffer s, RustCallStatus *out_status
 );
 #endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_PUBLICKEY_AS_VEC
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_PUBLICKEY_AS_VEC
+RustBuffer uniffi_iroh_streamplace_fn_method_publickey_as_vec(void* ptr, RustCallStatus *out_status
+);
+#endif
 #ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_PUBLICKEY_EQUAL
 #define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_PUBLICKEY_EQUAL
 int8_t uniffi_iroh_streamplace_fn_method_publickey_equal(void* ptr, void* other, RustCallStatus *out_status
···
 RustBuffer uniffi_iroh_streamplace_fn_method_publickey_fmt_short(void* ptr, RustCallStatus *out_status
 );
 #endif
-#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_PUBLICKEY_TO_BYTES
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_PUBLICKEY_TO_BYTES
-RustBuffer uniffi_iroh_streamplace_fn_method_publickey_to_bytes(void* ptr, RustCallStatus *out_status
-);
-#endif
 #ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_PUBLICKEY_UNIFFI_TRAIT_DISPLAY
 #define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_PUBLICKEY_UNIFFI_TRAIT_DISPLAY
 RustBuffer uniffi_iroh_streamplace_fn_method_publickey_uniffi_trait_display(void* ptr, RustCallStatus *out_status
 );
 #endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_CLONE_PUBLICKEYOLD
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_CLONE_PUBLICKEYOLD
+void* uniffi_iroh_streamplace_fn_clone_publickeyold(void* ptr, RustCallStatus *out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_FREE_PUBLICKEYOLD
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_FREE_PUBLICKEYOLD
+void uniffi_iroh_streamplace_fn_free_publickeyold(void* ptr, RustCallStatus *out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_CONSTRUCTOR_PUBLICKEYOLD_FROM_BYTES
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_CONSTRUCTOR_PUBLICKEYOLD_FROM_BYTES
+void* uniffi_iroh_streamplace_fn_constructor_publickeyold_from_bytes(RustBuffer bytes, RustCallStatus *out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_CONSTRUCTOR_PUBLICKEYOLD_FROM_STRING
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_CONSTRUCTOR_PUBLICKEYOLD_FROM_STRING
+void* uniffi_iroh_streamplace_fn_constructor_publickeyold_from_string(RustBuffer s, RustCallStatus *out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_PUBLICKEYOLD_EQUAL
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_PUBLICKEYOLD_EQUAL
+int8_t uniffi_iroh_streamplace_fn_method_publickeyold_equal(void* ptr, void* other, RustCallStatus *out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_PUBLICKEYOLD_FMT_SHORT
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_PUBLICKEYOLD_FMT_SHORT
+RustBuffer uniffi_iroh_streamplace_fn_method_publickeyold_fmt_short(void* ptr, RustCallStatus *out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_PUBLICKEYOLD_TO_BYTES
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_PUBLICKEYOLD_TO_BYTES
+RustBuffer uniffi_iroh_streamplace_fn_method_publickeyold_to_bytes(void* ptr, RustCallStatus *out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_PUBLICKEYOLD_UNIFFI_TRAIT_DISPLAY
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_PUBLICKEYOLD_UNIFFI_TRAIT_DISPLAY
+RustBuffer uniffi_iroh_streamplace_fn_method_publickeyold_uniffi_trait_display(void* ptr, RustCallStatus *out_status
+);
+#endif
 #ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_CLONE_RECEIVER
 #define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_CLONE_RECEIVER
 void* uniffi_iroh_streamplace_fn_clone_receiver(void* ptr, RustCallStatus *out_status
···
 uint64_t uniffi_iroh_streamplace_fn_method_sender_send(void* ptr, RustBuffer key, RustBuffer data
 );
 #endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_CLONE_SUBSCRIBERESPONSE
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_CLONE_SUBSCRIBERESPONSE
+void* uniffi_iroh_streamplace_fn_clone_subscriberesponse(void* ptr, RustCallStatus *out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_FREE_SUBSCRIBERESPONSE
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_FREE_SUBSCRIBERESPONSE
+void uniffi_iroh_streamplace_fn_free_subscriberesponse(void* ptr, RustCallStatus *out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_SUBSCRIBERESPONSE_NEXT_RAW
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_SUBSCRIBERESPONSE_NEXT_RAW
+uint64_t uniffi_iroh_streamplace_fn_method_subscriberesponse_next_raw(void* ptr
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_SUBSCRIBERESPONSE_UNIFFI_TRAIT_DEBUG
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_SUBSCRIBERESPONSE_UNIFFI_TRAIT_DEBUG
+RustBuffer uniffi_iroh_streamplace_fn_method_subscriberesponse_uniffi_trait_debug(void* ptr, RustCallStatus *out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_CLONE_WRITESCOPE
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_CLONE_WRITESCOPE
+void* uniffi_iroh_streamplace_fn_clone_writescope(void* ptr, RustCallStatus *out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_FREE_WRITESCOPE
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_FREE_WRITESCOPE
+void uniffi_iroh_streamplace_fn_free_writescope(void* ptr, RustCallStatus *out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_WRITESCOPE_PUT
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_WRITESCOPE_PUT
+uint64_t uniffi_iroh_streamplace_fn_method_writescope_put(void* ptr, RustBuffer stream, RustBuffer key, RustBuffer value
+);
+#endif
 #ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_FUNC_GET_MANIFEST_AND_CERT
 #define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_FUNC_GET_MANIFEST_AND_CERT
 RustBuffer uniffi_iroh_streamplace_fn_func_get_manifest_and_cert(RustBuffer data, RustCallStatus *out_status
···
 #ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_FUNC_SIGN
 #define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_FUNC_SIGN
 RustBuffer uniffi_iroh_streamplace_fn_func_sign(RustBuffer manifest, RustBuffer data, RustBuffer certs, void* gosigner, RustCallStatus *out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_FUNC_SUBSCRIBE_ITEM_DEBUG
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_FUNC_SUBSCRIBE_ITEM_DEBUG
+RustBuffer uniffi_iroh_streamplace_fn_func_subscribe_item_debug(RustBuffer item, RustCallStatus *out_status
 );
 #endif
 #ifndef UNIFFI_FFIDEF_FFI_IROH_STREAMPLACE_RUSTBUFFER_ALLOC
···
     
 );
 #endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_FUNC_SUBSCRIBE_ITEM_DEBUG
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_FUNC_SUBSCRIBE_ITEM_DEBUG
+uint16_t uniffi_iroh_streamplace_checksum_func_subscribe_item_debug(void
+    
+);
+#endif
 #ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_DATAHANDLER_HANDLE_DATA
 #define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_DATAHANDLER_HANDLE_DATA
 uint16_t uniffi_iroh_streamplace_checksum_method_datahandler_handle_data(void
     
 );
 #endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_DATAHANDLEROLD_HANDLE_DATA
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_DATAHANDLEROLD_HANDLE_DATA
+uint16_t uniffi_iroh_streamplace_checksum_method_datahandlerold_handle_data(void
+    
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_DB_ITER_WITH_OPTS
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_DB_ITER_WITH_OPTS
+uint16_t uniffi_iroh_streamplace_checksum_method_db_iter_with_opts(void
+    
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_DB_SUBSCRIBE
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_DB_SUBSCRIBE
+uint16_t uniffi_iroh_streamplace_checksum_method_db_subscribe(void
+    
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_DB_SUBSCRIBE_WITH_OPTS
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_DB_SUBSCRIBE_WITH_OPTS
+uint16_t uniffi_iroh_streamplace_checksum_method_db_subscribe_with_opts(void
+    
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_DB_WRITE
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_DB_WRITE
+uint16_t uniffi_iroh_streamplace_checksum_method_db_write(void
+    
+);
+#endif
 #ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_ENDPOINT_NODE_ADDR
 #define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_ENDPOINT_NODE_ADDR
 uint16_t uniffi_iroh_streamplace_checksum_method_endpoint_node_addr(void
     
 );
 #endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_FILTER_GLOBAL
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_FILTER_GLOBAL
+uint16_t uniffi_iroh_streamplace_checksum_method_filter_global(void
+    
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_FILTER_SCOPE
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_FILTER_SCOPE
+uint16_t uniffi_iroh_streamplace_checksum_method_filter_scope(void
+    
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_FILTER_SCOPES
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_FILTER_SCOPES
+uint16_t uniffi_iroh_streamplace_checksum_method_filter_scopes(void
+    
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_FILTER_STREAM
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_FILTER_STREAM
+uint16_t uniffi_iroh_streamplace_checksum_method_filter_stream(void
+    
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_FILTER_TIME_FROM
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_FILTER_TIME_FROM
+uint16_t uniffi_iroh_streamplace_checksum_method_filter_time_from(void
+    
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_FILTER_TIME_RANGE
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_FILTER_TIME_RANGE
+uint16_t uniffi_iroh_streamplace_checksum_method_filter_time_range(void
+    
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_FILTER_TIMESTAMPS
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_FILTER_TIMESTAMPS
+uint16_t uniffi_iroh_streamplace_checksum_method_filter_timestamps(void
+    
+);
+#endif
 #ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_GOSIGNER_SIGN
 #define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_GOSIGNER_SIGN
 uint16_t uniffi_iroh_streamplace_checksum_method_gosigner_sign(void
     
 );
 #endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_NODE_DB
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_NODE_DB
+uint16_t uniffi_iroh_streamplace_checksum_method_node_db(void
+    
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_NODE_JOIN_PEERS
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_NODE_JOIN_PEERS
+uint16_t uniffi_iroh_streamplace_checksum_method_node_join_peers(void
+    
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_NODE_NODE_ID
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_NODE_NODE_ID
+uint16_t uniffi_iroh_streamplace_checksum_method_node_node_id(void
+    
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_NODE_NODE_SCOPE
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_NODE_NODE_SCOPE
+uint16_t uniffi_iroh_streamplace_checksum_method_node_node_scope(void
+    
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_NODE_SEND_SEGMENT
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_NODE_SEND_SEGMENT
+uint16_t uniffi_iroh_streamplace_checksum_method_node_send_segment(void
+    
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_NODE_SUBSCRIBE
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_NODE_SUBSCRIBE
+uint16_t uniffi_iroh_streamplace_checksum_method_node_subscribe(void
+    
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_NODE_TICKET
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_NODE_TICKET
+uint16_t uniffi_iroh_streamplace_checksum_method_node_ticket(void
+    
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_NODE_UNSUBSCRIBE
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_NODE_UNSUBSCRIBE
+uint16_t uniffi_iroh_streamplace_checksum_method_node_unsubscribe(void
+    
+);
+#endif
 #ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_NODEADDR_DIRECT_ADDRESSES
 #define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_NODEADDR_DIRECT_ADDRESSES
 uint16_t uniffi_iroh_streamplace_checksum_method_nodeaddr_direct_addresses(void
···
     
 );
 #endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_PUBLICKEY_AS_VEC
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_PUBLICKEY_AS_VEC
+uint16_t uniffi_iroh_streamplace_checksum_method_publickey_as_vec(void
+    
+);
+#endif
 #ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_PUBLICKEY_EQUAL
 #define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_PUBLICKEY_EQUAL
 uint16_t uniffi_iroh_streamplace_checksum_method_publickey_equal(void
···
     
 );
 #endif
-#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_PUBLICKEY_TO_BYTES
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_PUBLICKEY_TO_BYTES
-uint16_t uniffi_iroh_streamplace_checksum_method_publickey_to_bytes(void
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_PUBLICKEYOLD_EQUAL
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_PUBLICKEYOLD_EQUAL
+uint16_t uniffi_iroh_streamplace_checksum_method_publickeyold_equal(void
+    
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_PUBLICKEYOLD_FMT_SHORT
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_PUBLICKEYOLD_FMT_SHORT
+uint16_t uniffi_iroh_streamplace_checksum_method_publickeyold_fmt_short(void
+    
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_PUBLICKEYOLD_TO_BYTES
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_PUBLICKEYOLD_TO_BYTES
+uint16_t uniffi_iroh_streamplace_checksum_method_publickeyold_to_bytes(void
     
 );
 #endif
···
     
 );
 #endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_SUBSCRIBERESPONSE_NEXT_RAW
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_SUBSCRIBERESPONSE_NEXT_RAW
+uint16_t uniffi_iroh_streamplace_checksum_method_subscriberesponse_next_raw(void
+    
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_WRITESCOPE_PUT
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_WRITESCOPE_PUT
+uint16_t uniffi_iroh_streamplace_checksum_method_writescope_put(void
+    
+);
+#endif
 #ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_CONSTRUCTOR_ENDPOINT_NEW
 #define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_CONSTRUCTOR_ENDPOINT_NEW
 uint16_t uniffi_iroh_streamplace_checksum_constructor_endpoint_new(void
     
 );
 #endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_CONSTRUCTOR_FILTER_NEW
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_CONSTRUCTOR_FILTER_NEW
+uint16_t uniffi_iroh_streamplace_checksum_constructor_filter_new(void
+    
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_CONSTRUCTOR_NODE_FORWARDER
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_CONSTRUCTOR_NODE_FORWARDER
+uint16_t uniffi_iroh_streamplace_checksum_constructor_node_forwarder(void
+    
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_CONSTRUCTOR_NODE_RECEIVER
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_CONSTRUCTOR_NODE_RECEIVER
+uint16_t uniffi_iroh_streamplace_checksum_constructor_node_receiver(void
+    
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_CONSTRUCTOR_NODE_SENDER
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_CONSTRUCTOR_NODE_SENDER
+uint16_t uniffi_iroh_streamplace_checksum_constructor_node_sender(void
+    
+);
+#endif
 #ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_CONSTRUCTOR_NODEADDR_NEW
 #define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_CONSTRUCTOR_NODEADDR_NEW
 uint16_t uniffi_iroh_streamplace_checksum_constructor_nodeaddr_new(void
···
     
 );
 #endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_CONSTRUCTOR_PUBLICKEYOLD_FROM_BYTES
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_CONSTRUCTOR_PUBLICKEYOLD_FROM_BYTES
+uint16_t uniffi_iroh_streamplace_checksum_constructor_publickeyold_from_bytes(void
+    
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_CONSTRUCTOR_PUBLICKEYOLD_FROM_STRING
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_CONSTRUCTOR_PUBLICKEYOLD_FROM_STRING
+uint16_t uniffi_iroh_streamplace_checksum_constructor_publickeyold_from_string(void
+    
+);
+#endif
 #ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_CONSTRUCTOR_RECEIVER_NEW
 #define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_CONSTRUCTOR_RECEIVER_NEW
 uint16_t uniffi_iroh_streamplace_checksum_constructor_receiver_new(void
···
 
  void iroh_streamplace_cgo_dispatchCallbackInterfaceDataHandlerMethod0(uint64_t uniffi_handle, RustBuffer topic, RustBuffer data, UniffiForeignFutureCompleteVoid uniffi_future_callback, uint64_t uniffi_callback_data, UniffiForeignFuture* uniffi_out_return);
  void iroh_streamplace_cgo_dispatchCallbackInterfaceDataHandlerFree(uint64_t handle);
+ void iroh_streamplace_cgo_dispatchCallbackInterfaceDataHandlerOldMethod0(uint64_t uniffi_handle, RustBuffer topic, RustBuffer data, UniffiForeignFutureCompleteVoid uniffi_future_callback, uint64_t uniffi_callback_data, UniffiForeignFuture* uniffi_out_return);
+ void iroh_streamplace_cgo_dispatchCallbackInterfaceDataHandlerOldFree(uint64_t handle);
  void iroh_streamplace_cgo_dispatchCallbackInterfaceGoSignerMethod0(uint64_t uniffi_handle, RustBuffer data, RustBuffer* uniffi_out_return, RustCallStatus* callStatus );
  void iroh_streamplace_cgo_dispatchCallbackInterfaceGoSignerFree(uint64_t handle);
 

rust/iroh-streamplace/src/endpoint.rs

···
 use iroh::Watcher;
 
-use crate::{error::Error, utils::NodeAddr};
+use crate::{error::Error, node_addr::NodeAddr};
 
 #[derive(uniffi::Object, Debug, Clone)]
 pub struct Endpoint {

rust/iroh-streamplace/src/error.rs

···
 pub enum Error {
     #[snafu(display("Bind failure"), context(false))]
     IrohBind { source: iroh::endpoint::BindError },
-    #[snafu(display("Invalid URL"), context(false))]
-    InvalidUrl { source: url::ParseError },
     #[snafu(display("Failed to connect"), context(false))]
     IrohConnect {
         source: iroh::endpoint::ConnectError,
     },
-    #[snafu(display("Invalid network address"), context(false))]
-    InvalidNetworkAddress { source: std::net::AddrParseError },
-    #[snafu(display("No connection available"))]
     MissingConnection,
-    #[snafu(display("Invalid public key"))]
-    InvalidPublicKey,
     #[snafu(display("RPC error"), context(false))]
     Irpc { source: irpc::Error },
 }

rust/iroh-streamplace/src/key.rs

···
-use std::str::FromStr;
-
-use crate::error::{Error, InvalidPublicKeySnafu};
-
-/// A public key.
-///
-/// The key itself is just a 32 byte array, but a key has associated crypto
-/// information that is cached for performance reasons.
-#[derive(Debug, Clone, Eq, uniffi::Object)]
-#[uniffi::export(Display)]
-pub struct PublicKeyOld {
-    pub(crate) key: [u8; 32],
-}
-
-impl From<iroh::PublicKey> for PublicKeyOld {
-    fn from(key: iroh::PublicKey) -> Self {
-        PublicKeyOld {
-            key: *key.as_bytes(),
-        }
-    }
-}
-impl From<&PublicKeyOld> for iroh::PublicKey {
-    fn from(key: &PublicKeyOld) -> Self {
-        iroh::PublicKey::from_bytes(&key.key).unwrap()
-    }
-}
-
-#[uniffi::export]
-impl PublicKeyOld {
-    /// Returns true if the PublicKeys are equal
-    pub fn equal(&self, other: &PublicKeyOld) -> bool {
-        *self == *other
-    }
-
-    /// Express the PublicKey as a byte array
-    pub fn to_bytes(&self) -> Vec<u8> {
-        self.key.to_vec()
-    }
-
-    /// Make a PublicKey from base32 string
-    #[uniffi::constructor]
-    pub fn from_string(s: String) -> Result<Self, Error> {
-        let key = iroh::PublicKey::from_str(&s).map_err(|_| InvalidPublicKeySnafu.build())?;
-        Ok(key.into())
-    }
-
-    /// Make a PublicKey from byte array
-    #[uniffi::constructor]
-    pub fn from_bytes(bytes: Vec<u8>) -> Result<Self, Error> {
-        if bytes.len() != 32 {
-            InvalidPublicKeySnafu.fail()?;
-        }
-        let bytes: [u8; 32] = bytes.try_into().expect("checked above");
-        let key = iroh::PublicKey::from_bytes(&bytes).map_err(|_| InvalidPublicKeySnafu.build())?;
-        Ok(key.into())
-    }
-
-    /// Convert to a base32 string limited to the first 10 bytes for a friendly string
-    /// representation of the key.
-    pub fn fmt_short(&self) -> String {
-        iroh::PublicKey::from(self).fmt_short()
-    }
-}
-
-impl PartialEq for PublicKeyOld {
-    fn eq(&self, other: &PublicKeyOld) -> bool {
-        self.key == other.key
-    }
-}
-
-impl std::fmt::Display for PublicKeyOld {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        iroh::PublicKey::from(self).fmt(f)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_public_key() {
-        let key_str =
-            String::from("523c7996bad77424e96786cf7a7205115337a5b4565cd25506a0f297b191a5ea");
-        let fmt_str = String::from("523c7996ba");
-        let bytes = b"\x52\x3c\x79\x96\xba\xd7\x74\x24\xe9\x67\x86\xcf\x7a\x72\x05\x11\x53\x37\xa5\xb4\x56\x5c\xd2\x55\x06\xa0\xf2\x97\xb1\x91\xa5\xea";
-        //
-        // create key from string
-        let key = PublicKeyOld::from_string(key_str.clone()).unwrap();
-        //
-        // test methods are as expected
-        assert_eq!(key_str, key.to_string());
-        assert_eq!(bytes.to_vec(), key.to_bytes());
-        assert_eq!(fmt_str, key.fmt_short());
-        //
-        // create key from bytes
-        let key_0 = PublicKeyOld::from_bytes(bytes.to_vec()).unwrap();
-        //
-        // test methods are as expected
-        assert_eq!(key_str, key_0.to_string());
-        assert_eq!(bytes.to_vec(), key_0.to_bytes());
-        assert_eq!(fmt_str, key_0.fmt_short());
-        //
-        // test that the eq function works
-        assert!(key.equal(&key_0));
-        assert!(key_0.equal(&key));
-    }
-}

rust/iroh-streamplace/src/lib.rs

···
 pub mod c2pa;
 pub mod endpoint;
 pub mod error;
-pub mod key;
+pub mod public_key;
 pub mod node;
 pub mod receiver;
 pub mod sender;
-pub mod utils;
+pub mod node_addr;
 
 mod api;

rust/iroh-streamplace/src/node/db.rs

···
 use snafu::Snafu;
 use tokio::sync::Mutex;
 
+use crate::public_key::PublicKey;
+
 use super::db;
 
 // the files here are just copied from iroh-smol-kv-uniffi/src/code
 mod kv {
-    mod public_key;
-    pub use public_key::PublicKey;
     mod time_bound;
     pub use time_bound::TimeBound;
     mod subscribe_mode;
     pub use subscribe_mode::SubscribeMode;
 }
 use db::util::format_bytes;
-pub use kv::{PublicKey, SubscribeMode, TimeBound};
+pub use kv::{SubscribeMode, TimeBound};
 
 /// Error creating a new database node.
 #[derive(Debug, Snafu, uniffi::Error)]

rust/iroh-streamplace/src/node/streams.rs

···
     pub async fn subscribe(
         &self,
         key: String,
-        remote_id: Arc<super::PublicKey>,
+        remote_id: Arc<crate::public_key::PublicKey>,
     ) -> Result<(), PutError> {
         self.api
             .rpc(api::Subscribe {
···
     pub async fn unsubscribe(
         &self,
         key: String,
-        remote_id: Arc<super::PublicKey>,
+        remote_id: Arc<crate::public_key::PublicKey>,
     ) -> Result<(), PutError> {
         self.api
             .rpc(api::Unsubscribe {
···
     }
 
     /// Get this node's node ID.
-    pub async fn node_id(&self) -> Result<Arc<super::PublicKey>, PutError> {
+    pub async fn node_id(&self) -> Result<Arc<crate::public_key::PublicKey>, PutError> {
         let addr = self
             .api
             .rpc(api::GetNodeAddr)

rust/iroh-streamplace/src/node/tests.rs

···
 
 struct TestNode {
     node: Arc<Node>,
-    public: Arc<PublicKey>,
+    public: Arc<crate::public_key::PublicKey>,
     ticket: String,
     #[allow(dead_code)]
     private: Vec<u8>,

rust/iroh-streamplace/src/receiver.rs

···
 
 use iroh::protocol::Router;
 
-use crate::{api::Api, endpoint::Endpoint, error::Error, key::PublicKeyOld, utils::NodeAddr};
+use crate::{api::Api, endpoint::Endpoint, error::Error, public_key::PublicKey, node_addr::NodeAddr};
 
 #[derive(uniffi::Object)]
 pub struct Receiver {
···
 
     /// Subscribe to the given topic on the remote.
     #[uniffi::method(async_runtime = "tokio")]
-    pub async fn subscribe(&self, remote_id: Arc<PublicKeyOld>, topic: &str) -> Result<(), Error> {
+    pub async fn subscribe(&self, remote_id: Arc<PublicKey>, topic: &str) -> Result<(), Error> {
         let remote_id: iroh::NodeId = remote_id.as_ref().into();
         let api = Api::connect(self.endpoint.endpoint.clone(), remote_id);
         api.subscribe(topic.to_string(), self.endpoint.endpoint.node_id())
···
     #[uniffi::method(async_runtime = "tokio")]
     pub async fn unsubscribe(
         &self,
-        remote_id: Arc<PublicKeyOld>,
+        remote_id: Arc<PublicKey>,
         topic: &str,
     ) -> Result<(), Error> {
         let remote_id: iroh::NodeId = remote_id.as_ref().into();

rust/iroh-streamplace/src/sender.rs

···
 use bytes::Bytes;
 use iroh::protocol::Router;
 
-use crate::{api::Api, endpoint::Endpoint, error::Error, utils::NodeAddr};
+use crate::{api::Api, endpoint::Endpoint, error::Error, node_addr::NodeAddr};
 
 #[derive(uniffi::Object)]
 pub struct Sender {

rust/iroh-streamplace/src/utils.rs rust/iroh-streamplace/src/node_addr.rs

···
 use std::{str::FromStr, sync::Arc};
 
-use crate::{error::Error, key::PublicKeyOld};
+use crate::public_key::PublicKey;
 
 /// A peer and it's addressing information.
 #[derive(Debug, Clone, PartialEq, Eq, uniffi::Object)]
 pub struct NodeAddr {
-    node_id: Arc<PublicKeyOld>,
+    node_id: Arc<PublicKey>,
     relay_url: Option<String>,
     addresses: Vec<String>,
 }
···
 impl NodeAddr {
     /// Create a new [`NodeAddr`] with empty [`AddrInfo`].
     #[uniffi::constructor]
-    pub fn new(node_id: &PublicKeyOld, derp_url: Option<String>, addresses: Vec<String>) -> Self {
+    pub fn new(node_id: &PublicKey, derp_url: Option<String>, addresses: Vec<String>) -> Self {
         Self {
             node_id: Arc::new(node_id.clone()),
             relay_url: derp_url,
···
         }
     }
 
-    pub fn node_id(&self) -> PublicKeyOld {
+    pub fn node_id(&self) -> PublicKey {
         self.node_id.as_ref().clone()
     }
 
···
     }
 }
 
+/// Error when converting from ffi NodeAddr to iroh::NodeAddr
+#[derive(Debug, snafu::Snafu, uniffi::Error)]
+#[uniffi(flat_error)]
+#[snafu(visibility(pub(crate)))]
+pub enum NodeAddrError {
+    #[snafu(display("Invalid URL"), context(false))]
+    InvalidUrl { source: url::ParseError },
+    #[snafu(display("Invalid network address"), context(false))]
+    InvalidNetworkAddress { source: std::net::AddrParseError },
+}
+
+
 impl TryFrom<NodeAddr> for iroh::NodeAddr {
-    type Error = Error;
+    type Error = NodeAddrError;
 
     fn try_from(value: NodeAddr) -> Result<Self, Self::Error> {
         let mut node_addr = iroh::NodeAddr::new((&*value.node_id).into());
         let addresses = value
             .direct_addresses()
             .into_iter()
-            .map(|addr| std::net::SocketAddr::from_str(&addr).map_err(Error::from))
+            .map(|addr| std::net::SocketAddr::from_str(&addr))
             .collect::<Result<Vec<_>, _>>()?;
 
         if let Some(derp_url) = value.relay_url() {