slidge-whatsapp 0.2.5__cp313-cp313-manylinux_2_36_aarch64.whl → 0.2.7__cp313-cp313-manylinux_2_36_aarch64.whl

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/store/signal.go

@@ -7,6 +7,9 @@
 package store
 
 import (
+	"context"
+	"fmt"
+
 	"go.mau.fi/libsignal/ecc"
 	groupRecord "go.mau.fi/libsignal/groups/state/record"
 	"go.mau.fi/libsignal/keys/identity"
@@ -14,8 +17,6 @@ import (
 	"go.mau.fi/libsignal/serialize"
 	"go.mau.fi/libsignal/state/record"
 	"go.mau.fi/libsignal/state/store"
-
-	"go.mau.fi/whatsmeow/util/keys"
 )
 
 var SignalProtobufSerializer = serialize.NewProtoBufSerializer()
@@ -29,167 +30,153 @@ func (device *Device) GetIdentityKeyPair() *identity.KeyPair {
 	)
 }
 
-func (device *Device) GetLocalRegistrationId() uint32 {
+func (device *Device) GetLocalRegistrationID() uint32 {
 	return device.RegistrationID
 }
 
-func (device *Device) SaveIdentity(address *protocol.SignalAddress, identityKey *identity.Key) {
-	for i := 0; ; i++ {
-		err := device.Identities.PutIdentity(address.String(), identityKey.PublicKey().PublicKey())
-		if err == nil || !device.handleDatabaseError(i, err, "save identity of %s", address.String()) {
-			break
-		}
+func (device *Device) SaveIdentity(ctx context.Context, address *protocol.SignalAddress, identityKey *identity.Key) error {
+	addrString := address.String()
+	err := device.Identities.PutIdentity(ctx, addrString, identityKey.PublicKey().PublicKey())
+	if err != nil {
+		return fmt.Errorf("failed to save identity of %s: %w", addrString, err)
 	}
+	return nil
 }
 
-func (device *Device) IsTrustedIdentity(address *protocol.SignalAddress, identityKey *identity.Key) bool {
-	for i := 0; ; i++ {
-		isTrusted, err := device.Identities.IsTrustedIdentity(address.String(), identityKey.PublicKey().PublicKey())
-		if err == nil || !device.handleDatabaseError(i, err, "check if %s's identity is trusted", address.String()) {
-			return isTrusted
-		}
+func (device *Device) IsTrustedIdentity(ctx context.Context, address *protocol.SignalAddress, identityKey *identity.Key) (bool, error) {
+	addrString := address.String()
+	isTrusted, err := device.Identities.IsTrustedIdentity(ctx, addrString, identityKey.PublicKey().PublicKey())
+	if err != nil {
+		return false, fmt.Errorf("failed to check if %s's identity is trusted: %w", addrString, err)
 	}
+	return isTrusted, nil
 }
 
-func (device *Device) LoadPreKey(id uint32) *record.PreKey {
-	var preKey *keys.PreKey
-	for i := 0; ; i++ {
-		var err error
-		preKey, err = device.PreKeys.GetPreKey(id)
-		if err == nil || !device.handleDatabaseError(i, err, "load prekey %d", id) {
-			break
-		}
+func (device *Device) LoadPreKey(ctx context.Context, id uint32) (*record.PreKey, error) {
+	preKey, err := device.PreKeys.GetPreKey(ctx, id)
+	if err != nil {
+		return nil, fmt.Errorf("failed to load prekey %d: %w", id, err)
 	}
 	if preKey == nil {
-		return nil
+		return nil, nil
 	}
 	return record.NewPreKey(preKey.KeyID, ecc.NewECKeyPair(
 		ecc.NewDjbECPublicKey(*preKey.Pub),
 		ecc.NewDjbECPrivateKey(*preKey.Priv),
-	), nil)
+	), nil), nil
 }
 
-func (device *Device) RemovePreKey(id uint32) {
-	for i := 0; ; i++ {
-		err := device.PreKeys.RemovePreKey(id)
-		if err == nil || !device.handleDatabaseError(i, err, "remove prekey %d", id) {
-			break
-		}
+func (device *Device) RemovePreKey(ctx context.Context, id uint32) error {
+	err := device.PreKeys.RemovePreKey(ctx, id)
+	if err != nil {
+		return fmt.Errorf("failed to remove prekey %d: %w", id, err)
 	}
+	return nil
 }
 
-func (device *Device) StorePreKey(preKeyID uint32, preKeyRecord *record.PreKey) {
+func (device *Device) StorePreKey(ctx context.Context, preKeyID uint32, preKeyRecord *record.PreKey) error {
 	panic("not implemented")
 }
 
-func (device *Device) ContainsPreKey(preKeyID uint32) bool {
+func (device *Device) ContainsPreKey(ctx context.Context, preKeyID uint32) (bool, error) {
 	panic("not implemented")
 }
 
-func (device *Device) LoadSession(address *protocol.SignalAddress) *record.Session {
-	var rawSess []byte
-	var err error
-	for i := 0; ; i++ {
-		rawSess, err = device.Sessions.GetSession(address.String())
-		if err == nil || !device.handleDatabaseError(i, err, "load session with %s", address.String()) {
-			break
-		}
+func (device *Device) LoadSession(ctx context.Context, address *protocol.SignalAddress) (*record.Session, error) {
+	addrString := address.String()
+	rawSess, err := device.Sessions.GetSession(ctx, addrString)
+	if err != nil {
+		return nil, fmt.Errorf("failed to load session with %s: %w", addrString, err)
 	}
 	if rawSess == nil {
-		if err != nil {
-			return nil
-		}
-		return record.NewSession(SignalProtobufSerializer.Session, SignalProtobufSerializer.State)
+		return record.NewSession(SignalProtobufSerializer.Session, SignalProtobufSerializer.State), nil
 	}
 	sess, err := record.NewSessionFromBytes(rawSess, SignalProtobufSerializer.Session, SignalProtobufSerializer.State)
 	if err != nil {
-		device.Log.Errorf("Failed to deserialize session with %s: %v", address.String(), err)
-		return nil
+		return nil, fmt.Errorf("failed to deserialize session with %s: %w", addrString, err)
 	}
-	return sess
+	return sess, nil
 }
 
-func (device *Device) GetSubDeviceSessions(name string) []uint32 {
+func (device *Device) GetSubDeviceSessions(ctx context.Context, name string) ([]uint32, error) {
 	panic("not implemented")
 }
 
-func (device *Device) StoreSession(address *protocol.SignalAddress, record *record.Session) {
-	for i := 0; ; i++ {
-		err := device.Sessions.PutSession(address.String(), record.Serialize())
-		if err == nil || !device.handleDatabaseError(i, err, "store session with %s", address.String()) {
-			return
-		}
+func (device *Device) StoreSession(ctx context.Context, address *protocol.SignalAddress, record *record.Session) error {
+	addrString := address.String()
+	err := device.Sessions.PutSession(ctx, addrString, record.Serialize())
+	if err != nil {
+		return fmt.Errorf("failed to store session with %s: %w", addrString, err)
 	}
+	return nil
 }
 
-func (device *Device) ContainsSession(remoteAddress *protocol.SignalAddress) bool {
-	for i := 0; ; i++ {
-		hasSession, err := device.Sessions.HasSession(remoteAddress.String())
-		if err == nil || !device.handleDatabaseError(i, err, "store has session for %s", remoteAddress.String()) {
-			return hasSession
-		}
+func (device *Device) ContainsSession(ctx context.Context, remoteAddress *protocol.SignalAddress) (bool, error) {
+	addrString := remoteAddress.String()
+	hasSession, err := device.Sessions.HasSession(ctx, addrString)
+	if err != nil {
+		return false, fmt.Errorf("failed to check if store has session for %s: %w", addrString, err)
 	}
+	return hasSession, nil
 }
 
-func (device *Device) DeleteSession(remoteAddress *protocol.SignalAddress) {
+func (device *Device) DeleteSession(ctx context.Context, remoteAddress *protocol.SignalAddress) error {
 	panic("not implemented")
 }
 
-func (device *Device) DeleteAllSessions() {
+func (device *Device) DeleteAllSessions(ctx context.Context) error {
 	panic("not implemented")
 }
 
-func (device *Device) LoadSignedPreKey(signedPreKeyID uint32) *record.SignedPreKey {
+func (device *Device) LoadSignedPreKey(ctx context.Context, signedPreKeyID uint32) (*record.SignedPreKey, error) {
 	if signedPreKeyID == device.SignedPreKey.KeyID {
 		return record.NewSignedPreKey(signedPreKeyID, 0, ecc.NewECKeyPair(
 			ecc.NewDjbECPublicKey(*device.SignedPreKey.Pub),
 			ecc.NewDjbECPrivateKey(*device.SignedPreKey.Priv),
-		), *device.SignedPreKey.Signature, nil)
+		), *device.SignedPreKey.Signature, nil), nil
 	}
-	return nil
+	return nil, nil
 }
 
-func (device *Device) LoadSignedPreKeys() []*record.SignedPreKey {
+func (device *Device) LoadSignedPreKeys(ctx context.Context) ([]*record.SignedPreKey, error) {
 	panic("not implemented")
 }
 
-func (device *Device) StoreSignedPreKey(signedPreKeyID uint32, record *record.SignedPreKey) {
+func (device *Device) StoreSignedPreKey(ctx context.Context, signedPreKeyID uint32, record *record.SignedPreKey) error {
 	panic("not implemented")
 }
 
-func (device *Device) ContainsSignedPreKey(signedPreKeyID uint32) bool {
+func (device *Device) ContainsSignedPreKey(ctx context.Context, signedPreKeyID uint32) (bool, error) {
 	panic("not implemented")
 }
 
-func (device *Device) RemoveSignedPreKey(signedPreKeyID uint32) {
+func (device *Device) RemoveSignedPreKey(ctx context.Context, signedPreKeyID uint32) error {
 	panic("not implemented")
 }
 
-func (device *Device) StoreSenderKey(senderKeyName *protocol.SenderKeyName, keyRecord *groupRecord.SenderKey) {
-	for i := 0; ; i++ {
-		err := device.SenderKeys.PutSenderKey(senderKeyName.GroupID(), senderKeyName.Sender().String(), keyRecord.Serialize())
-		if err == nil || !device.handleDatabaseError(i, err, "store sender key from %s", senderKeyName.Sender().String()) {
-			return
-		}
+func (device *Device) StoreSenderKey(ctx context.Context, senderKeyName *protocol.SenderKeyName, keyRecord *groupRecord.SenderKey) error {
+	groupID := senderKeyName.GroupID()
+	senderString := senderKeyName.Sender().String()
+	err := device.SenderKeys.PutSenderKey(ctx, groupID, senderString, keyRecord.Serialize())
+	if err != nil {
+		return fmt.Errorf("failed to store sender key from %s for %s: %w", senderString, groupID, err)
 	}
+	return nil
 }
 
-func (device *Device) LoadSenderKey(senderKeyName *protocol.SenderKeyName) *groupRecord.SenderKey {
-	var rawKey []byte
-	for i := 0; ; i++ {
-		var err error
-		rawKey, err = device.SenderKeys.GetSenderKey(senderKeyName.GroupID(), senderKeyName.Sender().String())
-		if err == nil || !device.handleDatabaseError(i, err, "load sender key from %s for %s", senderKeyName.Sender().String(), senderKeyName.GroupID()) {
-			break
-		}
+func (device *Device) LoadSenderKey(ctx context.Context, senderKeyName *protocol.SenderKeyName) (*groupRecord.SenderKey, error) {
+	groupID := senderKeyName.GroupID()
+	senderString := senderKeyName.Sender().String()
+	rawKey, err := device.SenderKeys.GetSenderKey(ctx, groupID, senderString)
+	if err != nil {
+		return nil, fmt.Errorf("failed to load sender key from %s for %s: %w", senderString, groupID, err)
 	}
 	if rawKey == nil {
-		return groupRecord.NewSenderKey(SignalProtobufSerializer.SenderKeyRecord, SignalProtobufSerializer.SenderKeyState)
+		return groupRecord.NewSenderKey(SignalProtobufSerializer.SenderKeyRecord, SignalProtobufSerializer.SenderKeyState), nil
 	}
 	key, err := groupRecord.NewSenderKeyFromBytes(rawKey, SignalProtobufSerializer.SenderKeyRecord, SignalProtobufSerializer.SenderKeyState)
 	if err != nil {
-		device.Log.Errorf("Failed to deserialize sender key from %s for %s: %v", senderKeyName.Sender().String(), senderKeyName.GroupID(), err)
-		return groupRecord.NewSenderKey(SignalProtobufSerializer.SenderKeyRecord, SignalProtobufSerializer.SenderKeyState)
+		return nil, fmt.Errorf("failed to deserialize sender key from %s for %s: %w", senderString, groupID, err)
 	}
-	return key
+	return key, nil
 }

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/store/sqlstore/container.go

@@ -7,16 +7,19 @@
 package sqlstore
 
 import (
+	"context"
 	"database/sql"
 	"errors"
 	"fmt"
-	mathRand "math/rand"
+	mathRand "math/rand/v2"
 
 	"github.com/google/uuid"
+	"go.mau.fi/util/dbutil"
 	"go.mau.fi/util/random"
 
 	"go.mau.fi/whatsmeow/proto/waAdv"
 	"go.mau.fi/whatsmeow/store"
+	"go.mau.fi/whatsmeow/store/sqlstore/upgrades"
 	"go.mau.fi/whatsmeow/types"
 	"go.mau.fi/whatsmeow/util/keys"
 	waLog "go.mau.fi/whatsmeow/util/log"
@@ -24,11 +27,9 @@ import (
 
 // Container is a wrapper for a SQL database that can contain multiple whatsmeow sessions.
 type Container struct {
-	db      *sql.DB
-	dialect string
-	log     waLog.Logger
-
-	DatabaseErrorHandler func(device *store.Device, action string, attemptIndex int, err error) (retry bool)
+	db     *dbutil.Database
+	log    waLog.Logger
+	LIDMap *CachedLIDMap
 }
 
 var _ store.DeviceContainer = (*Container)(nil)
@@ -41,14 +42,14 @@ var _ store.DeviceContainer = (*Container)(nil)
 //
 // When using SQLite, it's strongly recommended to enable foreign keys by adding `?_foreign_keys=true`:
 //
-//	container, err := sqlstore.New("sqlite3", "file:yoursqlitefile.db?_foreign_keys=on", nil)
-func New(dialect, address string, log waLog.Logger) (*Container, error) {
+//	container, err := sqlstore.New(context.Background(), "sqlite3", "file:yoursqlitefile.db?_foreign_keys=on", nil)
+func New(ctx context.Context, dialect, address string, log waLog.Logger) (*Container, error) {
 	db, err := sql.Open(dialect, address)
 	if err != nil {
 		return nil, fmt.Errorf("failed to open database: %w", err)
 	}
 	container := NewWithDB(db, dialect, log)
-	err = container.Upgrade()
+	err = container.Upgrade(ctx)
 	if err != nil {
 		return nil, fmt.Errorf("failed to upgrade database: %w", err)
 	}
@@ -74,33 +75,54 @@ func New(dialect, address string, log waLog.Logger) (*Container, error) {
 //	container := sqlstore.NewWithDB(...)
 //	err := container.Upgrade()
 func NewWithDB(db *sql.DB, dialect string, log waLog.Logger) *Container {
+	wrapped, err := dbutil.NewWithDB(db, dialect)
+	if err != nil {
+		// This will only panic if the dialect is invalid
+		panic(err)
+	}
+	wrapped.UpgradeTable = upgrades.Table
+	wrapped.VersionTable = "whatsmeow_version"
+	return NewWithWrappedDB(wrapped, log)
+}
+
+func NewWithWrappedDB(wrapped *dbutil.Database, log waLog.Logger) *Container {
 	if log == nil {
 		log = waLog.Noop
 	}
 	return &Container{
-		db:      db,
-		dialect: dialect,
-		log:     log,
+		db:     wrapped,
+		log:    log,
+		LIDMap: NewCachedLIDMap(wrapped),
 	}
 }
 
+// Upgrade upgrades the database from the current to the latest version available.
+func (c *Container) Upgrade(ctx context.Context) error {
+	if c.db.Dialect == dbutil.SQLite {
+		var foreignKeysEnabled bool
+		err := c.db.QueryRow(ctx, "PRAGMA foreign_keys").Scan(&foreignKeysEnabled)
+		if err != nil {
+			return fmt.Errorf("failed to check if foreign keys are enabled: %w", err)
+		} else if !foreignKeysEnabled {
+			return fmt.Errorf("foreign keys are not enabled")
+		}
+	}
+
+	return c.db.Upgrade(ctx)
+}
+
 const getAllDevicesQuery = `
-SELECT jid, registration_id, noise_key, identity_key,
+SELECT jid, lid, registration_id, noise_key, identity_key,
        signed_pre_key, signed_pre_key_id, signed_pre_key_sig,
        adv_key, adv_details, adv_account_sig, adv_account_sig_key, adv_device_sig,
-       platform, business_name, push_name, facebook_uuid
+       platform, business_name, push_name, facebook_uuid, lid_migration_ts
 FROM whatsmeow_device
 `
 
 const getDeviceQuery = getAllDevicesQuery + " WHERE jid=$1"
 
-type scannable interface {
-	Scan(dest ...interface{}) error
-}
-
-func (c *Container) scanDevice(row scannable) (*store.Device, error) {
+func (c *Container) scanDevice(row dbutil.Scannable) (*store.Device, error) {
 	var device store.Device
-	device.DatabaseErrorHandler = c.DatabaseErrorHandler
 	device.Log = c.log
 	device.SignedPreKey = &keys.PreKey{}
 	var noisePriv, identityPriv, preKeyPriv, preKeySig []byte
@@ -108,10 +130,10 @@ func (c *Container) scanDevice(row scannable) (*store.Device, error) {
 	var fbUUID uuid.NullUUID
 
 	err := row.Scan(
-		&device.ID, &device.RegistrationID, &noisePriv, &identityPriv,
+		&device.ID, &device.LID, &device.RegistrationID, &noisePriv, &identityPriv,
 		&preKeyPriv, &device.SignedPreKey.KeyID, &preKeySig,
 		&device.AdvSecretKey, &account.Details, &account.AccountSignature, &account.AccountSignatureKey, &account.DeviceSignature,
-		&device.Platform, &device.BusinessName, &device.PushName, &fbUUID)
+		&device.Platform, &device.BusinessName, &device.PushName, &fbUUID, &device.LIDMigrationTimestamp)
 	if err != nil {
 		return nil, fmt.Errorf("failed to scan session: %w", err)
 	} else if len(noisePriv) != 32 || len(identityPriv) != 32 || len(preKeyPriv) != 32 || len(preKeySig) != 64 {
@@ -125,26 +147,14 @@ func (c *Container) scanDevice(row scannable) (*store.Device, error) {
 	device.Account = &account
 	device.FacebookUUID = fbUUID.UUID
 
-	innerStore := NewSQLStore(c, *device.ID)
-	device.Identities = innerStore
-	device.Sessions = innerStore
-	device.PreKeys = innerStore
-	device.SenderKeys = innerStore
-	device.AppStateKeys = innerStore
-	device.AppState = innerStore
-	device.Contacts = innerStore
-	device.ChatSettings = innerStore
-	device.MsgSecrets = innerStore
-	device.PrivacyTokens = innerStore
-	device.Container = c
-	device.Initialized = true
+	c.initializeDevice(&device)
 
 	return &device, nil
 }
 
 // GetAllDevices finds all the devices in the database.
-func (c *Container) GetAllDevices() ([]*store.Device, error) {
-	res, err := c.db.Query(getAllDevicesQuery)
+func (c *Container) GetAllDevices(ctx context.Context) ([]*store.Device, error) {
+	res, err := c.db.Query(ctx, getAllDevicesQuery)
 	if err != nil {
 		return nil, fmt.Errorf("failed to query sessions: %w", err)
 	}
@@ -162,8 +172,8 @@ func (c *Container) GetAllDevices() ([]*store.Device, error) {
 // GetFirstDevice is a convenience method for getting the first device in the store. If there are
 // no devices, then a new device will be created. You should only use this if you don't want to
 // have multiple sessions simultaneously.
-func (c *Container) GetFirstDevice() (*store.Device, error) {
-	devices, err := c.GetAllDevices()
+func (c *Container) GetFirstDevice(ctx context.Context) (*store.Device, error) {
+	devices, err := c.GetAllDevices(ctx)
 	if err != nil {
 		return nil, err
 	}
@@ -179,8 +189,8 @@ func (c *Container) GetFirstDevice() (*store.Device, error) {
 // If the device is not found, nil is returned instead.
 //
 // Note that the parameter usually must be an AD-JID.
-func (c *Container) GetDevice(jid types.JID) (*store.Device, error) {
-	sess, err := c.scanDevice(c.db.QueryRow(getDeviceQuery, jid))
+func (c *Container) GetDevice(ctx context.Context, jid types.JID) (*store.Device, error) {
+	sess, err := c.scanDevice(c.db.QueryRow(ctx, getDeviceQuery, jid))
 	if errors.Is(err, sql.ErrNoRows) {
 		return nil, nil
 	}
@@ -189,13 +199,17 @@ func (c *Container) GetDevice(jid types.JID) (*store.Device, error) {
 
 const (
 	insertDeviceQuery = `
-		INSERT INTO whatsmeow_device (jid, registration_id, noise_key, identity_key,
+		INSERT INTO whatsmeow_device (jid, lid, registration_id, noise_key, identity_key,
 									  signed_pre_key, signed_pre_key_id, signed_pre_key_sig,
 									  adv_key, adv_details, adv_account_sig, adv_account_sig_key, adv_device_sig,
-									  platform, business_name, push_name, facebook_uuid)
-		VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16)
+									  platform, business_name, push_name, facebook_uuid, lid_migration_ts)
+		VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18)
 		ON CONFLICT (jid) DO UPDATE
-		    SET platform=excluded.platform, business_name=excluded.business_name, push_name=excluded.push_name
+			SET lid=excluded.lid,
+				platform=excluded.platform,
+				business_name=excluded.business_name,
+				push_name=excluded.push_name,
+				lid_migration_ts=excluded.lid_migration_ts
 	`
 	deleteDeviceQuery = `DELETE FROM whatsmeow_device WHERE jid=$1`
 )
@@ -209,8 +223,6 @@ func (c *Container) NewDevice() *store.Device {
 		Log:       c.log,
 		Container: c,
 
-		DatabaseErrorHandler: c.DatabaseErrorHandler,
-
 		NoiseKey:       keys.NewKeyPair(),
 		IdentityKey:    keys.NewKeyPair(),
 		RegistrationID: mathRand.Uint32(),
@@ -233,38 +245,47 @@ func (c *Container) Close() error {
 
 // PutDevice stores the given device in this database. This should be called through Device.Save()
 // (which usually doesn't need to be called manually, as the library does that automatically when relevant).
-func (c *Container) PutDevice(device *store.Device) error {
+func (c *Container) PutDevice(ctx context.Context, device *store.Device) error {
 	if device.ID == nil {
 		return ErrDeviceIDMustBeSet
 	}
-	_, err := c.db.Exec(insertDeviceQuery,
-		device.ID.String(), device.RegistrationID, device.NoiseKey.Priv[:], device.IdentityKey.Priv[:],
+	_, err := c.db.Exec(ctx, insertDeviceQuery,
+		device.ID, device.LID, device.RegistrationID, device.NoiseKey.Priv[:], device.IdentityKey.Priv[:],
 		device.SignedPreKey.Priv[:], device.SignedPreKey.KeyID, device.SignedPreKey.Signature[:],
 		device.AdvSecretKey, device.Account.Details, device.Account.AccountSignature, device.Account.AccountSignatureKey, device.Account.DeviceSignature,
-		device.Platform, device.BusinessName, device.PushName, uuid.NullUUID{UUID: device.FacebookUUID, Valid: device.FacebookUUID != uuid.Nil})
+		device.Platform, device.BusinessName, device.PushName, uuid.NullUUID{UUID: device.FacebookUUID, Valid: device.FacebookUUID != uuid.Nil},
+		device.LIDMigrationTimestamp,
+	)
 
 	if !device.Initialized {
-		innerStore := NewSQLStore(c, *device.ID)
-		device.Identities = innerStore
-		device.Sessions = innerStore
-		device.PreKeys = innerStore
-		device.SenderKeys = innerStore
-		device.AppStateKeys = innerStore
-		device.AppState = innerStore
-		device.Contacts = innerStore
-		device.ChatSettings = innerStore
-		device.MsgSecrets = innerStore
-		device.PrivacyTokens = innerStore
-		device.Initialized = true
+		c.initializeDevice(device)
 	}
 	return err
 }
 
+func (c *Container) initializeDevice(device *store.Device) {
+	innerStore := NewSQLStore(c, *device.ID)
+	device.Identities = innerStore
+	device.Sessions = innerStore
+	device.PreKeys = innerStore
+	device.SenderKeys = innerStore
+	device.AppStateKeys = innerStore
+	device.AppState = innerStore
+	device.Contacts = innerStore
+	device.ChatSettings = innerStore
+	device.MsgSecrets = innerStore
+	device.PrivacyTokens = innerStore
+	device.EventBuffer = innerStore
+	device.LIDs = c.LIDMap
+	device.Container = c
+	device.Initialized = true
+}
+
 // DeleteDevice deletes the given device from this database. This should be called through Device.Delete()
-func (c *Container) DeleteDevice(store *store.Device) error {
+func (c *Container) DeleteDevice(ctx context.Context, store *store.Device) error {
 	if store.ID == nil {
 		return ErrDeviceIDMustBeSet
 	}
-	_, err := c.db.Exec(deleteDeviceQuery, store.ID.String())
+	_, err := c.db.Exec(ctx, deleteDeviceQuery, store.ID)
 	return err
 }