diff --git a/core/state/snapshot/conversion.go b/core/state/snapshot/conversion.go
index b56757952..7d89c2f0c 100644
--- a/core/state/snapshot/conversion.go
+++ b/core/state/snapshot/conversion.go
@@ -366,11 +366,11 @@ func stackTrieGenerate(db ethdb.KeyValueWriter, scheme string, owner common.Hash
 	var nodeWriter trie.NodeWriteFunc
 	// Implement nodeWriter in case db is existed otherwise let it be nil.
 	if db != nil {
-		nodeWriter = func(owner common.Hash, path []byte, hash common.Hash, blob []byte) {
+		nodeWriter = func(path []byte, hash common.Hash, blob []byte) {
 			rawdb.WriteTrieNode(db, owner, path, hash, blob, scheme)
 		}
 	}
-	t := trie.NewStackTrieWithOwner(nodeWriter, owner)
+	t := trie.NewStackTrie(nodeWriter)
 	for leaf := range in {
 		t.TryUpdate(leaf.key[:], leaf.value)
 	}
diff --git a/eth/protocols/snap/sync.go b/eth/protocols/snap/sync.go
index 538d6f0b5..3d293aee6 100644
--- a/eth/protocols/snap/sync.go
+++ b/eth/protocols/snap/sync.go
@@ -721,8 +721,8 @@ func (s *Syncer) loadSyncStatus() {
 						s.accountBytes += common.StorageSize(len(key) + len(value))
 					},
 				}
-				task.genTrie = trie.NewStackTrie(func(owner common.Hash, path []byte, hash common.Hash, val []byte) {
-					rawdb.WriteTrieNode(task.genBatch, owner, path, hash, val, s.scheme)
+				task.genTrie = trie.NewStackTrie(func(path []byte, hash common.Hash, val []byte) {
+					rawdb.WriteTrieNode(task.genBatch, common.Hash{}, path, hash, val, s.scheme)
 				})
 
 				for accountHash, subtasks := range task.SubTasks {
@@ -735,9 +735,10 @@ func (s *Syncer) loadSyncStatus() {
 								s.storageBytes += common.StorageSize(len(key) + len(value))
 							},
 						}
-						subtask.genTrie = trie.NewStackTrieWithOwner(func(owner common.Hash, path []byte, hash common.Hash, val []byte) {
+						owner := accountHash // local assignment for stacktrie writer closure
+						subtask.genTrie = trie.NewStackTrie(func(path []byte, hash common.Hash, val []byte) {
 							rawdb.WriteTrieNode(subtask.genBatch, owner, path, hash, val, s.scheme)
-						}, accountHash)
+						})
 					}
 				}
 			}
@@ -791,8 +792,8 @@ func (s *Syncer) loadSyncStatus() {
 			Last:     last,
 			SubTasks: make(map[common.Hash][]*storageTask),
 			genBatch: batch,
-			genTrie: trie.NewStackTrie(func(owner common.Hash, path []byte, hash common.Hash, val []byte) {
-				rawdb.WriteTrieNode(batch, owner, path, hash, val, s.scheme)
+			genTrie: trie.NewStackTrie(func(path []byte, hash common.Hash, val []byte) {
+				rawdb.WriteTrieNode(batch, common.Hash{}, path, hash, val, s.scheme)
 			}),
 		})
 		log.Debug("Created account sync task", "from", next, "last", last)
@@ -1973,14 +1974,15 @@ func (s *Syncer) processStorageResponse(res *storageResponse) {
 							s.storageBytes += common.StorageSize(len(key) + len(value))
 						},
 					}
+					owner := account // local assignment for stacktrie writer closure
 					tasks = append(tasks, &storageTask{
 						Next:     common.Hash{},
 						Last:     r.End(),
 						root:     acc.Root,
 						genBatch: batch,
-						genTrie: trie.NewStackTrieWithOwner(func(owner common.Hash, path []byte, hash common.Hash, val []byte) {
+						genTrie: trie.NewStackTrie(func(path []byte, hash common.Hash, val []byte) {
 							rawdb.WriteTrieNode(batch, owner, path, hash, val, s.scheme)
-						}, account),
+						}),
 					})
 					for r.Next() {
 						batch := ethdb.HookedBatch{
@@ -1994,9 +1996,9 @@ func (s *Syncer) processStorageResponse(res *storageResponse) {
 							Last:     r.End(),
 							root:     acc.Root,
 							genBatch: batch,
-							genTrie: trie.NewStackTrieWithOwner(func(owner common.Hash, path []byte, hash common.Hash, val []byte) {
+							genTrie: trie.NewStackTrie(func(path []byte, hash common.Hash, val []byte) {
 								rawdb.WriteTrieNode(batch, owner, path, hash, val, s.scheme)
-							}, account),
+							}),
 						})
 					}
 					for _, task := range tasks {
@@ -2041,9 +2043,10 @@ func (s *Syncer) processStorageResponse(res *storageResponse) {
 		slots += len(res.hashes[i])
 
 		if i < len(res.hashes)-1 || res.subTask == nil {
-			tr := trie.NewStackTrieWithOwner(func(owner common.Hash, path []byte, hash common.Hash, val []byte) {
-				rawdb.WriteTrieNode(batch, owner, path, hash, val, s.scheme)
-			}, account)
+			// no need to make local reassignment of account: this closure does not outlive the loop
+			tr := trie.NewStackTrie(func(path []byte, hash common.Hash, val []byte) {
+				rawdb.WriteTrieNode(batch, account, path, hash, val, s.scheme)
+			})
 			for j := 0; j < len(res.hashes[i]); j++ {
 				tr.Update(res.hashes[i][j][:], res.slots[i][j])
 			}
diff --git a/tests/fuzzers/stacktrie/trie_fuzzer.go b/tests/fuzzers/stacktrie/trie_fuzzer.go
index 9ade6f2b2..d1efced9b 100644
--- a/tests/fuzzers/stacktrie/trie_fuzzer.go
+++ b/tests/fuzzers/stacktrie/trie_fuzzer.go
@@ -153,8 +153,8 @@ func (f *fuzzer) fuzz() int {
 		trieA   = trie.NewEmpty(dbA)
 		spongeB = &spongeDb{sponge: sha3.NewLegacyKeccak256()}
 		dbB     = trie.NewDatabase(rawdb.NewDatabase(spongeB), nil)
-		trieB   = trie.NewStackTrie(func(owner common.Hash, path []byte, hash common.Hash, blob []byte) {
-			rawdb.WriteTrieNode(spongeB, owner, path, hash, blob, dbB.Scheme())
+		trieB   = trie.NewStackTrie(func(path []byte, hash common.Hash, blob []byte) {
+			rawdb.WriteTrieNode(spongeB, common.Hash{}, path, hash, blob, dbB.Scheme())
 		})
 		vals        kvs
 		useful      bool
@@ -218,13 +218,10 @@ func (f *fuzzer) fuzz() int {
 	// Need tracked deleted nodes.
 	var (
 		nodeset = make(map[string][]byte) // path -> blob
-		trieC   = trie.NewStackTrie(func(owner common.Hash, path []byte, hash common.Hash, blob []byte) {
+		trieC   = trie.NewStackTrie(func(path []byte, hash common.Hash, blob []byte) {
 			if crypto.Keccak256Hash(blob) != hash {
 				panic("invalid node blob")
 			}
-			if owner != (common.Hash{}) {
-				panic("invalid node owner")
-			}
 			nodeset[string(path)] = common.CopyBytes(blob)
 		})
 		checked int
diff --git a/trie/stacktrie.go b/trie/stacktrie.go
index 28d5bed82..278c1e51b 100644
--- a/trie/stacktrie.go
+++ b/trie/stacktrie.go
@@ -34,13 +34,12 @@ var (
 
 // NodeWriteFunc is used to provide all information of a dirty node for committing
 // so that callers can flush nodes into database with desired scheme.
-type NodeWriteFunc = func(owner common.Hash, path []byte, hash common.Hash, blob []byte)
+type NodeWriteFunc = func(path []byte, hash common.Hash, blob []byte)
 
 // StackTrie is a trie implementation that expects keys to be inserted
 // in order. Once it determines that a subtree will no longer be inserted
 // into, it will hash it and free up the memory it uses.
 type StackTrie struct {
-	owner   common.Hash   // the owner of the trie
 	writeFn NodeWriteFunc // function for committing nodes, can be nil
 	root    *stNode
 	h       *hasher
@@ -55,14 +54,6 @@ func NewStackTrie(writeFn NodeWriteFunc) *StackTrie {
 	}
 }
 
-// NewStackTrieWithOwner allocates and initializes an empty trie, but with
-// the additional owner field.
-func NewStackTrieWithOwner(writeFn NodeWriteFunc, owner common.Hash) *StackTrie {
-	stack := NewStackTrie(writeFn)
-	stack.owner = owner
-	return stack
-}
-
 func (t *StackTrie) Update(key, value []byte) {
 	if err := t.TryUpdate(key, value); err != nil {
 		log.Error(fmt.Sprintf("Unhandled trie error: %v", err))
@@ -376,7 +367,7 @@ func (t *StackTrie) hash(st *stNode, path []byte) {
 	st.val = t.h.hashData(encodedNode)
 
 	if t.writeFn != nil {
-		t.writeFn(t.owner, path, common.BytesToHash(st.val), encodedNode)
+		t.writeFn(path, common.BytesToHash(st.val), encodedNode)
 	}
 }
 
@@ -419,7 +410,7 @@ func (t *StackTrie) Commit() (common.Hash, error) {
 		// hash st.val -> ret
 		t.h.sha.Write(st.val)
 		t.h.sha.Read(ret)
-		t.writeFn(t.owner, nil, common.BytesToHash(ret), st.val)
+		t.writeFn(nil, common.BytesToHash(ret), st.val)
 		return common.BytesToHash(ret), nil
 	}
 	return common.BytesToHash(st.val), nil
diff --git a/trie/stacktrie_marshalling.go b/trie/stacktrie_marshalling.go
deleted file mode 100644
index c0bb07f86..000000000
--- a/trie/stacktrie_marshalling.go
+++ /dev/null
@@ -1,120 +0,0 @@
-// Copyright 2023 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package trie
-
-import (
-	"bufio"
-	"bytes"
-	"encoding"
-	"encoding/gob"
-)
-
-// Compile-time interface checks.
-var (
-	_ = encoding.BinaryMarshaler((*StackTrie)(nil))
-	_ = encoding.BinaryUnmarshaler((*StackTrie)(nil))
-)
-
-// NewFromBinaryV2 initialises a serialized stacktrie with the given db.
-// OBS! Format was changed along with the name of this constructor.
-func NewFromBinaryV2(data []byte) (*StackTrie, error) {
-	stack := NewStackTrie(nil)
-	if err := stack.UnmarshalBinary(data); err != nil {
-		return nil, err
-	}
-	return stack, nil
-}
-
-// MarshalBinary implements encoding.BinaryMarshaler.
-func (t *StackTrie) MarshalBinary() (data []byte, err error) {
-	var (
-		b bytes.Buffer
-		w = bufio.NewWriter(&b)
-	)
-	if err := gob.NewEncoder(w).Encode(t.owner); err != nil {
-		return nil, err
-	}
-	if err := t.root.marshalInto(w); err != nil {
-		return nil, err
-	}
-	w.Flush()
-	return b.Bytes(), nil
-}
-
-// UnmarshalBinary implements encoding.BinaryUnmarshaler.
-func (t *StackTrie) UnmarshalBinary(data []byte) error {
-	r := bytes.NewReader(data)
-	if err := gob.NewDecoder(r).Decode(&t.owner); err != nil {
-		return err
-	}
-	if err := t.root.unmarshalFrom(r); err != nil {
-		return err
-	}
-	return nil
-}
-
-type stackNodeMarshaling struct {
-	Typ uint8
-	Key []byte
-	Val []byte
-}
-
-func (n *stNode) marshalInto(w *bufio.Writer) (err error) {
-	enc := stackNodeMarshaling{
-		Typ: n.typ,
-		Key: n.key,
-		Val: n.val,
-	}
-	if err := gob.NewEncoder(w).Encode(enc); err != nil {
-		return err
-	}
-	for _, child := range n.children {
-		if child == nil {
-			w.WriteByte(0)
-			continue
-		}
-		w.WriteByte(1)
-		if err := child.marshalInto(w); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func (n *stNode) unmarshalFrom(r *bytes.Reader) error {
-	var dec stackNodeMarshaling
-	if err := gob.NewDecoder(r).Decode(&dec); err != nil {
-		return err
-	}
-	n.typ = dec.Typ
-	n.key = dec.Key
-	n.val = dec.Val
-
-	for i := range n.children {
-		if b, err := r.ReadByte(); err != nil {
-			return err
-		} else if b == 0 {
-			continue
-		}
-		var child stNode
-		if err := child.unmarshalFrom(r); err != nil {
-			return err
-		}
-		n.children[i] = &child
-	}
-	return nil
-}
diff --git a/trie/stacktrie_test.go b/trie/stacktrie_test.go
index cdf91ccf4..c33a71584 100644
--- a/trie/stacktrie_test.go
+++ b/trie/stacktrie_test.go
@@ -348,51 +348,3 @@ func TestStacktrieNotModifyValues(t *testing.T) {
 
 	}
 }
-
-// TestStacktrieSerialization tests that the stacktrie works well if we
-// serialize/unserialize it a lot
-func TestStacktrieSerialization(t *testing.T) {
-	var (
-		st       = NewStackTrieWithOwner(nil, common.Hash{0x12})
-		nt       = NewEmpty(NewDatabase(rawdb.NewMemoryDatabase(), nil))
-		keyB     = big.NewInt(1)
-		keyDelta = big.NewInt(1)
-		vals     [][]byte
-		keys     [][]byte
-	)
-	getValue := func(i int) []byte {
-		if i%2 == 0 { // large
-			return crypto.Keccak256(big.NewInt(int64(i)).Bytes())
-		} else { //small
-			return big.NewInt(int64(i)).Bytes()
-		}
-	}
-	for i := 0; i < 10; i++ {
-		vals = append(vals, getValue(i))
-		keys = append(keys, common.BigToHash(keyB).Bytes())
-		keyB = keyB.Add(keyB, keyDelta)
-		keyDelta.Add(keyDelta, common.Big1)
-	}
-	for i, k := range keys {
-		nt.TryUpdate(k, common.CopyBytes(vals[i]))
-	}
-
-	for i, k := range keys {
-		blob, err := st.MarshalBinary()
-		if err != nil {
-			t.Fatal(err)
-		}
-		newSt, err := NewFromBinaryV2(blob)
-		if err != nil {
-			t.Fatal(err)
-		}
-		st = newSt
-		st.TryUpdate(k, common.CopyBytes(vals[i]))
-	}
-	if have, want := st.Hash(), nt.Hash(); have != want {
-		t.Fatalf("have %#x want %#x", have, want)
-	}
-	if have, want := st.owner, (common.Hash{0x12}); have != want {
-		t.Fatalf("have %#x want %#x", have, want)
-	}
-}
diff --git a/trie/trie_test.go b/trie/trie_test.go
index b53f6f83e..b3deef83c 100644
--- a/trie/trie_test.go
+++ b/trie/trie_test.go
@@ -893,8 +893,8 @@ func TestCommitSequenceStackTrie(t *testing.T) {
 		trie := NewEmpty(db)
 		// Another sponge is used for the stacktrie commits
 		stackTrieSponge := &spongeDb{sponge: sha3.NewLegacyKeccak256(), id: "b"}
-		writeFn := func(owner common.Hash, path []byte, hash common.Hash, blob []byte) {
-			rawdb.WriteTrieNode(stackTrieSponge, owner, path, hash, blob, db.Scheme())
+		writeFn := func(path []byte, hash common.Hash, blob []byte) {
+			rawdb.WriteTrieNode(stackTrieSponge, common.Hash{}, path, hash, blob, db.Scheme())
 		}
 		stTrie := NewStackTrie(writeFn)
 		// Fill the trie with elements, should start 0, otherwise nodes will be nil in the first time.
@@ -953,8 +953,8 @@ func TestCommitSequenceSmallRoot(t *testing.T) {
 	trie := NewEmpty(db)
 	// Another sponge is used for the stacktrie commits
 	stackTrieSponge := &spongeDb{sponge: sha3.NewLegacyKeccak256(), id: "b"}
-	writeFn := func(owner common.Hash, path []byte, hash common.Hash, blob []byte) {
-		rawdb.WriteTrieNode(stackTrieSponge, owner, path, hash, blob, db.Scheme())
+	writeFn := func(path []byte, hash common.Hash, blob []byte) {
+		rawdb.WriteTrieNode(stackTrieSponge, common.Hash{}, path, hash, blob, db.Scheme())
 	}
 	stTrie := NewStackTrie(writeFn)
 	// Add a single small-element to the trie(s)