diff --git a/pkg/local_object_storage/metabase/containers_test.go b/pkg/local_object_storage/metabase/containers_test.go
index 8fb431ccd..be8795bec 100644
--- a/pkg/local_object_storage/metabase/containers_test.go
+++ b/pkg/local_object_storage/metabase/containers_test.go
@@ -6,7 +6,6 @@ import (
 	"testing"
 
 	"github.com/nspcc-dev/neofs-node/pkg/core/object"
-	meta "github.com/nspcc-dev/neofs-node/pkg/local_object_storage/metabase"
 	cid "github.com/nspcc-dev/neofs-sdk-go/container/id"
 	cidtest "github.com/nspcc-dev/neofs-sdk-go/container/id/test"
 	objectSDK "github.com/nspcc-dev/neofs-sdk-go/object"
@@ -64,7 +63,7 @@ func TestDB_Containers(t *testing.T) {
 
 		assertContains(cnrs, cnr)
 
-		require.NoError(t, meta.Inhume(db, object.AddressOf(obj), oidtest.Address()))
+		require.NoError(t, metaInhume(db, object.AddressOf(obj), oidtest.Address()))
 
 		cnrs, err = db.Containers()
 		require.NoError(t, err)
@@ -81,7 +80,7 @@ func TestDB_Containers(t *testing.T) {
 		cnr, _ := obj.ContainerID()
 		assertContains(cnrs, cnr)
 
-		require.NoError(t, meta.ToMoveIt(db, object.AddressOf(obj)))
+		require.NoError(t, metaToMoveIt(db, object.AddressOf(obj)))
 
 		cnrs, err = db.Containers()
 		require.NoError(t, err)
@@ -179,7 +178,7 @@ func TestDB_ContainerSize(t *testing.T) {
 			volume := cids[cnr]
 
 			for _, obj := range list {
-				require.NoError(t, meta.Inhume(
+				require.NoError(t, metaInhume(
 					db,
 					object.AddressOf(obj),
 					oidtest.Address(),
diff --git a/pkg/local_object_storage/metabase/control_test.go b/pkg/local_object_storage/metabase/control_test.go
index b41ec0d52..765b39b66 100644
--- a/pkg/local_object_storage/metabase/control_test.go
+++ b/pkg/local_object_storage/metabase/control_test.go
@@ -22,7 +22,7 @@ func TestReset(t *testing.T) {
 	addrToInhume := oidtest.Address()
 
 	assertExists := func(addr oid.Address, expExists bool, assertErr func(error) bool) {
-		exists, err := meta.Exists(db, addr)
+		exists, err := metaExists(db, addr)
 		if assertErr != nil {
 			require.True(t, assertErr(err))
 		} else {
@@ -37,7 +37,7 @@ func TestReset(t *testing.T) {
 	err = putBig(db, obj)
 	require.NoError(t, err)
 
-	err = meta.Inhume(db, addrToInhume, oidtest.Address())
+	err = metaInhume(db, addrToInhume, oidtest.Address())
 	require.NoError(t, err)
 
 	assertExists(addr, true, nil)
@@ -49,3 +49,11 @@ func TestReset(t *testing.T) {
 	assertExists(addr, false, nil)
 	assertExists(addr, false, nil)
 }
+
+func metaExists(db *meta.DB, addr oid.Address) (bool, error) {
+	var existsPrm meta.ExistsPrm
+	existsPrm.WithAddress(addr)
+
+	res, err := db.Exists(existsPrm)
+	return res.Exists(), err
+}
diff --git a/pkg/local_object_storage/metabase/db_test.go b/pkg/local_object_storage/metabase/db_test.go
index b8613f872..dfa5c7647 100644
--- a/pkg/local_object_storage/metabase/db_test.go
+++ b/pkg/local_object_storage/metabase/db_test.go
@@ -20,11 +20,11 @@ import (
 
 // saves "big" object in DB.
 func putBig(db *meta.DB, obj *object.Object) error {
-	return meta.Put(db, obj, nil)
+	return metaPut(db, obj, nil)
 }
 
 func testSelect(t *testing.T, db *meta.DB, cnr cid.ID, fs object.SearchFilters, exp ...oid.Address) {
-	res, err := meta.Select(db, cnr, fs)
+	res, err := metaSelect(db, cnr, fs)
 	require.NoError(t, err)
 	require.Len(t, res, len(exp))
 
diff --git a/pkg/local_object_storage/metabase/delete.go b/pkg/local_object_storage/metabase/delete.go
index 2fc21a991..b72e5cfe3 100644
--- a/pkg/local_object_storage/metabase/delete.go
+++ b/pkg/local_object_storage/metabase/delete.go
@@ -30,15 +30,6 @@ func (p *DeletePrm) WithAddresses(addrs ...oid.Address) {
 	}
 }
 
-// Delete removes objects from DB.
-func Delete(db *DB, addrs ...oid.Address) error {
-	var deletePrm DeletePrm
-	deletePrm.WithAddresses(addrs...)
-
-	_, err := db.Delete(deletePrm)
-	return err
-}
-
 type referenceNumber struct {
 	all, cur int
 
diff --git a/pkg/local_object_storage/metabase/delete_test.go b/pkg/local_object_storage/metabase/delete_test.go
index 420758fe4..748f1f921 100644
--- a/pkg/local_object_storage/metabase/delete_test.go
+++ b/pkg/local_object_storage/metabase/delete_test.go
@@ -9,6 +9,7 @@ import (
 	apistatus "github.com/nspcc-dev/neofs-sdk-go/client/status"
 	cidtest "github.com/nspcc-dev/neofs-sdk-go/container/id/test"
 	objectSDK "github.com/nspcc-dev/neofs-sdk-go/object"
+	oid "github.com/nspcc-dev/neofs-sdk-go/object/id"
 	oidtest "github.com/nspcc-dev/neofs-sdk-go/object/id/test"
 	"github.com/stretchr/testify/require"
 )
@@ -30,40 +31,40 @@ func TestDB_Delete(t *testing.T) {
 	require.NoError(t, err)
 
 	// fill ToMoveIt index
-	err = meta.ToMoveIt(db, object.AddressOf(child))
+	err = metaToMoveIt(db, object.AddressOf(child))
 	require.NoError(t, err)
 
 	// check if Movable list is not empty
-	l, err := meta.Movable(db)
+	l, err := metaMovable(db)
 	require.NoError(t, err)
 	require.Len(t, l, 1)
 
 	// try to remove parent unsuccessfully
-	err = meta.Delete(db, object.AddressOf(parent))
+	err = metaDelete(db, object.AddressOf(parent))
 	require.Error(t, err)
 
 	// inhume parent and child so they will be on graveyard
 	ts := generateObjectWithCID(t, cnr)
 
-	err = meta.Inhume(db, object.AddressOf(child), object.AddressOf(ts))
+	err = metaInhume(db, object.AddressOf(child), object.AddressOf(ts))
 	require.NoError(t, err)
 
 	// delete object
-	err = meta.Delete(db, object.AddressOf(child))
+	err = metaDelete(db, object.AddressOf(child))
 	require.NoError(t, err)
 
 	// check if there is no data in Movable index
-	l, err = meta.Movable(db)
+	l, err = metaMovable(db)
 	require.NoError(t, err)
 	require.Len(t, l, 0)
 
 	// check if they marked as already removed
 
-	ok, err := meta.Exists(db, object.AddressOf(child))
+	ok, err := metaExists(db, object.AddressOf(child))
 	require.Error(t, apistatus.ObjectAlreadyRemoved{})
 	require.False(t, ok)
 
-	ok, err = meta.Exists(db, object.AddressOf(parent))
+	ok, err = metaExists(db, object.AddressOf(parent))
 	require.Error(t, apistatus.ObjectAlreadyRemoved{})
 	require.False(t, ok)
 }
@@ -91,16 +92,16 @@ func TestDeleteAllChildren(t *testing.T) {
 	require.NoError(t, putBig(db, child2))
 
 	// Exists should return split info for parent
-	_, err := meta.Exists(db, object.AddressOf(parent))
+	_, err := metaExists(db, object.AddressOf(parent))
 	siErr := objectSDK.NewSplitInfoError(nil)
 	require.True(t, errors.As(err, &siErr))
 
 	// remove all children in single call
-	err = meta.Delete(db, object.AddressOf(child1), object.AddressOf(child2))
+	err = metaDelete(db, object.AddressOf(child1), object.AddressOf(child2))
 	require.NoError(t, err)
 
 	// parent should not be found now
-	ex, err := meta.Exists(db, object.AddressOf(parent))
+	ex, err := metaExists(db, object.AddressOf(parent))
 	require.NoError(t, err)
 	require.False(t, ex)
 }
@@ -111,8 +112,16 @@ func TestGraveOnlyDelete(t *testing.T) {
 	addr := oidtest.Address()
 
 	// inhume non-existent object by address
-	require.NoError(t, meta.Inhume(db, addr, oidtest.Address()))
+	require.NoError(t, metaInhume(db, addr, oidtest.Address()))
 
 	// delete the object data
-	require.NoError(t, meta.Delete(db, addr))
+	require.NoError(t, metaDelete(db, addr))
+}
+
+func metaDelete(db *meta.DB, addrs ...oid.Address) error {
+	var deletePrm meta.DeletePrm
+	deletePrm.WithAddresses(addrs...)
+
+	_, err := db.Delete(deletePrm)
+	return err
 }
diff --git a/pkg/local_object_storage/metabase/exists.go b/pkg/local_object_storage/metabase/exists.go
index d18b07cdd..5ec468db7 100644
--- a/pkg/local_object_storage/metabase/exists.go
+++ b/pkg/local_object_storage/metabase/exists.go
@@ -35,21 +35,6 @@ func (p ExistsRes) Exists() bool {
 	return p.exists
 }
 
-// Exists checks if object is presented in DB.
-//
-// See DB.Exists docs.
-func Exists(db *DB, addr oid.Address) (bool, error) {
-	var existsPrm ExistsPrm
-	existsPrm.WithAddress(addr)
-
-	r, err := db.Exists(existsPrm)
-	if err != nil {
-		return false, err
-	}
-
-	return r.Exists(), nil
-}
-
 // Exists returns ErrAlreadyRemoved if addr was marked as removed. Otherwise it
 // returns true if addr is in primary index or false if it is not.
 //
diff --git a/pkg/local_object_storage/metabase/exists_test.go b/pkg/local_object_storage/metabase/exists_test.go
index 02dacfb3b..8e03c0f89 100644
--- a/pkg/local_object_storage/metabase/exists_test.go
+++ b/pkg/local_object_storage/metabase/exists_test.go
@@ -5,7 +5,6 @@ import (
 	"testing"
 
 	"github.com/nspcc-dev/neofs-node/pkg/core/object"
-	meta "github.com/nspcc-dev/neofs-node/pkg/local_object_storage/metabase"
 	cidtest "github.com/nspcc-dev/neofs-sdk-go/container/id/test"
 	objectSDK "github.com/nspcc-dev/neofs-sdk-go/object"
 	"github.com/stretchr/testify/require"
@@ -16,7 +15,7 @@ func TestDB_Exists(t *testing.T) {
 
 	t.Run("no object", func(t *testing.T) {
 		nonExist := generateObject(t)
-		exists, err := meta.Exists(db, object.AddressOf(nonExist))
+		exists, err := metaExists(db, object.AddressOf(nonExist))
 		require.NoError(t, err)
 		require.False(t, exists)
 	})
@@ -26,7 +25,7 @@ func TestDB_Exists(t *testing.T) {
 		err := putBig(db, regular)
 		require.NoError(t, err)
 
-		exists, err := meta.Exists(db, object.AddressOf(regular))
+		exists, err := metaExists(db, object.AddressOf(regular))
 		require.NoError(t, err)
 		require.True(t, exists)
 	})
@@ -38,7 +37,7 @@ func TestDB_Exists(t *testing.T) {
 		err := putBig(db, ts)
 		require.NoError(t, err)
 
-		exists, err := meta.Exists(db, object.AddressOf(ts))
+		exists, err := metaExists(db, object.AddressOf(ts))
 		require.NoError(t, err)
 		require.True(t, exists)
 	})
@@ -50,7 +49,7 @@ func TestDB_Exists(t *testing.T) {
 		err := putBig(db, sg)
 		require.NoError(t, err)
 
-		exists, err := meta.Exists(db, object.AddressOf(sg))
+		exists, err := metaExists(db, object.AddressOf(sg))
 		require.NoError(t, err)
 		require.True(t, exists)
 	})
@@ -62,7 +61,7 @@ func TestDB_Exists(t *testing.T) {
 		err := putBig(db, lock)
 		require.NoError(t, err)
 
-		exists, err := meta.Exists(db, object.AddressOf(lock))
+		exists, err := metaExists(db, object.AddressOf(lock))
 		require.NoError(t, err)
 		require.True(t, exists)
 	})
@@ -79,7 +78,7 @@ func TestDB_Exists(t *testing.T) {
 		err := putBig(db, child)
 		require.NoError(t, err)
 
-		_, err = meta.Exists(db, object.AddressOf(parent))
+		_, err = metaExists(db, object.AddressOf(parent))
 
 		var expectedErr *objectSDK.SplitInfoError
 		require.True(t, errors.As(err, &expectedErr))
@@ -112,7 +111,7 @@ func TestDB_Exists(t *testing.T) {
 			err = putBig(db, link)
 			require.NoError(t, err)
 
-			_, err = meta.Exists(db, object.AddressOf(parent))
+			_, err = metaExists(db, object.AddressOf(parent))
 			require.Error(t, err)
 
 			si, ok := err.(*objectSDK.SplitInfoError)
@@ -130,13 +129,13 @@ func TestDB_Exists(t *testing.T) {
 		})
 
 		t.Run("reverse order", func(t *testing.T) {
-			err := meta.Put(db, link, nil)
+			err := metaPut(db, link, nil)
 			require.NoError(t, err)
 
 			err = putBig(db, child)
 			require.NoError(t, err)
 
-			_, err = meta.Exists(db, object.AddressOf(parent))
+			_, err = metaExists(db, object.AddressOf(parent))
 			require.Error(t, err)
 
 			si, ok := err.(*objectSDK.SplitInfoError)
diff --git a/pkg/local_object_storage/metabase/get.go b/pkg/local_object_storage/metabase/get.go
index baff225c0..611aeff67 100644
--- a/pkg/local_object_storage/metabase/get.go
+++ b/pkg/local_object_storage/metabase/get.go
@@ -44,33 +44,6 @@ func (r GetRes) Header() *objectSDK.Object {
 	return r.hdr
 }
 
-// Get reads the object from DB.
-func Get(db *DB, addr oid.Address) (*objectSDK.Object, error) {
-	var getPrm GetPrm
-	getPrm.WithAddress(addr)
-
-	r, err := db.Get(getPrm)
-	if err != nil {
-		return nil, err
-	}
-
-	return r.Header(), nil
-}
-
-// GetRaw reads physically stored object from DB.
-func GetRaw(db *DB, addr oid.Address, raw bool) (*objectSDK.Object, error) {
-	var getPrm GetPrm
-	getPrm.WithAddress(addr)
-	getPrm.WithRaw(raw)
-
-	r, err := db.Get(getPrm)
-	if err != nil {
-		return nil, err
-	}
-
-	return r.Header(), nil
-}
-
 // Get returns object header for specified address.
 //
 // Returns an error of type apistatus.ObjectNotFound if object is missing in DB.
diff --git a/pkg/local_object_storage/metabase/get_test.go b/pkg/local_object_storage/metabase/get_test.go
index 95c345bcd..0a17793fe 100644
--- a/pkg/local_object_storage/metabase/get_test.go
+++ b/pkg/local_object_storage/metabase/get_test.go
@@ -26,7 +26,7 @@ func TestDB_Get(t *testing.T) {
 	addAttribute(raw, "foo", "bar")
 
 	t.Run("object not found", func(t *testing.T) {
-		_, err := meta.Get(db, object.AddressOf(raw))
+		_, err := metaGet(db, object.AddressOf(raw), false)
 		require.Error(t, err)
 	})
 
@@ -34,7 +34,7 @@ func TestDB_Get(t *testing.T) {
 		err := putBig(db, raw)
 		require.NoError(t, err)
 
-		newObj, err := meta.Get(db, object.AddressOf(raw))
+		newObj, err := metaGet(db, object.AddressOf(raw), false)
 		require.NoError(t, err)
 		require.Equal(t, raw.CutPayload(), newObj)
 	})
@@ -46,7 +46,7 @@ func TestDB_Get(t *testing.T) {
 		err := putBig(db, raw)
 		require.NoError(t, err)
 
-		newObj, err := meta.Get(db, object.AddressOf(raw))
+		newObj, err := metaGet(db, object.AddressOf(raw), false)
 		require.NoError(t, err)
 		require.Equal(t, raw.CutPayload(), newObj)
 	})
@@ -58,7 +58,7 @@ func TestDB_Get(t *testing.T) {
 		err := putBig(db, raw)
 		require.NoError(t, err)
 
-		newObj, err := meta.Get(db, object.AddressOf(raw))
+		newObj, err := metaGet(db, object.AddressOf(raw), false)
 		require.NoError(t, err)
 		require.Equal(t, raw.CutPayload(), newObj)
 	})
@@ -70,7 +70,7 @@ func TestDB_Get(t *testing.T) {
 		err := putBig(db, raw)
 		require.NoError(t, err)
 
-		newObj, err := meta.Get(db, object.AddressOf(raw))
+		newObj, err := metaGet(db, object.AddressOf(raw), false)
 		require.NoError(t, err)
 		require.Equal(t, raw.CutPayload(), newObj)
 	})
@@ -92,7 +92,7 @@ func TestDB_Get(t *testing.T) {
 		require.NoError(t, err)
 
 		t.Run("raw is true", func(t *testing.T) {
-			_, err = meta.GetRaw(db, object.AddressOf(parent), true)
+			_, err = metaGet(db, object.AddressOf(parent), true)
 			require.Error(t, err)
 
 			siErr, ok := err.(*objectSDK.SplitInfoError)
@@ -108,11 +108,11 @@ func TestDB_Get(t *testing.T) {
 			require.False(t, ok)
 		})
 
-		newParent, err := meta.GetRaw(db, object.AddressOf(parent), false)
+		newParent, err := metaGet(db, object.AddressOf(parent), false)
 		require.NoError(t, err)
 		require.True(t, binaryEqual(parent.CutPayload(), newParent))
 
-		newChild, err := meta.GetRaw(db, object.AddressOf(child), true)
+		newChild, err := metaGet(db, object.AddressOf(child), true)
 		require.NoError(t, err)
 		require.True(t, binaryEqual(child.CutPayload(), newChild))
 	})
@@ -121,8 +121,8 @@ func TestDB_Get(t *testing.T) {
 		obj := oidtest.Address()
 		ts := oidtest.Address()
 
-		require.NoError(t, meta.Inhume(db, obj, ts))
-		_, err := meta.Get(db, obj)
+		require.NoError(t, metaInhume(db, obj, ts))
+		_, err := metaGet(db, obj, false)
 		require.ErrorAs(t, err, new(apistatus.ObjectAlreadyRemoved))
 
 		obj = oidtest.Address()
@@ -132,7 +132,7 @@ func TestDB_Get(t *testing.T) {
 
 		_, err = db.Inhume(prm)
 		require.NoError(t, err)
-		_, err = meta.Get(db, obj)
+		_, err = metaGet(db, obj, false)
 		require.ErrorAs(t, err, new(apistatus.ObjectNotFound))
 	})
 }
@@ -203,3 +203,12 @@ func benchmarkGet(b *testing.B, numOfObj int) {
 
 	}
 }
+
+func metaGet(db *meta.DB, addr oid.Address, raw bool) (*objectSDK.Object, error) {
+	var prm meta.GetPrm
+	prm.WithAddress(addr)
+	prm.WithRaw(raw)
+
+	res, err := db.Get(prm)
+	return res.Header(), err
+}
diff --git a/pkg/local_object_storage/metabase/inhume.go b/pkg/local_object_storage/metabase/inhume.go
index d5049bdce..bd85047fe 100644
--- a/pkg/local_object_storage/metabase/inhume.go
+++ b/pkg/local_object_storage/metabase/inhume.go
@@ -78,19 +78,6 @@ func (p *InhumePrm) WithForceGCMark() {
 	}
 }
 
-// Inhume inhumes the object by specified address.
-//
-// tomb should not be nil.
-func Inhume(db *DB, target, tomb oid.Address) error {
-	var inhumePrm InhumePrm
-	inhumePrm.WithAddresses(target)
-	inhumePrm.WithTombstoneAddress(tomb)
-
-	_, err := db.Inhume(inhumePrm)
-
-	return err
-}
-
 var errBreakBucketForEach = errors.New("bucket ForEach break")
 
 // ErrLockObjectRemoval is returned when inhume operation is being
diff --git a/pkg/local_object_storage/metabase/inhume_test.go b/pkg/local_object_storage/metabase/inhume_test.go
index 915184181..92f53dbdb 100644
--- a/pkg/local_object_storage/metabase/inhume_test.go
+++ b/pkg/local_object_storage/metabase/inhume_test.go
@@ -22,13 +22,13 @@ func TestDB_Inhume(t *testing.T) {
 	err := putBig(db, raw)
 	require.NoError(t, err)
 
-	err = meta.Inhume(db, object.AddressOf(raw), tombstoneID)
+	err = metaInhume(db, object.AddressOf(raw), tombstoneID)
 	require.NoError(t, err)
 
-	_, err = meta.Exists(db, object.AddressOf(raw))
+	_, err = metaExists(db, object.AddressOf(raw))
 	require.ErrorAs(t, err, new(apistatus.ObjectAlreadyRemoved))
 
-	_, err = meta.Get(db, object.AddressOf(raw))
+	_, err = metaGet(db, object.AddressOf(raw), false)
 	require.ErrorAs(t, err, new(apistatus.ObjectAlreadyRemoved))
 }
 
@@ -110,3 +110,12 @@ func TestInhumeLocked(t *testing.T) {
 	var e apistatus.ObjectLocked
 	require.ErrorAs(t, err, &e)
 }
+
+func metaInhume(db *meta.DB, target, tomb oid.Address) error {
+	var inhumePrm meta.InhumePrm
+	inhumePrm.WithAddresses(target)
+	inhumePrm.WithTombstoneAddress(tomb)
+
+	_, err := db.Inhume(inhumePrm)
+	return err
+}
diff --git a/pkg/local_object_storage/metabase/list.go b/pkg/local_object_storage/metabase/list.go
index 1140162fd..12f34a1bc 100644
--- a/pkg/local_object_storage/metabase/list.go
+++ b/pkg/local_object_storage/metabase/list.go
@@ -54,25 +54,6 @@ func (l ListRes) Cursor() *Cursor {
 	return l.cursor
 }
 
-// ListWithCursor lists physical objects available in metabase starting from
-// cursor. Includes objects of all types. Does not include inhumed objects.
-// Use cursor value from response for consecutive requests.
-//
-// Returns ErrEndOfListing if there are no more objects to return or count
-// parameter set to zero.
-func ListWithCursor(db *DB, count uint32, cursor *Cursor) ([]oid.Address, *Cursor, error) {
-	var listPrm ListPrm
-	listPrm.WithCount(count)
-	listPrm.WithCursor(cursor)
-
-	r, err := db.ListWithCursor(listPrm)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	return r.AddressList(), r.Cursor(), nil
-}
-
 // ListWithCursor lists physical objects available in metabase starting from
 // cursor. Includes objects of all types. Does not include inhumed objects.
 // Use cursor value from response for consecutive requests.
diff --git a/pkg/local_object_storage/metabase/list_test.go b/pkg/local_object_storage/metabase/list_test.go
index 6cf5814ac..899c6c92e 100644
--- a/pkg/local_object_storage/metabase/list_test.go
+++ b/pkg/local_object_storage/metabase/list_test.go
@@ -113,7 +113,7 @@ func TestLisObjectsWithCursor(t *testing.T) {
 		err = putBig(db, obj)
 		require.NoError(t, err)
 		ts := generateObjectWithCID(t, containerID)
-		err = meta.Inhume(db, object.AddressOf(obj), object.AddressOf(ts))
+		err = metaInhume(db, object.AddressOf(obj), object.AddressOf(ts))
 		require.NoError(t, err)
 
 		// add one child object (do not include parent into expected)
@@ -136,7 +136,7 @@ func TestLisObjectsWithCursor(t *testing.T) {
 		for countPerReq := 1; countPerReq <= total; countPerReq++ {
 			got := make([]oid.Address, 0, total)
 
-			res, cursor, err := meta.ListWithCursor(db, uint32(countPerReq), nil)
+			res, cursor, err := metaListWithCursor(db, uint32(countPerReq), nil)
 			require.NoError(t, err, "count:%d", countPerReq)
 			got = append(got, res...)
 
@@ -146,12 +146,12 @@ func TestLisObjectsWithCursor(t *testing.T) {
 			}
 
 			for i := 0; i < expectedIterations; i++ {
-				res, cursor, err = meta.ListWithCursor(db, uint32(countPerReq), cursor)
+				res, cursor, err = metaListWithCursor(db, uint32(countPerReq), cursor)
 				require.NoError(t, err, "count:%d", countPerReq)
 				got = append(got, res...)
 			}
 
-			_, _, err = meta.ListWithCursor(db, uint32(countPerReq), cursor)
+			_, _, err = metaListWithCursor(db, uint32(countPerReq), cursor)
 			require.ErrorIs(t, err, meta.ErrEndOfListing, "count:%d", countPerReq, cursor)
 
 			got = sortAddresses(got)
@@ -160,7 +160,7 @@ func TestLisObjectsWithCursor(t *testing.T) {
 	})
 
 	t.Run("invalid count", func(t *testing.T) {
-		_, _, err := meta.ListWithCursor(db, 0, nil)
+		_, _, err := metaListWithCursor(db, 0, nil)
 		require.ErrorIs(t, err, meta.ErrEndOfListing)
 	})
 }
@@ -181,7 +181,7 @@ func TestAddObjectDuringListingWithCursor(t *testing.T) {
 	}
 
 	// get half of the objects
-	got, cursor, err := meta.ListWithCursor(db, total/2, nil)
+	got, cursor, err := metaListWithCursor(db, total/2, nil)
 	require.NoError(t, err)
 	for _, obj := range got {
 		if _, ok := expected[obj.EncodeToString()]; ok {
@@ -198,7 +198,7 @@ func TestAddObjectDuringListingWithCursor(t *testing.T) {
 
 	// get remaining objects
 	for {
-		got, cursor, err = meta.ListWithCursor(db, total, cursor)
+		got, cursor, err = metaListWithCursor(db, total, cursor)
 		if errors.Is(err, meta.ErrEndOfListing) {
 			break
 		}
@@ -222,3 +222,12 @@ func sortAddresses(addr []oid.Address) []oid.Address {
 	})
 	return addr
 }
+
+func metaListWithCursor(db *meta.DB, count uint32, cursor *meta.Cursor) ([]oid.Address, *meta.Cursor, error) {
+	var listPrm meta.ListPrm
+	listPrm.WithCount(count)
+	listPrm.WithCursor(cursor)
+
+	r, err := db.ListWithCursor(listPrm)
+	return r.AddressList(), r.Cursor(), err
+}
diff --git a/pkg/local_object_storage/metabase/lock_test.go b/pkg/local_object_storage/metabase/lock_test.go
index 09ed672fd..31d418755 100644
--- a/pkg/local_object_storage/metabase/lock_test.go
+++ b/pkg/local_object_storage/metabase/lock_test.go
@@ -35,7 +35,7 @@ func TestDB_Lock(t *testing.T) {
 			obj.SetContainerID(cnr)
 
 			// save irregular object
-			err := meta.Put(db, obj, nil)
+			err := metaPut(db, obj, nil)
 			require.NoError(t, err, typ)
 
 			var e apistatus.LockNonRegularObject
@@ -95,7 +95,7 @@ func TestDB_Lock(t *testing.T) {
 		lockAddr := objectcore.AddressOf(lockObj)
 
 		// try to inhume locked object using tombstone
-		err := meta.Inhume(db, objAddr, lockAddr)
+		err := metaInhume(db, objAddr, lockAddr)
 		require.ErrorAs(t, err, new(apistatus.ObjectLocked))
 
 		// free locked object
diff --git a/pkg/local_object_storage/metabase/movable.go b/pkg/local_object_storage/metabase/movable.go
index abf47171a..33ce06f5b 100644
--- a/pkg/local_object_storage/metabase/movable.go
+++ b/pkg/local_object_storage/metabase/movable.go
@@ -50,15 +50,6 @@ func (p MovableRes) AddressList() []oid.Address {
 	return p.addrList
 }
 
-// ToMoveIt marks object to move it into another shard.
-func ToMoveIt(db *DB, addr oid.Address) error {
-	var toMovePrm ToMoveItPrm
-	toMovePrm.WithAddress(addr)
-
-	_, err := db.ToMoveIt(toMovePrm)
-	return err
-}
-
 // ToMoveIt marks objects to move it into another shard. This useful for
 // faster HRW fetching.
 func (db *DB) ToMoveIt(prm ToMoveItPrm) (res ToMoveItRes, err error) {
@@ -74,15 +65,6 @@ func (db *DB) ToMoveIt(prm ToMoveItPrm) (res ToMoveItRes, err error) {
 	return
 }
 
-// DoNotMove prevents the object to be moved into another shard.
-func DoNotMove(db *DB, addr oid.Address) error {
-	var doNotMovePrm DoNotMovePrm
-	doNotMovePrm.WithAddress(addr)
-
-	_, err := db.DoNotMove(doNotMovePrm)
-	return err
-}
-
 // DoNotMove removes `MoveIt` mark from the object.
 func (db *DB) DoNotMove(prm DoNotMovePrm) (res DoNotMoveRes, err error) {
 	err = db.boltDB.Update(func(tx *bbolt.Tx) error {
@@ -97,16 +79,6 @@ func (db *DB) DoNotMove(prm DoNotMovePrm) (res DoNotMoveRes, err error) {
 	return
 }
 
-// Movable returns all movable objects of DB.
-func Movable(db *DB) ([]oid.Address, error) {
-	r, err := db.Movable(MovablePrm{})
-	if err != nil {
-		return nil, err
-	}
-
-	return r.AddressList(), nil
-}
-
 // Movable returns list of marked objects to move into other shard.
 func (db *DB) Movable(_ MovablePrm) (MovableRes, error) {
 	var strAddrs []string
diff --git a/pkg/local_object_storage/metabase/movable_test.go b/pkg/local_object_storage/metabase/movable_test.go
index faebbe194..ad1ca08eb 100644
--- a/pkg/local_object_storage/metabase/movable_test.go
+++ b/pkg/local_object_storage/metabase/movable_test.go
@@ -5,6 +5,7 @@ import (
 
 	"github.com/nspcc-dev/neofs-node/pkg/core/object"
 	meta "github.com/nspcc-dev/neofs-node/pkg/local_object_storage/metabase"
+	oid "github.com/nspcc-dev/neofs-sdk-go/object/id"
 	"github.com/stretchr/testify/require"
 )
 
@@ -22,35 +23,60 @@ func TestDB_Movable(t *testing.T) {
 	require.NoError(t, err)
 
 	// check if toMoveIt index empty
-	toMoveList, err := meta.Movable(db)
+	toMoveList, err := metaMovable(db)
 	require.NoError(t, err)
 	require.Len(t, toMoveList, 0)
 
 	// mark to move object2
-	err = meta.ToMoveIt(db, object.AddressOf(raw2))
+	err = metaToMoveIt(db, object.AddressOf(raw2))
 	require.NoError(t, err)
 
 	// check if toMoveIt index contains address of object 2
-	toMoveList, err = meta.Movable(db)
+	toMoveList, err = metaMovable(db)
 	require.NoError(t, err)
 	require.Len(t, toMoveList, 1)
 	require.Contains(t, toMoveList, object.AddressOf(raw2))
 
 	// remove from toMoveIt index non existing address
-	err = meta.DoNotMove(db, object.AddressOf(raw1))
+	err = metaDoNotMove(db, object.AddressOf(raw1))
 	require.NoError(t, err)
 
 	// check if toMoveIt index hasn't changed
-	toMoveList, err = meta.Movable(db)
+	toMoveList, err = metaMovable(db)
 	require.NoError(t, err)
 	require.Len(t, toMoveList, 1)
 
 	// remove from toMoveIt index existing address
-	err = meta.DoNotMove(db, object.AddressOf(raw2))
+	err = metaDoNotMove(db, object.AddressOf(raw2))
 	require.NoError(t, err)
 
 	// check if toMoveIt index is empty now
-	toMoveList, err = meta.Movable(db)
+	toMoveList, err = metaMovable(db)
 	require.NoError(t, err)
 	require.Len(t, toMoveList, 0)
 }
+
+func metaToMoveIt(db *meta.DB, addr oid.Address) error {
+	var toMovePrm meta.ToMoveItPrm
+	toMovePrm.WithAddress(addr)
+
+	_, err := db.ToMoveIt(toMovePrm)
+	return err
+}
+
+func metaMovable(db *meta.DB) ([]oid.Address, error) {
+	r, err := db.Movable(meta.MovablePrm{})
+	if err != nil {
+		return nil, err
+	}
+
+	return r.AddressList(), nil
+}
+
+func metaDoNotMove(db *meta.DB, addr oid.Address) error {
+	var doNotMovePrm meta.DoNotMovePrm
+	doNotMovePrm.WithAddress(addr)
+
+	_, err := db.DoNotMove(doNotMovePrm)
+	return err
+}
diff --git a/pkg/local_object_storage/metabase/put.go b/pkg/local_object_storage/metabase/put.go
index 21c0b93a3..0db4330b6 100644
--- a/pkg/local_object_storage/metabase/put.go
+++ b/pkg/local_object_storage/metabase/put.go
@@ -53,19 +53,6 @@ var (
 	ErrIncorrectRootObject      = errors.New("invalid root object")
 )
 
-// Put saves the object in DB.
-//
-// See DB.Put docs.
-func Put(db *DB, obj *objectSDK.Object, id *blobovnicza.ID) error {
-	var putPrm PutPrm
-	putPrm.WithObject(obj)
-	putPrm.WithBlobovniczaID(id)
-
-	_, err := db.Put(putPrm)
-
-	return err
-}
-
 // Put saves object header in metabase. Object payload expected to be cut.
 // Big objects have nil blobovniczaID.
 //
diff --git a/pkg/local_object_storage/metabase/put_test.go b/pkg/local_object_storage/metabase/put_test.go
index d02b2a48f..bbf8a91c7 100644
--- a/pkg/local_object_storage/metabase/put_test.go
+++ b/pkg/local_object_storage/metabase/put_test.go
@@ -54,7 +54,7 @@ func BenchmarkPut(b *testing.B) {
 		b.ReportAllocs()
 		b.RunParallel(func(pb *testing.PB) {
 			for pb.Next() {
-				if err := meta.Put(db, objs[index.Inc()], nil); err != nil {
+				if err := metaPut(db, objs[index.Inc()], nil); err != nil {
 					b.Fatal(err)
 				}
 			}
@@ -69,7 +69,7 @@ func BenchmarkPut(b *testing.B) {
 		b.ResetTimer()
 		b.ReportAllocs()
 		for i := 0; i < b.N; i++ {
-			if err := meta.Put(db, objs[index.Inc()], nil); err != nil {
+			if err := metaPut(db, objs[index.Inc()], nil); err != nil {
 				b.Fatal(err)
 			}
 		}
@@ -83,20 +83,20 @@ func TestDB_PutBlobovnicaUpdate(t *testing.T) {
 	blobovniczaID := blobovnicza.ID{1, 2, 3, 4}
 
 	// put one object with blobovniczaID
-	err := meta.Put(db, raw1, &blobovniczaID)
+	err := metaPut(db, raw1, &blobovniczaID)
 	require.NoError(t, err)
 
-	fetchedBlobovniczaID, err := meta.IsSmall(db, object.AddressOf(raw1))
+	fetchedBlobovniczaID, err := metaIsSmall(db, object.AddressOf(raw1))
 	require.NoError(t, err)
 	require.Equal(t, &blobovniczaID, fetchedBlobovniczaID)
 
 	t.Run("update blobovniczaID", func(t *testing.T) {
 		newID := blobovnicza.ID{5, 6, 7, 8}
 
-		err := meta.Put(db, raw1, &newID)
+		err := metaPut(db, raw1, &newID)
 		require.NoError(t, err)
 
-		fetchedBlobovniczaID, err := meta.IsSmall(db, object.AddressOf(raw1))
+		fetchedBlobovniczaID, err := metaIsSmall(db, object.AddressOf(raw1))
 		require.NoError(t, err)
 		require.Equal(t, &newID, fetchedBlobovniczaID)
 	})
@@ -106,8 +106,18 @@ func TestDB_PutBlobovnicaUpdate(t *testing.T) {
 		err := putBig(db, raw2)
 		require.NoError(t, err)
 
-		fetchedBlobovniczaID, err := meta.IsSmall(db, object.AddressOf(raw2))
+		fetchedBlobovniczaID, err := metaIsSmall(db, object.AddressOf(raw2))
 		require.NoError(t, err)
 		require.Nil(t, fetchedBlobovniczaID)
 	})
 }
+
+func metaPut(db *meta.DB, obj *objectSDK.Object, id *blobovnicza.ID) error {
+	var putPrm meta.PutPrm
+	putPrm.WithObject(obj)
+	putPrm.WithBlobovniczaID(id)
+
+	_, err := db.Put(putPrm)
+
+	return err
+}
diff --git a/pkg/local_object_storage/metabase/select.go b/pkg/local_object_storage/metabase/select.go
index f3ae6bafa..7c7e67213 100644
--- a/pkg/local_object_storage/metabase/select.go
+++ b/pkg/local_object_storage/metabase/select.go
@@ -58,20 +58,6 @@ func (r SelectRes) AddressList() []oid.Address {
 	return r.addrList
 }
 
-// Select selects the objects from DB with filtering.
-func Select(db *DB, cnr cid.ID, fs object.SearchFilters) ([]oid.Address, error) {
-	var selectPrm SelectPrm
-	selectPrm.WithFilters(fs)
-	selectPrm.WithContainerID(cnr)
-
-	r, err := db.Select(selectPrm)
-	if err != nil {
-		return nil, err
-	}
-
-	return r.AddressList(), nil
-}
-
 // Select returns list of addresses of objects that match search filters.
 func (db *DB) Select(prm SelectPrm) (res SelectRes, err error) {
 	if blindlyProcess(prm.filters) {
diff --git a/pkg/local_object_storage/metabase/select_test.go b/pkg/local_object_storage/metabase/select_test.go
index db9737903..557ebede5 100644
--- a/pkg/local_object_storage/metabase/select_test.go
+++ b/pkg/local_object_storage/metabase/select_test.go
@@ -344,7 +344,7 @@ func TestDB_SelectInhume(t *testing.T) {
 	tombstone.SetContainer(cnr)
 	tombstone.SetObject(oidtest.ID())
 
-	err = meta.Inhume(db, object.AddressOf(raw2), tombstone)
+	err = metaInhume(db, object.AddressOf(raw2), tombstone)
 	require.NoError(t, err)
 
 	fs = objectSDK.SearchFilters{}
@@ -777,7 +777,7 @@ func BenchmarkSelect(b *testing.B) {
 		attr.SetValue(strconv.Itoa(i))
 		obj := generateObjectWithCID(b, cid)
 		obj.SetAttributes(attr)
-		require.NoError(b, meta.Put(db, obj, nil))
+		require.NoError(b, metaPut(db, obj, nil))
 	}
 
 	b.Run("string equal", func(b *testing.B) {
@@ -806,13 +806,26 @@ func BenchmarkSelect(b *testing.B) {
 }
 
 func benchmarkSelect(b *testing.B, db *meta.DB, cid cidSDK.ID, fs objectSDK.SearchFilters, expected int) {
+	var prm meta.SelectPrm
+	prm.WithContainerID(cid)
+	prm.WithFilters(fs)
+
 	for i := 0; i < b.N; i++ {
-		res, err := meta.Select(db, cid, fs)
+		res, err := db.Select(prm)
 		if err != nil {
 			b.Fatal(err)
 		}
-		if len(res) != expected {
-			b.Fatalf("expected %d items, got %d", expected, len(res))
+		if len(res.AddressList()) != expected {
+			b.Fatalf("expected %d items, got %d", expected, len(res.AddressList()))
 		}
 	}
 }
+
+func metaSelect(db *meta.DB, cnr cidSDK.ID, fs objectSDK.SearchFilters) ([]oid.Address, error) {
+	var prm meta.SelectPrm
+	prm.WithFilters(fs)
+	prm.WithContainerID(cnr)
+
+	res, err := db.Select(prm)
+	return res.AddressList(), err
+}
diff --git a/pkg/local_object_storage/metabase/small.go b/pkg/local_object_storage/metabase/small.go
index 6c88a3474..fc73410c5 100644
--- a/pkg/local_object_storage/metabase/small.go
+++ b/pkg/local_object_storage/metabase/small.go
@@ -29,21 +29,6 @@ func (r IsSmallRes) BlobovniczaID() *blobovnicza.ID {
 	return r.id
 }
 
-// IsSmall wraps work with DB.IsSmall method with specified
-// address and other parameters by default. Returns only
-// the blobovnicza identifier.
-func IsSmall(db *DB, addr oid.Address) (*blobovnicza.ID, error) {
-	var isSmallPrm IsSmallPrm
-	isSmallPrm.WithAddress(addr)
-
-	r, err := db.IsSmall(isSmallPrm)
-	if err != nil {
-		return nil, err
-	}
-
-	return r.BlobovniczaID(), nil
-}
-
 // IsSmall returns blobovniczaID for small objects and nil for big objects.
 // Small objects stored in blobovnicza instances. Big objects stored in FS by
 // shallow path which is calculated from address and therefore it is not
diff --git a/pkg/local_object_storage/metabase/small_test.go b/pkg/local_object_storage/metabase/small_test.go
index 0745e0a4c..534a6862b 100644
--- a/pkg/local_object_storage/metabase/small_test.go
+++ b/pkg/local_object_storage/metabase/small_test.go
@@ -6,6 +6,7 @@ import (
 	"github.com/nspcc-dev/neofs-node/pkg/core/object"
 	"github.com/nspcc-dev/neofs-node/pkg/local_object_storage/blobovnicza"
 	meta "github.com/nspcc-dev/neofs-node/pkg/local_object_storage/metabase"
+	oid "github.com/nspcc-dev/neofs-sdk-go/object/id"
 	"github.com/stretchr/testify/require"
 )
 
@@ -18,12 +19,12 @@ func TestDB_IsSmall(t *testing.T) {
 	blobovniczaID := blobovnicza.ID{1, 2, 3, 4}
 
 	// check IsSmall from empty database
-	fetchedBlobovniczaID, err := meta.IsSmall(db, object.AddressOf(raw1))
+	fetchedBlobovniczaID, err := metaIsSmall(db, object.AddressOf(raw1))
 	require.NoError(t, err)
 	require.Nil(t, fetchedBlobovniczaID)
 
 	// put one object with blobovniczaID
-	err = meta.Put(db, raw1, &blobovniczaID)
+	err = metaPut(db, raw1, &blobovniczaID)
 	require.NoError(t, err)
 
 	// put one object without blobovniczaID
@@ -31,12 +32,20 @@ func TestDB_IsSmall(t *testing.T) {
 	require.NoError(t, err)
 
 	// check IsSmall for object without blobovniczaID
-	fetchedBlobovniczaID, err = meta.IsSmall(db, object.AddressOf(raw2))
+	fetchedBlobovniczaID, err = metaIsSmall(db, object.AddressOf(raw2))
 	require.NoError(t, err)
 	require.Nil(t, fetchedBlobovniczaID)
 
 	// check IsSmall for object with blobovniczaID
-	fetchedBlobovniczaID, err = meta.IsSmall(db, object.AddressOf(raw1))
+	fetchedBlobovniczaID, err = metaIsSmall(db, object.AddressOf(raw1))
 	require.NoError(t, err)
 	require.Equal(t, &blobovniczaID, fetchedBlobovniczaID)
 }
+
+func metaIsSmall(db *meta.DB, addr oid.Address) (*blobovnicza.ID, error) {
+	var isSmallPrm meta.IsSmallPrm
+	isSmallPrm.WithAddress(addr)
+
+	r, err := db.IsSmall(isSmallPrm)
+	return r.BlobovniczaID(), err
+}
diff --git a/pkg/local_object_storage/shard/control.go b/pkg/local_object_storage/shard/control.go
index c4a1e5efd..da9abd470 100644
--- a/pkg/local_object_storage/shard/control.go
+++ b/pkg/local_object_storage/shard/control.go
@@ -145,7 +145,11 @@ func (s *Shard) refillMetabase() error {
 			}
 		}
 
-		err := meta.Put(s.metaBase, obj, blzID)
+		var mPrm meta.PutPrm
+		mPrm.WithObject(obj)
+		mPrm.WithBlobovniczaID(blzID)
+
+		_, err := s.metaBase.Put(mPrm)
 		if err != nil && !meta.IsErrRemoved(err) {
 			return err
 		}
diff --git a/pkg/local_object_storage/shard/delete.go b/pkg/local_object_storage/shard/delete.go
index 239fe2ebe..5ec4ea604 100644
--- a/pkg/local_object_storage/shard/delete.go
+++ b/pkg/local_object_storage/shard/delete.go
@@ -47,7 +47,10 @@ func (s *Shard) Delete(prm DeletePrm) (DeleteRes, error) {
 			}
 		}
 
-		blobovniczaID, err := meta.IsSmall(s.metaBase, prm.addr[i])
+		var sPrm meta.IsSmallPrm
+		sPrm.WithAddress(prm.addr[i])
+
+		res, err := s.metaBase.IsSmall(sPrm)
 		if err != nil {
 			s.log.Debug("can't get blobovniczaID from metabase",
 				zap.Stringer("object", prm.addr[i]),
@@ -56,12 +59,15 @@ func (s *Shard) Delete(prm DeletePrm) (DeleteRes, error) {
 			continue
 		}
 
-		if blobovniczaID != nil {
-			smalls[prm.addr[i]] = blobovniczaID
+		if res.BlobovniczaID() != nil {
+			smalls[prm.addr[i]] = res.BlobovniczaID()
 		}
 	}
 
-	err := meta.Delete(s.metaBase, prm.addr...)
+	var delPrm meta.DeletePrm
+	delPrm.WithAddresses(prm.addr...)
+
+	_, err := s.metaBase.Delete(delPrm)
 	if err != nil {
 		return DeleteRes{}, err // stop on metabase error ?
 	}
diff --git a/pkg/local_object_storage/shard/exists.go b/pkg/local_object_storage/shard/exists.go
index 6cb481f11..149a337e5 100644
--- a/pkg/local_object_storage/shard/exists.go
+++ b/pkg/local_object_storage/shard/exists.go
@@ -38,7 +38,11 @@ func (p ExistsRes) Exists() bool {
 //
 // Returns an error of type apistatus.ObjectAlreadyRemoved if object has been marked as removed.
 func (s *Shard) Exists(prm ExistsPrm) (ExistsRes, error) {
-	exists, err := meta.Exists(s.metaBase, prm.addr)
+	var existsPrm meta.ExistsPrm
+	existsPrm.WithAddress(prm.addr)
+
+	res, err := s.metaBase.Exists(existsPrm)
+	exists := res.Exists()
 	if err != nil {
 		// If the shard is in degraded mode, try to consult blobstor directly.
 		// Otherwise, just return an error.
diff --git a/pkg/local_object_storage/shard/get.go b/pkg/local_object_storage/shard/get.go
index cb2e18732..d69518147 100644
--- a/pkg/local_object_storage/shard/get.go
+++ b/pkg/local_object_storage/shard/get.go
@@ -119,10 +119,14 @@ func (s *Shard) fetchObjectData(addr oid.Address, skipMeta bool, big, small stor
 
 	var exists bool
 	if !skipMeta {
-		exists, err = meta.Exists(s.metaBase, addr)
+		var mPrm meta.ExistsPrm
+		mPrm.WithAddress(addr)
+
+		mRes, err := s.metaBase.Exists(mPrm)
 		if err != nil && s.GetMode() != ModeDegraded {
 			return res, false, err
 		}
+		exists = mRes.Exists()
 	}
 
 	if skipMeta || err != nil {
@@ -140,13 +144,16 @@ func (s *Shard) fetchObjectData(addr oid.Address, skipMeta bool, big, small stor
 		return nil, false, errNotFound
 	}
 
-	blobovniczaID, err := meta.IsSmall(s.metaBase, addr)
+	var mPrm meta.IsSmallPrm
+	mPrm.WithAddress(addr)
+
+	mRes, err := s.metaBase.IsSmall(mPrm)
 	if err != nil {
 		return nil, true, fmt.Errorf("can't fetch blobovnicza id from metabase: %w", err)
 	}
 
-	if blobovniczaID != nil {
-		res, err = small(s.blobStor, blobovniczaID)
+	if mRes.BlobovniczaID() != nil {
+		res, err = small(s.blobStor, mRes.BlobovniczaID())
 	} else {
 		res, err = big(s.blobStor, nil)
 	}
diff --git a/pkg/local_object_storage/shard/list.go b/pkg/local_object_storage/shard/list.go
index 701f546fd..6110b6aad 100644
--- a/pkg/local_object_storage/shard/list.go
+++ b/pkg/local_object_storage/shard/list.go
@@ -73,7 +73,11 @@ func (s *Shard) List() (res SelectRes, err error) {
 	filters.AddPhyFilter()
 
 	for i := range lst {
-		ids, err := meta.Select(s.metaBase, lst[i], filters) // consider making List in metabase
+		var sPrm meta.SelectPrm
+		sPrm.WithContainerID(lst[i])
+		sPrm.WithFilters(filters)
+
+		sRes, err := s.metaBase.Select(sPrm) // consider making List in metabase
 		if err != nil {
 			s.log.Debug("can't select all objects",
 				zap.Stringer("cid", lst[i]),
@@ -82,7 +86,7 @@ func (s *Shard) List() (res SelectRes, err error) {
 			continue
 		}
 
-		res.addrList = append(res.addrList, ids...)
+		res.addrList = append(res.addrList, sRes.AddressList()...)
 	}
 
 	return res, nil
diff --git a/pkg/local_object_storage/shard/move.go b/pkg/local_object_storage/shard/move.go
index 7fa0f6d80..3ccb6f97e 100644
--- a/pkg/local_object_storage/shard/move.go
+++ b/pkg/local_object_storage/shard/move.go
@@ -29,7 +29,10 @@ func (s *Shard) ToMoveIt(prm ToMoveItPrm) (ToMoveItRes, error) {
 		return ToMoveItRes{}, ErrReadOnlyMode
 	}
 
-	err := meta.ToMoveIt(s.metaBase, prm.addr)
+	var toMovePrm meta.ToMoveItPrm
+	toMovePrm.WithAddress(prm.addr)
+
+	_, err := s.metaBase.ToMoveIt(toMovePrm)
 	if err != nil {
 		s.log.Debug("could not mark object for shard relocation in metabase",
 			zap.String("error", err.Error()),
diff --git a/pkg/local_object_storage/shard/put.go b/pkg/local_object_storage/shard/put.go
index cdc582d56..ab3ce8a65 100644
--- a/pkg/local_object_storage/shard/put.go
+++ b/pkg/local_object_storage/shard/put.go
@@ -60,7 +60,10 @@ func (s *Shard) Put(prm PutPrm) (PutRes, error) {
 	}
 
 	// put to metabase
-	if err := meta.Put(s.metaBase, prm.obj, res.BlobovniczaID()); err != nil {
+	var pPrm meta.PutPrm
+	pPrm.WithObject(prm.obj)
+	pPrm.WithBlobovniczaID(res.BlobovniczaID())
+	if _, err := s.metaBase.Put(pPrm); err != nil {
 		// may we need to handle this case in a special way
 		// since the object has been successfully written to BlobStor
 		return PutRes{}, fmt.Errorf("could not put object to metabase: %w", err)
diff --git a/pkg/local_object_storage/shard/select.go b/pkg/local_object_storage/shard/select.go
index d3a432f76..d7db7b1a8 100644
--- a/pkg/local_object_storage/shard/select.go
+++ b/pkg/local_object_storage/shard/select.go
@@ -44,12 +44,16 @@ func (r SelectRes) AddressList() []oid.Address {
 // Returns any error encountered that
 // did not allow to completely select the objects.
 func (s *Shard) Select(prm SelectPrm) (SelectRes, error) {
-	addrList, err := meta.Select(s.metaBase, prm.cnr, prm.filters)
+	var selectPrm meta.SelectPrm
+	selectPrm.WithFilters(prm.filters)
+	selectPrm.WithContainerID(prm.cnr)
+
+	mRes, err := s.metaBase.Select(selectPrm)
 	if err != nil {
 		return SelectRes{}, fmt.Errorf("could not select objects from metabase: %w", err)
 	}
 
 	return SelectRes{
-		addrList: addrList,
+		addrList: mRes.AddressList(),
 	}, nil
 }
diff --git a/pkg/local_object_storage/writecache/flush.go b/pkg/local_object_storage/writecache/flush.go
index 074f2cf97..2d3fd897f 100644
--- a/pkg/local_object_storage/writecache/flush.go
+++ b/pkg/local_object_storage/writecache/flush.go
@@ -238,7 +238,12 @@ func (c *cache) writeObject(obj *object.Object, metaOnly bool) error {
 		id = res.BlobovniczaID()
 	}
 
-	return meta.Put(c.metabase, obj, id)
+	var pPrm meta.PutPrm
+	pPrm.WithObject(obj)
+	pPrm.WithBlobovniczaID(id)
+
+	_, err := c.metabase.Put(pPrm)
+	return err
 }
 
 func cloneBytes(a []byte) []byte {