Rip out everything but the "iroh websocket"

...and rename some things

pkg/iroh/generated/iroh_streamplace/iroh_streamplace.go

···
 import (
 	"bytes"
 	"encoding/binary"
-	"errors"
 	"fmt"
 	"io"
 	"math"
 	"runtime"
 	"runtime/cgo"
-	"sync"
 	"sync/atomic"
-	"time"
 	"unsafe"
 )
 
···
 
 func init() {
 
-	FfiConverterDataHandlerINSTANCE.register()
-	FfiConverterGoSignerINSTANCE.register()
-	FfiConverterManySegmentsToSignINSTANCE.register()
-	FfiConverterManyStreamsINSTANCE.register()
-	FfiConverterSegmentToSignINSTANCE.register()
-	FfiConverterStreamINSTANCE.register()
 	uniffiCheckChecksums()
 }
 
···
 	}
 	{
 		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
-			return C.uniffi_iroh_streamplace_checksum_func_get_manifest_and_cert()
-		})
-		if checksum != 36028 {
-			// If this happens try cleaning and rebuilding your project
-			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_func_get_manifest_and_cert: UniFFI API checksum mismatch")
-		}
-	}
-	{
-		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
-			return C.uniffi_iroh_streamplace_checksum_func_get_manifests()
-		})
-		if checksum != 2548 {
-			// If this happens try cleaning and rebuilding your project
-			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_func_get_manifests: UniFFI API checksum mismatch")
-		}
-	}
-	{
-		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
 			return C.uniffi_iroh_streamplace_checksum_func_init_logging()
 		})
 		if checksum != 40911 {
···
 	}
 	{
 		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
-			return C.uniffi_iroh_streamplace_checksum_func_resign()
-		})
-		if checksum != 34597 {
-			// If this happens try cleaning and rebuilding your project
-			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_func_resign: UniFFI API checksum mismatch")
-		}
-	}
-	{
-		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
-			return C.uniffi_iroh_streamplace_checksum_func_sign()
-		})
-		if checksum != 41179 {
-			// If this happens try cleaning and rebuilding your project
-			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_func_sign: UniFFI API checksum mismatch")
-		}
-	}
-	{
-		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
-			return C.uniffi_iroh_streamplace_checksum_func_sign_with_ingredients()
-		})
-		if checksum != 15411 {
-			// If this happens try cleaning and rebuilding your project
-			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_func_sign_with_ingredients: UniFFI API checksum mismatch")
-		}
-	}
-	{
-		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 != 48772 {
-			// If this happens try cleaning and rebuilding your project
-			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_datahandler_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_shutdown()
-		})
-		if checksum != 9825 {
-			// If this happens try cleaning and rebuilding your project
-			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_db_shutdown: 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_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 {
-			// If this happens try cleaning and rebuilding your project
-			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_gosigner_sign: UniFFI API checksum mismatch")
-		}
-	}
-	{
-		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
-			return C.uniffi_iroh_streamplace_checksum_method_manysegmentstosign_next()
-		})
-		if checksum != 53885 {
-			// If this happens try cleaning and rebuilding your project
-			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_manysegmentstosign_next: UniFFI API checksum mismatch")
-		}
-	}
-	{
-		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
-			return C.uniffi_iroh_streamplace_checksum_method_manystreams_next()
-		})
-		if checksum != 50757 {
-			// If this happens try cleaning and rebuilding your project
-			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_manystreams_next: UniFFI API checksum mismatch")
-		}
-	}
-	{
-		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
-			return C.uniffi_iroh_streamplace_checksum_method_node_add_tickets()
-		})
-		if checksum != 8701 {
-			// If this happens try cleaning and rebuilding your project
-			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_node_add_tickets: UniFFI API checksum mismatch")
-		}
-	}
-	{
-		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_shutdown()
-		})
-		if checksum != 18129 {
-			// If this happens try cleaning and rebuilding your project
-			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_node_shutdown: 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_segmenttosign_unsigned_seg_stream()
-		})
-		if checksum != 25252 {
-			// If this happens try cleaning and rebuilding your project
-			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_segmenttosign_unsigned_seg_stream: UniFFI API checksum mismatch")
-		}
-	}
-	{
-		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
-			return C.uniffi_iroh_streamplace_checksum_method_segmenttosign_manifest_id()
-		})
-		if checksum != 60736 {
-			// If this happens try cleaning and rebuilding your project
-			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_segmenttosign_manifest_id: UniFFI API checksum mismatch")
-		}
-	}
-	{
-		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
-			return C.uniffi_iroh_streamplace_checksum_method_segmenttosign_cert()
-		})
-		if checksum != 51060 {
-			// If this happens try cleaning and rebuilding your project
-			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_segmenttosign_cert: UniFFI API checksum mismatch")
-		}
-	}
-	{
-		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
-			return C.uniffi_iroh_streamplace_checksum_method_segmenttosign_output_seg_stream()
-		})
-		if checksum != 6113 {
-			// If this happens try cleaning and rebuilding your project
-			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_segmenttosign_output_seg_stream: UniFFI API checksum mismatch")
-		}
-	}
-	{
-		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
-			return C.uniffi_iroh_streamplace_checksum_method_segmenttosign_close()
-		})
-		if checksum != 39185 {
-			// If this happens try cleaning and rebuilding your project
-			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_segmenttosign_close: UniFFI API checksum mismatch")
-		}
-	}
-	{
-		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
 			return C.uniffi_iroh_streamplace_checksum_method_socket_accept()
 		})
-		if checksum != 12240 {
+		if checksum != 57029 {
 			// If this happens try cleaning and rebuilding your project
 			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_socket_accept: UniFFI API checksum mismatch")
 		}
···
 		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
 			return C.uniffi_iroh_streamplace_checksum_method_socket_close()
 		})
-		if checksum != 32603 {
+		if checksum != 61206 {
 			// If this happens try cleaning and rebuilding your project
 			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_socket_close: UniFFI API checksum mismatch")
 		}
···
 		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
 			return C.uniffi_iroh_streamplace_checksum_method_socket_connect()
 		})
-		if checksum != 63133 {
+		if checksum != 10698 {
 			// If this happens try cleaning and rebuilding your project
 			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_socket_connect: UniFFI API checksum mismatch")
 		}
···
 		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
 			return C.uniffi_iroh_streamplace_checksum_method_socket_online()
 		})
-		if checksum != 52016 {
+		if checksum != 7658 {
 			// If this happens try cleaning and rebuilding your project
 			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_socket_online: UniFFI API checksum mismatch")
 		}
···
 		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
 			return C.uniffi_iroh_streamplace_checksum_method_socket_ticket()
 		})
-		if checksum != 29083 {
+		if checksum != 43285 {
 			// If this happens try cleaning and rebuilding your project
 			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_socket_ticket: UniFFI API checksum mismatch")
 		}
 	}
 	{
 		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
-			return C.uniffi_iroh_streamplace_checksum_method_stream_read_stream()
+			return C.uniffi_iroh_streamplace_checksum_method_stream_close()
 		})
-		if checksum != 62815 {
+		if checksum != 42672 {
 			// If this happens try cleaning and rebuilding your project
-			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_stream_read_stream: UniFFI API checksum mismatch")
+			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_stream_close: UniFFI API checksum mismatch")
 		}
 	}
 	{
 		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
-			return C.uniffi_iroh_streamplace_checksum_method_stream_seek_stream()
+			return C.uniffi_iroh_streamplace_checksum_method_stream_close_read()
 		})
-		if checksum != 56397 {
+		if checksum != 37182 {
 			// If this happens try cleaning and rebuilding your project
-			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_stream_seek_stream: UniFFI API checksum mismatch")
+			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_stream_close_read: UniFFI API checksum mismatch")
 		}
 	}
 	{
 		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
-			return C.uniffi_iroh_streamplace_checksum_method_stream_write_stream()
+			return C.uniffi_iroh_streamplace_checksum_method_stream_close_write()
 		})
-		if checksum != 59847 {
+		if checksum != 3902 {
 			// If this happens try cleaning and rebuilding your project
-			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_stream_write_stream: UniFFI API checksum mismatch")
+			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_stream_close_write: UniFFI API checksum mismatch")
 		}
 	}
 	{
 		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
-			return C.uniffi_iroh_streamplace_checksum_method_stream2_close()
+			return C.uniffi_iroh_streamplace_checksum_method_stream_closed()
 		})
-		if checksum != 7588 {
+		if checksum != 29084 {
 			// If this happens try cleaning and rebuilding your project
-			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_stream2_close: UniFFI API checksum mismatch")
+			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_stream_closed: UniFFI API checksum mismatch")
 		}
 	}
 	{
 		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
-			return C.uniffi_iroh_streamplace_checksum_method_stream2_close_read()
+			return C.uniffi_iroh_streamplace_checksum_method_stream_read()
 		})
-		if checksum != 15135 {
+		if checksum != 28625 {
 			// If this happens try cleaning and rebuilding your project
-			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_stream2_close_read: UniFFI API checksum mismatch")
+			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_stream_read: UniFFI API checksum mismatch")
 		}
 	}
 	{
 		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
-			return C.uniffi_iroh_streamplace_checksum_method_stream2_close_write()
-		})
-		if checksum != 35288 {
-			// If this happens try cleaning and rebuilding your project
-			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_stream2_close_write: UniFFI API checksum mismatch")
-		}
-	}
-	{
-		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
-			return C.uniffi_iroh_streamplace_checksum_method_stream2_closed()
-		})
-		if checksum != 48312 {
-			// If this happens try cleaning and rebuilding your project
-			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_stream2_closed: UniFFI API checksum mismatch")
-		}
-	}
-	{
-		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
-			return C.uniffi_iroh_streamplace_checksum_method_stream2_read()
+			return C.uniffi_iroh_streamplace_checksum_method_stream_write()
 		})
-		if checksum != 55348 {
+		if checksum != 7829 {
 			// If this happens try cleaning and rebuilding your project
-			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_stream2_read: UniFFI API checksum mismatch")
+			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_stream_write: UniFFI API checksum mismatch")
 		}
 	}
 	{
 		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
-			return C.uniffi_iroh_streamplace_checksum_method_stream2_write()
+			return C.uniffi_iroh_streamplace_checksum_method_stream_write_all()
 		})
-		if checksum != 35047 {
+		if checksum != 28367 {
 			// If this happens try cleaning and rebuilding your project
-			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_stream2_write: UniFFI API checksum mismatch")
-		}
-	}
-	{
-		checksum := rustCall(func(_uniffiStatus *C.RustCallStatus) C.uint16_t {
-			return C.uniffi_iroh_streamplace_checksum_method_stream2_write_all()
-		})
-		if checksum != 29695 {
-			// If this happens try cleaning and rebuilding your project
-			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_stream2_write_all: 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_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")
+			panic("iroh_streamplace: uniffi_iroh_streamplace_checksum_method_stream_write_all: UniFFI API checksum mismatch")
 		}
 	}
 	{
···
 
 func (FfiDestroyerUint64) Destroy(_ uint64) {}
 
-type FfiConverterInt64 struct{}
-
-var FfiConverterInt64INSTANCE = FfiConverterInt64{}
-
-func (FfiConverterInt64) Lower(value int64) C.int64_t {
-	return C.int64_t(value)
-}
-
-func (FfiConverterInt64) Write(writer io.Writer, value int64) {
-	writeInt64(writer, value)
-}
-
-func (FfiConverterInt64) Lift(value C.int64_t) int64 {
-	return int64(value)
-}
-
-func (FfiConverterInt64) Read(reader io.Reader) int64 {
-	return readInt64(reader)
-}
-
-type FfiDestroyerInt64 struct{}
-
-func (FfiDestroyerInt64) Destroy(_ int64) {}
-
 type FfiConverterBool struct{}
 
 var FfiConverterBoolINSTANCE = FfiConverterBool{}
···
 
 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(from *PublicKey, topic string, data []byte)
-}
-
-// DataHandler trait that is exported to go for receiving data callbacks.
-type DataHandlerImpl struct {
-	ffiObject FfiObject
-}
-
-func (_self *DataHandlerImpl) HandleData(from *PublicKey, topic string, data []byte) {
-	_pointer := _self.ffiObject.incrementPointer("DataHandler")
-	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_datahandler_handle_data(
-			_pointer, FfiConverterPublicKeyINSTANCE.Lower(from), 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 *DataHandlerImpl) Destroy() {
-	runtime.SetFinalizer(object, nil)
-	object.ffiObject.destroy()
-}
-
-type FfiConverterDataHandler struct {
-	handleMap *concurrentHandleMap[DataHandler]
-}
-
-var FfiConverterDataHandlerINSTANCE = FfiConverterDataHandler{
-	handleMap: newConcurrentHandleMap[DataHandler](),
-}
-
-func (c FfiConverterDataHandler) Lift(pointer unsafe.Pointer) DataHandler {
-	result := &DataHandlerImpl{
-		newFfiObject(
-			pointer,
-			func(pointer unsafe.Pointer, status *C.RustCallStatus) unsafe.Pointer {
-				return C.uniffi_iroh_streamplace_fn_clone_datahandler(pointer, status)
-			},
-			func(pointer unsafe.Pointer, status *C.RustCallStatus) {
-				C.uniffi_iroh_streamplace_fn_free_datahandler(pointer, status)
-			},
-		),
-	}
-	runtime.SetFinalizer(result, (*DataHandlerImpl).Destroy)
-	return result
-}
-
-func (c FfiConverterDataHandler) Read(reader io.Reader) DataHandler {
-	return c.Lift(unsafe.Pointer(uintptr(readUint64(reader))))
-}
-
-func (c FfiConverterDataHandler) Lower(value DataHandler) 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 FfiConverterDataHandler) Write(writer io.Writer, value DataHandler) {
-	writeUint64(writer, uint64(uintptr(c.Lower(value))))
-}
-
-type FfiDestroyerDataHandler struct{}
-
-func (_ FfiDestroyerDataHandler) Destroy(value DataHandler) {
-	if val, ok := value.(*DataHandlerImpl); ok {
-		val.Destroy()
-	} else {
-		panic("Expected *DataHandlerImpl")
-	}
-}
-
-type uniffiCallbackResult C.int8_t
-
-const (
-	uniffiIdxCallbackFree               uniffiCallbackResult = 0
-	uniffiCallbackResultSuccess         uniffiCallbackResult = 0
-	uniffiCallbackResultError           uniffiCallbackResult = 1
-	uniffiCallbackUnexpectedResultError uniffiCallbackResult = 2
-	uniffiCallbackCancelled             uniffiCallbackResult = 3
-)
-
-type concurrentHandleMap[T any] struct {
-	handles       map[uint64]T
-	currentHandle uint64
-	lock          sync.RWMutex
-}
-
-func newConcurrentHandleMap[T any]() *concurrentHandleMap[T] {
-	return &concurrentHandleMap[T]{
-		handles: map[uint64]T{},
-	}
-}
-
-func (cm *concurrentHandleMap[T]) insert(obj T) uint64 {
-	cm.lock.Lock()
-	defer cm.lock.Unlock()
-
-	cm.currentHandle = cm.currentHandle + 1
-	cm.handles[cm.currentHandle] = obj
-	return cm.currentHandle
-}
-
-func (cm *concurrentHandleMap[T]) remove(handle uint64) {
-	cm.lock.Lock()
-	defer cm.lock.Unlock()
-
-	delete(cm.handles, handle)
-}
-
-func (cm *concurrentHandleMap[T]) tryGet(handle uint64) (T, bool) {
-	cm.lock.RLock()
-	defer cm.lock.RUnlock()
-
-	val, ok := cm.handles[handle]
-	return val, ok
-}
-
-//export iroh_streamplace_cgo_dispatchCallbackInterfaceDataHandlerMethod0
-func iroh_streamplace_cgo_dispatchCallbackInterfaceDataHandlerMethod0(uniffiHandle C.uint64_t, from unsafe.Pointer, topic C.RustBuffer, data C.RustBuffer, uniffiFutureCallback C.UniffiForeignFutureCompleteVoid, uniffiCallbackData C.uint64_t, uniffiOutReturn *C.UniffiForeignFuture) {
-	handle := uint64(uniffiHandle)
-	uniffiObj, ok := FfiConverterDataHandlerINSTANCE.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(
-			FfiConverterPublicKeyINSTANCE.Lift(from),
-			FfiConverterStringINSTANCE.Lift(GoRustBuffer{
-				inner: topic,
-			}),
-			FfiConverterBytesINSTANCE.Lift(GoRustBuffer{
-				inner: data,
-			}),
-		)
-
-	}()
-}
-
-var UniffiVTableCallbackInterfaceDataHandlerINSTANCE = C.UniffiVTableCallbackInterfaceDataHandler{
-	handleData: (C.UniffiCallbackInterfaceDataHandlerMethod0)(C.iroh_streamplace_cgo_dispatchCallbackInterfaceDataHandlerMethod0),
-
-	uniffiFree: (C.UniffiCallbackInterfaceFree)(C.iroh_streamplace_cgo_dispatchCallbackInterfaceDataHandlerFree),
-}
-
-//export iroh_streamplace_cgo_dispatchCallbackInterfaceDataHandlerFree
-func iroh_streamplace_cgo_dispatchCallbackInterfaceDataHandlerFree(handle C.uint64_t) {
-	FfiConverterDataHandlerINSTANCE.handleMap.remove(uint64(handle))
-}
-
-func (c FfiConverterDataHandler) register() {
-	C.uniffi_iroh_streamplace_fn_init_callback_vtable_datahandler(&UniffiVTableCallbackInterfaceDataHandlerINSTANCE)
-}
-
-// Iroh-streamplace specific metadata database.
-type DbInterface interface {
-	IterWithOpts(filter *Filter) ([]Entry, error)
-	// Shutdown the database client and all subscriptions.
-	Shutdown() 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)
-		},
-	)
-
-	if err == nil {
-		return res, nil
-	}
-
-	return res, err
-}
-
-// Shutdown the database client and all subscriptions.
-func (_self *Db) Shutdown() error {
-	_pointer := _self.ffiObject.incrementPointer("*Db")
-	defer _self.ffiObject.decrementPointer()
-	_, err := uniffiRustCallAsync[ShutdownError](
-		FfiConverterShutdownErrorINSTANCE,
-		// 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_db_shutdown(
-			_pointer),
-		// 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)
-		},
-	)
-
-	if err == nil {
-		return nil
-	}
-
-	return 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()
-}
-
-// 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, error)
-}
-type GoSignerImpl struct {
-	ffiObject FfiObject
-}
-
-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 {
-		return GoRustBuffer{
-			inner: C.uniffi_iroh_streamplace_fn_method_gosigner_sign(
-				_pointer, FfiConverterBytesINSTANCE.Lower(data), _uniffiStatus),
-		}
-	})
-	if _uniffiErr != nil {
-		var _uniffiDefaultValue []byte
-		return _uniffiDefaultValue, _uniffiErr
-	} else {
-		return FfiConverterBytesINSTANCE.Lift(_uniffiRV), nil
-	}
-}
-func (object *GoSignerImpl) Destroy() {
-	runtime.SetFinalizer(object, nil)
-	object.ffiObject.destroy()
-}
-
-type FfiConverterGoSigner struct {
-	handleMap *concurrentHandleMap[GoSigner]
-}
-
-var FfiConverterGoSignerINSTANCE = FfiConverterGoSigner{
-	handleMap: newConcurrentHandleMap[GoSigner](),
-}
-
-func (c FfiConverterGoSigner) Lift(pointer unsafe.Pointer) GoSigner {
-	result := &GoSignerImpl{
-		newFfiObject(
-			pointer,
-			func(pointer unsafe.Pointer, status *C.RustCallStatus) unsafe.Pointer {
-				return C.uniffi_iroh_streamplace_fn_clone_gosigner(pointer, status)
-			},
-			func(pointer unsafe.Pointer, status *C.RustCallStatus) {
-				C.uniffi_iroh_streamplace_fn_free_gosigner(pointer, status)
-			},
-		),
-	}
-	runtime.SetFinalizer(result, (*GoSignerImpl).Destroy)
-	return result
-}
-
-func (c FfiConverterGoSigner) Read(reader io.Reader) GoSigner {
-	return c.Lift(unsafe.Pointer(uintptr(readUint64(reader))))
-}
-
-func (c FfiConverterGoSigner) Lower(value GoSigner) 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 FfiConverterGoSigner) Write(writer io.Writer, value GoSigner) {
-	writeUint64(writer, uint64(uintptr(c.Lower(value))))
-}
-
-type FfiDestroyerGoSigner struct{}
-
-func (_ FfiDestroyerGoSigner) Destroy(value GoSigner) {
-	if val, ok := value.(*GoSignerImpl); ok {
-		val.Destroy()
-	} else {
-		panic("Expected *GoSignerImpl")
-	}
-}
-
-//export iroh_streamplace_cgo_dispatchCallbackInterfaceGoSignerMethod0
-func iroh_streamplace_cgo_dispatchCallbackInterfaceGoSignerMethod0(uniffiHandle C.uint64_t, data C.RustBuffer, uniffiOutReturn *C.RustBuffer, callStatus *C.RustCallStatus) {
-	handle := uint64(uniffiHandle)
-	uniffiObj, ok := FfiConverterGoSignerINSTANCE.handleMap.tryGet(handle)
-	if !ok {
-		panic(fmt.Errorf("no callback in handle map: %d", handle))
-	}
-
-	res, err :=
-		uniffiObj.Sign(
-			FfiConverterBytesINSTANCE.Lift(GoRustBuffer{
-				inner: data,
-			}),
-		)
-
-	if 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
-	}
-
-	*uniffiOutReturn = FfiConverterBytesINSTANCE.Lower(res)
-}
-
-var UniffiVTableCallbackInterfaceGoSignerINSTANCE = C.UniffiVTableCallbackInterfaceGoSigner{
-	sign: (C.UniffiCallbackInterfaceGoSignerMethod0)(C.iroh_streamplace_cgo_dispatchCallbackInterfaceGoSignerMethod0),
-
-	uniffiFree: (C.UniffiCallbackInterfaceFree)(C.iroh_streamplace_cgo_dispatchCallbackInterfaceGoSignerFree),
-}
-
-//export iroh_streamplace_cgo_dispatchCallbackInterfaceGoSignerFree
-func iroh_streamplace_cgo_dispatchCallbackInterfaceGoSignerFree(handle C.uint64_t) {
-	FfiConverterGoSignerINSTANCE.handleMap.remove(uint64(handle))
-}
-
-func (c FfiConverterGoSigner) register() {
-	C.uniffi_iroh_streamplace_fn_init_callback_vtable_gosigner(&UniffiVTableCallbackInterfaceGoSignerINSTANCE)
-}
-
-type ManySegmentsToSign interface {
-	Next() *SegmentToSign
-}
-type ManySegmentsToSignImpl struct {
-	ffiObject FfiObject
-}
-
-func (_self *ManySegmentsToSignImpl) Next() *SegmentToSign {
-	_pointer := _self.ffiObject.incrementPointer("ManySegmentsToSign")
-	defer _self.ffiObject.decrementPointer()
-	return FfiConverterOptionalSegmentToSignINSTANCE.Lift(rustCall(func(_uniffiStatus *C.RustCallStatus) RustBufferI {
-		return GoRustBuffer{
-			inner: C.uniffi_iroh_streamplace_fn_method_manysegmentstosign_next(
-				_pointer, _uniffiStatus),
-		}
-	}))
-}
-func (object *ManySegmentsToSignImpl) Destroy() {
-	runtime.SetFinalizer(object, nil)
-	object.ffiObject.destroy()
-}
-
-type FfiConverterManySegmentsToSign struct {
-	handleMap *concurrentHandleMap[ManySegmentsToSign]
-}
-
-var FfiConverterManySegmentsToSignINSTANCE = FfiConverterManySegmentsToSign{
-	handleMap: newConcurrentHandleMap[ManySegmentsToSign](),
-}
-
-func (c FfiConverterManySegmentsToSign) Lift(pointer unsafe.Pointer) ManySegmentsToSign {
-	result := &ManySegmentsToSignImpl{
-		newFfiObject(
-			pointer,
-			func(pointer unsafe.Pointer, status *C.RustCallStatus) unsafe.Pointer {
-				return C.uniffi_iroh_streamplace_fn_clone_manysegmentstosign(pointer, status)
-			},
-			func(pointer unsafe.Pointer, status *C.RustCallStatus) {
-				C.uniffi_iroh_streamplace_fn_free_manysegmentstosign(pointer, status)
-			},
-		),
-	}
-	runtime.SetFinalizer(result, (*ManySegmentsToSignImpl).Destroy)
-	return result
-}
-
-func (c FfiConverterManySegmentsToSign) Read(reader io.Reader) ManySegmentsToSign {
-	return c.Lift(unsafe.Pointer(uintptr(readUint64(reader))))
-}
-
-func (c FfiConverterManySegmentsToSign) Lower(value ManySegmentsToSign) 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 FfiConverterManySegmentsToSign) Write(writer io.Writer, value ManySegmentsToSign) {
-	writeUint64(writer, uint64(uintptr(c.Lower(value))))
-}
-
-type FfiDestroyerManySegmentsToSign struct{}
-
-func (_ FfiDestroyerManySegmentsToSign) Destroy(value ManySegmentsToSign) {
-	if val, ok := value.(*ManySegmentsToSignImpl); ok {
-		val.Destroy()
-	} else {
-		panic("Expected *ManySegmentsToSignImpl")
-	}
-}
-
-//export iroh_streamplace_cgo_dispatchCallbackInterfaceManySegmentsToSignMethod0
-func iroh_streamplace_cgo_dispatchCallbackInterfaceManySegmentsToSignMethod0(uniffiHandle C.uint64_t, uniffiOutReturn *C.RustBuffer, callStatus *C.RustCallStatus) {
-	handle := uint64(uniffiHandle)
-	uniffiObj, ok := FfiConverterManySegmentsToSignINSTANCE.handleMap.tryGet(handle)
-	if !ok {
-		panic(fmt.Errorf("no callback in handle map: %d", handle))
-	}
-
-	res :=
-		uniffiObj.Next()
-
-	*uniffiOutReturn = FfiConverterOptionalSegmentToSignINSTANCE.Lower(res)
-}
-
-var UniffiVTableCallbackInterfaceManySegmentsToSignINSTANCE = C.UniffiVTableCallbackInterfaceManySegmentsToSign{
-	next: (C.UniffiCallbackInterfaceManySegmentsToSignMethod0)(C.iroh_streamplace_cgo_dispatchCallbackInterfaceManySegmentsToSignMethod0),
-
-	uniffiFree: (C.UniffiCallbackInterfaceFree)(C.iroh_streamplace_cgo_dispatchCallbackInterfaceManySegmentsToSignFree),
-}
-
-//export iroh_streamplace_cgo_dispatchCallbackInterfaceManySegmentsToSignFree
-func iroh_streamplace_cgo_dispatchCallbackInterfaceManySegmentsToSignFree(handle C.uint64_t) {
-	FfiConverterManySegmentsToSignINSTANCE.handleMap.remove(uint64(handle))
-}
-
-func (c FfiConverterManySegmentsToSign) register() {
-	C.uniffi_iroh_streamplace_fn_init_callback_vtable_manysegmentstosign(&UniffiVTableCallbackInterfaceManySegmentsToSignINSTANCE)
-}
-
-type ManyStreams interface {
-	// Get the next stream from the many streams
-	Next() *Stream
-}
-type ManyStreamsImpl struct {
-	ffiObject FfiObject
-}
-
-// Get the next stream from the many streams
-func (_self *ManyStreamsImpl) Next() *Stream {
-	_pointer := _self.ffiObject.incrementPointer("ManyStreams")
-	defer _self.ffiObject.decrementPointer()
-	return FfiConverterOptionalStreamINSTANCE.Lift(rustCall(func(_uniffiStatus *C.RustCallStatus) RustBufferI {
-		return GoRustBuffer{
-			inner: C.uniffi_iroh_streamplace_fn_method_manystreams_next(
-				_pointer, _uniffiStatus),
-		}
-	}))
-}
-func (object *ManyStreamsImpl) Destroy() {
-	runtime.SetFinalizer(object, nil)
-	object.ffiObject.destroy()
-}
-
-type FfiConverterManyStreams struct {
-	handleMap *concurrentHandleMap[ManyStreams]
-}
-
-var FfiConverterManyStreamsINSTANCE = FfiConverterManyStreams{
-	handleMap: newConcurrentHandleMap[ManyStreams](),
-}
-
-func (c FfiConverterManyStreams) Lift(pointer unsafe.Pointer) ManyStreams {
-	result := &ManyStreamsImpl{
-		newFfiObject(
-			pointer,
-			func(pointer unsafe.Pointer, status *C.RustCallStatus) unsafe.Pointer {
-				return C.uniffi_iroh_streamplace_fn_clone_manystreams(pointer, status)
-			},
-			func(pointer unsafe.Pointer, status *C.RustCallStatus) {
-				C.uniffi_iroh_streamplace_fn_free_manystreams(pointer, status)
-			},
-		),
-	}
-	runtime.SetFinalizer(result, (*ManyStreamsImpl).Destroy)
-	return result
-}
-
-func (c FfiConverterManyStreams) Read(reader io.Reader) ManyStreams {
-	return c.Lift(unsafe.Pointer(uintptr(readUint64(reader))))
-}
-
-func (c FfiConverterManyStreams) Lower(value ManyStreams) 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 FfiConverterManyStreams) Write(writer io.Writer, value ManyStreams) {
-	writeUint64(writer, uint64(uintptr(c.Lower(value))))
-}
-
-type FfiDestroyerManyStreams struct{}
-
-func (_ FfiDestroyerManyStreams) Destroy(value ManyStreams) {
-	if val, ok := value.(*ManyStreamsImpl); ok {
-		val.Destroy()
-	} else {
-		panic("Expected *ManyStreamsImpl")
-	}
-}
-
-//export iroh_streamplace_cgo_dispatchCallbackInterfaceManyStreamsMethod0
-func iroh_streamplace_cgo_dispatchCallbackInterfaceManyStreamsMethod0(uniffiHandle C.uint64_t, uniffiOutReturn *C.RustBuffer, callStatus *C.RustCallStatus) {
-	handle := uint64(uniffiHandle)
-	uniffiObj, ok := FfiConverterManyStreamsINSTANCE.handleMap.tryGet(handle)
-	if !ok {
-		panic(fmt.Errorf("no callback in handle map: %d", handle))
-	}
-
-	res :=
-		uniffiObj.Next()
-
-	*uniffiOutReturn = FfiConverterOptionalStreamINSTANCE.Lower(res)
-}
-
-var UniffiVTableCallbackInterfaceManyStreamsINSTANCE = C.UniffiVTableCallbackInterfaceManyStreams{
-	next: (C.UniffiCallbackInterfaceManyStreamsMethod0)(C.iroh_streamplace_cgo_dispatchCallbackInterfaceManyStreamsMethod0),
-
-	uniffiFree: (C.UniffiCallbackInterfaceFree)(C.iroh_streamplace_cgo_dispatchCallbackInterfaceManyStreamsFree),
-}
-
-//export iroh_streamplace_cgo_dispatchCallbackInterfaceManyStreamsFree
-func iroh_streamplace_cgo_dispatchCallbackInterfaceManyStreamsFree(handle C.uint64_t) {
-	FfiConverterManyStreamsINSTANCE.handleMap.remove(uint64(handle))
-}
-
-func (c FfiConverterManyStreams) register() {
-	C.uniffi_iroh_streamplace_fn_init_callback_vtable_manystreams(&UniffiVTableCallbackInterfaceManyStreamsINSTANCE)
-}
-
-// Iroh-streamplace node that can send, forward or receive stream segments.
-type NodeInterface interface {
-	// Add tickets for remote peers
-	AddTickets(peers []string) error
-	// 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
-	// Shutdown the node, including the streaming system and the metadata db.
-	Shutdown() 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)
-		},
-	)
-
-	if err == nil {
-		return res, nil
-	}
-
-	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)
-		},
-	)
-
-	if err == nil {
-		return res, nil
-	}
-
-	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)
-		},
-	)
-
-	if err == nil {
-		return res, nil
-	}
-
-	return res, err
-}
-
-// Add tickets for remote peers
-func (_self *Node) AddTickets(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_add_tickets(
-			_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)
-		},
-	)
-
-	if err == nil {
-		return nil
-	}
-
-	return 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)
-		},
-	)
-
-	if err == nil {
-		return nil
-	}
-
-	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)
-		},
-	)
-
-	if err == nil {
-		return res, nil
-	}
-
-	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)
-		},
-	)
-
-	if err == nil {
-		return nil
-	}
-
-	return err
-}
-
-// Shutdown the node, including the streaming system and the metadata db.
-func (_self *Node) Shutdown() error {
-	_pointer := _self.ffiObject.incrementPointer("*Node")
-	defer _self.ffiObject.decrementPointer()
-	_, err := uniffiRustCallAsync[ShutdownError](
-		FfiConverterShutdownErrorINSTANCE,
-		// 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_shutdown(
-			_pointer),
-		// 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)
-		},
-	)
-
-	if err == nil {
-		return nil
-	}
-
-	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)
-		},
-	)
-
-	if err == nil {
-		return nil
-	}
-
-	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)
-		},
-	)
-
-	if err == nil {
-		return res, nil
-	}
-
-	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)
-		},
-	)
-
-	if err == nil {
-		return nil
-	}
-
-	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.
···
 	value.Destroy()
 }
 
-type SegmentToSign interface {
-	UnsignedSegStream() Stream
-	ManifestId() string
-	Cert() []byte
-	OutputSegStream() Stream
-	Close()
-}
-type SegmentToSignImpl struct {
-	ffiObject FfiObject
-}
-
-func (_self *SegmentToSignImpl) UnsignedSegStream() Stream {
-	_pointer := _self.ffiObject.incrementPointer("SegmentToSign")
-	defer _self.ffiObject.decrementPointer()
-	return FfiConverterStreamINSTANCE.Lift(rustCall(func(_uniffiStatus *C.RustCallStatus) unsafe.Pointer {
-		return C.uniffi_iroh_streamplace_fn_method_segmenttosign_unsigned_seg_stream(
-			_pointer, _uniffiStatus)
-	}))
-}
-
-func (_self *SegmentToSignImpl) ManifestId() string {
-	_pointer := _self.ffiObject.incrementPointer("SegmentToSign")
-	defer _self.ffiObject.decrementPointer()
-	return FfiConverterStringINSTANCE.Lift(rustCall(func(_uniffiStatus *C.RustCallStatus) RustBufferI {
-		return GoRustBuffer{
-			inner: C.uniffi_iroh_streamplace_fn_method_segmenttosign_manifest_id(
-				_pointer, _uniffiStatus),
-		}
-	}))
-}
-
-func (_self *SegmentToSignImpl) Cert() []byte {
-	_pointer := _self.ffiObject.incrementPointer("SegmentToSign")
-	defer _self.ffiObject.decrementPointer()
-	return FfiConverterBytesINSTANCE.Lift(rustCall(func(_uniffiStatus *C.RustCallStatus) RustBufferI {
-		return GoRustBuffer{
-			inner: C.uniffi_iroh_streamplace_fn_method_segmenttosign_cert(
-				_pointer, _uniffiStatus),
-		}
-	}))
-}
-
-func (_self *SegmentToSignImpl) OutputSegStream() Stream {
-	_pointer := _self.ffiObject.incrementPointer("SegmentToSign")
-	defer _self.ffiObject.decrementPointer()
-	return FfiConverterStreamINSTANCE.Lift(rustCall(func(_uniffiStatus *C.RustCallStatus) unsafe.Pointer {
-		return C.uniffi_iroh_streamplace_fn_method_segmenttosign_output_seg_stream(
-			_pointer, _uniffiStatus)
-	}))
-}
-
-func (_self *SegmentToSignImpl) Close() {
-	_pointer := _self.ffiObject.incrementPointer("SegmentToSign")
-	defer _self.ffiObject.decrementPointer()
-	rustCall(func(_uniffiStatus *C.RustCallStatus) bool {
-		C.uniffi_iroh_streamplace_fn_method_segmenttosign_close(
-			_pointer, _uniffiStatus)
-		return false
-	})
-}
-func (object *SegmentToSignImpl) Destroy() {
-	runtime.SetFinalizer(object, nil)
-	object.ffiObject.destroy()
-}
-
-type FfiConverterSegmentToSign struct {
-	handleMap *concurrentHandleMap[SegmentToSign]
-}
-
-var FfiConverterSegmentToSignINSTANCE = FfiConverterSegmentToSign{
-	handleMap: newConcurrentHandleMap[SegmentToSign](),
-}
-
-func (c FfiConverterSegmentToSign) Lift(pointer unsafe.Pointer) SegmentToSign {
-	result := &SegmentToSignImpl{
-		newFfiObject(
-			pointer,
-			func(pointer unsafe.Pointer, status *C.RustCallStatus) unsafe.Pointer {
-				return C.uniffi_iroh_streamplace_fn_clone_segmenttosign(pointer, status)
-			},
-			func(pointer unsafe.Pointer, status *C.RustCallStatus) {
-				C.uniffi_iroh_streamplace_fn_free_segmenttosign(pointer, status)
-			},
-		),
-	}
-	runtime.SetFinalizer(result, (*SegmentToSignImpl).Destroy)
-	return result
-}
-
-func (c FfiConverterSegmentToSign) Read(reader io.Reader) SegmentToSign {
-	return c.Lift(unsafe.Pointer(uintptr(readUint64(reader))))
-}
-
-func (c FfiConverterSegmentToSign) Lower(value SegmentToSign) 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 FfiConverterSegmentToSign) Write(writer io.Writer, value SegmentToSign) {
-	writeUint64(writer, uint64(uintptr(c.Lower(value))))
-}
-
-type FfiDestroyerSegmentToSign struct{}
-
-func (_ FfiDestroyerSegmentToSign) Destroy(value SegmentToSign) {
-	if val, ok := value.(*SegmentToSignImpl); ok {
-		val.Destroy()
-	} else {
-		panic("Expected *SegmentToSignImpl")
-	}
-}
-
-//export iroh_streamplace_cgo_dispatchCallbackInterfaceSegmentToSignMethod0
-func iroh_streamplace_cgo_dispatchCallbackInterfaceSegmentToSignMethod0(uniffiHandle C.uint64_t, uniffiOutReturn *unsafe.Pointer, callStatus *C.RustCallStatus) {
-	handle := uint64(uniffiHandle)
-	uniffiObj, ok := FfiConverterSegmentToSignINSTANCE.handleMap.tryGet(handle)
-	if !ok {
-		panic(fmt.Errorf("no callback in handle map: %d", handle))
-	}
-
-	res :=
-		uniffiObj.UnsignedSegStream()
-
-	*uniffiOutReturn = FfiConverterStreamINSTANCE.Lower(res)
-}
-
-//export iroh_streamplace_cgo_dispatchCallbackInterfaceSegmentToSignMethod1
-func iroh_streamplace_cgo_dispatchCallbackInterfaceSegmentToSignMethod1(uniffiHandle C.uint64_t, uniffiOutReturn *C.RustBuffer, callStatus *C.RustCallStatus) {
-	handle := uint64(uniffiHandle)
-	uniffiObj, ok := FfiConverterSegmentToSignINSTANCE.handleMap.tryGet(handle)
-	if !ok {
-		panic(fmt.Errorf("no callback in handle map: %d", handle))
-	}
-
-	res :=
-		uniffiObj.ManifestId()
-
-	*uniffiOutReturn = FfiConverterStringINSTANCE.Lower(res)
-}
-
-//export iroh_streamplace_cgo_dispatchCallbackInterfaceSegmentToSignMethod2
-func iroh_streamplace_cgo_dispatchCallbackInterfaceSegmentToSignMethod2(uniffiHandle C.uint64_t, uniffiOutReturn *C.RustBuffer, callStatus *C.RustCallStatus) {
-	handle := uint64(uniffiHandle)
-	uniffiObj, ok := FfiConverterSegmentToSignINSTANCE.handleMap.tryGet(handle)
-	if !ok {
-		panic(fmt.Errorf("no callback in handle map: %d", handle))
-	}
-
-	res :=
-		uniffiObj.Cert()
-
-	*uniffiOutReturn = FfiConverterBytesINSTANCE.Lower(res)
-}
-
-//export iroh_streamplace_cgo_dispatchCallbackInterfaceSegmentToSignMethod3
-func iroh_streamplace_cgo_dispatchCallbackInterfaceSegmentToSignMethod3(uniffiHandle C.uint64_t, uniffiOutReturn *unsafe.Pointer, callStatus *C.RustCallStatus) {
-	handle := uint64(uniffiHandle)
-	uniffiObj, ok := FfiConverterSegmentToSignINSTANCE.handleMap.tryGet(handle)
-	if !ok {
-		panic(fmt.Errorf("no callback in handle map: %d", handle))
-	}
-
-	res :=
-		uniffiObj.OutputSegStream()
-
-	*uniffiOutReturn = FfiConverterStreamINSTANCE.Lower(res)
-}
-
-//export iroh_streamplace_cgo_dispatchCallbackInterfaceSegmentToSignMethod4
-func iroh_streamplace_cgo_dispatchCallbackInterfaceSegmentToSignMethod4(uniffiHandle C.uint64_t, uniffiOutReturn *C.void, callStatus *C.RustCallStatus) {
-	handle := uint64(uniffiHandle)
-	uniffiObj, ok := FfiConverterSegmentToSignINSTANCE.handleMap.tryGet(handle)
-	if !ok {
-		panic(fmt.Errorf("no callback in handle map: %d", handle))
-	}
-
-	uniffiObj.Close()
-
-}
-
-var UniffiVTableCallbackInterfaceSegmentToSignINSTANCE = C.UniffiVTableCallbackInterfaceSegmentToSign{
-	unsignedSegStream: (C.UniffiCallbackInterfaceSegmentToSignMethod0)(C.iroh_streamplace_cgo_dispatchCallbackInterfaceSegmentToSignMethod0),
-	manifestId:        (C.UniffiCallbackInterfaceSegmentToSignMethod1)(C.iroh_streamplace_cgo_dispatchCallbackInterfaceSegmentToSignMethod1),
-	cert:              (C.UniffiCallbackInterfaceSegmentToSignMethod2)(C.iroh_streamplace_cgo_dispatchCallbackInterfaceSegmentToSignMethod2),
-	outputSegStream:   (C.UniffiCallbackInterfaceSegmentToSignMethod3)(C.iroh_streamplace_cgo_dispatchCallbackInterfaceSegmentToSignMethod3),
-	close:             (C.UniffiCallbackInterfaceSegmentToSignMethod4)(C.iroh_streamplace_cgo_dispatchCallbackInterfaceSegmentToSignMethod4),
-
-	uniffiFree: (C.UniffiCallbackInterfaceFree)(C.iroh_streamplace_cgo_dispatchCallbackInterfaceSegmentToSignFree),
-}
-
-//export iroh_streamplace_cgo_dispatchCallbackInterfaceSegmentToSignFree
-func iroh_streamplace_cgo_dispatchCallbackInterfaceSegmentToSignFree(handle C.uint64_t) {
-	FfiConverterSegmentToSignINSTANCE.handleMap.remove(uint64(handle))
-}
-
-func (c FfiConverterSegmentToSign) register() {
-	C.uniffi_iroh_streamplace_fn_init_callback_vtable_segmenttosign(&UniffiVTableCallbackInterfaceSegmentToSignINSTANCE)
-}
-
 // A wrapper for an iroh endpoint that works basically as a socket for streams.
 type SocketInterface interface {
-	// Accept an incoming connection and return a [`Stream2`].
-	Accept() (*Stream2, error)
+	// Accept an incoming connection and return a [`Stream`].
+	Accept() (*Stream, error)
 	// Get the ALPN for this socket.
 	Alpn() []byte
+	// Close the socket.
 	Close()
-	// Connect to a peer at the given [`NodeAddr`] and return a [`Stream2`].
-	Connect(addr *NodeAddr) (*Stream2, error)
+	// Connect to a peer at the given [`NodeAddr`] and return a [`Stream`].
+	Connect(addr *NodeAddr) (*Stream, error)
+	// Wait until the socket is online.
 	Online()
+	// Get the ticket for this socket.
 	Ticket() string
 }
 
···
 	return res, err
 }
 
-// Accept an incoming connection and return a [`Stream2`].
-func (_self *Socket) Accept() (*Stream2, error) {
+// Accept an incoming connection and return a [`Stream`].
+func (_self *Socket) Accept() (*Stream, error) {
 	_pointer := _self.ffiObject.incrementPointer("*Socket")
 	defer _self.ffiObject.decrementPointer()
 	res, err := uniffiRustCallAsync[AcceptError](
···
 			return res
 		},
 		// liftFn
-		func(ffi unsafe.Pointer) *Stream2 {
-			return FfiConverterStream2INSTANCE.Lift(ffi)
+		func(ffi unsafe.Pointer) *Stream {
+			return FfiConverterStreamINSTANCE.Lift(ffi)
 		},
 		C.uniffi_iroh_streamplace_fn_method_socket_accept(
 			_pointer),
···
 	}))
 }
 
+// Close the socket.
 func (_self *Socket) Close() {
 	_pointer := _self.ffiObject.incrementPointer("*Socket")
 	defer _self.ffiObject.decrementPointer()
···
 
 }
 
-// Connect to a peer at the given [`NodeAddr`] and return a [`Stream2`].
-func (_self *Socket) Connect(addr *NodeAddr) (*Stream2, error) {
+// Connect to a peer at the given [`NodeAddr`] and return a [`Stream`].
+func (_self *Socket) Connect(addr *NodeAddr) (*Stream, error) {
 	_pointer := _self.ffiObject.incrementPointer("*Socket")
 	defer _self.ffiObject.decrementPointer()
 	res, err := uniffiRustCallAsync[ConnectError](
···
 			return res
 		},
 		// liftFn
-		func(ffi unsafe.Pointer) *Stream2 {
-			return FfiConverterStream2INSTANCE.Lift(ffi)
+		func(ffi unsafe.Pointer) *Stream {
+			return FfiConverterStreamINSTANCE.Lift(ffi)
 		},
 		C.uniffi_iroh_streamplace_fn_method_socket_connect(
 			_pointer, FfiConverterNodeAddrINSTANCE.Lower(addr)),
···
 	return res, err
 }
 
+// Wait until the socket is online.
 func (_self *Socket) Online() {
 	_pointer := _self.ffiObject.incrementPointer("*Socket")
 	defer _self.ffiObject.decrementPointer()
···
 
 }
 
+// Get the ticket for this socket.
 func (_self *Socket) Ticket() string {
 	_pointer := _self.ffiObject.incrementPointer("*Socket")
 	defer _self.ffiObject.decrementPointer()
···
 	value.Destroy()
 }
 
-// This allows for a callback stream over the Uniffi interface.
-// Implement these stream functions in the foreign language
-// and this will provide Rust Stream trait implementations
-// This is necessary since the Rust traits cannot be implemented directly
-// as uniffi callbacks
-type Stream interface {
-	// Read a stream of bytes from the stream
-	ReadStream(length uint64) ([]byte, error)
-	// Seek to a position in the stream
-	SeekStream(pos int64, mode uint64) (uint64, error)
-	// Write a stream of bytes to the stream
-	WriteStream(data []byte) (uint64, error)
-}
-
-// This allows for a callback stream over the Uniffi interface.
-// Implement these stream functions in the foreign language
-// and this will provide Rust Stream trait implementations
-// This is necessary since the Rust traits cannot be implemented directly
-// as uniffi callbacks
-type StreamImpl struct {
-	ffiObject FfiObject
-}
-
-// Read a stream of bytes from the stream
-func (_self *StreamImpl) ReadStream(length uint64) ([]byte, error) {
-	_pointer := _self.ffiObject.incrementPointer("Stream")
-	defer _self.ffiObject.decrementPointer()
-	_uniffiRV, _uniffiErr := rustCallWithError[SpError](FfiConverterSpError{}, func(_uniffiStatus *C.RustCallStatus) RustBufferI {
-		return GoRustBuffer{
-			inner: C.uniffi_iroh_streamplace_fn_method_stream_read_stream(
-				_pointer, FfiConverterUint64INSTANCE.Lower(length), _uniffiStatus),
-		}
-	})
-	if _uniffiErr != nil {
-		var _uniffiDefaultValue []byte
-		return _uniffiDefaultValue, _uniffiErr
-	} else {
-		return FfiConverterBytesINSTANCE.Lift(_uniffiRV), nil
-	}
-}
-
-// Seek to a position in the stream
-func (_self *StreamImpl) SeekStream(pos int64, mode uint64) (uint64, error) {
-	_pointer := _self.ffiObject.incrementPointer("Stream")
-	defer _self.ffiObject.decrementPointer()
-	_uniffiRV, _uniffiErr := rustCallWithError[SpError](FfiConverterSpError{}, func(_uniffiStatus *C.RustCallStatus) C.uint64_t {
-		return C.uniffi_iroh_streamplace_fn_method_stream_seek_stream(
-			_pointer, FfiConverterInt64INSTANCE.Lower(pos), FfiConverterUint64INSTANCE.Lower(mode), _uniffiStatus)
-	})
-	if _uniffiErr != nil {
-		var _uniffiDefaultValue uint64
-		return _uniffiDefaultValue, _uniffiErr
-	} else {
-		return FfiConverterUint64INSTANCE.Lift(_uniffiRV), nil
-	}
-}
-
-// Write a stream of bytes to the stream
-func (_self *StreamImpl) WriteStream(data []byte) (uint64, error) {
-	_pointer := _self.ffiObject.incrementPointer("Stream")
-	defer _self.ffiObject.decrementPointer()
-	_uniffiRV, _uniffiErr := rustCallWithError[SpError](FfiConverterSpError{}, func(_uniffiStatus *C.RustCallStatus) C.uint64_t {
-		return C.uniffi_iroh_streamplace_fn_method_stream_write_stream(
-			_pointer, FfiConverterBytesINSTANCE.Lower(data), _uniffiStatus)
-	})
-	if _uniffiErr != nil {
-		var _uniffiDefaultValue uint64
-		return _uniffiDefaultValue, _uniffiErr
-	} else {
-		return FfiConverterUint64INSTANCE.Lift(_uniffiRV), nil
-	}
-}
-func (object *StreamImpl) Destroy() {
-	runtime.SetFinalizer(object, nil)
-	object.ffiObject.destroy()
-}
-
-type FfiConverterStream struct {
-	handleMap *concurrentHandleMap[Stream]
-}
-
-var FfiConverterStreamINSTANCE = FfiConverterStream{
-	handleMap: newConcurrentHandleMap[Stream](),
-}
-
-func (c FfiConverterStream) Lift(pointer unsafe.Pointer) Stream {
-	result := &StreamImpl{
-		newFfiObject(
-			pointer,
-			func(pointer unsafe.Pointer, status *C.RustCallStatus) unsafe.Pointer {
-				return C.uniffi_iroh_streamplace_fn_clone_stream(pointer, status)
-			},
-			func(pointer unsafe.Pointer, status *C.RustCallStatus) {
-				C.uniffi_iroh_streamplace_fn_free_stream(pointer, status)
-			},
-		),
-	}
-	runtime.SetFinalizer(result, (*StreamImpl).Destroy)
-	return result
-}
-
-func (c FfiConverterStream) Read(reader io.Reader) Stream {
-	return c.Lift(unsafe.Pointer(uintptr(readUint64(reader))))
-}
-
-func (c FfiConverterStream) Lower(value Stream) 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 FfiConverterStream) Write(writer io.Writer, value Stream) {
-	writeUint64(writer, uint64(uintptr(c.Lower(value))))
-}
-
-type FfiDestroyerStream struct{}
-
-func (_ FfiDestroyerStream) Destroy(value Stream) {
-	if val, ok := value.(*StreamImpl); ok {
-		val.Destroy()
-	} else {
-		panic("Expected *StreamImpl")
-	}
-}
-
-//export iroh_streamplace_cgo_dispatchCallbackInterfaceStreamMethod0
-func iroh_streamplace_cgo_dispatchCallbackInterfaceStreamMethod0(uniffiHandle C.uint64_t, length C.uint64_t, uniffiOutReturn *C.RustBuffer, callStatus *C.RustCallStatus) {
-	handle := uint64(uniffiHandle)
-	uniffiObj, ok := FfiConverterStreamINSTANCE.handleMap.tryGet(handle)
-	if !ok {
-		panic(fmt.Errorf("no callback in handle map: %d", handle))
-	}
-
-	res, err :=
-		uniffiObj.ReadStream(
-			FfiConverterUint64INSTANCE.Lift(length),
-		)
-
-	if 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
-	}
-
-	*uniffiOutReturn = FfiConverterBytesINSTANCE.Lower(res)
-}
-
-//export iroh_streamplace_cgo_dispatchCallbackInterfaceStreamMethod1
-func iroh_streamplace_cgo_dispatchCallbackInterfaceStreamMethod1(uniffiHandle C.uint64_t, pos C.int64_t, mode C.uint64_t, uniffiOutReturn *C.uint64_t, callStatus *C.RustCallStatus) {
-	handle := uint64(uniffiHandle)
-	uniffiObj, ok := FfiConverterStreamINSTANCE.handleMap.tryGet(handle)
-	if !ok {
-		panic(fmt.Errorf("no callback in handle map: %d", handle))
-	}
-
-	res, err :=
-		uniffiObj.SeekStream(
-			FfiConverterInt64INSTANCE.Lift(pos),
-			FfiConverterUint64INSTANCE.Lift(mode),
-		)
-
-	if 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
-	}
-
-	*uniffiOutReturn = FfiConverterUint64INSTANCE.Lower(res)
-}
-
-//export iroh_streamplace_cgo_dispatchCallbackInterfaceStreamMethod2
-func iroh_streamplace_cgo_dispatchCallbackInterfaceStreamMethod2(uniffiHandle C.uint64_t, data C.RustBuffer, uniffiOutReturn *C.uint64_t, callStatus *C.RustCallStatus) {
-	handle := uint64(uniffiHandle)
-	uniffiObj, ok := FfiConverterStreamINSTANCE.handleMap.tryGet(handle)
-	if !ok {
-		panic(fmt.Errorf("no callback in handle map: %d", handle))
-	}
-
-	res, err :=
-		uniffiObj.WriteStream(
-			FfiConverterBytesINSTANCE.Lift(GoRustBuffer{
-				inner: data,
-			}),
-		)
-
-	if 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
-	}
-
-	*uniffiOutReturn = FfiConverterUint64INSTANCE.Lower(res)
-}
-
-var UniffiVTableCallbackInterfaceStreamINSTANCE = C.UniffiVTableCallbackInterfaceStream{
-	readStream:  (C.UniffiCallbackInterfaceStreamMethod0)(C.iroh_streamplace_cgo_dispatchCallbackInterfaceStreamMethod0),
-	seekStream:  (C.UniffiCallbackInterfaceStreamMethod1)(C.iroh_streamplace_cgo_dispatchCallbackInterfaceStreamMethod1),
-	writeStream: (C.UniffiCallbackInterfaceStreamMethod2)(C.iroh_streamplace_cgo_dispatchCallbackInterfaceStreamMethod2),
-
-	uniffiFree: (C.UniffiCallbackInterfaceFree)(C.iroh_streamplace_cgo_dispatchCallbackInterfaceStreamFree),
-}
-
-//export iroh_streamplace_cgo_dispatchCallbackInterfaceStreamFree
-func iroh_streamplace_cgo_dispatchCallbackInterfaceStreamFree(handle C.uint64_t) {
-	FfiConverterStreamINSTANCE.handleMap.remove(uint64(handle))
-}
-
-func (c FfiConverterStream) register() {
-	C.uniffi_iroh_streamplace_fn_init_callback_vtable_stream(&UniffiVTableCallbackInterfaceStreamINSTANCE)
-}
-
-type Stream2Interface interface {
+// A bidirectional stream over an iroh connection.
+//
+// In QUIC streams and connections are separate concepts. A connection can have multiple streams.
+// For simplicity we expose a single bidirectional stream per connection here.
+type StreamInterface interface {
+	// Close the underlying connection.
 	Close()
+	// Close the read side of the stream.
+	//
+	// Note: this does not close the underlying connection.
 	CloseRead() error
+	// Close the write side of the stream.
+	//
+	// Note: this does not close the underlying connection.
 	CloseWrite() error
+	// Wait until the connection is closed.
 	Closed()
+	// Read up to n bytes from the stream.
+	//
+	// Due to the way uniffi works, this can't have the signature that is
+	// usually used in golang code. Instead of taking a mutable buffer and
+	// returning the number of bytes read, it takes the number of bytes to read
+	// and returns a vector with the data read.
+	//
+	// Wrapping this into a more idiomatic golang interface needs a few lines
+	// on the golang side.
 	Read(n uint64) ([]byte, error)
+	// Write up to n bytes from buf to the stream.
 	Write(buf []byte) (uint32, error)
+	// Write all bytes in buf to the stream.
 	WriteAll(buf []byte) error
 }
-type Stream2 struct {
+
+// A bidirectional stream over an iroh connection.
+//
+// In QUIC streams and connections are separate concepts. A connection can have multiple streams.
+// For simplicity we expose a single bidirectional stream per connection here.
+type Stream struct {
 	ffiObject FfiObject
 }
 
-func (_self *Stream2) Close() {
-	_pointer := _self.ffiObject.incrementPointer("*Stream2")
+// Close the underlying connection.
+func (_self *Stream) Close() {
+	_pointer := _self.ffiObject.incrementPointer("*Stream")
 	defer _self.ffiObject.decrementPointer()
 	rustCall(func(_uniffiStatus *C.RustCallStatus) bool {
-		C.uniffi_iroh_streamplace_fn_method_stream2_close(
+		C.uniffi_iroh_streamplace_fn_method_stream_close(
 			_pointer, _uniffiStatus)
 		return false
 	})
 }
 
-func (_self *Stream2) CloseRead() error {
-	_pointer := _self.ffiObject.incrementPointer("*Stream2")
+// Close the read side of the stream.
+//
+// Note: this does not close the underlying connection.
+func (_self *Stream) CloseRead() error {
+	_pointer := _self.ffiObject.incrementPointer("*Stream")
 	defer _self.ffiObject.decrementPointer()
 	_, err := uniffiRustCallAsync[ReadError](
 		FfiConverterReadErrorINSTANCE,
···
 		},
 		// liftFn
 		func(_ struct{}) struct{} { return struct{}{} },
-		C.uniffi_iroh_streamplace_fn_method_stream2_close_read(
+		C.uniffi_iroh_streamplace_fn_method_stream_close_read(
 			_pointer),
 		// pollFn
 		func(handle C.uint64_t, continuation C.UniffiRustFutureContinuationCallback, data C.uint64_t) {
···
 	return err
 }
 
-func (_self *Stream2) CloseWrite() error {
-	_pointer := _self.ffiObject.incrementPointer("*Stream2")
+// Close the write side of the stream.
+//
+// Note: this does not close the underlying connection.
+func (_self *Stream) CloseWrite() error {
+	_pointer := _self.ffiObject.incrementPointer("*Stream")
 	defer _self.ffiObject.decrementPointer()
 	_, err := uniffiRustCallAsync[WriteError2](
 		FfiConverterWriteError2INSTANCE,
···
 		},
 		// liftFn
 		func(_ struct{}) struct{} { return struct{}{} },
-		C.uniffi_iroh_streamplace_fn_method_stream2_close_write(
+		C.uniffi_iroh_streamplace_fn_method_stream_close_write(
 			_pointer),
 		// pollFn
 		func(handle C.uint64_t, continuation C.UniffiRustFutureContinuationCallback, data C.uint64_t) {
···
 	return err
 }
 
-func (_self *Stream2) Closed() {
-	_pointer := _self.ffiObject.incrementPointer("*Stream2")
+// Wait until the connection is closed.
+func (_self *Stream) Closed() {
+	_pointer := _self.ffiObject.incrementPointer("*Stream")
 	defer _self.ffiObject.decrementPointer()
 	uniffiRustCallAsync[error](
 		nil,
···
 		},
 		// liftFn
 		func(_ struct{}) struct{} { return struct{}{} },
-		C.uniffi_iroh_streamplace_fn_method_stream2_closed(
+		C.uniffi_iroh_streamplace_fn_method_stream_closed(
 			_pointer),
 		// pollFn
 		func(handle C.uint64_t, continuation C.UniffiRustFutureContinuationCallback, data C.uint64_t) {
···
 
 }
 
-func (_self *Stream2) Read(n uint64) ([]byte, error) {
-	_pointer := _self.ffiObject.incrementPointer("*Stream2")
+// Read up to n bytes from the stream.
+//
+// Due to the way uniffi works, this can't have the signature that is
+// usually used in golang code. Instead of taking a mutable buffer and
+// returning the number of bytes read, it takes the number of bytes to read
+// and returns a vector with the data read.
+//
+// Wrapping this into a more idiomatic golang interface needs a few lines
+// on the golang side.
+func (_self *Stream) Read(n uint64) ([]byte, error) {
+	_pointer := _self.ffiObject.incrementPointer("*Stream")
 	defer _self.ffiObject.decrementPointer()
 	res, err := uniffiRustCallAsync[ReadError](
 		FfiConverterReadErrorINSTANCE,
···
 		func(ffi RustBufferI) []byte {
 			return FfiConverterBytesINSTANCE.Lift(ffi)
 		},
-		C.uniffi_iroh_streamplace_fn_method_stream2_read(
+		C.uniffi_iroh_streamplace_fn_method_stream_read(
 			_pointer, FfiConverterUint64INSTANCE.Lower(n)),
 		// pollFn
 		func(handle C.uint64_t, continuation C.UniffiRustFutureContinuationCallback, data C.uint64_t) {
···
 	return res, err
 }
 
-func (_self *Stream2) Write(buf []byte) (uint32, error) {
-	_pointer := _self.ffiObject.incrementPointer("*Stream2")
+// Write up to n bytes from buf to the stream.
+func (_self *Stream) Write(buf []byte) (uint32, error) {
+	_pointer := _self.ffiObject.incrementPointer("*Stream")
 	defer _self.ffiObject.decrementPointer()
 	res, err := uniffiRustCallAsync[WriteError2](
 		FfiConverterWriteError2INSTANCE,
···
 		func(ffi C.uint32_t) uint32 {
 			return FfiConverterUint32INSTANCE.Lift(ffi)
 		},
-		C.uniffi_iroh_streamplace_fn_method_stream2_write(
+		C.uniffi_iroh_streamplace_fn_method_stream_write(
 			_pointer, FfiConverterBytesINSTANCE.Lower(buf)),
 		// pollFn
 		func(handle C.uint64_t, continuation C.UniffiRustFutureContinuationCallback, data C.uint64_t) {
···
 	return res, err
 }
 
-func (_self *Stream2) WriteAll(buf []byte) error {
-	_pointer := _self.ffiObject.incrementPointer("*Stream2")
+// Write all bytes in buf to the stream.
+func (_self *Stream) WriteAll(buf []byte) error {
+	_pointer := _self.ffiObject.incrementPointer("*Stream")
 	defer _self.ffiObject.decrementPointer()
 	_, err := uniffiRustCallAsync[WriteError2](
 		FfiConverterWriteError2INSTANCE,
···
 		},
 		// liftFn
 		func(_ struct{}) struct{} { return struct{}{} },
-		C.uniffi_iroh_streamplace_fn_method_stream2_write_all(
+		C.uniffi_iroh_streamplace_fn_method_stream_write_all(
 			_pointer, FfiConverterBytesINSTANCE.Lower(buf)),
 		// pollFn
 		func(handle C.uint64_t, continuation C.UniffiRustFutureContinuationCallback, data C.uint64_t) {
···
 
 	return err
 }
-func (object *Stream2) Destroy() {
-	runtime.SetFinalizer(object, nil)
-	object.ffiObject.destroy()
-}
-
-type FfiConverterStream2 struct{}
-
-var FfiConverterStream2INSTANCE = FfiConverterStream2{}
-
-func (c FfiConverterStream2) Lift(pointer unsafe.Pointer) *Stream2 {
-	result := &Stream2{
-		newFfiObject(
-			pointer,
-			func(pointer unsafe.Pointer, status *C.RustCallStatus) unsafe.Pointer {
-				return C.uniffi_iroh_streamplace_fn_clone_stream2(pointer, status)
-			},
-			func(pointer unsafe.Pointer, status *C.RustCallStatus) {
-				C.uniffi_iroh_streamplace_fn_free_stream2(pointer, status)
-			},
-		),
-	}
-	runtime.SetFinalizer(result, (*Stream2).Destroy)
-	return result
-}
-
-func (c FfiConverterStream2) Read(reader io.Reader) *Stream2 {
-	return c.Lift(unsafe.Pointer(uintptr(readUint64(reader))))
-}
-
-func (c FfiConverterStream2) Lower(value *Stream2) 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("*Stream2")
-	defer value.ffiObject.decrementPointer()
-	return pointer
-
-}
-
-func (c FfiConverterStream2) Write(writer io.Writer, value *Stream2) {
-	writeUint64(writer, uint64(uintptr(c.Lower(value))))
-}
-
-type FfiDestroyerStream2 struct{}
-
-func (_ FfiDestroyerStream2) Destroy(value *Stream2) {
-	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)
-		},
-	)
-
-	if err == nil {
-		return res, nil
-	}
-
-	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() {
+func (object *Stream) Destroy() {
 	runtime.SetFinalizer(object, nil)
 	object.ffiObject.destroy()
 }
 
-type FfiConverterSubscribeResponse struct{}
+type FfiConverterStream struct{}
 
-var FfiConverterSubscribeResponseINSTANCE = FfiConverterSubscribeResponse{}
+var FfiConverterStreamINSTANCE = FfiConverterStream{}
 
-func (c FfiConverterSubscribeResponse) Lift(pointer unsafe.Pointer) *SubscribeResponse {
-	result := &SubscribeResponse{
+func (c FfiConverterStream) Lift(pointer unsafe.Pointer) *Stream {
+	result := &Stream{
 		newFfiObject(
 			pointer,
 			func(pointer unsafe.Pointer, status *C.RustCallStatus) unsafe.Pointer {
-				return C.uniffi_iroh_streamplace_fn_clone_subscriberesponse(pointer, status)
+				return C.uniffi_iroh_streamplace_fn_clone_stream(pointer, status)
 			},
 			func(pointer unsafe.Pointer, status *C.RustCallStatus) {
-				C.uniffi_iroh_streamplace_fn_free_subscriberesponse(pointer, status)
+				C.uniffi_iroh_streamplace_fn_free_stream(pointer, status)
 			},
 		),
 	}
-	runtime.SetFinalizer(result, (*SubscribeResponse).Destroy)
+	runtime.SetFinalizer(result, (*Stream).Destroy)
 	return result
 }
 
-func (c FfiConverterSubscribeResponse) Read(reader io.Reader) *SubscribeResponse {
+func (c FfiConverterStream) Read(reader io.Reader) *Stream {
 	return c.Lift(unsafe.Pointer(uintptr(readUint64(reader))))
 }
 
-func (c FfiConverterSubscribeResponse) Lower(value *SubscribeResponse) unsafe.Pointer {
+func (c FfiConverterStream) Lower(value *Stream) 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")
+	pointer := value.ffiObject.incrementPointer("*Stream")
 	defer value.ffiObject.decrementPointer()
 	return pointer
 
 }
 
-func (c FfiConverterSubscribeResponse) Write(writer io.Writer, value *SubscribeResponse) {
+func (c FfiConverterStream) Write(writer io.Writer, value *Stream) {
 	writeUint64(writer, uint64(uintptr(c.Lower(value))))
 }
 
-type FfiDestroyerSubscribeResponse struct{}
+type FfiDestroyerStream 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)
-		},
-	)
-
-	if err == nil {
-		return nil
-	}
-
-	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) {
+func (_ FfiDestroyerStream) Destroy(value *Stream) {
 	value.Destroy()
 }
 
 // Configuration for creating a [`Socket`].
 type SocketConfig struct {
+	// A 32-byte secret key for the socket.
 	Secret []byte
-	Alpn   []byte
+	// The ALPN to use for this socket.
+	Alpn []byte
 }
 
 func (r *SocketConfig) Destroy() {
···
 	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()
-}
-
 type AcceptError struct {
 	err error
 }
···
 	}
 }
 
-// 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))
-	}
-}
-
-// 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))
-	}
-}
-
 // Error when converting from ffi NodeAddr to iroh::NodeAddr
 type NodeAddrError struct {
 	err error
···
 	}
 }
 
-// Error joining peers.
-type ParseError struct {
-	err error
-}
-
-// Convience method to turn *ParseError into error
-// Avoiding treating nil pointer as non nil error interface
-func (err *ParseError) AsError() error {
-	if err == nil {
-		return nil
-	} else {
-		return err
-	}
-}
-
-func (err ParseError) Error() string {
-	return fmt.Sprintf("ParseError: %s", err.err.Error())
-}
-
-func (err ParseError) Unwrap() error {
-	return err.err
-}
-
-// Err* are used for checking error type with `errors.Is`
-var ErrParseErrorTicket = fmt.Errorf("ParseErrorTicket")
-
-// Variant structs
-// Failed to parse a provided iroh node ticket.
-type ParseErrorTicket struct {
-	Message string
-}
-
-// Failed to parse a provided iroh node ticket.
-func NewParseErrorTicket(
-	message string,
-) *ParseError {
-	return &ParseError{err: &ParseErrorTicket{
-		Message: message}}
-}
-
-func (e ParseErrorTicket) destroy() {
-	FfiDestroyerString{}.Destroy(e.Message)
-}
-
-func (err ParseErrorTicket) Error() string {
-	return fmt.Sprint("Ticket",
-		": ",
-
-		"Message=",
-		err.Message,
-	)
-}
-
-func (self ParseErrorTicket) Is(target error) bool {
-	return target == ErrParseErrorTicket
-}
-
-type FfiConverterParseError struct{}
-
-var FfiConverterParseErrorINSTANCE = FfiConverterParseError{}
-
-func (c FfiConverterParseError) Lift(eb RustBufferI) *ParseError {
-	return LiftFromRustBuffer[*ParseError](c, eb)
-}
-
-func (c FfiConverterParseError) Lower(value *ParseError) C.RustBuffer {
-	return LowerIntoRustBuffer[*ParseError](c, value)
-}
-
-func (c FfiConverterParseError) Read(reader io.Reader) *ParseError {
-	errorID := readUint32(reader)
-
-	switch errorID {
-	case 1:
-		return &ParseError{&ParseErrorTicket{
-			Message: FfiConverterStringINSTANCE.Read(reader),
-		}}
-	default:
-		panic(fmt.Sprintf("Unknown error code %d in FfiConverterParseError.Read()", errorID))
-	}
-}
-
-func (c FfiConverterParseError) Write(writer io.Writer, value *ParseError) {
-	switch variantValue := value.err.(type) {
-	case *ParseErrorTicket:
-		writeInt32(writer, 1)
-		FfiConverterStringINSTANCE.Write(writer, variantValue.Message)
-	default:
-		_ = variantValue
-		panic(fmt.Sprintf("invalid error value `%v` in FfiConverterParseError.Write", value))
-	}
-}
-
-type FfiDestroyerParseError struct{}
-
-func (_ FfiDestroyerParseError) Destroy(value *ParseError) {
-	switch variantValue := value.err.(type) {
-	case ParseErrorTicket:
-		variantValue.destroy()
-	default:
-		_ = variantValue
-		panic(fmt.Sprintf("invalid error value `%v` in FfiDestroyerParseError.Destroy", value))
-	}
-}
-
 type PublicKeyError struct {
 	err error
 }
···
 	}
 }
 
-// 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 ReadError struct {
 	err error
 }
···
 	}
 }
 
-type SpError struct {
-	err error
-}
-
-// Convience method to turn *SpError into error
-// Avoiding treating nil pointer as non nil error interface
-func (err *SpError) AsError() error {
-	if err == nil {
-		return nil
-	} else {
-		return err
-	}
-}
-
-func (err SpError) Error() string {
-	return fmt.Sprintf("SpError: %s", err.err.Error())
-}
-
-func (err SpError) Unwrap() error {
-	return err.err
-}
-
-// Err* are used for checking error type with `errors.Is`
-var ErrSpErrorNoCertificateChainFound = fmt.Errorf("SpErrorNoCertificateChainFound")
-var ErrSpErrorC2paError = fmt.Errorf("SpErrorC2paError")
-var ErrSpErrorIoError = fmt.Errorf("SpErrorIoError")
-
-// Variant structs
-type SpErrorNoCertificateChainFound struct {
-	message string
-}
-
-func NewSpErrorNoCertificateChainFound() *SpError {
-	return &SpError{err: &SpErrorNoCertificateChainFound{}}
-}
-
-func (e SpErrorNoCertificateChainFound) destroy() {
-}
-
-func (err SpErrorNoCertificateChainFound) Error() string {
-	return fmt.Sprintf("NoCertificateChainFound: %s", err.message)
-}
-
-func (self SpErrorNoCertificateChainFound) Is(target error) bool {
-	return target == ErrSpErrorNoCertificateChainFound
-}
-
-type SpErrorC2paError struct {
-	message string
-}
-
-func NewSpErrorC2paError() *SpError {
-	return &SpError{err: &SpErrorC2paError{}}
-}
-
-func (e SpErrorC2paError) destroy() {
-}
-
-func (err SpErrorC2paError) Error() string {
-	return fmt.Sprintf("C2paError: %s", err.message)
-}
-
-func (self SpErrorC2paError) Is(target error) bool {
-	return target == ErrSpErrorC2paError
-}
-
-type SpErrorIoError struct {
-	message string
-}
-
-func NewSpErrorIoError() *SpError {
-	return &SpError{err: &SpErrorIoError{}}
-}
-
-func (e SpErrorIoError) destroy() {
-}
-
-func (err SpErrorIoError) Error() string {
-	return fmt.Sprintf("IoError: %s", err.message)
-}
-
-func (self SpErrorIoError) Is(target error) bool {
-	return target == ErrSpErrorIoError
-}
-
-type FfiConverterSpError struct{}
-
-var FfiConverterSpErrorINSTANCE = FfiConverterSpError{}
-
-func (c FfiConverterSpError) Lift(eb RustBufferI) *SpError {
-	return LiftFromRustBuffer[*SpError](c, eb)
-}
-
-func (c FfiConverterSpError) Lower(value *SpError) C.RustBuffer {
-	return LowerIntoRustBuffer[*SpError](c, value)
-}
-
-func (c FfiConverterSpError) Read(reader io.Reader) *SpError {
-	errorID := readUint32(reader)
-
-	message := FfiConverterStringINSTANCE.Read(reader)
-	switch errorID {
-	case 1:
-		return &SpError{&SpErrorNoCertificateChainFound{message}}
-	case 2:
-		return &SpError{&SpErrorC2paError{message}}
-	case 3:
-		return &SpError{&SpErrorIoError{message}}
-	default:
-		panic(fmt.Sprintf("Unknown error code %d in FfiConverterSpError.Read()", errorID))
-	}
-
-}
-
-func (c FfiConverterSpError) Write(writer io.Writer, value *SpError) {
-	switch variantValue := value.err.(type) {
-	case *SpErrorNoCertificateChainFound:
-		writeInt32(writer, 1)
-	case *SpErrorC2paError:
-		writeInt32(writer, 2)
-	case *SpErrorIoError:
-		writeInt32(writer, 3)
-	default:
-		_ = variantValue
-		panic(fmt.Sprintf("invalid error value `%v` in FfiConverterSpError.Write", value))
-	}
-}
-
-type FfiDestroyerSpError struct{}
-
-func (_ FfiDestroyerSpError) Destroy(value *SpError) {
-	switch variantValue := value.err.(type) {
-	case SpErrorNoCertificateChainFound:
-		variantValue.destroy()
-	case SpErrorC2paError:
-		variantValue.destroy()
-	case SpErrorIoError:
-		variantValue.destroy()
-	default:
-		_ = variantValue
-		panic(fmt.Sprintf("invalid error value `%v` in FfiDestroyerSpError.Destroy", value))
-	}
-}
-
-// Error shutting down the database.
-//
-// This can occur if the db is already shut down or if there is an internal error.
-type ShutdownError struct {
-	err error
-}
-
-// Convience method to turn *ShutdownError into error
-// Avoiding treating nil pointer as non nil error interface
-func (err *ShutdownError) AsError() error {
-	if err == nil {
-		return nil
-	} else {
-		return err
-	}
-}
-
-func (err ShutdownError) Error() string {
-	return fmt.Sprintf("ShutdownError: %s", err.err.Error())
-}
-
-func (err ShutdownError) Unwrap() error {
-	return err.err
-}
-
-// Err* are used for checking error type with `errors.Is`
-var ErrShutdownErrorIrpc = fmt.Errorf("ShutdownErrorIrpc")
-
-// Variant structs
-// Error during the shutdown operation.
-type ShutdownErrorIrpc struct {
-	Message string
-}
-
-// Error during the shutdown operation.
-func NewShutdownErrorIrpc(
-	message string,
-) *ShutdownError {
-	return &ShutdownError{err: &ShutdownErrorIrpc{
-		Message: message}}
-}
-
-func (e ShutdownErrorIrpc) destroy() {
-	FfiDestroyerString{}.Destroy(e.Message)
-}
-
-func (err ShutdownErrorIrpc) Error() string {
-	return fmt.Sprint("Irpc",
-		": ",
-
-		"Message=",
-		err.Message,
-	)
-}
-
-func (self ShutdownErrorIrpc) Is(target error) bool {
-	return target == ErrShutdownErrorIrpc
-}
-
-type FfiConverterShutdownError struct{}
-
-var FfiConverterShutdownErrorINSTANCE = FfiConverterShutdownError{}
-
-func (c FfiConverterShutdownError) Lift(eb RustBufferI) *ShutdownError {
-	return LiftFromRustBuffer[*ShutdownError](c, eb)
-}
-
-func (c FfiConverterShutdownError) Lower(value *ShutdownError) C.RustBuffer {
-	return LowerIntoRustBuffer[*ShutdownError](c, value)
-}
-
-func (c FfiConverterShutdownError) Read(reader io.Reader) *ShutdownError {
-	errorID := readUint32(reader)
-
-	switch errorID {
-	case 1:
-		return &ShutdownError{&ShutdownErrorIrpc{
-			Message: FfiConverterStringINSTANCE.Read(reader),
-		}}
-	default:
-		panic(fmt.Sprintf("Unknown error code %d in FfiConverterShutdownError.Read()", errorID))
-	}
-}
-
-func (c FfiConverterShutdownError) Write(writer io.Writer, value *ShutdownError) {
-	switch variantValue := value.err.(type) {
-	case *ShutdownErrorIrpc:
-		writeInt32(writer, 1)
-		FfiConverterStringINSTANCE.Write(writer, variantValue.Message)
-	default:
-		_ = variantValue
-		panic(fmt.Sprintf("invalid error value `%v` in FfiConverterShutdownError.Write", value))
-	}
-}
-
-type FfiDestroyerShutdownError struct{}
-
-func (_ FfiDestroyerShutdownError) Destroy(value *ShutdownError) {
-	switch variantValue := value.err.(type) {
-	case ShutdownErrorIrpc:
-		variantValue.destroy()
-	default:
-		_ = variantValue
-		panic(fmt.Sprintf("invalid error value `%v` in FfiDestroyerShutdownError.Destroy", value))
-	}
-}
-
 type SocketNewError 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))
-	}
-}
-
 // Error when converting from ffi NodeAddr to iroh::NodeAddr
 type TicketError struct {
 	err error
···
 	}
 }
 
-// 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 WriteError2 struct {
 	err error
 }
···
 	}
 }
 
-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 FfiConverterOptionalSegmentToSign struct{}
-
-var FfiConverterOptionalSegmentToSignINSTANCE = FfiConverterOptionalSegmentToSign{}
-
-func (c FfiConverterOptionalSegmentToSign) Lift(rb RustBufferI) *SegmentToSign {
-	return LiftFromRustBuffer[*SegmentToSign](c, rb)
-}
-
-func (_ FfiConverterOptionalSegmentToSign) Read(reader io.Reader) *SegmentToSign {
-	if readInt8(reader) == 0 {
-		return nil
-	}
-	temp := FfiConverterSegmentToSignINSTANCE.Read(reader)
-	return &temp
-}
-
-func (c FfiConverterOptionalSegmentToSign) Lower(value *SegmentToSign) C.RustBuffer {
-	return LowerIntoRustBuffer[*SegmentToSign](c, value)
-}
-
-func (_ FfiConverterOptionalSegmentToSign) Write(writer io.Writer, value *SegmentToSign) {
-	if value == nil {
-		writeInt8(writer, 0)
-	} else {
-		writeInt8(writer, 1)
-		FfiConverterSegmentToSignINSTANCE.Write(writer, *value)
-	}
-}
-
-type FfiDestroyerOptionalSegmentToSign struct{}
-
-func (_ FfiDestroyerOptionalSegmentToSign) Destroy(value *SegmentToSign) {
-	if value != nil {
-		FfiDestroyerSegmentToSign{}.Destroy(*value)
-	}
-}
-
-type FfiConverterOptionalStream struct{}
-
-var FfiConverterOptionalStreamINSTANCE = FfiConverterOptionalStream{}
-
-func (c FfiConverterOptionalStream) Lift(rb RustBufferI) *Stream {
-	return LiftFromRustBuffer[*Stream](c, rb)
-}
-
-func (_ FfiConverterOptionalStream) Read(reader io.Reader) *Stream {
-	if readInt8(reader) == 0 {
-		return nil
-	}
-	temp := FfiConverterStreamINSTANCE.Read(reader)
-	return &temp
-}
-
-func (c FfiConverterOptionalStream) Lower(value *Stream) C.RustBuffer {
-	return LowerIntoRustBuffer[*Stream](c, value)
-}
-
-func (_ FfiConverterOptionalStream) Write(writer io.Writer, value *Stream) {
-	if value == nil {
-		writeInt8(writer, 0)
-	} else {
-		writeInt8(writer, 1)
-		FfiConverterStreamINSTANCE.Write(writer, *value)
-	}
-}
-
-type FfiDestroyerOptionalStream struct{}
-
-func (_ FfiDestroyerOptionalStream) Destroy(value *Stream) {
-	if value != nil {
-		FfiDestroyerStream{}.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 Stream) (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(FfiConverterStreamINSTANCE.Lower(data), _uniffiStatus),
-		}
-	})
-	if _uniffiErr != nil {
-		var _uniffiDefaultValue string
-		return _uniffiDefaultValue, _uniffiErr
-	} else {
-		return FfiConverterStringINSTANCE.Lift(_uniffiRV), nil
-	}
-}
-
-func GetManifests(data Stream) (string, error) {
-	_uniffiRV, _uniffiErr := rustCallWithError[SpError](FfiConverterSpError{}, func(_uniffiStatus *C.RustCallStatus) RustBufferI {
-		return GoRustBuffer{
-			inner: C.uniffi_iroh_streamplace_fn_func_get_manifests(FfiConverterStreamINSTANCE.Lower(data), _uniffiStatus),
-		}
-	})
-	if _uniffiErr != nil {
-		var _uniffiDefaultValue string
-		return _uniffiDefaultValue, _uniffiErr
-	} else {
-		return FfiConverterStringINSTANCE.Lift(_uniffiRV), nil
-	}
-}
-
 // Initialize logging with the default subscriber that respects RUST_LOG environment variable.
 // This function is safe to call multiple times - it will only initialize logging once.
 func InitLogging() {
···
 		return FfiConverterPublicKeyINSTANCE.Lift(_uniffiRV), nil
 	}
 }
-
-func Resign(segsToSign ManySegmentsToSign, signedConcatData Stream) error {
-	_, _uniffiErr := rustCallWithError[SpError](FfiConverterSpError{}, func(_uniffiStatus *C.RustCallStatus) bool {
-		C.uniffi_iroh_streamplace_fn_func_resign(FfiConverterManySegmentsToSignINSTANCE.Lower(segsToSign), FfiConverterStreamINSTANCE.Lower(signedConcatData), _uniffiStatus)
-		return false
-	})
-	return _uniffiErr.AsError()
-}
-
-func Sign(manifest string, data Stream, certsStr string, 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), FfiConverterStreamINSTANCE.Lower(data), FfiConverterStringINSTANCE.Lower(certsStr), FfiConverterGoSignerINSTANCE.Lower(gosigner), _uniffiStatus),
-		}
-	})
-	if _uniffiErr != nil {
-		var _uniffiDefaultValue []byte
-		return _uniffiDefaultValue, _uniffiErr
-	} else {
-		return FfiConverterBytesINSTANCE.Lift(_uniffiRV), nil
-	}
-}
-
-func SignWithIngredients(manifest string, data Stream, certsStr string, ingredients ManyStreams, gosigner GoSigner, output Stream) error {
-	_, _uniffiErr := rustCallWithError[SpError](FfiConverterSpError{}, func(_uniffiStatus *C.RustCallStatus) bool {
-		C.uniffi_iroh_streamplace_fn_func_sign_with_ingredients(FfiConverterStringINSTANCE.Lower(manifest), FfiConverterStreamINSTANCE.Lower(data), FfiConverterStringINSTANCE.Lower(certsStr), FfiConverterManyStreamsINSTANCE.Lower(ingredients), FfiConverterGoSignerINSTANCE.Lower(gosigner), FfiConverterStreamINSTANCE.Lower(output), _uniffiStatus)
-		return false
-	})
-	return _uniffiErr.AsError()
-}
-
-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_METHOD0
-#define UNIFFI_FFIDEF_CALLBACK_INTERFACE_DATA_HANDLER_METHOD0
-typedef void (*UniffiCallbackInterfaceDataHandlerMethod0)(uint64_t uniffi_handle, void* from, 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_UniffiCallbackInterfaceDataHandlerMethod0(
-				UniffiCallbackInterfaceDataHandlerMethod0 cb, uint64_t uniffi_handle, void* from, RustBuffer topic, RustBuffer data, UniffiForeignFutureCompleteVoid uniffi_future_callback, uint64_t uniffi_callback_data, UniffiForeignFuture* uniffi_out_return)
-{
-	return cb(uniffi_handle, from, 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 );
-
-// Making function static works arround:
-// https://github.com/golang/go/issues/11263
-static void call_UniffiCallbackInterfaceGoSignerMethod0(
-				UniffiCallbackInterfaceGoSignerMethod0 cb, uint64_t uniffi_handle, RustBuffer data, RustBuffer* uniffi_out_return, RustCallStatus* callStatus )
-{
-	return cb(uniffi_handle, data, uniffi_out_return, callStatus );
-}
-
-
-#endif
-#ifndef UNIFFI_FFIDEF_CALLBACK_INTERFACE_MANY_SEGMENTS_TO_SIGN_METHOD0
-#define UNIFFI_FFIDEF_CALLBACK_INTERFACE_MANY_SEGMENTS_TO_SIGN_METHOD0
-typedef void (*UniffiCallbackInterfaceManySegmentsToSignMethod0)(uint64_t uniffi_handle, RustBuffer* uniffi_out_return, RustCallStatus* callStatus );
-
-// Making function static works arround:
-// https://github.com/golang/go/issues/11263
-static void call_UniffiCallbackInterfaceManySegmentsToSignMethod0(
-				UniffiCallbackInterfaceManySegmentsToSignMethod0 cb, uint64_t uniffi_handle, RustBuffer* uniffi_out_return, RustCallStatus* callStatus )
-{
-	return cb(uniffi_handle, uniffi_out_return, callStatus );
-}
-
-
-#endif
-#ifndef UNIFFI_FFIDEF_CALLBACK_INTERFACE_MANY_STREAMS_METHOD0
-#define UNIFFI_FFIDEF_CALLBACK_INTERFACE_MANY_STREAMS_METHOD0
-typedef void (*UniffiCallbackInterfaceManyStreamsMethod0)(uint64_t uniffi_handle, RustBuffer* uniffi_out_return, RustCallStatus* callStatus );
-
-// Making function static works arround:
-// https://github.com/golang/go/issues/11263
-static void call_UniffiCallbackInterfaceManyStreamsMethod0(
-				UniffiCallbackInterfaceManyStreamsMethod0 cb, uint64_t uniffi_handle, RustBuffer* uniffi_out_return, RustCallStatus* callStatus )
-{
-	return cb(uniffi_handle, uniffi_out_return, callStatus );
-}
-
-
-#endif
-#ifndef UNIFFI_FFIDEF_CALLBACK_INTERFACE_SEGMENT_TO_SIGN_METHOD0
-#define UNIFFI_FFIDEF_CALLBACK_INTERFACE_SEGMENT_TO_SIGN_METHOD0
-typedef void (*UniffiCallbackInterfaceSegmentToSignMethod0)(uint64_t uniffi_handle, void** uniffi_out_return, RustCallStatus* callStatus );
-
-// Making function static works arround:
-// https://github.com/golang/go/issues/11263
-static void call_UniffiCallbackInterfaceSegmentToSignMethod0(
-				UniffiCallbackInterfaceSegmentToSignMethod0 cb, uint64_t uniffi_handle, void** uniffi_out_return, RustCallStatus* callStatus )
-{
-	return cb(uniffi_handle, uniffi_out_return, callStatus );
-}
-
-
-#endif
-#ifndef UNIFFI_FFIDEF_CALLBACK_INTERFACE_SEGMENT_TO_SIGN_METHOD1
-#define UNIFFI_FFIDEF_CALLBACK_INTERFACE_SEGMENT_TO_SIGN_METHOD1
-typedef void (*UniffiCallbackInterfaceSegmentToSignMethod1)(uint64_t uniffi_handle, RustBuffer* uniffi_out_return, RustCallStatus* callStatus );
-
-// Making function static works arround:
-// https://github.com/golang/go/issues/11263
-static void call_UniffiCallbackInterfaceSegmentToSignMethod1(
-				UniffiCallbackInterfaceSegmentToSignMethod1 cb, uint64_t uniffi_handle, RustBuffer* uniffi_out_return, RustCallStatus* callStatus )
-{
-	return cb(uniffi_handle, uniffi_out_return, callStatus );
-}
-
-
-#endif
-#ifndef UNIFFI_FFIDEF_CALLBACK_INTERFACE_SEGMENT_TO_SIGN_METHOD2
-#define UNIFFI_FFIDEF_CALLBACK_INTERFACE_SEGMENT_TO_SIGN_METHOD2
-typedef void (*UniffiCallbackInterfaceSegmentToSignMethod2)(uint64_t uniffi_handle, RustBuffer* uniffi_out_return, RustCallStatus* callStatus );
-
-// Making function static works arround:
-// https://github.com/golang/go/issues/11263
-static void call_UniffiCallbackInterfaceSegmentToSignMethod2(
-				UniffiCallbackInterfaceSegmentToSignMethod2 cb, uint64_t uniffi_handle, RustBuffer* uniffi_out_return, RustCallStatus* callStatus )
-{
-	return cb(uniffi_handle, uniffi_out_return, callStatus );
-}
-
-
-#endif
-#ifndef UNIFFI_FFIDEF_CALLBACK_INTERFACE_SEGMENT_TO_SIGN_METHOD3
-#define UNIFFI_FFIDEF_CALLBACK_INTERFACE_SEGMENT_TO_SIGN_METHOD3
-typedef void (*UniffiCallbackInterfaceSegmentToSignMethod3)(uint64_t uniffi_handle, void** uniffi_out_return, RustCallStatus* callStatus );
-
-// Making function static works arround:
-// https://github.com/golang/go/issues/11263
-static void call_UniffiCallbackInterfaceSegmentToSignMethod3(
-				UniffiCallbackInterfaceSegmentToSignMethod3 cb, uint64_t uniffi_handle, void** uniffi_out_return, RustCallStatus* callStatus )
-{
-	return cb(uniffi_handle, uniffi_out_return, callStatus );
-}
-
-
-#endif
-#ifndef UNIFFI_FFIDEF_CALLBACK_INTERFACE_SEGMENT_TO_SIGN_METHOD4
-#define UNIFFI_FFIDEF_CALLBACK_INTERFACE_SEGMENT_TO_SIGN_METHOD4
-typedef void (*UniffiCallbackInterfaceSegmentToSignMethod4)(uint64_t uniffi_handle, void* uniffi_out_return, RustCallStatus* callStatus );
-
-// Making function static works arround:
-// https://github.com/golang/go/issues/11263
-static void call_UniffiCallbackInterfaceSegmentToSignMethod4(
-				UniffiCallbackInterfaceSegmentToSignMethod4 cb, uint64_t uniffi_handle, void* uniffi_out_return, RustCallStatus* callStatus )
-{
-	return cb(uniffi_handle, uniffi_out_return, callStatus );
-}
-
-
-#endif
-#ifndef UNIFFI_FFIDEF_CALLBACK_INTERFACE_STREAM_METHOD0
-#define UNIFFI_FFIDEF_CALLBACK_INTERFACE_STREAM_METHOD0
-typedef void (*UniffiCallbackInterfaceStreamMethod0)(uint64_t uniffi_handle, uint64_t length, RustBuffer* uniffi_out_return, RustCallStatus* callStatus );
-
-// Making function static works arround:
-// https://github.com/golang/go/issues/11263
-static void call_UniffiCallbackInterfaceStreamMethod0(
-				UniffiCallbackInterfaceStreamMethod0 cb, uint64_t uniffi_handle, uint64_t length, RustBuffer* uniffi_out_return, RustCallStatus* callStatus )
-{
-	return cb(uniffi_handle, length, uniffi_out_return, callStatus );
-}
-
-
-#endif
-#ifndef UNIFFI_FFIDEF_CALLBACK_INTERFACE_STREAM_METHOD1
-#define UNIFFI_FFIDEF_CALLBACK_INTERFACE_STREAM_METHOD1
-typedef void (*UniffiCallbackInterfaceStreamMethod1)(uint64_t uniffi_handle, int64_t pos, uint64_t mode, uint64_t* uniffi_out_return, RustCallStatus* callStatus );
-
-// Making function static works arround:
-// https://github.com/golang/go/issues/11263
-static void call_UniffiCallbackInterfaceStreamMethod1(
-				UniffiCallbackInterfaceStreamMethod1 cb, uint64_t uniffi_handle, int64_t pos, uint64_t mode, uint64_t* uniffi_out_return, RustCallStatus* callStatus )
-{
-	return cb(uniffi_handle, pos, mode, uniffi_out_return, callStatus );
-}
-
-
-#endif
-#ifndef UNIFFI_FFIDEF_CALLBACK_INTERFACE_STREAM_METHOD2
-#define UNIFFI_FFIDEF_CALLBACK_INTERFACE_STREAM_METHOD2
-typedef void (*UniffiCallbackInterfaceStreamMethod2)(uint64_t uniffi_handle, RustBuffer data, uint64_t* uniffi_out_return, RustCallStatus* callStatus );
-
-// Making function static works arround:
-// https://github.com/golang/go/issues/11263
-static void call_UniffiCallbackInterfaceStreamMethod2(
-				UniffiCallbackInterfaceStreamMethod2 cb, uint64_t uniffi_handle, RustBuffer data, uint64_t* uniffi_out_return, RustCallStatus* callStatus )
-{
-	return cb(uniffi_handle, data, uniffi_out_return, callStatus );
-}
-
-
-#endif
-#ifndef UNIFFI_FFIDEF_V_TABLE_CALLBACK_INTERFACE_DATA_HANDLER
-#define UNIFFI_FFIDEF_V_TABLE_CALLBACK_INTERFACE_DATA_HANDLER
-typedef struct UniffiVTableCallbackInterfaceDataHandler {
-    UniffiCallbackInterfaceDataHandlerMethod0 handleData;
-    UniffiCallbackInterfaceFree uniffiFree;
-} UniffiVTableCallbackInterfaceDataHandler;
-
-#endif
-#ifndef UNIFFI_FFIDEF_V_TABLE_CALLBACK_INTERFACE_GO_SIGNER
-#define UNIFFI_FFIDEF_V_TABLE_CALLBACK_INTERFACE_GO_SIGNER
-typedef struct UniffiVTableCallbackInterfaceGoSigner {
-    UniffiCallbackInterfaceGoSignerMethod0 sign;
-    UniffiCallbackInterfaceFree uniffiFree;
-} UniffiVTableCallbackInterfaceGoSigner;
-
-#endif
-#ifndef UNIFFI_FFIDEF_V_TABLE_CALLBACK_INTERFACE_MANY_SEGMENTS_TO_SIGN
-#define UNIFFI_FFIDEF_V_TABLE_CALLBACK_INTERFACE_MANY_SEGMENTS_TO_SIGN
-typedef struct UniffiVTableCallbackInterfaceManySegmentsToSign {
-    UniffiCallbackInterfaceManySegmentsToSignMethod0 next;
-    UniffiCallbackInterfaceFree uniffiFree;
-} UniffiVTableCallbackInterfaceManySegmentsToSign;
-
-#endif
-#ifndef UNIFFI_FFIDEF_V_TABLE_CALLBACK_INTERFACE_MANY_STREAMS
-#define UNIFFI_FFIDEF_V_TABLE_CALLBACK_INTERFACE_MANY_STREAMS
-typedef struct UniffiVTableCallbackInterfaceManyStreams {
-    UniffiCallbackInterfaceManyStreamsMethod0 next;
-    UniffiCallbackInterfaceFree uniffiFree;
-} UniffiVTableCallbackInterfaceManyStreams;
-
-#endif
-#ifndef UNIFFI_FFIDEF_V_TABLE_CALLBACK_INTERFACE_SEGMENT_TO_SIGN
-#define UNIFFI_FFIDEF_V_TABLE_CALLBACK_INTERFACE_SEGMENT_TO_SIGN
-typedef struct UniffiVTableCallbackInterfaceSegmentToSign {
-    UniffiCallbackInterfaceSegmentToSignMethod0 unsignedSegStream;
-    UniffiCallbackInterfaceSegmentToSignMethod1 manifestId;
-    UniffiCallbackInterfaceSegmentToSignMethod2 cert;
-    UniffiCallbackInterfaceSegmentToSignMethod3 outputSegStream;
-    UniffiCallbackInterfaceSegmentToSignMethod4 close;
-    UniffiCallbackInterfaceFree uniffiFree;
-} UniffiVTableCallbackInterfaceSegmentToSign;
-
-#endif
-#ifndef UNIFFI_FFIDEF_V_TABLE_CALLBACK_INTERFACE_STREAM
-#define UNIFFI_FFIDEF_V_TABLE_CALLBACK_INTERFACE_STREAM
-typedef struct UniffiVTableCallbackInterfaceStream {
-    UniffiCallbackInterfaceStreamMethod0 readStream;
-    UniffiCallbackInterfaceStreamMethod1 seekStream;
-    UniffiCallbackInterfaceStreamMethod2 writeStream;
-    UniffiCallbackInterfaceFree uniffiFree;
-} UniffiVTableCallbackInterfaceStream;
-
-#endif
-#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_CLONE_DATAHANDLER
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_CLONE_DATAHANDLER
-void* uniffi_iroh_streamplace_fn_clone_datahandler(void* ptr, RustCallStatus *out_status
-);
-#endif
-#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_FREE_DATAHANDLER
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_FREE_DATAHANDLER
-void uniffi_iroh_streamplace_fn_free_datahandler(void* ptr, RustCallStatus *out_status
-);
-#endif
-#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_INIT_CALLBACK_VTABLE_DATAHANDLER
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_INIT_CALLBACK_VTABLE_DATAHANDLER
-void uniffi_iroh_streamplace_fn_init_callback_vtable_datahandler(UniffiVTableCallbackInterfaceDataHandler* vtable
-);
-#endif
-#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_DATAHANDLER_HANDLE_DATA
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_DATAHANDLER_HANDLE_DATA
-uint64_t uniffi_iroh_streamplace_fn_method_datahandler_handle_data(void* ptr, void* from, 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_SHUTDOWN
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_DB_SHUTDOWN
-uint64_t uniffi_iroh_streamplace_fn_method_db_shutdown(void* ptr
-);
-#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_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
-);
-#endif
-#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_FREE_GOSIGNER
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_FREE_GOSIGNER
-void uniffi_iroh_streamplace_fn_free_gosigner(void* ptr, RustCallStatus *out_status
-);
-#endif
-#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_INIT_CALLBACK_VTABLE_GOSIGNER
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_INIT_CALLBACK_VTABLE_GOSIGNER
-void uniffi_iroh_streamplace_fn_init_callback_vtable_gosigner(UniffiVTableCallbackInterfaceGoSigner* vtable
-);
-#endif
-#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_GOSIGNER_SIGN
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_GOSIGNER_SIGN
-RustBuffer uniffi_iroh_streamplace_fn_method_gosigner_sign(void* ptr, RustBuffer data, RustCallStatus *out_status
-);
-#endif
-#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_CLONE_MANYSEGMENTSTOSIGN
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_CLONE_MANYSEGMENTSTOSIGN
-void* uniffi_iroh_streamplace_fn_clone_manysegmentstosign(void* ptr, RustCallStatus *out_status
-);
-#endif
-#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_FREE_MANYSEGMENTSTOSIGN
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_FREE_MANYSEGMENTSTOSIGN
-void uniffi_iroh_streamplace_fn_free_manysegmentstosign(void* ptr, RustCallStatus *out_status
-);
-#endif
-#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_INIT_CALLBACK_VTABLE_MANYSEGMENTSTOSIGN
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_INIT_CALLBACK_VTABLE_MANYSEGMENTSTOSIGN
-void uniffi_iroh_streamplace_fn_init_callback_vtable_manysegmentstosign(UniffiVTableCallbackInterfaceManySegmentsToSign* vtable
-);
-#endif
-#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_MANYSEGMENTSTOSIGN_NEXT
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_MANYSEGMENTSTOSIGN_NEXT
-RustBuffer uniffi_iroh_streamplace_fn_method_manysegmentstosign_next(void* ptr, RustCallStatus *out_status
-);
-#endif
-#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_CLONE_MANYSTREAMS
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_CLONE_MANYSTREAMS
-void* uniffi_iroh_streamplace_fn_clone_manystreams(void* ptr, RustCallStatus *out_status
-);
-#endif
-#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_FREE_MANYSTREAMS
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_FREE_MANYSTREAMS
-void uniffi_iroh_streamplace_fn_free_manystreams(void* ptr, RustCallStatus *out_status
-);
-#endif
-#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_INIT_CALLBACK_VTABLE_MANYSTREAMS
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_INIT_CALLBACK_VTABLE_MANYSTREAMS
-void uniffi_iroh_streamplace_fn_init_callback_vtable_manystreams(UniffiVTableCallbackInterfaceManyStreams* vtable
-);
-#endif
-#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_MANYSTREAMS_NEXT
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_MANYSTREAMS_NEXT
-RustBuffer uniffi_iroh_streamplace_fn_method_manystreams_next(void* ptr, 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_ADD_TICKETS
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_NODE_ADD_TICKETS
-uint64_t uniffi_iroh_streamplace_fn_method_node_add_tickets(void* ptr, RustBuffer peers
-);
-#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_SHUTDOWN
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_NODE_SHUTDOWN
-uint64_t uniffi_iroh_streamplace_fn_method_node_shutdown(void* ptr
-);
-#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
···
 RustBuffer uniffi_iroh_streamplace_fn_method_publickey_uniffi_trait_display(void* ptr, RustCallStatus *out_status
 );
 #endif
-#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_CLONE_SEGMENTTOSIGN
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_CLONE_SEGMENTTOSIGN
-void* uniffi_iroh_streamplace_fn_clone_segmenttosign(void* ptr, RustCallStatus *out_status
-);
-#endif
-#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_FREE_SEGMENTTOSIGN
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_FREE_SEGMENTTOSIGN
-void uniffi_iroh_streamplace_fn_free_segmenttosign(void* ptr, RustCallStatus *out_status
-);
-#endif
-#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_INIT_CALLBACK_VTABLE_SEGMENTTOSIGN
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_INIT_CALLBACK_VTABLE_SEGMENTTOSIGN
-void uniffi_iroh_streamplace_fn_init_callback_vtable_segmenttosign(UniffiVTableCallbackInterfaceSegmentToSign* vtable
-);
-#endif
-#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_SEGMENTTOSIGN_UNSIGNED_SEG_STREAM
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_SEGMENTTOSIGN_UNSIGNED_SEG_STREAM
-void* uniffi_iroh_streamplace_fn_method_segmenttosign_unsigned_seg_stream(void* ptr, RustCallStatus *out_status
-);
-#endif
-#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_SEGMENTTOSIGN_MANIFEST_ID
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_SEGMENTTOSIGN_MANIFEST_ID
-RustBuffer uniffi_iroh_streamplace_fn_method_segmenttosign_manifest_id(void* ptr, RustCallStatus *out_status
-);
-#endif
-#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_SEGMENTTOSIGN_CERT
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_SEGMENTTOSIGN_CERT
-RustBuffer uniffi_iroh_streamplace_fn_method_segmenttosign_cert(void* ptr, RustCallStatus *out_status
-);
-#endif
-#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_SEGMENTTOSIGN_OUTPUT_SEG_STREAM
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_SEGMENTTOSIGN_OUTPUT_SEG_STREAM
-void* uniffi_iroh_streamplace_fn_method_segmenttosign_output_seg_stream(void* ptr, RustCallStatus *out_status
-);
-#endif
-#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_SEGMENTTOSIGN_CLOSE
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_SEGMENTTOSIGN_CLOSE
-void uniffi_iroh_streamplace_fn_method_segmenttosign_close(void* ptr, RustCallStatus *out_status
-);
-#endif
 #ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_CLONE_SOCKET
 #define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_CLONE_SOCKET
 void* uniffi_iroh_streamplace_fn_clone_socket(void* ptr, RustCallStatus *out_status
···
 void uniffi_iroh_streamplace_fn_free_stream(void* ptr, RustCallStatus *out_status
 );
 #endif
-#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_INIT_CALLBACK_VTABLE_STREAM
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_INIT_CALLBACK_VTABLE_STREAM
-void uniffi_iroh_streamplace_fn_init_callback_vtable_stream(UniffiVTableCallbackInterfaceStream* vtable
-);
-#endif
-#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_STREAM_READ_STREAM
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_STREAM_READ_STREAM
-RustBuffer uniffi_iroh_streamplace_fn_method_stream_read_stream(void* ptr, uint64_t length, RustCallStatus *out_status
-);
-#endif
-#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_STREAM_SEEK_STREAM
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_STREAM_SEEK_STREAM
-uint64_t uniffi_iroh_streamplace_fn_method_stream_seek_stream(void* ptr, int64_t pos, uint64_t mode, RustCallStatus *out_status
-);
-#endif
-#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_STREAM_WRITE_STREAM
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_STREAM_WRITE_STREAM
-uint64_t uniffi_iroh_streamplace_fn_method_stream_write_stream(void* ptr, RustBuffer data, RustCallStatus *out_status
-);
-#endif
-#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_CLONE_STREAM2
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_CLONE_STREAM2
-void* uniffi_iroh_streamplace_fn_clone_stream2(void* ptr, RustCallStatus *out_status
-);
-#endif
-#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_FREE_STREAM2
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_FREE_STREAM2
-void uniffi_iroh_streamplace_fn_free_stream2(void* ptr, RustCallStatus *out_status
-);
-#endif
-#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_STREAM2_CLOSE
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_STREAM2_CLOSE
-void uniffi_iroh_streamplace_fn_method_stream2_close(void* ptr, RustCallStatus *out_status
-);
-#endif
-#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_STREAM2_CLOSE_READ
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_STREAM2_CLOSE_READ
-uint64_t uniffi_iroh_streamplace_fn_method_stream2_close_read(void* ptr
-);
-#endif
-#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_STREAM2_CLOSE_WRITE
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_STREAM2_CLOSE_WRITE
-uint64_t uniffi_iroh_streamplace_fn_method_stream2_close_write(void* ptr
-);
-#endif
-#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_STREAM2_CLOSED
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_STREAM2_CLOSED
-uint64_t uniffi_iroh_streamplace_fn_method_stream2_closed(void* ptr
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_STREAM_CLOSE
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_STREAM_CLOSE
+void uniffi_iroh_streamplace_fn_method_stream_close(void* ptr, RustCallStatus *out_status
 );
 #endif
-#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_STREAM2_READ
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_STREAM2_READ
-uint64_t uniffi_iroh_streamplace_fn_method_stream2_read(void* ptr, uint64_t n
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_STREAM_CLOSE_READ
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_STREAM_CLOSE_READ
+uint64_t uniffi_iroh_streamplace_fn_method_stream_close_read(void* ptr
 );
 #endif
-#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_STREAM2_WRITE
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_STREAM2_WRITE
-uint64_t uniffi_iroh_streamplace_fn_method_stream2_write(void* ptr, RustBuffer buf
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_STREAM_CLOSE_WRITE
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_STREAM_CLOSE_WRITE
+uint64_t uniffi_iroh_streamplace_fn_method_stream_close_write(void* ptr
 );
 #endif
-#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_STREAM2_WRITE_ALL
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_STREAM2_WRITE_ALL
-uint64_t uniffi_iroh_streamplace_fn_method_stream2_write_all(void* ptr, RustBuffer buf
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_STREAM_CLOSED
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_STREAM_CLOSED
+uint64_t uniffi_iroh_streamplace_fn_method_stream_closed(void* ptr
 );
 #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
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_STREAM_READ
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_STREAM_READ
+uint64_t uniffi_iroh_streamplace_fn_method_stream_read(void* ptr, uint64_t n
 );
 #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(void* data, RustCallStatus *out_status
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_STREAM_WRITE
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_STREAM_WRITE
+uint64_t uniffi_iroh_streamplace_fn_method_stream_write(void* ptr, RustBuffer buf
 );
 #endif
-#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_FUNC_GET_MANIFESTS
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_FUNC_GET_MANIFESTS
-RustBuffer uniffi_iroh_streamplace_fn_func_get_manifests(void* data, RustCallStatus *out_status
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_STREAM_WRITE_ALL
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_METHOD_STREAM_WRITE_ALL
+uint64_t uniffi_iroh_streamplace_fn_method_stream_write_all(void* ptr, RustBuffer buf
 );
 #endif
 #ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_FUNC_INIT_LOGGING
···
 #ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_FUNC_NODE_ID_FROM_TICKET
 #define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_FUNC_NODE_ID_FROM_TICKET
 void* uniffi_iroh_streamplace_fn_func_node_id_from_ticket(RustBuffer ticket_str, RustCallStatus *out_status
-);
-#endif
-#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_FUNC_RESIGN
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_FUNC_RESIGN
-void uniffi_iroh_streamplace_fn_func_resign(void* segs_to_sign, void* signed_concat_data, RustCallStatus *out_status
-);
-#endif
-#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, void* data, RustBuffer certs_str, void* gosigner, RustCallStatus *out_status
-);
-#endif
-#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_FUNC_SIGN_WITH_INGREDIENTS
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_FN_FUNC_SIGN_WITH_INGREDIENTS
-void uniffi_iroh_streamplace_fn_func_sign_with_ingredients(RustBuffer manifest, void* data, RustBuffer certs_str, void* ingredients, void* gosigner, void* output, 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
···
 void ffi_iroh_streamplace_rust_future_complete_void(uint64_t handle, RustCallStatus *out_status
 );
 #endif
-#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_FUNC_GET_MANIFEST_AND_CERT
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_FUNC_GET_MANIFEST_AND_CERT
-uint16_t uniffi_iroh_streamplace_checksum_func_get_manifest_and_cert(void
-    
-);
-#endif
-#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_FUNC_GET_MANIFESTS
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_FUNC_GET_MANIFESTS
-uint16_t uniffi_iroh_streamplace_checksum_func_get_manifests(void
-    
-);
-#endif
 #ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_FUNC_INIT_LOGGING
 #define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_FUNC_INIT_LOGGING
 uint16_t uniffi_iroh_streamplace_checksum_func_init_logging(void
···
     
 );
 #endif
-#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_FUNC_RESIGN
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_FUNC_RESIGN
-uint16_t uniffi_iroh_streamplace_checksum_func_resign(void
-    
-);
-#endif
-#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_FUNC_SIGN
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_FUNC_SIGN
-uint16_t uniffi_iroh_streamplace_checksum_func_sign(void
-    
-);
-#endif
-#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_FUNC_SIGN_WITH_INGREDIENTS
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_FUNC_SIGN_WITH_INGREDIENTS
-uint16_t uniffi_iroh_streamplace_checksum_func_sign_with_ingredients(void
-    
-);
-#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_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_SHUTDOWN
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_DB_SHUTDOWN
-uint16_t uniffi_iroh_streamplace_checksum_method_db_shutdown(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_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_MANYSEGMENTSTOSIGN_NEXT
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_MANYSEGMENTSTOSIGN_NEXT
-uint16_t uniffi_iroh_streamplace_checksum_method_manysegmentstosign_next(void
-    
-);
-#endif
-#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_MANYSTREAMS_NEXT
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_MANYSTREAMS_NEXT
-uint16_t uniffi_iroh_streamplace_checksum_method_manystreams_next(void
-    
-);
-#endif
-#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_NODE_ADD_TICKETS
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_NODE_ADD_TICKETS
-uint16_t uniffi_iroh_streamplace_checksum_method_node_add_tickets(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_SHUTDOWN
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_NODE_SHUTDOWN
-uint16_t uniffi_iroh_streamplace_checksum_method_node_shutdown(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_SEGMENTTOSIGN_UNSIGNED_SEG_STREAM
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_SEGMENTTOSIGN_UNSIGNED_SEG_STREAM
-uint16_t uniffi_iroh_streamplace_checksum_method_segmenttosign_unsigned_seg_stream(void
-    
-);
-#endif
-#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_SEGMENTTOSIGN_MANIFEST_ID
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_SEGMENTTOSIGN_MANIFEST_ID
-uint16_t uniffi_iroh_streamplace_checksum_method_segmenttosign_manifest_id(void
-    
-);
-#endif
-#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_SEGMENTTOSIGN_CERT
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_SEGMENTTOSIGN_CERT
-uint16_t uniffi_iroh_streamplace_checksum_method_segmenttosign_cert(void
-    
-);
-#endif
-#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_SEGMENTTOSIGN_OUTPUT_SEG_STREAM
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_SEGMENTTOSIGN_OUTPUT_SEG_STREAM
-uint16_t uniffi_iroh_streamplace_checksum_method_segmenttosign_output_seg_stream(void
-    
-);
-#endif
-#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_SEGMENTTOSIGN_CLOSE
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_SEGMENTTOSIGN_CLOSE
-uint16_t uniffi_iroh_streamplace_checksum_method_segmenttosign_close(void
-    
-);
-#endif
 #ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_SOCKET_ACCEPT
 #define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_SOCKET_ACCEPT
 uint16_t uniffi_iroh_streamplace_checksum_method_socket_accept(void
···
     
 );
 #endif
-#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_STREAM_READ_STREAM
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_STREAM_READ_STREAM
-uint16_t uniffi_iroh_streamplace_checksum_method_stream_read_stream(void
-    
-);
-#endif
-#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_STREAM_SEEK_STREAM
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_STREAM_SEEK_STREAM
-uint16_t uniffi_iroh_streamplace_checksum_method_stream_seek_stream(void
-    
-);
-#endif
-#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_STREAM_WRITE_STREAM
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_STREAM_WRITE_STREAM
-uint16_t uniffi_iroh_streamplace_checksum_method_stream_write_stream(void
-    
-);
-#endif
-#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_STREAM2_CLOSE
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_STREAM2_CLOSE
-uint16_t uniffi_iroh_streamplace_checksum_method_stream2_close(void
-    
-);
-#endif
-#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_STREAM2_CLOSE_READ
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_STREAM2_CLOSE_READ
-uint16_t uniffi_iroh_streamplace_checksum_method_stream2_close_read(void
-    
-);
-#endif
-#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_STREAM2_CLOSE_WRITE
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_STREAM2_CLOSE_WRITE
-uint16_t uniffi_iroh_streamplace_checksum_method_stream2_close_write(void
-    
-);
-#endif
-#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_STREAM2_CLOSED
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_STREAM2_CLOSED
-uint16_t uniffi_iroh_streamplace_checksum_method_stream2_closed(void
-    
-);
-#endif
-#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_STREAM2_READ
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_STREAM2_READ
-uint16_t uniffi_iroh_streamplace_checksum_method_stream2_read(void
-    
-);
-#endif
-#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_STREAM2_WRITE
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_STREAM2_WRITE
-uint16_t uniffi_iroh_streamplace_checksum_method_stream2_write(void
-    
-);
-#endif
-#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_STREAM2_WRITE_ALL
-#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_STREAM2_WRITE_ALL
-uint16_t uniffi_iroh_streamplace_checksum_method_stream2_write_all(void
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_STREAM_CLOSE
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_STREAM_CLOSE
+uint16_t uniffi_iroh_streamplace_checksum_method_stream_close(void
     
 );
 #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
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_STREAM_CLOSE_READ
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_STREAM_CLOSE_READ
+uint16_t uniffi_iroh_streamplace_checksum_method_stream_close_read(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
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_STREAM_CLOSE_WRITE
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_STREAM_CLOSE_WRITE
+uint16_t uniffi_iroh_streamplace_checksum_method_stream_close_write(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
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_STREAM_CLOSED
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_STREAM_CLOSED
+uint16_t uniffi_iroh_streamplace_checksum_method_stream_closed(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
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_STREAM_READ
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_STREAM_READ
+uint16_t uniffi_iroh_streamplace_checksum_method_stream_read(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
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_STREAM_WRITE
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_STREAM_WRITE
+uint16_t uniffi_iroh_streamplace_checksum_method_stream_write(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
+#ifndef UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_STREAM_WRITE_ALL
+#define UNIFFI_FFIDEF_UNIFFI_IROH_STREAMPLACE_CHECKSUM_METHOD_STREAM_WRITE_ALL
+uint16_t uniffi_iroh_streamplace_checksum_method_stream_write_all(void
     
 );
 #endif
···
 );
 #endif
 
- void iroh_streamplace_cgo_dispatchCallbackInterfaceDataHandlerMethod0(uint64_t uniffi_handle, void* from, 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_dispatchCallbackInterfaceGoSignerMethod0(uint64_t uniffi_handle, RustBuffer data, RustBuffer* uniffi_out_return, RustCallStatus* callStatus );
- void iroh_streamplace_cgo_dispatchCallbackInterfaceGoSignerFree(uint64_t handle);
- void iroh_streamplace_cgo_dispatchCallbackInterfaceManySegmentsToSignMethod0(uint64_t uniffi_handle, RustBuffer* uniffi_out_return, RustCallStatus* callStatus );
- void iroh_streamplace_cgo_dispatchCallbackInterfaceManySegmentsToSignFree(uint64_t handle);
- void iroh_streamplace_cgo_dispatchCallbackInterfaceManyStreamsMethod0(uint64_t uniffi_handle, RustBuffer* uniffi_out_return, RustCallStatus* callStatus );
- void iroh_streamplace_cgo_dispatchCallbackInterfaceManyStreamsFree(uint64_t handle);
- void iroh_streamplace_cgo_dispatchCallbackInterfaceSegmentToSignMethod0(uint64_t uniffi_handle, void** uniffi_out_return, RustCallStatus* callStatus );
- void iroh_streamplace_cgo_dispatchCallbackInterfaceSegmentToSignMethod1(uint64_t uniffi_handle, RustBuffer* uniffi_out_return, RustCallStatus* callStatus );
- void iroh_streamplace_cgo_dispatchCallbackInterfaceSegmentToSignMethod2(uint64_t uniffi_handle, RustBuffer* uniffi_out_return, RustCallStatus* callStatus );
- void iroh_streamplace_cgo_dispatchCallbackInterfaceSegmentToSignMethod3(uint64_t uniffi_handle, void** uniffi_out_return, RustCallStatus* callStatus );
- void iroh_streamplace_cgo_dispatchCallbackInterfaceSegmentToSignMethod4(uint64_t uniffi_handle, void* uniffi_out_return, RustCallStatus* callStatus );
- void iroh_streamplace_cgo_dispatchCallbackInterfaceSegmentToSignFree(uint64_t handle);
- void iroh_streamplace_cgo_dispatchCallbackInterfaceStreamMethod0(uint64_t uniffi_handle, uint64_t length, RustBuffer* uniffi_out_return, RustCallStatus* callStatus );
- void iroh_streamplace_cgo_dispatchCallbackInterfaceStreamMethod1(uint64_t uniffi_handle, int64_t pos, uint64_t mode, uint64_t* uniffi_out_return, RustCallStatus* callStatus );
- void iroh_streamplace_cgo_dispatchCallbackInterfaceStreamMethod2(uint64_t uniffi_handle, RustBuffer data, uint64_t* uniffi_out_return, RustCallStatus* callStatus );
- void iroh_streamplace_cgo_dispatchCallbackInterfaceStreamFree(uint64_t handle);
 
 void iroh_streamplace_uniffiFutureContinuationCallback(uint64_t, int8_t);
 void iroh_streamplace_uniffiFreeGorutine(uint64_t);

rust/iroh-streamplace/src/c2pa.rs

···
-use std::{io::Cursor, sync::Arc};
-
-use base64::{Engine as _, engine::general_purpose::STANDARD};
-use c2pa::{
-    Builder, CallbackSigner, Ingredient, Reader, jumbf_io, settings::Settings,
-    status_tracker::StatusTracker, store::Store,
-};
-use serde_json;
-
-use crate::{
-    error::SPError,
-    streams::{ManyStreams, Stream, StreamAdapter},
-};
-#[uniffi::export]
-pub fn get_manifest_and_cert(data: &dyn Stream) -> Result<String, SPError> {
-    let reader = Reader::from_stream("video/mp4", StreamAdapter::from(data))
-        .map_err(|e| SPError::C2paError(e.to_string()))?;
-
-    if let Some(manifest) = reader.active_manifest() {
-        let cert_chain = if let Some(si) = manifest.signature_info() {
-            si.cert_chain()
-        } else {
-            return Err(SPError::NoCertificateChainFound);
-        };
-
-        let result = serde_json::json!({
-            "manifest": manifest,
-            "cert": cert_chain,
-            "validation_results": reader.validation_results(),
-            "validation_state": reader.validation_state(),
-        });
-
-        return Ok(result.to_string());
-    }
-    Err(SPError::NoCertificateChainFound)
-}
-
-#[uniffi::export(with_foreign)]
-pub trait GoSigner: Send + Sync {
-    fn sign(&self, data: Vec<u8>) -> Result<Vec<u8>, SPError>;
-}
-
-// #[derive(uniffi::Object)]
-// struct Authenticator {
-//     gosigner: Arc<dyn GoSigner>,
-// }
-
-// impl Authenticator {
-//     pub fn new(gosigner: Arc<dyn GoSigner>) -> Self {
-//         Self { gosigner }
-//     }
-
-//     pub fn login(&self) {
-//         let username = self.gosigner.get("username".into());
-//         let password = self.gosigner.get("password".into());
-//     }
-// }
-
-const TOML_SETTINGS: &str = r#"
-version_major = 1
-version_minor = 0
-
-[trust]
-
-[core]
-debug = true
-hash_alg = "sha256"
-salt_jumbf_boxes = true
-prefer_box_hash = false
-merkle_tree_max_proofs = 5
-compress_manifests = true
-
-[verify]
-verify_after_reading = false
-verify_after_sign = false
-verify_trust = false
-verify_timestamp_trust = false
-ocsp_fetch = false
-remote_manifest_fetch = false
-check_ingredient_trust = false
-skip_ingredient_conflict_resolution = false
-strict_v1_validation = false
-
-[builder.thumbnail]
-enabled = false
-ignore_errors = true
-long_edge = 1024
-prefer_smallest_format = true
-quality = "medium"
-
-[builder.actions]
-all_actions_included = false
-
-[builder.actions.auto_created_action]
-enabled = true
-source_type = "http://c2pa.org/digitalsourcetype/empty"
-
-[builder.actions.auto_opened_action]
-enabled = true
-
-[builder.actions.auto_placed_action]
-enabled = true
-"#;
-
-#[uniffi::export]
-pub fn sign(
-    manifest: String,
-    data: &dyn Stream,
-    certs_str: String,
-    gosigner: Arc<dyn GoSigner>,
-) -> Result<Vec<u8>, SPError> {
-    Settings::from_toml(TOML_SETTINGS).map_err(|e| SPError::C2paError(e.to_string()))?;
-    let certs = STANDARD
-        .decode(certs_str)
-        .map_err(|e| SPError::C2paError(e.to_string()))?;
-    let callback_signer = CallbackSigner::new(
-        move |_context: *const (), data: &[u8]| {
-            let signature = gosigner
-                .sign(data.to_vec())
-                .map_err(|e| c2pa::Error::BadParam(e.to_string()))?;
-            Ok(signature)
-        },
-        c2pa::SigningAlg::Es256K,
-        certs,
-    );
-    let mut builder =
-        Builder::from_json(&manifest).map_err(|e| SPError::C2paError(e.to_string()))?;
-    let mut output = Vec::new();
-    let mut input_cursor = StreamAdapter::from(data);
-    let mut output_cursor = Cursor::new(&mut output);
-    builder
-        .sign(
-            &callback_signer,
-            "video/mp4",
-            &mut input_cursor,
-            &mut output_cursor,
-        )
-        .map_err(|e| SPError::C2paError(e.to_string()))?;
-    Ok(output)
-}
-
-#[uniffi::export]
-pub fn get_manifests(data: &dyn Stream) -> Result<String, SPError> {
-    let store = Reader::from_stream("video/mp4", StreamAdapter::from(data))
-        .map_err(|e| SPError::C2paError(e.to_string()))?;
-    let mut certs: std::collections::HashMap<String, String> = std::collections::HashMap::new();
-    for (label, manifest) in store.manifests() {
-        let cert_chain = manifest
-            .signature_info()
-            .ok_or(SPError::C2paError(format!(
-                "No signature info for manifest: {}",
-                label
-            )))?
-            .cert_chain();
-        certs.insert(label.clone(), cert_chain.to_string());
-    }
-    let result = serde_json::json!({
-        "manifests": store.manifests(),
-        "certs": certs
-    });
-    Ok(result.to_string())
-}
-
-#[uniffi::export(with_foreign)]
-pub trait SegmentToSign: Send + Sync {
-    fn unsigned_seg_stream(&self) -> Arc<dyn Stream>;
-    fn manifest_id(&self) -> String;
-    fn cert(&self) -> Vec<u8>;
-    fn output_seg_stream(&self) -> Arc<dyn Stream>;
-    fn close(&self);
-}
-
-#[uniffi::export(with_foreign)]
-pub trait ManySegmentsToSign: Send + Sync {
-    fn next(&self) -> Option<Arc<dyn SegmentToSign>>;
-}
-
-#[uniffi::export]
-pub fn resign(
-    segs_to_sign: &dyn ManySegmentsToSign,
-    signed_concat_data: &dyn Stream,
-) -> Result<(), SPError> {
-    let mut validation_log = StatusTracker::default();
-
-    let combined_store = Store::from_stream(
-        "video/mp4",
-        StreamAdapter::from(signed_concat_data),
-        true,
-        &mut validation_log,
-    )
-    .map_err(|e| SPError::C2paError(format!("from_stream failed: {}", e)))?;
-
-    while let Some(seg) = segs_to_sign.next() {
-        let unsigned_seg_data_stream = seg.unsigned_seg_stream();
-        let manifest_id = seg.manifest_id();
-        let cert = seg.cert();
-        let output_stream = seg.output_seg_stream();
-        let mut input_cursor = StreamAdapter::from(&*unsigned_seg_data_stream);
-        let mut output_cursor = StreamAdapter::from(&*output_stream);
-
-        // let mut output = Vec::<u8>::new();
-        let seg_claim =
-            combined_store
-                .get_claim(manifest_id.as_str())
-                .ok_or(SPError::C2paError(format!(
-                    "Segment claim not found: {}",
-                    manifest_id
-                )))?;
-        let signature_val = seg_claim.signature_val().clone();
-
-        let callback_signer = CallbackSigner::new(
-            move |_context: *const (), _data: &[u8]| Ok(signature_val.clone()),
-            c2pa::SigningAlg::Es256K,
-            cert,
-        );
-
-        let mut seg_store = Store::new();
-        let _provenance = seg_store
-            .commit_claim(seg_claim.clone())
-            .map_err(|e| SPError::C2paError(format!("commit_claim failed: {}", e)))?;
-
-        let jumbf_bytes = seg_store
-            .to_jumbf(&callback_signer)
-            .map_err(|e| SPError::C2paError(format!("to_jumbf failed: {}", e)))?;
-
-        jumbf_io::save_jumbf_to_stream(
-            "video/mp4",
-            &mut input_cursor,
-            &mut output_cursor,
-            &jumbf_bytes,
-        )
-        .map_err(|e| SPError::C2paError(format!("save_jumbf_to_stream failed: {}", e)))?;
-        seg.close();
-    }
-
-    Ok(())
-}
-
-#[uniffi::export]
-pub fn sign_with_ingredients(
-    manifest: String,
-    data: &dyn Stream,
-    certs_str: String,
-    ingredients: &dyn ManyStreams,
-    gosigner: Arc<dyn GoSigner>,
-    output: &dyn Stream,
-) -> Result<(), SPError> {
-    let certs = STANDARD
-        .decode(certs_str)
-        .map_err(|e| SPError::C2paError(e.to_string()))?;
-    Settings::from_toml(TOML_SETTINGS).map_err(|e| SPError::C2paError(e.to_string()))?;
-    let callback_signer = CallbackSigner::new(
-        move |_context: *const (), data: &[u8]| {
-            gosigner
-                .sign(data.to_vec())
-                .map_err(|e| c2pa::Error::BadParam(e.to_string()))
-        },
-        c2pa::SigningAlg::Es256K,
-        certs,
-    );
-    let mut builder =
-        Builder::from_json(&manifest).map_err(|e| SPError::C2paError(e.to_string()))?;
-    while let Some(ingredient) = ingredients.next() {
-        let mut cursor = StreamAdapter::from(&*ingredient);
-        let ingredient = Ingredient::from_stream("video/mp4", &mut cursor)
-            .map_err(|e| SPError::C2paError(e.to_string()))?;
-        builder.add_ingredient(ingredient);
-    }
-    let mut input_cursor = StreamAdapter::from(data);
-    let mut output_cursor = StreamAdapter::from(output);
-    builder
-        .sign(
-            &callback_signer,
-            "video/mp4",
-            &mut input_cursor,
-            &mut output_cursor,
-        )
-        .map_err(|e| SPError::C2paError(e.to_string()))?;
-    Ok(())
-}

rust/iroh-streamplace/src/db.rs

···
-use std::{
-    fmt::{self, Debug},
-    ops::Bound,
-    pin::Pin,
-    sync::Arc,
-    time::Duration,
-};
-
-use bytes::Bytes;
-use n0_future::{Stream, StreamExt};
-use ref_cast::RefCast;
-use snafu::Snafu;
-use tokio::sync::Mutex;
-
-use crate::public_key::PublicKey;
-
-// the files here are just copied from iroh-smol-kv-uniffi/src/code
-mod kv {
-    mod time_bound;
-    pub use time_bound::TimeBound;
-    mod subscribe_mode;
-    pub use subscribe_mode::SubscribeMode;
-}
-pub use kv::{SubscribeMode, TimeBound};
-use util::format_bytes;
-
-/// Error creating a new database node.
-#[derive(Debug, Snafu, uniffi::Error)]
-#[snafu(module)]
-pub enum CreateError {
-    /// The provided private key is invalid (not 32 bytes).
-    PrivateKey { size: u64 },
-    /// The provided gossip topic is invalid (not 32 bytes).
-    Topic { size: u64 },
-    /// Failed to bind the iroh endpoint.
-    Bind { message: String },
-    /// Failed to subscribe to the gossip topic.
-    Subscribe { message: String },
-}
-
-/// Error joining peers.
-#[derive(Debug, Snafu, uniffi::Error)]
-#[snafu(module)]
-pub enum JoinPeersError {
-    /// Failed to parse a provided iroh node ticket.
-    Ticket { message: String },
-    /// Error during the join peers operation.
-    Irpc { message: String },
-}
-
-/// Error joining peers.
-#[derive(Debug, Snafu, uniffi::Error)]
-#[snafu(module)]
-pub enum ParseError {
-    /// Failed to parse a provided iroh node ticket.
-    Ticket { message: String },
-}
-
-/// Error putting a value into the database.
-#[derive(Debug, Snafu, uniffi::Error)]
-#[snafu(module)]
-pub enum PutError {
-    /// Error during the put operation.
-    Irpc { message: String },
-}
-
-/// Configuration for an iroh-streamplace node.
-#[derive(uniffi::Record, Clone)]
-pub struct Config {
-    /// An Ed25519 secret key as a 32 byte array.
-    pub key: Vec<u8>,
-    /// 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.
-    pub topic: Vec<u8>,
-    /// Maximum duration to wait for sending a stream piece to a peer.
-    pub max_send_duration: Duration,
-    /// Disable using relays, for tests.
-    pub disable_relay: bool,
-}
-
-#[derive(uniffi::Enum, Debug, Clone)]
-enum StreamFilter {
-    All,
-    Global,
-    Stream(Vec<u8>),
-}
-
-/// A filter for subscriptions and iteration.
-#[derive(uniffi::Object, Debug, Clone)]
-pub struct Filter {
-    scope: Option<Vec<Arc<PublicKey>>>,
-    stream: StreamFilter,
-    min_time: TimeBound,
-    max_time: TimeBound,
-}
-
-#[uniffi::export]
-impl Filter {
-    /// Creates a new filter that matches everything.
-    #[uniffi::constructor]
-    pub fn new() -> Arc<Self> {
-        Arc::new(Self {
-            scope: None,
-            stream: StreamFilter::All,
-            min_time: TimeBound::Unbounded,
-            max_time: TimeBound::Unbounded,
-        })
-    }
-
-    /// Restrict to the global namespace, no per stream data.
-    pub fn global(mut self: Arc<Self>) -> Arc<Self> {
-        let this = Arc::make_mut(&mut self);
-        this.stream = StreamFilter::Global;
-        self
-    }
-
-    /// Restrict to one specific stream, no global data.
-    pub fn stream(mut self: Arc<Self>, stream: Vec<u8>) -> Arc<Self> {
-        let this = Arc::make_mut(&mut self);
-        this.stream = StreamFilter::Stream(stream);
-        self
-    }
-
-    /// Restrict to a set of scopes.
-    pub fn scopes(mut self: Arc<Self>, scopes: Vec<Arc<PublicKey>>) -> Arc<Self> {
-        let this = Arc::make_mut(&mut self);
-        this.scope = Some(scopes);
-        self
-    }
-
-    /// Restrict to a single scope.
-    pub fn scope(self: Arc<Self>, scope: Arc<PublicKey>) -> Arc<Self> {
-        self.scopes(vec![scope])
-    }
-
-    /// Restrict to a time range.
-    pub fn timestamps(mut self: Arc<Self>, min: TimeBound, max: TimeBound) -> Arc<Self> {
-        let this = Arc::make_mut(&mut self);
-        this.min_time = min;
-        this.max_time = max;
-        self
-    }
-
-    /// Restrict to a time range given in nanoseconds since unix epoch.
-    pub fn time_range(self: Arc<Self>, min: u64, max: u64) -> Arc<Self> {
-        self.timestamps(TimeBound::Included(min), TimeBound::Excluded(max))
-    }
-
-    /// Restrict to a time range starting at min, unbounded at the top.
-    pub fn time_from(self: Arc<Self>, min: u64) -> Arc<Self> {
-        self.timestamps(TimeBound::Included(min), TimeBound::Unbounded)
-    }
-}
-
-impl From<Filter> for iroh_smol_kv::Filter {
-    fn from(value: Filter) -> Self {
-        let mut filter = iroh_smol_kv::Filter::ALL;
-        match value.stream {
-            // everything
-            StreamFilter::All => {}
-            // everything starting with 'g', for the global namespace
-            StreamFilter::Global => {
-                filter = filter.key_prefix(b"g".as_ref());
-            }
-            // a specific stream, everything starting with 's' + escaped stream name
-            StreamFilter::Stream(t) => {
-                let prefix = util::encode_stream_and_key(Some(&t), &[]);
-                filter = filter.key_prefix(prefix);
-            }
-        };
-        filter = filter.timestamps_nanos((
-            Bound::<u64>::from(value.min_time),
-            Bound::<u64>::from(value.max_time),
-        ));
-        if let Some(scopes) = value.scope {
-            let keys = scopes.iter().map(|k| iroh::PublicKey::from(k.as_ref()));
-            filter = filter.scopes(keys);
-        }
-        filter
-    }
-}
-
-/// Error getting the next item from a subscription.
-#[derive(uniffi::Enum, Snafu, Debug)]
-#[snafu(module)]
-pub enum SubscribeNextError {
-    /// Error during the subscribe next operation.
-    Irpc { message: String },
-}
-
-/// Error getting the next item from a subscription.
-#[derive(uniffi::Enum, Snafu, Debug)]
-#[snafu(module)]
-pub enum WriteError {
-    /// The provided private key is invalid (not 32 bytes).
-    PrivateKeySize { size: u64 },
-}
-
-/// Error shutting down the database.
-///
-/// This can occur if the db is already shut down or if there is an internal error.
-#[derive(uniffi::Enum, Snafu, Debug)]
-#[snafu(module)]
-pub enum ShutdownError {
-    /// Error during the shutdown operation.
-    Irpc { message: String },
-}
-
-/// An entry returned from the database.
-#[derive(uniffi::Record, Debug, PartialEq, Eq)]
-pub struct Entry {
-    scope: Arc<PublicKey>,
-    stream: Option<Vec<u8>>,
-    key: Vec<u8>,
-    value: Vec<u8>,
-    timestamp: u64,
-}
-
-/// An item returned from a subscription.
-#[derive(uniffi::Enum, Debug)]
-pub enum SubscribeItem {
-    Entry {
-        scope: Arc<PublicKey>,
-        stream: Option<Vec<u8>>,
-        key: Vec<u8>,
-        value: Vec<u8>,
-        timestamp: u64,
-    },
-    CurrentDone,
-    Expired {
-        scope: Arc<PublicKey>,
-        stream: Option<Vec<u8>>,
-        key: Vec<u8>,
-        timestamp: u64,
-    },
-    Other,
-}
-
-fn fmt_stream(stream: &Option<Vec<u8>>) -> String {
-    match stream {
-        None => "<nil>".to_string(),
-        Some(s) => format_bytes(s),
-    }
-}
-
-#[uniffi::export]
-pub fn subscribe_item_debug(item: &SubscribeItem) -> String {
-    match item {
-        SubscribeItem::Entry {
-            scope,
-            stream,
-            key,
-            value,
-            timestamp,
-        } => format!(
-            "Entry {{ scope: {}, stream: {}, key: {}, value: {}, timestamp: {} }}",
-            scope.fmt_short(),
-            fmt_stream(stream),
-            format_bytes(key),
-            format_bytes(value),
-            timestamp
-        ),
-        SubscribeItem::CurrentDone => "CurrentDone".to_string(),
-        SubscribeItem::Expired {
-            scope,
-            stream,
-            key,
-            timestamp,
-        } => format!(
-            "Expired {{ scope: {}, stream: {}, key: {}, timestamp: {} }}",
-            scope.fmt_short(),
-            fmt_stream(stream),
-            format_bytes(key),
-            timestamp
-        ),
-        SubscribeItem::Other => "Other".to_string(),
-    }
-}
-
-impl From<iroh_smol_kv::SubscribeItem> for SubscribeItem {
-    fn from(item: iroh_smol_kv::SubscribeItem) -> Self {
-        match &item {
-            iroh_smol_kv::SubscribeItem::Entry((scope, key, value)) => {
-                let Some((stream, key)) = util::decode_stream_and_key(key) else {
-                    return Self::Other;
-                };
-                Self::Entry {
-                    scope: Arc::new((*scope).into()),
-                    stream,
-                    key,
-                    value: value.value.to_vec(),
-                    timestamp: value.timestamp,
-                }
-            }
-            iroh_smol_kv::SubscribeItem::CurrentDone => Self::CurrentDone,
-            iroh_smol_kv::SubscribeItem::Expired((scope, topic, timestamp)) => {
-                let (stream, key) = util::decode_stream_and_key(topic).unwrap();
-                Self::Expired {
-                    scope: Arc::new((*scope).into()),
-                    stream,
-                    key,
-                    timestamp: *timestamp,
-                }
-            }
-        }
-    }
-}
-
-/// A response to a subscribe request.
-///
-/// This can be used as a stream of [`SubscribeItem`]s.
-#[derive(uniffi::Object)]
-#[uniffi::export(Debug)]
-#[allow(clippy::type_complexity)]
-pub struct SubscribeResponse {
-    inner: Mutex<
-        Pin<
-            Box<
-                dyn Stream<Item = Result<iroh_smol_kv::SubscribeItem, irpc::Error>>
-                    + Send
-                    + Sync
-                    + 'static,
-            >,
-        >,
-    >,
-}
-
-impl fmt::Debug for SubscribeResponse {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("SubscribeResponse").finish_non_exhaustive()
-    }
-}
-
-#[uniffi::export]
-impl SubscribeResponse {
-    pub async fn next_raw(&self) -> Result<Option<SubscribeItem>, SubscribeNextError> {
-        let mut this = self.inner.lock().await;
-        match this.as_mut().next().await {
-            None => Ok(None),
-            Some(Ok(item)) => Ok(Some(item.into())),
-            Some(Err(e)) => Err(SubscribeNextError::Irpc {
-                message: e.to_string(),
-            }),
-        }
-    }
-}
-
-/// Options for subscribing.
-///
-/// `filter` specifies what to subscribe to.
-/// `mode` specifies whether to get current items, new items, or both.
-#[derive(uniffi::Record)]
-pub struct SubscribeOpts {
-    pub filter: Arc<Filter>,
-    pub mode: SubscribeMode,
-}
-
-impl From<SubscribeOpts> for iroh_smol_kv::Subscribe {
-    fn from(opts: SubscribeOpts) -> Self {
-        iroh_smol_kv::Subscribe {
-            filter: opts.filter.as_ref().clone().into(),
-            mode: opts.mode.into(),
-        }
-    }
-}
-
-/// 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.
-#[derive(Clone, Debug, RefCast, uniffi::Object)]
-#[repr(transparent)]
-pub struct WriteScope(iroh_smol_kv::WriteScope);
-
-#[uniffi::export]
-impl WriteScope {
-    pub async fn put(
-        &self,
-        stream: Option<Vec<u8>>,
-        key: Vec<u8>,
-        value: Vec<u8>,
-    ) -> Result<(), PutError> {
-        self.put_impl(stream, key, value.into())
-            .await
-            .map_err(|e| PutError::Irpc {
-                message: e.to_string(),
-            })
-    }
-}
-
-impl WriteScope {
-    pub fn new(inner: iroh_smol_kv::WriteScope) -> Self {
-        Self(inner)
-    }
-
-    /// Put a value into the database, optionally in a specific stream.
-    pub async fn put_impl(
-        &self,
-        stream: Option<impl AsRef<[u8]>>,
-        key: impl AsRef<[u8]>,
-        value: Bytes,
-    ) -> Result<(), irpc::Error> {
-        let key = key.as_ref();
-        let stream = stream.as_ref().map(|s| s.as_ref());
-        let encoded = util::encode_stream_and_key(stream, key);
-        self.0.put(encoded, value).await?;
-        Ok(())
-    }
-}
-
-/// Iroh-streamplace specific metadata database.
-#[derive(Debug, Clone, RefCast, uniffi::Object)]
-#[repr(transparent)]
-pub struct Db(iroh_smol_kv::Client);
-
-impl Db {
-    pub fn new(inner: iroh_smol_kv::Client) -> Self {
-        Self(inner)
-    }
-
-    pub fn inner(&self) -> &iroh_smol_kv::Client {
-        &self.0
-    }
-}
-
-#[uniffi::export]
-impl Db {
-    pub fn write(&self, secret: Vec<u8>) -> Result<Arc<WriteScope>, WriteError> {
-        let secret = iroh::SecretKey::from_bytes(&secret.try_into().map_err(|e: Vec<u8>| {
-            WriteError::PrivateKeySize {
-                size: e.len() as u64,
-            }
-        })?);
-        let write = self.0.write(secret);
-        Ok(Arc::new(WriteScope::new(write)))
-    }
-
-    pub async fn iter_with_opts(
-        &self,
-        filter: Arc<Filter>,
-    ) -> Result<Vec<Entry>, SubscribeNextError> {
-        let sub = self.subscribe_with_opts(SubscribeOpts {
-            filter,
-            mode: SubscribeMode::Current,
-        });
-        let mut items = Vec::new();
-        while let Some(item) = sub.next_raw().await? {
-            match item {
-                SubscribeItem::Entry {
-                    scope,
-                    stream,
-                    key,
-                    value,
-                    timestamp,
-                } => {
-                    items.push(Entry {
-                        scope,
-                        stream,
-                        key,
-                        value,
-                        timestamp,
-                    });
-                }
-                _ => unreachable!("we used SubscribeMode::Current, so we should only get entries"),
-            }
-        }
-        Ok(items)
-    }
-
-    pub fn subscribe(&self, filter: Arc<Filter>) -> Arc<SubscribeResponse> {
-        self.subscribe_with_opts(SubscribeOpts {
-            filter,
-            mode: SubscribeMode::Both,
-        })
-    }
-
-    /// Subscribe with options.
-    pub fn subscribe_with_opts(&self, opts: SubscribeOpts) -> Arc<SubscribeResponse> {
-        Arc::new(SubscribeResponse {
-            inner: Mutex::new(Box::pin(
-                self.0.subscribe_with_opts(opts.into()).stream_raw(),
-            )),
-        })
-    }
-
-    /// Shutdown the database client and all subscriptions.
-    pub async fn shutdown(&self) -> Result<(), ShutdownError> {
-        Ok(self.0.shutdown().await.map_err(|e| ShutdownError::Irpc {
-            message: e.to_string(),
-        })?)
-    }
-}
-
-mod util {
-
-    pub fn encode_stream_and_key(stream: Option<&[u8]>, key: &[u8]) -> Vec<u8> {
-        let mut result = Vec::new();
-        if let Some(s) = stream {
-            result.push(b's');
-            postcard::to_io(s, &mut result).unwrap();
-        } else {
-            result.push(b'g');
-        }
-        result.extend(key);
-        result
-    }
-
-    pub fn decode_stream_and_key(encoded: &[u8]) -> Option<(Option<Vec<u8>>, Vec<u8>)> {
-        match encoded.split_first() {
-            Some((b's', mut rest)) => {
-                let (stream, rest) = postcard::take_from_bytes(&mut rest).ok()?;
-                Some((Some(stream), rest.to_vec()))
-            }
-            Some((b'g', rest)) => Some((None, rest.to_vec())),
-            _ => None,
-        }
-    }
-
-    pub fn format_bytes(bytes: &[u8]) -> String {
-        if bytes.is_empty() {
-            return "\"\"".to_string();
-        }
-        let Ok(s) = std::str::from_utf8(bytes) else {
-            return hex::encode(bytes);
-        };
-        if s.chars()
-            .any(|c| c.is_control() && c != '\n' && c != '\t' && c != '\r')
-        {
-            return hex::encode(bytes);
-        }
-        format!("\"{}\"", escape_string(s))
-    }
-
-    pub fn escape_string(s: &str) -> String {
-        s.chars()
-            .map(|c| match c {
-                '"' => "\\\"".to_string(),
-                '\\' => "\\\\".to_string(),
-                '\n' => "\\n".to_string(),
-                '\t' => "\\t".to_string(),
-                '\r' => "\\r".to_string(),
-                c => c.to_string(),
-            })
-            .collect()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::util;
-
-    #[test]
-    fn escape_unescape() {
-        let cases: Vec<(Option<&[u8]>, &[u8])> = vec![
-            (None, b"key1"),
-            (Some(b""), b""),
-            (Some(b""), b"a"),
-            (Some(b"a"), b""),
-        ];
-        for (stream, key) in cases {
-            let encoded = util::encode_stream_and_key(stream, key);
-            let (decoded_stream, decoded_key) = util::decode_stream_and_key(&encoded).unwrap();
-            assert_eq!(decoded_stream.as_deref(), stream);
-            assert_eq!(decoded_key.as_slice(), key);
-        }
-    }
-}

rust/iroh-streamplace/src/db/kv/subscribe_mode.rs

···
-use iroh_smol_kv as w;
-
-/// Subscription mode for key-value subscriptions.
-#[derive(uniffi::Enum, Debug, Clone, Copy)]
-pub enum SubscribeMode {
-    Current,
-    Future,
-    Both,
-}
-
-impl From<w::SubscribeMode> for SubscribeMode {
-    fn from(m: w::SubscribeMode) -> Self {
-        match m {
-            w::SubscribeMode::Current => SubscribeMode::Current,
-            w::SubscribeMode::Future => SubscribeMode::Future,
-            w::SubscribeMode::Both => SubscribeMode::Both,
-        }
-    }
-}
-
-impl From<SubscribeMode> for w::SubscribeMode {
-    fn from(m: SubscribeMode) -> Self {
-        match m {
-            SubscribeMode::Current => w::SubscribeMode::Current,
-            SubscribeMode::Future => w::SubscribeMode::Future,
-            SubscribeMode::Both => w::SubscribeMode::Both,
-        }
-    }
-}

rust/iroh-streamplace/src/db/kv/time_bound.rs

···
-use std::ops::Bound;
-
-/// A bound on time for filtering.
-#[derive(uniffi::Enum, Debug, Clone, Copy)]
-pub enum TimeBound {
-    Unbounded,
-    Included(u64),
-    Excluded(u64),
-}
-
-impl From<Bound<u64>> for TimeBound {
-    fn from(b: Bound<u64>) -> Self {
-        match b {
-            Bound::Unbounded => TimeBound::Unbounded,
-            Bound::Included(t) => TimeBound::Included(t),
-            Bound::Excluded(t) => TimeBound::Excluded(t),
-        }
-    }
-}
-
-impl From<TimeBound> for Bound<u64> {
-    fn from(b: TimeBound) -> Self {
-        match b {
-            TimeBound::Unbounded => Bound::Unbounded,
-            TimeBound::Included(t) => Bound::Included(t),
-            TimeBound::Excluded(t) => Bound::Excluded(t),
-        }
-    }
-}

rust/iroh-streamplace/src/error.rs

···
-#[derive(Debug, thiserror::Error, uniffi::Error)]
-#[uniffi(flat_error)]
-pub enum SPError {
-    #[error("No certificate chain found")]
-    NoCertificateChainFound,
-    #[error("C2PA error: {0}")]
-    C2paError(String),
-    #[error("IO Error: {0}")]
-    IOError(String),
-}

rust/iroh-streamplace/src/lib.rs

···
 uniffi::setup_scaffolding!();
 
-pub mod c2pa;
-pub mod error;
 pub mod node_addr;
 pub mod public_key;
-pub mod streams;
 
 use std::sync::{LazyLock, Once};
 
-mod db;
-pub use db::*;
-#[cfg(test)]
-mod tests;
-
-#[cfg(test)]
-mod test_stream;
-
 mod socket;
 pub use socket::*;
 
···
 /// Ensure logging is only initialized once
 static LOGGING_INIT: Once = Once::new();
 
-use std::{
-    collections::{BTreeMap, BTreeSet, HashSet},
-    str::FromStr,
-    sync::Arc,
-};
-
-use bytes::Bytes;
-use iroh::{NodeId, PublicKey, RelayMode, SecretKey, discovery::static_provider::StaticProvider};
-use iroh_base::ticket::NodeTicket;
-use iroh_gossip::{net::Gossip, proto::TopicId};
-use irpc::{WithChannels, rpc::RemoteService};
-use irpc_iroh::{IrohProtocol, IrohRemoteConnection};
-use n0_future::future::Boxed;
-
-mod rpc {
-    //! Protocol API
-    use bytes::Bytes;
-    use iroh::NodeId;
-    use irpc::{channel::oneshot, rpc_requests};
-    use serde::{Deserialize, Serialize};
-
-    pub const ALPN: &[u8] = b"/iroh/streamplace/1";
-
-    /// Subscribe to the given `key`
-    #[derive(Debug, Serialize, Deserialize)]
-    pub struct Subscribe {
-        pub key: String,
-        // TODO: verify
-        pub remote_id: NodeId,
-    }
-
-    /// Unsubscribe from the given `key`
-    #[derive(Debug, Serialize, Deserialize)]
-    pub struct Unsubscribe {
-        pub key: String,
-        // TODO: verify
-        pub remote_id: NodeId,
-    }
-
-    // #[derive(Debug, Serialize, Deserialize)]
-    // pub struct SendSegment {
-    //     pub key: String,
-    //     pub data: Bytes,
-    // }
-
-    #[derive(Debug, Clone, Serialize, Deserialize)]
-    pub struct RecvSegment {
-        pub from: NodeId,
-        pub key: String,
-        pub data: Bytes,
-    }
-
-    // Use the macro to generate both the Protocol and Message enums
-    // plus implement Channels for each type
-    #[rpc_requests(message = Message)]
-    #[derive(Serialize, Deserialize, Debug)]
-    pub enum Protocol {
-        #[rpc(tx=oneshot::Sender<()>)]
-        Subscribe(Subscribe),
-        #[rpc(tx=oneshot::Sender<()>)]
-        Unsubscribe(Unsubscribe),
-        #[rpc(tx=oneshot::Sender<()>)]
-        RecvSegment(RecvSegment),
-    }
-}
-
-mod api {
-    //! Protocol API
-    use bytes::Bytes;
-    use iroh::{NodeAddr, NodeId};
-    use irpc::{channel::oneshot, rpc_requests};
-    use serde::{Deserialize, Serialize};
-
-    /// Subscribe to the given `key`
-    #[derive(Debug, Serialize, Deserialize)]
-    pub struct Subscribe {
-        pub key: String,
-        // TODO: verify
-        pub remote_id: NodeId,
-    }
-
-    /// Unsubscribe from the given `key`
-    #[derive(Debug, Serialize, Deserialize)]
-    pub struct Unsubscribe {
-        pub key: String,
-        // TODO: verify
-        pub remote_id: NodeId,
-    }
-
-    #[derive(Debug, Serialize, Deserialize)]
-    pub struct SendSegment {
-        pub key: String,
-        pub data: Bytes,
-    }
-
-    #[derive(Debug, Serialize, Deserialize)]
-    pub struct JoinPeers {
-        pub peers: Vec<NodeAddr>,
-    }
-
-    #[derive(Debug, Serialize, Deserialize)]
-    pub struct AddTickets {
-        pub peers: Vec<NodeAddr>,
-    }
-
-    #[derive(Debug, Serialize, Deserialize)]
-    pub struct GetNodeAddr;
-
-    #[derive(Debug, Serialize, Deserialize)]
-    pub struct Shutdown;
-
-    // Use the macro to generate both the Protocol and Message enums
-    // plus implement Channels for each type
-    #[rpc_requests(message = Message)]
-    #[derive(Serialize, Deserialize, Debug)]
-    pub enum Protocol {
-        #[rpc(tx=oneshot::Sender<()>)]
-        Subscribe(Subscribe),
-        #[rpc(tx=oneshot::Sender<()>)]
-        Unsubscribe(Unsubscribe),
-        #[rpc(tx=oneshot::Sender<()>)]
-        SendSegment(SendSegment),
-        #[rpc(tx=oneshot::Sender<()>)]
-        JoinPeers(JoinPeers),
-        #[rpc(tx=oneshot::Sender<()>)]
-        AddTickets(AddTickets),
-        #[rpc(tx=oneshot::Sender<NodeAddr>)]
-        GetNodeAddr(GetNodeAddr),
-        #[rpc(tx=oneshot::Sender<()>)]
-        Shutdown(Shutdown),
-    }
-}
-use api::{Message as ApiMessage, Protocol as ApiProtocol};
-use n0_future::{FuturesUnordered, StreamExt};
-use rpc::{Message as RpcMessage, Protocol as RpcProtocol};
-use snafu::Snafu;
-use tracing::{Instrument, debug, error, trace, trace_span, warn};
-
-use crate::rpc::RecvSegment;
-
 /// Initialize logging with the default subscriber that respects RUST_LOG environment variable.
 /// This function is safe to call multiple times - it will only initialize logging once.
 #[uniffi::export]
···
         tracing_subscriber::fmt().with_env_filter(filter).init();
     });
 }
-
-pub(crate) enum HandlerMode {
-    Sender,
-    Forwarder,
-    Receiver(Arc<dyn DataHandler>),
-}
-
-impl HandlerMode {
-    pub fn mode_str(&self) -> &'static str {
-        match self {
-            HandlerMode::Sender => "sender",
-            HandlerMode::Forwarder => "forwarder",
-            HandlerMode::Receiver(_) => "receiver",
-        }
-    }
-}
-
-type Tasks = FuturesUnordered<Boxed<(NodeId, Result<(), RpcTaskError>)>>;
-
-/// Actor that contains both a kv db for metadata and a handler for the rpc protocol.
-///
-/// This can be used both for sender and receiver nodes. Sender nodes will just set the
-/// handler to None.
-struct Actor {
-    /// Receiver for rpc messages from remote nodes
-    rpc_rx: tokio::sync::mpsc::Receiver<RpcMessage>,
-    /// Receiver for API messages from the user
-    api_rx: tokio::sync::mpsc::Receiver<ApiMessage>,
-    /// nodes I need to send to for each stream
-    subscribers: BTreeMap<String, BTreeSet<NodeId>>,
-    /// nodes I am subscribed to
-    subscriptions: BTreeMap<String, NodeId>,
-    /// lightweight typed connection pool
-    connections: ConnectionPool,
-    /// How to handle incoming data
-    handler: HandlerMode,
-    /// Static provider for node discovery
-    sp: StaticProvider,
-    /// Iroh protocol router, I need to keep it around to keep the protocol alive
-    router: iroh::protocol::Router,
-    /// Metadata db
-    client: db::Db,
-    /// Write scope for this node for the metadata db
-    write: db::WriteScope,
-    /// Ongoing tasks
-    tasks: Tasks,
-    /// Configuration, needed for timeouts etc.
-    config: Arc<Config>,
-}
-
-#[derive(Debug, Clone)]
-struct Connection {
-    id: NodeId,
-    rpc: irpc::Client<RpcProtocol>,
-}
-
-#[derive(Debug, Snafu)]
-enum RpcTaskError {
-    #[snafu(transparent)]
-    Task { source: irpc::Error },
-    #[snafu(transparent)]
-    Timeout { source: tokio::time::error::Elapsed },
-}
-
-struct ConnectionPool {
-    endpoint: iroh::Endpoint,
-    connections: BTreeMap<NodeId, Connection>,
-}
-
-impl ConnectionPool {
-    fn new(endpoint: iroh::Endpoint) -> Self {
-        Self {
-            endpoint,
-            connections: BTreeMap::new(),
-        }
-    }
-
-    /// Cheap conn pool hack
-    fn get(&mut self, remote: &NodeId) -> Connection {
-        if !self.connections.contains_key(remote) {
-            trace!(remote = %remote.fmt_short(),"ConnectionPool.get is inserting a new remote connection");
-            let conn = IrohRemoteConnection::new(
-                self.endpoint.clone(),
-                (*remote).into(),
-                rpc::ALPN.to_vec(),
-            );
-            let conn = Connection {
-                rpc: irpc::Client::boxed(conn),
-                id: *remote,
-            };
-            self.connections.insert(*remote, conn);
-        }
-        self.connections
-            .get_mut(remote)
-            .expect("just inserted")
-            .clone()
-    }
-
-    fn remove(&mut self, remote: &NodeId) {
-        self.connections.remove(remote);
-    }
-}
-
-impl Actor {
-    pub async fn spawn(
-        endpoint: iroh::Endpoint,
-        sp: StaticProvider,
-        topic: iroh_gossip::proto::TopicId,
-        config: Config,
-        handler: HandlerMode,
-    ) -> Result<(Node, impl Future<Output = ()>), iroh_gossip::api::ApiError> {
-        let (rpc_tx, rpc_rx) = tokio::sync::mpsc::channel::<RpcMessage>(512);
-        let (api_tx, api_rx) = tokio::sync::mpsc::channel::<ApiMessage>(512);
-        let gossip = Gossip::builder().spawn(endpoint.clone());
-        let id = endpoint.node_id();
-        let router = iroh::protocol::Router::builder(endpoint.clone())
-            .accept(iroh_gossip::ALPN, gossip.clone())
-            .accept(
-                rpc::ALPN,
-                IrohProtocol::new(rpc::Protocol::remote_handler(rpc_tx.into())),
-            )
-            .spawn();
-        let topic = gossip.subscribe(topic, vec![]).await?;
-        let secret = router.endpoint().secret_key().clone();
-        let db_config = Default::default();
-        let client = iroh_smol_kv::Client::local(topic, db_config);
-        let write = db::WriteScope::new(client.write(secret.clone()));
-        let client = db::Db::new(client);
-        let actor = Self {
-            rpc_rx,
-            api_rx,
-            subscribers: BTreeMap::new(),
-            subscriptions: BTreeMap::new(),
-            connections: ConnectionPool::new(router.endpoint().clone()),
-            handler,
-            router,
-            sp,
-            write: write.clone(),
-            client: client.clone(),
-            tasks: FuturesUnordered::new(),
-            config: Arc::new(config),
-        };
-        let api = Node {
-            client: Arc::new(client),
-            write: Arc::new(write),
-            api: irpc::Client::local(api_tx),
-        };
-        Ok((
-            api,
-            actor
-                .run()
-                .instrument(trace_span!("actor", id=%id.fmt_short())),
-        ))
-    }
-
-    async fn run(mut self) {
-        loop {
-            tokio::select! {
-                msg = self.rpc_rx.recv() => {
-                    trace!("received local rpc message");
-                    let Some(msg) = msg else {
-                        error!("rpc channel closed");
-                        break;
-                    };
-                    self.handle_rpc(msg).instrument(trace_span!("rpc")).await;
-                }
-                msg = self.api_rx.recv() => {
-                    trace!("received remote rpc message");
-                    let Some(msg) = msg else {
-                        break;
-                    };
-                    if let Some(shutdown) = self.handle_api(msg).instrument(trace_span!("api")).await {
-                        shutdown.send(()).await.ok();
-                        break;
-                    }
-                }
-                res = self.tasks.next(), if !self.tasks.is_empty() => {
-                    trace!("processing task");
-                    let Some((remote_id, res)) = res else {
-                        error!("task finished but no result");
-                        break;
-                    };
-                    match res {
-                        Ok(()) => {}
-                        Err(RpcTaskError::Timeout { source }) => {
-                            warn!("call to {remote_id} timed out: {source}");
-                        }
-                        Err(RpcTaskError::Task { source }) => {
-                            warn!("call to {remote_id} failed: {source}");
-                        }
-                    }
-                    self.connections.remove(&remote_id);
-                }
-            }
-        }
-        warn!("RPC Actor loop has closed");
-    }
-
-    async fn update_subscriber_meta(&mut self, key: &str) {
-        let n = self
-            .subscribers
-            .get(key)
-            .map(|s| s.len())
-            .unwrap_or_default();
-        let v = n.to_string().into_bytes();
-        self.write
-            .put_impl(Some(key.as_bytes().to_vec()), b"subscribers", v.into())
-            .await
-            .ok();
-    }
-
-    /// Requests from remote nodes
-    async fn handle_rpc(&mut self, msg: RpcMessage) {
-        trace!("RPC.handle_rpc");
-        match msg {
-            RpcMessage::Subscribe(msg) => {
-                trace!(inner = ?msg.inner, "RpcMessage::Subscribe");
-                let WithChannels {
-                    tx,
-                    inner: rpc::Subscribe { key, remote_id },
-                    ..
-                } = msg;
-                self.subscribers
-                    .entry(key.clone())
-                    .or_default()
-                    .insert(remote_id);
-                self.update_subscriber_meta(&key).await;
-                tx.send(()).await.ok();
-            }
-            RpcMessage::Unsubscribe(msg) => {
-                debug!(inner = ?msg.inner, "RpcMessage::Unsubscribe");
-                let WithChannels {
-                    tx,
-                    inner: rpc::Unsubscribe { key, remote_id },
-                    ..
-                } = msg;
-                if let Some(e) = self.subscribers.get_mut(&key)
-                    && !e.remove(&remote_id)
-                {
-                    warn!(
-                        "unsubscribe: no subscription for {} from {}",
-                        key, remote_id
-                    );
-                }
-                if let Some(subscriptions) = self.subscribers.get(&key)
-                    && subscriptions.is_empty()
-                {
-                    self.subscribers.remove(&key);
-                }
-                self.update_subscriber_meta(&key).await;
-                tx.send(()).await.ok();
-            }
-            RpcMessage::RecvSegment(msg) => {
-                trace!(inner = ?msg.inner, "RpcMessage::RecvSegment");
-                let WithChannels {
-                    tx,
-                    inner: rpc::RecvSegment { key, from, data },
-                    ..
-                } = msg;
-                match &self.handler {
-                    HandlerMode::Sender => {
-                        warn!("received segment but in sender mode");
-                    }
-                    HandlerMode::Forwarder => {
-                        trace!("forwarding segment");
-                        if let Some(remotes) = self.subscribers.get(&key) {
-                            Self::handle_send(
-                                &mut self.tasks,
-                                &mut self.connections,
-                                &self.config,
-                                key,
-                                data,
-                                remotes,
-                            );
-                        } else {
-                            trace!("no subscribers for stream {}", key);
-                        }
-                    }
-                    HandlerMode::Receiver(handler) => {
-                        if self.subscriptions.contains_key(&key) {
-                            let from = Arc::new(from.into());
-                            handler.handle_data(from, key, data.to_vec()).await;
-                        } else {
-                            warn!("received segment for unsubscribed key: {}", key);
-                        }
-                    }
-                };
-                tx.send(()).await.ok();
-            }
-        }
-    }
-
-    async fn handle_api(&mut self, msg: ApiMessage) -> Option<irpc::channel::oneshot::Sender<()>> {
-        trace!("RPC.handle_api");
-        match msg {
-            ApiMessage::SendSegment(msg) => {
-                trace!(inner = ?msg.inner, "ApiMessage::SendSegment");
-                let WithChannels {
-                    tx,
-                    inner: api::SendSegment { key, data },
-                    ..
-                } = msg;
-                if let Some(remotes) = self.subscribers.get(&key) {
-                    Self::handle_send(
-                        &mut self.tasks,
-                        &mut self.connections,
-                        &self.config,
-                        key,
-                        data,
-                        remotes,
-                    );
-                } else {
-                    trace!("no subscribers for stream {}", key);
-                }
-                tx.send(()).await.ok();
-            }
-            ApiMessage::Subscribe(msg) => {
-                trace!(inner = ?msg.inner, "ApiMessage::Subscribe");
-                let WithChannels {
-                    tx,
-                    inner: api::Subscribe { key, remote_id },
-                    ..
-                } = msg;
-                let conn = self.connections.get(&remote_id);
-                tx.send(()).await.ok();
-                trace!(remote = %remote_id.fmt_short(), key = %key, "send rpc::Subscribe message");
-                conn.rpc
-                    .rpc(rpc::Subscribe {
-                        key: key.clone(),
-                        remote_id: self.node_id(),
-                    })
-                    .await
-                    .ok();
-                trace!(remote = %remote_id.fmt_short(), key = %key, "inserting subscription");
-                self.subscriptions.insert(key, remote_id);
-                trace!("finished inserting subscription");
-            }
-            ApiMessage::Unsubscribe(msg) => {
-                trace!(inner = ?msg.inner, "ApiMessage::Unsubscribe");
-                let WithChannels {
-                    tx,
-                    inner: api::Unsubscribe { key, remote_id },
-                    ..
-                } = msg;
-                let conn = self.connections.get(&remote_id);
-                tx.send(()).await.ok();
-                conn.rpc
-                    .rpc(rpc::Unsubscribe {
-                        key: key.clone(),
-                        remote_id: self.node_id(),
-                    })
-                    .await
-                    .ok();
-                self.subscriptions.remove(&key);
-            }
-            ApiMessage::AddTickets(msg) => {
-                trace!(inner = ?msg.inner, "ApiMessage::AddTickets");
-                let WithChannels {
-                    tx,
-                    inner: api::AddTickets { peers },
-                    ..
-                } = msg;
-                for addr in &peers {
-                    self.sp.add_node_info(addr.clone());
-                }
-                // self.client.inner().join_peers(ids).await.ok();
-                tx.send(()).await.ok();
-            }
-            ApiMessage::JoinPeers(msg) => {
-                trace!(inner = ?msg.inner, "ApiMessage::JoinPeers");
-                let WithChannels {
-                    tx,
-                    inner: api::JoinPeers { peers },
-                    ..
-                } = msg;
-                let ids = peers
-                    .iter()
-                    .map(|a| a.node_id)
-                    .filter(|id| *id != self.node_id())
-                    .collect::<HashSet<_>>();
-                for addr in &peers {
-                    self.sp.add_node_info(addr.clone());
-                }
-                self.client.inner().join_peers(ids).await.ok();
-                tx.send(()).await.ok();
-            }
-            ApiMessage::GetNodeAddr(msg) => {
-                trace!(inner = ?msg.inner, "ApiMessage::GetNodeAddr");
-                let WithChannels { tx, .. } = msg;
-                if !self.config.disable_relay {
-                    // don't await home relay if we have disabled relays, this will hang forever
-                    self.router.endpoint().online().await;
-                }
-                let addr = self.router.endpoint().node_addr();
-                tx.send(addr).await.ok();
-            }
-            ApiMessage::Shutdown(msg) => {
-                trace!(inner = ?msg.inner, "ApiMessage::Shutdown");
-                return Some(msg.tx);
-            }
-        }
-        None
-    }
-
-    fn handle_send(
-        tasks: &mut Tasks,
-        connections: &mut ConnectionPool,
-        config: &Arc<Config>,
-        key: String,
-        data: Bytes,
-        remotes: &BTreeSet<NodeId>,
-    ) {
-        let me = connections.endpoint.node_id();
-        let msg = rpc::RecvSegment {
-            key,
-            data,
-            from: me,
-        };
-        for remote in remotes {
-            trace!(remote = %remote.fmt_short(), key = %msg.key, "handle_send to remote");
-            let conn = connections.get(remote);
-            tasks.push(Box::pin(Self::forward_task(
-                config.clone(),
-                conn,
-                msg.clone(),
-            )));
-        }
-    }
-
-    async fn forward_task(
-        config: Arc<Config>,
-        conn: Connection,
-        msg: RecvSegment,
-    ) -> (NodeId, Result<(), RpcTaskError>) {
-        let id = conn.id;
-        let res = async move {
-            tokio::time::timeout(config.max_send_duration, conn.rpc.rpc(msg)).await??;
-            Ok(())
-        }
-        .await;
-        (id, res)
-    }
-
-    fn node_id(&self) -> PublicKey {
-        self.router.endpoint().node_id()
-    }
-}
-
-/// Iroh-streamplace node that can send, forward or receive stream segments.
-#[derive(Clone, uniffi::Object)]
-pub struct Node {
-    client: Arc<db::Db>,
-    write: Arc<db::WriteScope>,
-    api: irpc::Client<ApiProtocol>,
-}
-
-impl Node {
-    pub(crate) async fn new_in_runtime(
-        config: Config,
-        handler: HandlerMode,
-    ) -> Result<Arc<Self>, CreateError> {
-        let mode_str = Bytes::from(handler.mode_str());
-        let secret_key =
-            SecretKey::from_bytes(&<[u8; 32]>::try_from(config.key.clone()).map_err(|e| {
-                CreateError::PrivateKey {
-                    size: e.len() as u64,
-                }
-            })?);
-        let topic =
-            TopicId::from_bytes(<[u8; 32]>::try_from(config.topic.clone()).map_err(|e| {
-                CreateError::Topic {
-                    size: e.len() as u64,
-                }
-            })?);
-        let relay_mode = if config.disable_relay {
-            RelayMode::Disabled
-        } else {
-            RelayMode::Default
-        };
-        let sp = StaticProvider::new();
-        let endpoint = iroh::Endpoint::builder()
-            .secret_key(secret_key)
-            .relay_mode(relay_mode)
-            .discovery(sp.clone())
-            .bind()
-            .await
-            .map_err(|e| CreateError::Bind {
-                message: e.to_string(),
-            })?;
-        let (api, actor) = Actor::spawn(endpoint, sp, topic, config, handler)
-            .await
-            .map_err(|e| CreateError::Subscribe {
-                message: e.to_string(),
-            })?;
-        api.node_scope()
-            .put_impl(Option::<Vec<u8>>::None, b"mode", mode_str)
-            .await
-            .ok();
-        tokio::spawn(actor);
-        Ok(Arc::new(api))
-    }
-}
-
-/// DataHandler trait that is exported to go for receiving data callbacks.
-#[uniffi::export(with_foreign)]
-#[async_trait::async_trait]
-pub trait DataHandler: Send + Sync {
-    async fn handle_data(
-        &self,
-        from: Arc<crate::public_key::PublicKey>,
-        topic: String,
-        data: Vec<u8>,
-    );
-}
-
-#[uniffi::export]
-impl Node {
-    /// Create a new streamplace client node.
-    #[uniffi::constructor]
-    pub async fn sender(config: Config) -> Result<Arc<Self>, CreateError> {
-        RUNTIME.block_on(Self::new_in_runtime(config, HandlerMode::Sender))
-    }
-
-    #[uniffi::constructor]
-    pub async fn forwarder(config: Config) -> Result<Arc<Self>, CreateError> {
-        RUNTIME.block_on(Self::new_in_runtime(config, HandlerMode::Forwarder))
-    }
-
-    #[uniffi::constructor]
-    pub async fn receiver(
-        config: Config,
-        handler: Arc<dyn DataHandler>,
-    ) -> Result<Arc<Self>, CreateError> {
-        RUNTIME.block_on(Self::new_in_runtime(config, HandlerMode::Receiver(handler)))
-    }
-
-    /// Get a handle to the db to watch for changes locally or globally.
-    pub fn db(&self) -> Arc<db::Db> {
-        self.client.clone()
-    }
-
-    /// 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.
-    pub fn node_scope(&self) -> Arc<db::WriteScope> {
-        self.write.clone()
-    }
-
-    /// Subscribe to updates for a given stream from a remote node.
-    pub async fn subscribe(
-        &self,
-        key: String,
-        remote_id: Arc<crate::public_key::PublicKey>,
-    ) -> Result<(), PutError> {
-        self.api
-            .rpc(api::Subscribe {
-                key,
-                remote_id: remote_id.as_ref().into(),
-            })
-            .await
-            .map_err(|e| PutError::Irpc {
-                message: e.to_string(),
-            })
-    }
-
-    /// Unsubscribe from updates for a given stream from a remote node.
-    pub async fn unsubscribe(
-        &self,
-        key: String,
-        remote_id: Arc<crate::public_key::PublicKey>,
-    ) -> Result<(), PutError> {
-        self.api
-            .rpc(api::Unsubscribe {
-                key,
-                remote_id: remote_id.as_ref().into(),
-            })
-            .await
-            .map_err(|e| PutError::Irpc {
-                message: e.to_string(),
-            })
-    }
-
-    /// Send a segment to all subscribers of the given stream.
-    pub async fn send_segment(&self, key: String, data: Vec<u8>) -> Result<(), PutError> {
-        debug!(key = &key, data_len = data.len(), "Node.send_segment");
-        self.api
-            .rpc(api::SendSegment {
-                key,
-                data: data.into(),
-            })
-            .await
-            .map_err(|e| PutError::Irpc {
-                message: e.to_string(),
-            })
-    }
-
-    /// Join peers by their node tickets.
-    pub async fn join_peers(&self, peers: Vec<String>) -> Result<(), JoinPeersError> {
-        let peers = peers
-            .iter()
-            .map(|p| NodeTicket::from_str(p))
-            .collect::<Result<Vec<_>, _>>()
-            .map_err(|e| JoinPeersError::Ticket {
-                message: e.to_string(),
-            })?;
-        let addrs = peers
-            .iter()
-            .map(|t| t.node_addr().clone())
-            .collect::<Vec<_>>();
-        self.api
-            .rpc(api::JoinPeers { peers: addrs })
-            .await
-            .map_err(|e| JoinPeersError::Irpc {
-                message: e.to_string(),
-            })
-    }
-
-    /// Add tickets for remote peers
-    pub async fn add_tickets(&self, peers: Vec<String>) -> Result<(), JoinPeersError> {
-        let peers = peers
-            .iter()
-            .map(|p| NodeTicket::from_str(p))
-            .collect::<Result<Vec<_>, _>>()
-            .map_err(|e| JoinPeersError::Ticket {
-                message: e.to_string(),
-            })?;
-        let addrs = peers
-            .iter()
-            .map(|t| t.node_addr().clone())
-            .collect::<Vec<_>>();
-        self.api
-            .rpc(api::AddTickets { peers: addrs })
-            .await
-            .map_err(|e| JoinPeersError::Irpc {
-                message: e.to_string(),
-            })
-    }
-
-    /// Get this node's ticket.
-    pub async fn ticket(&self) -> Result<String, PutError> {
-        let addr = self
-            .api
-            .rpc(api::GetNodeAddr)
-            .await
-            .map_err(|e| PutError::Irpc {
-                message: e.to_string(),
-            })?;
-        Ok(NodeTicket::from(addr).to_string())
-    }
-
-    /// Get this node's node ID.
-    pub async fn node_id(&self) -> Result<Arc<crate::public_key::PublicKey>, PutError> {
-        let addr = self
-            .api
-            .rpc(api::GetNodeAddr)
-            .await
-            .map_err(|e| PutError::Irpc {
-                message: e.to_string(),
-            })?;
-        Ok(Arc::new(addr.node_id.into()))
-    }
-
-    /// Shutdown the node, including the streaming system and the metadata db.
-    pub async fn shutdown(&self) -> Result<(), ShutdownError> {
-        // shut down both the streams and the db concurrently, even if one fails
-        let (res1, res2) = tokio::join!(self.shutdown_streams(), self.client.shutdown());
-        res1?;
-        res2?;
-        Ok(())
-    }
-}
-
-impl Node {
-    async fn shutdown_streams(&self) -> std::result::Result<(), ShutdownError> {
-        self.api
-            .rpc(api::Shutdown)
-            .await
-            .map_err(|e| ShutdownError::Irpc {
-                message: e.to_string(),
-            })
-    }
-}

rust/iroh-streamplace/src/socket.rs

···
         self.alpn.clone()
     }
 
-    /// Accept an incoming connection and return a [`Stream2`].
-    pub async fn accept(&self) -> Result<Arc<Stream2>, AcceptError> {
+    /// Accept an incoming connection and return a [`Stream`].
+    pub async fn accept(&self) -> Result<Arc<Stream>, AcceptError> {
         RUNTIME.block_on(self.accept0())
     }
 
-    /// Connect to a peer at the given [`NodeAddr`] and return a [`Stream2`].
+    /// Connect to a peer at the given [`NodeAddr`] and return a [`Stream`].
     pub async fn connect(
         &self,
         addr: Arc<crate::node_addr::NodeAddr>,
-    ) -> Result<Arc<Stream2>, ConnectError> {
+    ) -> Result<Arc<Stream>, ConnectError> {
         RUNTIME.block_on(self.connect0(addr))
     }
 
···
         })
     }
 
-    async fn accept0(&self) -> Result<Arc<Stream2>, AcceptError> {
+    async fn accept0(&self) -> Result<Arc<Stream>, AcceptError> {
         let incoming = self
             .endpoint
             .accept()
···
         let (send, recv) = conn.accept_bi().await.map_err(|e| AcceptError::Other {
             message: e.to_string(),
         })?;
-        Ok(Arc::new(Stream2 {
+        Ok(Arc::new(Stream {
             recv: tokio::sync::Mutex::new(recv),
             send: tokio::sync::Mutex::new(send),
             conn,
···
     async fn connect0(
         &self,
         addr: Arc<crate::node_addr::NodeAddr>,
-    ) -> Result<Arc<Stream2>, ConnectError> {
+    ) -> Result<Arc<Stream>, ConnectError> {
         let node_addr: iroh::NodeAddr =
             (*addr)
                 .clone()
···
         let (send, recv) = conn.open_bi().await.map_err(|e| ConnectError::Other {
             message: e.to_string(),
         })?;
-        Ok(Arc::new(Stream2 {
+        Ok(Arc::new(Stream {
             recv: tokio::sync::Mutex::new(recv),
             send: tokio::sync::Mutex::new(send),
             conn,
···
 
 #[derive(Debug, thiserror::Error, uniffi::Error)]
 #[uniffi(flat_error)]
-pub enum WriteError2 {
+pub enum WriteError {
     #[error("Other error: {message}")]
     Other { message: String },
 }
···
     Other { message: String },
 }
 
+/// A bidirectional stream over an iroh connection.
+/// 
+/// In QUIC streams and connections are separate concepts. A connection can have multiple streams.
+/// For simplicity we expose a single bidirectional stream per connection here.
 #[derive(Debug, uniffi::Object)]
-pub struct Stream2 {
+pub struct Stream {
     recv: tokio::sync::Mutex<iroh::endpoint::RecvStream>,
     send: tokio::sync::Mutex<iroh::endpoint::SendStream>,
     conn: iroh::endpoint::Connection,
 }
 
 #[uniffi::export]
-impl Stream2 {
+impl Stream {
+
+    /// Read up to n bytes from the stream.
+    ///
+    /// Due to the way uniffi works, this can't have the signature that is
+    /// usually used in golang code. Instead of taking a mutable buffer and
+    /// returning the number of bytes read, it takes the number of bytes to read
+    /// and returns a vector with the data read.
+    /// 
+    /// Wrapping this into a more idiomatic golang interface needs a few lines
+    /// on the golang side.
     pub async fn read(&self, n: u64) -> Result<Vec<u8>, ReadError> {
         let mut buf = vec![0u8; n as usize];
         let n = self
···
         Ok(buf)
     }
 
-    pub async fn write_all(&self, buf: &[u8]) -> Result<(), WriteError2> {
-        self.send.lock().await.write_all(buf).await.map_err(|e| WriteError2::Other {
+    /// Write all bytes in buf to the stream.
+    pub async fn write_all(&self, buf: &[u8]) -> Result<(), WriteError> {
+        self.send.lock().await.write_all(buf).await.map_err(|e| WriteError::Other {
             message: e.to_string(),
         })
     }
 
-    pub async fn write(&self, buf: &[u8]) -> Result<u32, WriteError2> {
+    /// Write up to n bytes from buf to the stream.
+    pub async fn write(&self, buf: &[u8]) -> Result<u32, WriteError> {
         let n = self.send
             .lock()
             .await
             .write(&buf)
             .await
-            .map_err(|e| WriteError2::Other {
+            .map_err(|e| WriteError::Other {
                 message: e.to_string(),
             })?;
         Ok(n as u32)
     }
 
-    pub async fn close_write(&self) -> Result<(), WriteError2> {
-        self.send.lock().await.finish().map_err(|e| WriteError2::Other {
+    /// Close the write side of the stream.
+    /// 
+    /// Note: this does not close the underlying connection.
+    pub async fn close_write(&self) -> Result<(), WriteError> {
+        self.send.lock().await.finish().map_err(|e| WriteError::Other {
             message: e.to_string(),
         })?;
         Ok(())
     }
 
+    /// Close the read side of the stream.
+    /// 
+    /// Note: this does not close the underlying connection.
     pub async fn close_read(&self) -> Result<(), ReadError> {
         self.recv.lock().await.stop(0u32.into()).map_err(|e| ReadError::Other {
             message: e.to_string(),
···
         Ok(())
     }
 
+    /// Close the underlying connection.
     pub fn close(&self) {
         self.conn.close(0u32.into(), b"");
     }
 
+    /// Wait until the connection is closed.
     pub async fn closed(&self) {
         RUNTIME.block_on(async {
             let _reason = self.conn.closed().await;

rust/iroh-streamplace/src/streams.rs

···
-// Copyright 2023 Adobe. All rights reserved.
-// This file is licensed to you under the Apache License,
-// Version 2.0 (http://www.apache.org/licenses/LICENSE-2.0)
-// or the MIT license (http://opensource.org/licenses/MIT),
-// at your option.
-
-// Unless required by applicable law or agreed to in writing,
-// this software is distributed on an "AS IS" BASIS, WITHOUT
-// WARRANTIES OR REPRESENTATIONS OF ANY KIND, either express or
-// implied. See the LICENSE-MIT and LICENSE-APACHE files for the
-// specific language governing permissions and limitations under
-// each license.
-
-use std::{
-    io::{Read, Seek, SeekFrom, Write},
-    sync::Arc,
-};
-
-use crate::error::SPError;
-
-// #[repr(C)]
-// #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-// pub enum SeekMode {
-//     Start = 0,
-//     End = 1,
-//     Current = 2,
-// }
-
-/// This allows for a callback stream over the Uniffi interface.
-/// Implement these stream functions in the foreign language
-/// and this will provide Rust Stream trait implementations
-/// This is necessary since the Rust traits cannot be implemented directly
-/// as uniffi callbacks
-#[uniffi::export(with_foreign)]
-pub trait Stream: Send + Sync {
-    /// Read a stream of bytes from the stream
-    fn read_stream(&self, length: u64) -> Result<Vec<u8>, SPError>;
-    /// Seek to a position in the stream
-    fn seek_stream(&self, pos: i64, mode: u64) -> Result<u64, SPError>;
-    /// Write a stream of bytes to the stream
-    fn write_stream(&self, data: Vec<u8>) -> Result<u64, SPError>;
-}
-
-impl Stream for Arc<dyn Stream> {
-    fn read_stream(&self, length: u64) -> Result<Vec<u8>, SPError> {
-        (**self).read_stream(length)
-    }
-
-    fn seek_stream(&self, pos: i64, mode: u64) -> Result<u64, SPError> {
-        (**self).seek_stream(pos, mode)
-    }
-
-    fn write_stream(&self, data: Vec<u8>) -> Result<u64, SPError> {
-        (**self).write_stream(data)
-    }
-}
-
-impl AsMut<dyn Stream> for dyn Stream {
-    fn as_mut(&mut self) -> &mut Self {
-        self
-    }
-}
-
-pub struct StreamAdapter<'a> {
-    pub stream: &'a dyn Stream,
-}
-
-impl<'a> StreamAdapter<'a> {
-    pub fn from_stream_mut(stream: &'a mut dyn Stream) -> Self {
-        Self { stream }
-    }
-}
-
-impl<'a> From<&'a dyn Stream> for StreamAdapter<'a> {
-    fn from(stream: &'a dyn Stream) -> Self {
-        Self { stream }
-    }
-}
-
-impl<'a> Read for StreamAdapter<'a> {
-    fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
-        let mut bytes = self
-            .stream
-            .read_stream(buf.len() as u64)
-            .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e))?;
-        let len = bytes.len();
-        buf.iter_mut().zip(bytes.drain(..)).for_each(|(dest, src)| {
-            *dest = src;
-        });
-        //println!("read: {:?}", len);
-        Ok(len)
-    }
-}
-
-impl<'a> Seek for StreamAdapter<'a> {
-    fn seek(&mut self, pos: std::io::SeekFrom) -> std::io::Result<u64> {
-        let (pos, mode) = match pos {
-            SeekFrom::Current(pos) => (pos, 2),
-            SeekFrom::Start(pos) => (pos as i64, 0),
-            SeekFrom::End(pos) => (pos, 1),
-        };
-        //println!("Stream Seek {}", pos);
-        self.stream
-            .seek_stream(pos, mode)
-            .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e))
-    }
-}
-
-impl<'a> Write for StreamAdapter<'a> {
-    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
-        let len = self
-            .stream
-            .write_stream(buf.to_vec())
-            .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e))?;
-        Ok(len as usize)
-    }
-
-    fn flush(&mut self) -> std::io::Result<()> {
-        Ok(())
-    }
-}
-
-#[uniffi::export(with_foreign)]
-pub trait ManyStreams: Send + Sync {
-    /// Get the next stream from the many streams
-    fn next(&self) -> Option<Arc<dyn Stream>>;
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::test_stream::TestStream;
-
-    #[test]
-    fn test_stream_read() {
-        let mut test = TestStream::from_memory(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
-        let mut stream = StreamAdapter::from_stream_mut(&mut test);
-        let mut buf = [0u8; 5];
-        let len = stream.read(&mut buf).unwrap();
-        assert_eq!(len, 5);
-        assert_eq!(buf, [0, 1, 2, 3, 4]);
-    }
-
-    #[test]
-    fn test_stream_seek() {
-        let mut test = TestStream::from_memory(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
-        let mut stream = StreamAdapter { stream: &mut test };
-        let pos = stream.seek(SeekFrom::Start(5)).unwrap();
-        assert_eq!(pos, 5);
-        let mut buf = [0u8; 5];
-        let len = stream.read(&mut buf).unwrap();
-        assert_eq!(len, 5);
-        assert_eq!(buf, [5, 6, 7, 8, 9]);
-    }
-
-    #[test]
-    fn test_stream_write() {
-        let mut test = TestStream::new();
-        let mut stream = StreamAdapter { stream: &mut test };
-        let len = stream.write(&[0, 1, 2, 3, 4]).unwrap();
-        assert_eq!(len, 5);
-        stream.seek(SeekFrom::Start(0)).unwrap();
-        let mut buf = [0u8; 5];
-        let len = stream.read(&mut buf).unwrap();
-        assert_eq!(len, 5);
-        assert_eq!(buf, [0, 1, 2, 3, 4]);
-    }
-}

rust/iroh-streamplace/src/test_stream.rs

···
-// Copyright 2023 Adobe. All rights reserved.
-// This file is licensed to you under the Apache License,
-// Version 2.0 (http://www.apache.org/licenses/LICENSE-2.0)
-// or the MIT license (http://opensource.org/licenses/MIT),
-// at your option.
-
-// Unless required by applicable law or agreed to in writing,
-// this software is distributed on an "AS IS" BASIS, WITHOUT
-// WARRANTIES OR REPRESENTATIONS OF ANY KIND, either express or
-// implied. See the LICENSE-MIT and LICENSE-APACHE files for the
-// specific language governing permissions and limitations under
-// each license.
-
-use std::{
-    io::{Cursor, Read, Seek, SeekFrom, Write},
-    sync::RwLock,
-};
-
-use crate::{error::SPError, streams::Stream};
-
-pub struct TestStream {
-    stream: RwLock<Cursor<Vec<u8>>>,
-}
-
-impl TestStream {
-    pub fn new() -> Self {
-        Self {
-            stream: RwLock::new(Cursor::new(Vec::new())),
-        }
-    }
-    pub fn from_memory(data: Vec<u8>) -> Self {
-        Self {
-            stream: RwLock::new(Cursor::new(data)),
-        }
-    }
-}
-
-impl Stream for TestStream {
-    fn read_stream(&self, length: u64) -> Result<Vec<u8>, SPError> {
-        if let Ok(mut stream) = RwLock::write(&self.stream) {
-            let mut data = vec![0u8; length as usize];
-            let bytes_read = stream
-                .read(&mut data)
-                .map_err(|e| SPError::IOError(e.to_string()))?;
-            data.truncate(bytes_read);
-            //println!("read_stream: {:?}, pos {:?}", data.len(), (*stream).position());
-            Ok(data)
-        } else {
-            Err(SPError::IOError("RwLock".to_string()))?
-        }
-    }
-
-    fn seek_stream(&self, pos: i64, mode: u64) -> Result<u64, SPError> {
-        if let Ok(mut stream) = RwLock::write(&self.stream) {
-            //stream.seek(SeekFrom::Start(pos as u64)).map_err(|e| StreamError::Io{ reason: e.to_string()})?;
-            let whence = match mode {
-                0 => SeekFrom::Start(pos as u64),
-                1 => SeekFrom::End(pos as i64),
-                2 => SeekFrom::Current(pos as i64),
-                3_u64..=u64::MAX => unimplemented!(),
-            };
-            Ok(stream
-                .seek(whence)
-                .map_err(|e| SPError::IOError(e.to_string()))?)
-        } else {
-            Err(SPError::IOError("RwLock".to_string()))
-        }
-    }
-
-    fn write_stream(&self, data: Vec<u8>) -> Result<u64, SPError> {
-        if let Ok(mut stream) = RwLock::write(&self.stream) {
-            let len = stream
-                .write(&data)
-                .map_err(|e| SPError::IOError(e.to_string()))?;
-            Ok(len as u64)
-        } else {
-            Err(SPError::IOError("RwLock".to_string()))?
-        }
-    }
-}

rust/iroh-streamplace/src/tests.rs

···
-use std::{ops::Deref, sync::Arc, time::Duration};
-
-use async_trait::async_trait;
-use n0_future::{BufferedStreamExt, StreamExt, stream};
-use testresult::TestResult;
-
-use super::*;
-
-struct TestNode {
-    node: Arc<Node>,
-    public: Arc<crate::public_key::PublicKey>,
-    ticket: String,
-    #[allow(dead_code)]
-    private: Vec<u8>,
-}
-
-impl Deref for TestNode {
-    type Target = Node;
-
-    fn deref(&self) -> &Self::Target {
-        &self.node
-    }
-}
-
-impl TestNode {
-    /// Helper to create a test node with given config and handler mode.
-    async fn new(handler: HandlerMode) -> TestResult<TestNode> {
-        let config = Config {
-            key: vec![0_u8; 32],   // will be replaced
-            topic: vec![0_u8; 32], // all nodes use the same topic
-            max_send_duration: Duration::from_secs(10),
-            disable_relay: false,
-        };
-        Self::new_with_config(handler, config).await
-    }
-
-    async fn new_with_config(handler: HandlerMode, mut config: Config) -> TestResult<TestNode> {
-        let key = iroh::SecretKey::generate(&mut rand::rng());
-        let key = key.to_bytes().to_vec();
-        config.key = key.clone();
-        let node = Node::new_in_runtime(config, handler).await?;
-        let public = node.node_id().await?;
-        let ticket = node.ticket().await?;
-        Ok(TestNode {
-            node,
-            private: key,
-            public,
-            ticket,
-        })
-    }
-}
-
-/// Helper to create multiple test nodes with given handler mode.
-async fn test_nodes(
-    n: usize,
-    handler: impl Fn(usize) -> HandlerMode + Send + Sync,
-    disable_relay: bool,
-) -> TestResult<Vec<TestNode>> {
-    const PAR: usize = 32;
-    let modes = (0..n).map(handler).collect::<Vec<_>>();
-
-    let config = Config {
-        key: vec![0_u8; 32], // will be replaced
-        topic: vec![0_u8; 32],
-        max_send_duration: Duration::from_secs(10),
-        disable_relay,
-    };
-    // create all nodes in parallel
-    let nodes = stream::iter(modes)
-        .map(|mode| TestNode::new_with_config(mode, config.clone()))
-        .buffered_unordered(PAR)
-        .collect::<Vec<_>>()
-        .await;
-    let nodes = nodes.into_iter().collect::<TestResult<Vec<_>>>()?;
-    // join everyone to everyone
-    let tickets = nodes.iter().map(|n| n.ticket.clone()).collect::<Vec<_>>();
-    let res = stream::iter(&nodes)
-        .map(|n| n.join_peers(tickets.clone()))
-        .buffered_unordered(PAR)
-        .collect::<Vec<_>>()
-        .await;
-    res.into_iter().collect::<Result<Vec<_>, _>>()?;
-    Ok(nodes)
-}
-
-#[tokio::test]
-async fn one_node() -> TestResult<()> {
-    tracing_subscriber::fmt::try_init().ok();
-    let node = TestNode::new(HandlerMode::Sender).await?.node;
-    let write = node.node_scope();
-    let db = node.db();
-    println!("Ticket: {}", node.ticket().await?);
-    write
-        .put(Some(b"stream1".to_vec()), b"s".to_vec(), b"y".to_vec())
-        .await?;
-    write
-        .put(Some(b"stream2".to_vec()), b"s".to_vec(), b"y".to_vec())
-        .await?;
-    let res = db.subscribe_with_opts(SubscribeOpts {
-        filter: Filter::new(),
-        mode: SubscribeMode::Both,
-    });
-    while let Some(item) = res.next_raw().await? {
-        if let SubscribeItem::CurrentDone = item {
-            break;
-        }
-        println!("Got item: {item:?}");
-    }
-    let res = db
-        .iter_with_opts(
-            Filter::new()
-                .stream(b"stream1".to_vec())
-                .scope(node.node_id().await?),
-        )
-        .await?;
-    println!("Iter result: {res:?}");
-    Ok(())
-}
-
-struct TestHandler<T> {
-    info: T,
-    sender: tokio::sync::mpsc::Sender<(T, String, Vec<u8>)>,
-}
-
-impl<T> TestHandler<T> {
-    fn new(info: T, sender: tokio::sync::mpsc::Sender<(T, String, Vec<u8>)>) -> Self {
-        Self { info, sender }
-    }
-}
-
-#[async_trait]
-impl<T: Clone + Send + Sync + 'static> DataHandler for TestHandler<T> {
-    async fn handle_data(&self, _from: Arc<public_key::PublicKey>, topic: String, data: Vec<u8>) {
-        self.sender
-            .send((self.info.clone(), topic, data))
-            .await
-            .ok();
-    }
-}
-
-#[tokio::test]
-async fn two_nodes_send_receive() -> TestResult<()> {
-    tracing_subscriber::fmt::try_init().ok();
-    let (tx, mut rx) = tokio::sync::mpsc::channel(32);
-    let handler = Arc::new(TestHandler::new((), tx));
-    let sender = TestNode::new(HandlerMode::Sender).await?;
-    let receiver = TestNode::new(HandlerMode::Receiver(handler)).await?;
-    // join the sender to the receiver. This will also configure the receiver endpoint to be able to dial the sender.
-    receiver.join_peers(vec![sender.ticket.clone()]).await?;
-    let stream = "teststream".to_string();
-    receiver
-        .subscribe(stream.clone(), sender.public.clone())
-        .await?;
-    sender.send_segment(stream, b"segment1".to_vec()).await?;
-    let (_, stream, data) = rx.recv().await.expect("should get data");
-    assert_eq!(stream, "teststream");
-    assert_eq!(data, b"segment1".to_vec());
-    Ok(())
-}
-
-#[tokio::test]
-async fn three_nodes_send_forward_receive() -> TestResult<()> {
-    tracing_subscriber::fmt::try_init().ok();
-    let (tx, mut rx) = tokio::sync::mpsc::channel(32);
-    let handler = Arc::new(TestHandler::new((), tx));
-    let sender = TestNode::new(HandlerMode::Sender).await?;
-    let forwarder = TestNode::new(HandlerMode::Forwarder).await?;
-    let receiver = TestNode::new(HandlerMode::Receiver(handler)).await?;
-    // join everyone to everyone, so the receiver can reach the sender via the forwarder.
-    let tickets = vec![
-        sender.ticket.clone(),
-        forwarder.ticket.clone(),
-        receiver.ticket.clone(),
-    ];
-    receiver.join_peers(tickets.clone()).await?;
-    forwarder.join_peers(tickets.clone()).await?;
-    sender.join_peers(tickets).await?;
-    let stream = "teststream".to_string();
-    receiver
-        .subscribe(stream.clone(), forwarder.public.clone())
-        .await?;
-    forwarder
-        .subscribe(stream.clone(), sender.public.clone())
-        .await?;
-    sender.send_segment(stream, b"segment1".to_vec()).await?;
-    let (_, stream, data) = rx.recv().await.expect("should get data");
-    assert_eq!(stream, "teststream");
-    assert_eq!(data, b"segment1".to_vec());
-    Ok(())
-}
-
-#[tokio::test]
-async fn meta_three_nodes_send_forward_receive() -> TestResult<()> {
-    tracing_subscriber::fmt::try_init().ok();
-    let (tx, mut rx) = tokio::sync::mpsc::channel(32);
-    let handler = Arc::new(TestHandler::new((), tx));
-    let sender = TestNode::new(HandlerMode::Sender).await?;
-    let forwarder = TestNode::new(HandlerMode::Forwarder).await?;
-    let receiver = TestNode::new(HandlerMode::Receiver(handler)).await?;
-    // join everyone to everyone, so the receiver can reach the sender via the forwarder.
-    let tickets = vec![
-        sender.ticket.clone(),
-        forwarder.ticket.clone(),
-        receiver.ticket.clone(),
-    ];
-    receiver.join_peers(tickets.clone()).await?;
-    forwarder.join_peers(tickets.clone()).await?;
-    sender.join_peers(tickets).await?;
-    let stream = "teststream".to_string();
-    receiver
-        .subscribe(stream.clone(), forwarder.public.clone())
-        .await?;
-    forwarder
-        .subscribe(stream.clone(), sender.public.clone())
-        .await?;
-    sender.send_segment(stream, b"segment1".to_vec()).await?;
-    let (_, stream, data) = rx.recv().await.expect("should get data");
-    assert_eq!(stream, "teststream");
-    assert_eq!(data, b"segment1".to_vec());
-    let stream = receiver.db().subscribe(Filter::new());
-    while let Some(item) = stream.next_raw().await? {
-        println!("{}", subscribe_item_debug(&item));
-    }
-    Ok(())
-}
-
-async fn broadcast(
-    nsenders: usize,
-    nforwarders: usize,
-    nreceivers: usize,
-    nmsgs: usize,
-) -> TestResult<()> {
-    let (tx, mut rx) = tokio::sync::mpsc::channel(32);
-    let ntotal = nsenders + nforwarders + nreceivers;
-    let senders = 0..nsenders;
-    let forwarders = nsenders..(nsenders + nforwarders);
-    let receivers = (nsenders + nforwarders)..ntotal;
-    let make_handler = |i: usize| {
-        if senders.contains(&i) {
-            HandlerMode::Sender
-        } else if forwarders.contains(&i) {
-            HandlerMode::Forwarder
-        } else {
-            HandlerMode::Receiver(Arc::new(TestHandler::new(i, tx.clone())))
-        }
-    };
-    let nodes = test_nodes(ntotal, make_handler, true).await?;
-    let senders = &nodes[senders];
-    let forwarders = &nodes[forwarders];
-    let receivers = &nodes[receivers];
-    let stream = "teststream".to_string();
-    // subscribe all forwarders to a sender, round robin
-    for (i, forwarder) in forwarders.iter().enumerate() {
-        let sender = &senders[i % senders.len()];
-        forwarder
-            .subscribe(stream.clone(), sender.public.clone())
-            .await?;
-    }
-    // subscribe all receivers to a forwarder, round robin
-    for (i, receiver) in receivers.iter().enumerate() {
-        let forwarder = &forwarders[i % forwarders.len()];
-        receiver
-            .subscribe(stream.clone(), forwarder.public.clone())
-            .await?;
-    }
-    for _ in 0..nmsgs {
-        for sender in senders {
-            sender
-                .send_segment(stream.clone(), b"segment1".to_vec())
-                .await?;
-        }
-        for _ in 0..receivers.len() {
-            let (i, stream, _) = rx.recv().await.expect("should get data");
-            println!("Node {i} got data on stream {stream}");
-        }
-    }
-    Ok(())
-}
-
-#[tokio::test]
-async fn broadcast_1_2_4() -> TestResult<()> {
-    tracing_subscriber::fmt().try_init().ok();
-    broadcast(1, 2, 4, 1).await?;
-    Ok(())
-}
-
-#[tokio::test]
-async fn broadcast_1_3_9() -> TestResult<()> {
-    tracing_subscriber::fmt().try_init().ok();
-    broadcast(1, 3, 9, 1).await?;
-    Ok(())
-}
-
-#[tokio::test]
-async fn broadcast_1_4_16() -> TestResult<()> {
-    tracing_subscriber::fmt().try_init().ok();
-    broadcast(1, 4, 16, 100).await?;
-    Ok(())
-}