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

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

@@ -0,0 +1,214 @@
+// Copyright (c) 2025 Tulir Asokan
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package store
+
+import (
+	"errors"
+	"time"
+
+	"go.mau.fi/whatsmeow/types"
+	"go.mau.fi/whatsmeow/util/keys"
+)
+
+type NoopStore struct {
+	Error error
+}
+
+var nilStore = &NoopStore{Error: errors.New("store is nil")}
+var nilKey = &keys.KeyPair{Priv: &[32]byte{}, Pub: &[32]byte{}}
+var NoopDevice = &Device{
+	ID:          &types.EmptyJID,
+	NoiseKey:    nilKey,
+	IdentityKey: nilKey,
+
+	Identities:    nilStore,
+	Sessions:      nilStore,
+	PreKeys:       nilStore,
+	SenderKeys:    nilStore,
+	AppStateKeys:  nilStore,
+	AppState:      nilStore,
+	Contacts:      nilStore,
+	ChatSettings:  nilStore,
+	MsgSecrets:    nilStore,
+	PrivacyTokens: nilStore,
+	Container:     nilStore,
+}
+
+var _ AllStores = (*NoopStore)(nil)
+var _ DeviceContainer = (*NoopStore)(nil)
+
+func (n *NoopStore) PutIdentity(address string, key [32]byte) error {
+	return n.Error
+}
+
+func (n *NoopStore) DeleteAllIdentities(phone string) error {
+	return n.Error
+}
+
+func (n *NoopStore) DeleteIdentity(address string) error {
+	return n.Error
+}
+
+func (n *NoopStore) IsTrustedIdentity(address string, key [32]byte) (bool, error) {
+	return false, n.Error
+}
+
+func (n *NoopStore) GetSession(address string) ([]byte, error) {
+	return nil, n.Error
+}
+
+func (n *NoopStore) HasSession(address string) (bool, error) {
+	return false, n.Error
+}
+
+func (n *NoopStore) PutSession(address string, session []byte) error {
+	return n.Error
+}
+
+func (n *NoopStore) DeleteAllSessions(phone string) error {
+	return n.Error
+}
+
+func (n *NoopStore) DeleteSession(address string) error {
+	return n.Error
+}
+
+func (n *NoopStore) GetOrGenPreKeys(count uint32) ([]*keys.PreKey, error) {
+	return nil, n.Error
+}
+
+func (n *NoopStore) GenOnePreKey() (*keys.PreKey, error) {
+	return nil, n.Error
+}
+
+func (n *NoopStore) GetPreKey(id uint32) (*keys.PreKey, error) {
+	return nil, n.Error
+}
+
+func (n *NoopStore) RemovePreKey(id uint32) error {
+	return n.Error
+}
+
+func (n *NoopStore) MarkPreKeysAsUploaded(upToID uint32) error {
+	return n.Error
+}
+
+func (n *NoopStore) UploadedPreKeyCount() (int, error) {
+	return 0, n.Error
+}
+
+func (n *NoopStore) PutSenderKey(group, user string, session []byte) error {
+	return n.Error
+}
+
+func (n *NoopStore) GetSenderKey(group, user string) ([]byte, error) {
+	return nil, n.Error
+}
+
+func (n *NoopStore) PutAppStateSyncKey(id []byte, key AppStateSyncKey) error {
+	return n.Error
+}
+
+func (n *NoopStore) GetAppStateSyncKey(id []byte) (*AppStateSyncKey, error) {
+	return nil, n.Error
+}
+
+func (n *NoopStore) GetLatestAppStateSyncKeyID() ([]byte, error) {
+	return nil, n.Error
+}
+
+func (n *NoopStore) PutAppStateVersion(name string, version uint64, hash [128]byte) error {
+	return n.Error
+}
+
+func (n *NoopStore) GetAppStateVersion(name string) (uint64, [128]byte, error) {
+	return 0, [128]byte{}, n.Error
+}
+
+func (n *NoopStore) DeleteAppStateVersion(name string) error {
+	return n.Error
+}
+
+func (n *NoopStore) PutAppStateMutationMACs(name string, version uint64, mutations []AppStateMutationMAC) error {
+	return n.Error
+}
+
+func (n *NoopStore) DeleteAppStateMutationMACs(name string, indexMACs [][]byte) error {
+	return n.Error
+}
+
+func (n *NoopStore) GetAppStateMutationMAC(name string, indexMAC []byte) (valueMAC []byte, err error) {
+	return nil, n.Error
+}
+
+func (n *NoopStore) PutPushName(user types.JID, pushName string) (bool, string, error) {
+	return false, "", n.Error
+}
+
+func (n *NoopStore) PutBusinessName(user types.JID, businessName string) (bool, string, error) {
+	return false, "", n.Error
+}
+
+func (n *NoopStore) PutContactName(user types.JID, fullName, firstName string) error {
+	return n.Error
+}
+
+func (n *NoopStore) PutAllContactNames(contacts []ContactEntry) error {
+	return n.Error
+}
+
+func (n *NoopStore) GetContact(user types.JID) (types.ContactInfo, error) {
+	return types.ContactInfo{}, n.Error
+}
+
+func (n *NoopStore) GetAllContacts() (map[types.JID]types.ContactInfo, error) {
+	return nil, n.Error
+}
+
+func (n *NoopStore) PutMutedUntil(chat types.JID, mutedUntil time.Time) error {
+	return n.Error
+}
+
+func (n *NoopStore) PutPinned(chat types.JID, pinned bool) error {
+	return n.Error
+}
+
+func (n *NoopStore) PutArchived(chat types.JID, archived bool) error {
+	return n.Error
+}
+
+func (n *NoopStore) GetChatSettings(chat types.JID) (types.LocalChatSettings, error) {
+	return types.LocalChatSettings{}, n.Error
+}
+
+func (n *NoopStore) PutMessageSecrets(inserts []MessageSecretInsert) error {
+	return n.Error
+}
+
+func (n *NoopStore) PutMessageSecret(chat, sender types.JID, id types.MessageID, secret []byte) error {
+	return n.Error
+}
+
+func (n *NoopStore) GetMessageSecret(chat, sender types.JID, id types.MessageID) ([]byte, error) {
+	return nil, n.Error
+}
+
+func (n *NoopStore) PutPrivacyTokens(tokens ...PrivacyToken) error {
+	return n.Error
+}
+
+func (n *NoopStore) GetPrivacyToken(user types.JID) (*PrivacyToken, error) {
+	return nil, n.Error
+}
+
+func (n *NoopStore) PutDevice(store *Device) error {
+	return n.Error
+}
+
+func (n *NoopStore) DeleteDevice(store *Device) error {
+	return n.Error
+}

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

@@ -0,0 +1,195 @@
+// Copyright (c) 2022 Tulir Asokan
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package store
+
+import (
+	"go.mau.fi/libsignal/ecc"
+	groupRecord "go.mau.fi/libsignal/groups/state/record"
+	"go.mau.fi/libsignal/keys/identity"
+	"go.mau.fi/libsignal/protocol"
+	"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()
+
+var _ store.SignalProtocol = (*Device)(nil)
+
+func (device *Device) GetIdentityKeyPair() *identity.KeyPair {
+	return identity.NewKeyPair(
+		identity.NewKey(ecc.NewDjbECPublicKey(*device.IdentityKey.Pub)),
+		ecc.NewDjbECPrivateKey(*device.IdentityKey.Priv),
+	)
+}
+
+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) 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) 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
+		}
+	}
+	if preKey == nil {
+		return nil
+	}
+	return record.NewPreKey(preKey.KeyID, ecc.NewECKeyPair(
+		ecc.NewDjbECPublicKey(*preKey.Pub),
+		ecc.NewDjbECPrivateKey(*preKey.Priv),
+	), 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) StorePreKey(preKeyID uint32, preKeyRecord *record.PreKey) {
+	panic("not implemented")
+}
+
+func (device *Device) ContainsPreKey(preKeyID uint32) bool {
+	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
+		}
+	}
+	if rawSess == nil {
+		if err != nil {
+			return nil
+		}
+		return record.NewSession(SignalProtobufSerializer.Session, SignalProtobufSerializer.State)
+	}
+	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 sess
+}
+
+func (device *Device) GetSubDeviceSessions(name string) []uint32 {
+	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) 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) DeleteSession(remoteAddress *protocol.SignalAddress) {
+	panic("not implemented")
+}
+
+func (device *Device) DeleteAllSessions() {
+	panic("not implemented")
+}
+
+func (device *Device) LoadSignedPreKey(signedPreKeyID uint32) *record.SignedPreKey {
+	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)
+	}
+	return nil
+}
+
+func (device *Device) LoadSignedPreKeys() []*record.SignedPreKey {
+	panic("not implemented")
+}
+
+func (device *Device) StoreSignedPreKey(signedPreKeyID uint32, record *record.SignedPreKey) {
+	panic("not implemented")
+}
+
+func (device *Device) ContainsSignedPreKey(signedPreKeyID uint32) bool {
+	panic("not implemented")
+}
+
+func (device *Device) RemoveSignedPreKey(signedPreKeyID uint32) {
+	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) 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
+		}
+	}
+	if rawKey == nil {
+		return groupRecord.NewSenderKey(SignalProtobufSerializer.SenderKeyRecord, SignalProtobufSerializer.SenderKeyState)
+	}
+	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 key
+}

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

@@ -0,0 +1,270 @@
+// Copyright (c) 2022 Tulir Asokan
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package sqlstore
+
+import (
+	"database/sql"
+	"errors"
+	"fmt"
+	mathRand "math/rand"
+
+	"github.com/google/uuid"
+	"go.mau.fi/util/random"
+
+	"go.mau.fi/whatsmeow/proto/waAdv"
+	"go.mau.fi/whatsmeow/store"
+	"go.mau.fi/whatsmeow/types"
+	"go.mau.fi/whatsmeow/util/keys"
+	waLog "go.mau.fi/whatsmeow/util/log"
+)
+
+// 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)
+}
+
+var _ store.DeviceContainer = (*Container)(nil)
+
+// New connects to the given SQL database and wraps it in a Container.
+//
+// Only SQLite and Postgres are currently fully supported.
+//
+// The logger can be nil and will default to a no-op logger.
+//
+// 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) {
+	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()
+	if err != nil {
+		return nil, fmt.Errorf("failed to upgrade database: %w", err)
+	}
+	return container, nil
+}
+
+// NewWithDB wraps an existing SQL connection in a Container.
+//
+// Only SQLite and Postgres are currently fully supported.
+//
+// The logger can be nil and will default to a no-op logger.
+//
+// When using SQLite, it's strongly recommended to enable foreign keys by adding `?_foreign_keys=true`:
+//
+//	db, err := sql.Open("sqlite3", "file:yoursqlitefile.db?_foreign_keys=on")
+//	if err != nil {
+//	    panic(err)
+//	}
+//	container := sqlstore.NewWithDB(db, "sqlite3", nil)
+//
+// This method does not call Upgrade automatically like New does, so you must call it yourself:
+//
+//	container := sqlstore.NewWithDB(...)
+//	err := container.Upgrade()
+func NewWithDB(db *sql.DB, dialect string, log waLog.Logger) *Container {
+	if log == nil {
+		log = waLog.Noop
+	}
+	return &Container{
+		db:      db,
+		dialect: dialect,
+		log:     log,
+	}
+}
+
+const getAllDevicesQuery = `
+SELECT jid, 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
+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) {
+	var device store.Device
+	device.DatabaseErrorHandler = c.DatabaseErrorHandler
+	device.Log = c.log
+	device.SignedPreKey = &keys.PreKey{}
+	var noisePriv, identityPriv, preKeyPriv, preKeySig []byte
+	var account waAdv.ADVSignedDeviceIdentity
+	var fbUUID uuid.NullUUID
+
+	err := row.Scan(
+		&device.ID, &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)
+	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 {
+		return nil, ErrInvalidLength
+	}
+
+	device.NoiseKey = keys.NewKeyPairFromPrivateKey(*(*[32]byte)(noisePriv))
+	device.IdentityKey = keys.NewKeyPairFromPrivateKey(*(*[32]byte)(identityPriv))
+	device.SignedPreKey.KeyPair = *keys.NewKeyPairFromPrivateKey(*(*[32]byte)(preKeyPriv))
+	device.SignedPreKey.Signature = (*[64]byte)(preKeySig)
+	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
+
+	return &device, nil
+}
+
+// GetAllDevices finds all the devices in the database.
+func (c *Container) GetAllDevices() ([]*store.Device, error) {
+	res, err := c.db.Query(getAllDevicesQuery)
+	if err != nil {
+		return nil, fmt.Errorf("failed to query sessions: %w", err)
+	}
+	sessions := make([]*store.Device, 0)
+	for res.Next() {
+		sess, scanErr := c.scanDevice(res)
+		if scanErr != nil {
+			return sessions, scanErr
+		}
+		sessions = append(sessions, sess)
+	}
+	return sessions, nil
+}
+
+// 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()
+	if err != nil {
+		return nil, err
+	}
+	if len(devices) == 0 {
+		return c.NewDevice(), nil
+	} else {
+		return devices[0], nil
+	}
+}
+
+// GetDevice finds the device with the specified JID in the database.
+//
+// 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))
+	if errors.Is(err, sql.ErrNoRows) {
+		return nil, nil
+	}
+	return sess, err
+}
+
+const (
+	insertDeviceQuery = `
+		INSERT INTO whatsmeow_device (jid, 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)
+		ON CONFLICT (jid) DO UPDATE
+		    SET platform=excluded.platform, business_name=excluded.business_name, push_name=excluded.push_name
+	`
+	deleteDeviceQuery = `DELETE FROM whatsmeow_device WHERE jid=$1`
+)
+
+// NewDevice creates a new device in this database.
+//
+// No data is actually stored before Save is called. However, the pairing process will automatically
+// call Save after a successful pairing, so you most likely don't need to call it yourself.
+func (c *Container) NewDevice() *store.Device {
+	device := &store.Device{
+		Log:       c.log,
+		Container: c,
+
+		DatabaseErrorHandler: c.DatabaseErrorHandler,
+
+		NoiseKey:       keys.NewKeyPair(),
+		IdentityKey:    keys.NewKeyPair(),
+		RegistrationID: mathRand.Uint32(),
+		AdvSecretKey:   random.Bytes(32),
+	}
+	device.SignedPreKey = device.IdentityKey.CreateSignedPreKey(1)
+	return device
+}
+
+// ErrDeviceIDMustBeSet is the error returned by PutDevice if you try to save a device before knowing its JID.
+var ErrDeviceIDMustBeSet = errors.New("device JID must be known before accessing database")
+
+// Close will close the container's database
+func (c *Container) Close() error {
+	if c != nil && c.db != nil {
+		return c.db.Close()
+	}
+	return nil
+}
+
+// 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 {
+	if device.ID == nil {
+		return ErrDeviceIDMustBeSet
+	}
+	_, err := c.db.Exec(insertDeviceQuery,
+		device.ID.String(), 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})
+
+	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
+	}
+	return err
+}
+
+// DeleteDevice deletes the given device from this database. This should be called through Device.Delete()
+func (c *Container) DeleteDevice(store *store.Device) error {
+	if store.ID == nil {
+		return ErrDeviceIDMustBeSet
+	}
+	_, err := c.db.Exec(deleteDeviceQuery, store.ID.String())
+	return err
+}