Migrating from v1

v2 is a rewrite. It keeps v1's central idea, peers identified by VaultysID DIDs, and changes almost everything around it:

• Security: in v1, messages could flow, and be attributed to a DID, before the handshake completed. The DID of an incoming connection was taken from what the caller claimed. The identity's secret was written to storage. v2 fixes all three.
• Packaging: v1.0.1 couldn't be loaded by Node.js, and its runtime dependencies weren't declared. v2 ships working ESM and CommonJS builds.
• Design: v1's PeerService and VaultysPeer mixed connections, authentication, storage, calls and groups. v2 separates them into small layers with one entry point.

Side by side

v1

import { PeerService, BrowserStorageProvider } from "@vaultys/peer-sdk";

const service = new PeerService({
  vaultysId,
  relay: { host: "relay.example.com", secure: true },
  storageProvider: new BrowserStorageProvider(),
});
await service.initialize();

const bob = await service.addContact(bobDid, { nickname: "Bob" });
await bob.connect();
await service.sendMessage(bobDid, "Hello");

service.on("message-received", (message) => console.log(message.from, message.content));

v2

import { createPeer, indexedDBStore } from "@vaultys/peer-sdk";
import { peerjsTransport } from "@vaultys/peer-sdk/peerjs";

const peer = await createPeer({
  identity: vaultysId,
  transport: peerjsTransport({ host: "relay.example.com", secure: true }),
  store: indexedDBStore(),
});

await peer.contacts.add(bobDid, { name: "Bob" });
await peer.send(bobDid, { text: "Hello" }); // connects by itself, queues if offline

peer.on("message", ({ from, body }) => console.log(from, body));

API mapping

v1	v2
new PeerService(config) + initialize(), setupVaultysPeerSDK(config)	await createPeer(options)
config.vaultysId	options.identity
config.relay	transport: peerjsTransport({...}) from @vaultys/peer-sdk/peerjs
storageProvider (BrowserStorageProvider, IndexedDBStorageProvider, OPFSStorageProvider, NodeFSStorageProvider, MemoryStorageProvider)	store (indexedDBStore, fileStore, memoryStore)
getDid()	peer.did
addContact(did, metadata) / removeContact / getContacts / getPeers / getPeer	peer.contacts.add/remove/list/get
metadata.nickname	contact.name; custom fields go in contact.data
VaultysPeer.connect()	peer.connect(did), or nothing: sending connects
sendMessage(did, content, type, fileData)	peer.send(did, body) with any msgpack value
message.content / message.fileData	message.body, shaped as you choose
loadMessages(did)	Removed: keep your own history (how)
"message-received" / "message-sent" / "message-queued"	"message"; send() resolving = queued; "delivered" = acknowledged
"peer-status", "contact-online", "contact-offline", "peer-authenticated"	"connection" ({ did, online }); online always means authenticated
sendRoomData / RoomEnvelope / "room-message"	peer.protocol(name) with your own types
createGroup, addPeerToGroup, …	Removed: keep groups in your app and fan out
makeCall / answerCall / endCall	Not in v2.0 yet
VaultysSpace / OwnedVaultysSpace	YjsProvider from @vaultys/peer-sdk/yjs (ownedBy for owned spaces)
space.getText() / getMap() / getArray()	Use the Y.Doc directly: doc.getText()…
space.setCursor() / getPresenceStates()	provider.awareness
EventBus, SimpleEventBus, StandardEvents	Removed: peer.on() with typed events
getPeerIdFromDid, isValidDid	isVaultysDid; peer ids are internal to the transport

Behavior changes to watch

• Strangers are refused by default. v1 accepted any incoming connection. In v2, only contacts can connect, unless you pass acceptIncoming.
• The identity isn't saved for you. v1 wrote the secret to config.json in the storage provider. If you relied on that, store identity.getSecret() yourself, somewhere protected.
• VaultysID v1 DIDs only. Identities are switched to v1, so a peer's DID may differ from what an older app displayed for the same key.
• Data isn't migrated. v2 uses a new storage layout. Contacts from v1 must be re-added (read v1's peers.json with msgpack if you need to import them). v1's message history isn't read.
• v1 and v2 peers can't talk to each other. The handshake and wire format changed. Upgrade every app that needs to communicate together.