Revert "Outfox integration (#3331 )"

This reverts commit b5c8b69547.
2023-06-29 15:45:13 +03:00
88 changed files with 960 additions and 2346 deletions
@@ -42,5 +42,4 @@ storybook-static
 envs/qwerty.env
 .parcel-cache
 **/.DS_Store
-cpu-cycles/libcpucycles/build
-foxyfox.env
+cpu-cycles/libcpucycles/build
@@ -173,7 +173,7 @@ dependencies = [
 "serde_urlencoded",
 "smallvec",
 "socket2",
- "time 0.3.21",
+ "time 0.3.20",
 "url",
 ]

@@ -502,7 +502,7 @@ dependencies = [
 "num-traits",
 "rusticata-macros",
 "thiserror",
- "time 0.3.21",
+ "time 0.3.20",
 ]

 [[package]]
@@ -518,7 +518,7 @@ dependencies = [
 "num-traits",
 "rusticata-macros",
 "thiserror",
- "time 0.3.21",
+ "time 0.3.20",
 ]

 [[package]]
@@ -620,7 +620,7 @@ checksum = "16e62a023e7c117e27523144c5d2459f4397fcc3cab0085af8e2224f643a0193"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.16",
+ "syn 2.0.15",
 ]

 [[package]]
@@ -631,7 +631,7 @@ checksum = "b9ccdd8f2a161be9bd5c023df56f1b2a0bd1d83872ae53b71a84a12c9bf6e842"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.16",
+ "syn 2.0.15",
 ]

 [[package]]
@@ -667,9 +667,12 @@ dependencies = [

 [[package]]
 name = "atomic"
-version = "0.5.3"
+version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c59bdb34bc650a32731b31bd8f0829cc15d24a708ee31559e0bb34f2bc320cba"
+checksum = "b88d82667eca772c4aa12f0f1348b3ae643424c8876448f3f7bd5787032e234c"
+dependencies = [
+ "autocfg 1.1.0",
+]

 [[package]]
 name = "atomic-waker"
@@ -1019,9 +1022,9 @@ dependencies = [

 [[package]]
 name = "bumpalo"
-version = "3.12.2"
+version = "3.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c6ed94e98ecff0c12dd1b04c15ec0d7d9458ca8fe806cea6f12954efe74c63b"
+checksum = "9b1ce199063694f33ffb7dd4e0ee620741495c32833cde5aa08f02a0bf96f0c8"

 [[package]]
 name = "byte-tools"
@@ -1188,9 +1191,9 @@ dependencies = [

 [[package]]
 name = "ciborium"
-version = "0.2.1"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "effd91f6c78e5a4ace8a5d3c0b6bfaec9e2baaef55f3efc00e45fb2e477ee926"
+checksum = "b0c137568cc60b904a7724001b35ce2630fd00d5d84805fbb608ab89509d788f"
 dependencies = [
 "ciborium-io",
 "ciborium-ll",
@@ -1199,15 +1202,15 @@ dependencies = [

 [[package]]
 name = "ciborium-io"
-version = "0.2.1"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cdf919175532b369853f5d5e20b26b43112613fd6fe7aee757e35f7a44642656"
+checksum = "346de753af073cc87b52b2083a506b38ac176a44cfb05497b622e27be899b369"

 [[package]]
 name = "ciborium-ll"
-version = "0.2.1"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "defaa24ecc093c77630e6c15e17c51f5e187bf35ee514f4e2d67baaa96dae22b"
+checksum = "213030a2b5a4e0c0892b6652260cf6ccac84827b83a85a534e178e3906c4cf1b"
 dependencies = [
 "ciborium-io",
 "half",
@@ -1292,9 +1295,9 @@ dependencies = [

 [[package]]
 name = "clap_complete"
-version = "4.2.3"
+version = "4.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1594fe2312ec4abf402076e407628f5c313e54c32ade058521df4ee34ecac8a8"
+checksum = "1a19591b2ab0e3c04b588a0e04ddde7b9eaa423646d1b4a8092879216bf47473"
 dependencies = [
 "clap 4.2.7",
 ]
@@ -1318,7 +1321,7 @@ dependencies = [
 "heck 0.4.1",
 "proc-macro2",
 "quote",
- "syn 2.0.16",
+ "syn 2.0.15",
 ]

 [[package]]
@@ -1345,6 +1348,16 @@ dependencies = [
 "bitflags",
 ]

+[[package]]
+name = "codespan-reporting"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3538270d33cc669650c4b093848450d380def10c331d38c768e34cac80576e6e"
+dependencies = [
+ "termcolor",
+ "unicode-width",
+]
+
 [[package]]
 name = "colorchoice"
 version = "1.0.0"
@@ -1409,9 +1422,9 @@ dependencies = [

 [[package]]
 name = "console-api"
-version = "0.5.0"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c2895653b4d9f1538a83970077cb01dfc77a4810524e51a110944688e916b18e"
+checksum = "e57ff02e8ad8e06ab9731d5dc72dc23bef9200778eae1a89d555d8c42e5d4a86"
 dependencies = [
 "prost 0.11.9",
 "prost-types 0.11.9",
@@ -1421,9 +1434,9 @@ dependencies = [

 [[package]]
 name = "console-subscriber"
-version = "0.1.9"
+version = "0.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "57ab2224a0311582eb03adba4caaf18644f7b1f10a760803a803b9b605187fc7"
+checksum = "22a3a81dfaf6b66bce5d159eddae701e3a002f194d378cbf7be5f053c281d9be"
 dependencies = [
 "console-api",
 "crossbeam-channel",
@@ -1475,7 +1488,7 @@ dependencies = [
 "rand 0.8.5",
 "sha2 0.10.6",
 "subtle 2.4.1",
- "time 0.3.21",
+ "time 0.3.20",
 "version_check",
 ]

@@ -1993,6 +2006,50 @@ dependencies = [
 "serde",
 ]

+[[package]]
+name = "cxx"
+version = "1.0.94"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f61f1b6389c3fe1c316bf8a4dccc90a38208354b330925bce1f74a6c4756eb93"
+dependencies = [
+ "cc",
+ "cxxbridge-flags",
+ "cxxbridge-macro",
+ "link-cplusplus",
+]
+
+[[package]]
+name = "cxx-build"
+version = "1.0.94"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "12cee708e8962df2aeb38f594aae5d827c022b6460ac71a7a3e2c3c2aae5a07b"
+dependencies = [
+ "cc",
+ "codespan-reporting",
+ "once_cell",
+ "proc-macro2",
+ "quote",
+ "scratch",
+ "syn 2.0.15",
+]
+
+[[package]]
+name = "cxxbridge-flags"
+version = "1.0.94"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7944172ae7e4068c533afbb984114a56c46e9ccddda550499caa222902c7f7bb"
+
+[[package]]
+name = "cxxbridge-macro"
+version = "1.0.94"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2345488264226bf682893e25de0769f3360aac9957980ec49361b083ddaa5bc5"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.15",
+]
+
 [[package]]
 name = "darling"
 version = "0.13.4"
@@ -2317,7 +2374,7 @@ checksum = "487585f4d0c6655fe74905e2504d8ad6908e4db67f744eb140876906c2f3175d"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.16",
+ "syn 2.0.15",
 ]

 [[package]]
@@ -2468,7 +2525,7 @@ checksum = "eecf8589574ce9b895052fa12d69af7a233f99e6107f5cb8dd1044f2a17bfdcb"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.16",
+ "syn 2.0.15",
 ]

 [[package]]
@@ -2538,7 +2595,7 @@ dependencies = [
 "unsigned-varint",
 "utoipa",
 "utoipa-swagger-ui",
- "uuid 1.3.3",
+ "uuid 1.3.2",
 ]

 [[package]]
@@ -2896,7 +2953,7 @@ checksum = "89ca545a94061b6365f2c7355b4b32bd20df3ff95f02da9329b34ccc3bd6ee72"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.16",
+ "syn 2.0.15",
 ]

 [[package]]
@@ -3052,7 +3109,7 @@ checksum = "e77ac7b51b8e6313251737fcef4b1c01a2ea102bde68415b62c0ee9268fec357"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.16",
+ "syn 2.0.15",
 ]

 [[package]]
@@ -3129,9 +3186,9 @@ dependencies = [

 [[package]]
 name = "h2"
-version = "0.3.19"
+version = "0.3.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d357c7ae988e7d2182f7d7871d0b963962420b0678b0997ce7de72001aeab782"
+checksum = "17f8a914c2987b688368b5138aa05321db91f4090cf26118185672ad588bce21"
 dependencies = [
 "bytes",
 "fnv",
@@ -3204,11 +3261,11 @@ dependencies = [

 [[package]]
 name = "hashlink"
-version = "0.8.2"
+version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0761a1b9491c4f2e3d66aa0f62d0fba0af9a0e2852e4d48ea506632a4b56e6aa"
+checksum = "69fe1fcf8b4278d860ad0548329f892a3631fb63f82574df68275f34cdbe0ffa"
 dependencies = [
- "hashbrown 0.13.2",
+ "hashbrown 0.12.3",
 ]

 [[package]]
@@ -3531,11 +3588,12 @@ dependencies = [

 [[package]]
 name = "iana-time-zone-haiku"
-version = "0.1.2"
+version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f"
+checksum = "0703ae284fc167426161c2e3f1da3ea71d94b21bedbcc9494e92b28e334e3dca"
 dependencies = [
- "cc",
+ "cxx",
+ "cxx-build",
 ]

 [[package]]
@@ -3608,7 +3666,7 @@ checksum = "bfbcff6ae46750b15cc594bfd277b188cbddcfdc1817848f97f03f26f8625b9e"
 dependencies = [
 "cfg-if",
 "js-sys",
- "uuid 1.3.3",
+ "uuid 1.3.2",
 "wasm-bindgen",
 "wasm-bindgen-futures",
 "web-sys",
@@ -3962,9 +4020,9 @@ dependencies = [

 [[package]]
 name = "libc"
-version = "0.2.144"
+version = "0.2.142"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2b00cc1c228a6782d0f076e7b232802e0c5689d41bb5df366f2a6b6621cfdfe1"
+checksum = "6a987beff54b60ffa6d51982e1aa1146bc42f19bd26be28b0586f252fccf5317"

 [[package]]
 name = "libgit2-sys"
@@ -3996,9 +4054,9 @@ checksum = "7fc7aa29613bd6a620df431842069224d8bc9011086b1db4c0e0cd47fa03ec9a"

 [[package]]
 name = "libm"
-version = "0.2.7"
+version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f7012b1bbb0719e1097c47611d3898568c546d597c2e74d66f6087edd5233ff4"
+checksum = "348108ab3fba42ec82ff6e9564fc4ca0247bdccdc68dd8af9764bbc79c3c8ffb"

 [[package]]
 name = "libp2p"
@@ -4424,6 +4482,15 @@ dependencies = [
 "vcpkg",
 ]

+[[package]]
+name = "link-cplusplus"
+version = "1.0.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ecd207c9c713c34f95a097a5b029ac2ce6010530c7b49d7fea24d977dede04f5"
+dependencies = [
+ "cc",
+]
+
 [[package]]
 name = "linked-hash-map"
 version = "0.5.6"
@@ -4881,9 +4948,9 @@ dependencies = [

 [[package]]
 name = "notify"
-version = "5.2.0"
+version = "5.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "729f63e1ca555a43fe3efa4f3efdf4801c479da85b432242a7b726f353c88486"
+checksum = "58ea850aa68a06e48fdb069c0ec44d0d64c8dbffa49bf3b6f7f0a901fdea1ba9"
 dependencies = [
 "bitflags",
 "crossbeam-channel",
@@ -4894,7 +4961,7 @@ dependencies = [
 "libc",
 "mio",
 "walkdir",
- "windows-sys 0.45.0",
+ "windows-sys 0.42.0",
 ]

 [[package]]
@@ -4955,7 +5022,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "578ede34cf02f8924ab9447f50c28075b4d3e5b269972345e7e0372b38c6cdcd"
 dependencies = [
 "autocfg 1.1.0",
- "libm 0.2.7",
+ "libm 0.2.6",
 ]

 [[package]]
@@ -5031,7 +5098,7 @@ dependencies = [
 "sqlx 0.6.3",
 "tap",
 "thiserror",
- "time 0.3.21",
+ "time 0.3.20",
 "tokio",
 "tokio-stream",
 "ts-rs",
@@ -5161,7 +5228,7 @@ dependencies = [
 "serde_json",
 "tap",
 "thiserror",
- "time 0.3.21",
+ "time 0.3.20",
 "toml 0.5.11",
 "url",
 ]
@@ -5233,7 +5300,7 @@ dependencies = [
 "tap",
 "tempfile",
 "thiserror",
- "time 0.3.21",
+ "time 0.3.20",
 "tokio",
 "tokio-stream",
 "tokio-tungstenite 0.14.0",
@@ -5586,7 +5653,7 @@ dependencies = [
 "serde-json-wasm 0.4.1",
 "serde_repr",
 "thiserror",
- "time 0.3.21",
+ "time 0.3.20",
 "ts-rs",
 ]

@@ -5769,7 +5836,6 @@ dependencies = [
 "log",
 "nym-crypto",
 "nym-sphinx",
- "nym-sphinx-params",
 "nym-task",
 "nym-topology",
 "rand 0.7.3",
@@ -5811,10 +5877,8 @@ dependencies = [
 "curve25519-dalek 3.2.0",
 "fastrand",
 "getrandom 0.2.9",
- "log",
- "rand 0.7.3",
 "rayon",
- "sphinx-packet",
+ "sphinx-packet 0.1.0 (git+https://github.com/nymtech/sphinx.git)",
 "thiserror",
 "zeroize",
 ]
@@ -5993,6 +6057,7 @@ dependencies = [
 "log",
 "nym-crypto",
 "nym-mixnet-contract-common",
+ "nym-outfox",
 "nym-sphinx-acknowledgements",
 "nym-sphinx-addressing",
 "nym-sphinx-anonymous-replies",
@@ -6091,7 +6156,6 @@ dependencies = [
 "nym-sphinx-addressing",
 "nym-sphinx-params",
 "nym-sphinx-types",
- "thiserror",
 ]

 [[package]]
@@ -6128,9 +6192,7 @@ dependencies = [
 name = "nym-sphinx-types"
 version = "0.2.0"
 dependencies = [
- "nym-outfox",
- "sphinx-packet",
- "thiserror",
+ "sphinx-packet 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 ]

 [[package]]
@@ -6396,7 +6458,7 @@ checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.16",
+ "syn 2.0.15",
 ]

 [[package]]
@@ -6644,7 +6706,7 @@ dependencies = [
 "proc-macro2",
 "proc-macro2-diagnostics 0.10.0",
 "quote",
- "syn 2.0.16",
+ "syn 2.0.15",
 ]

 [[package]]
@@ -6745,7 +6807,7 @@ dependencies = [
 "pest_meta",
 "proc-macro2",
 "quote",
- "syn 2.0.16",
+ "syn 2.0.15",
 ]

 [[package]]
@@ -6761,22 +6823,22 @@ dependencies = [

 [[package]]
 name = "pin-project"
-version = "1.1.0"
+version = "1.0.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c95a7476719eab1e366eaf73d0260af3021184f18177925b07f54b30089ceead"
+checksum = "ad29a609b6bcd67fee905812e544992d216af9d755757c05ed2d0e15a74c6ecc"
 dependencies = [
 "pin-project-internal",
 ]

 [[package]]
 name = "pin-project-internal"
-version = "1.1.0"
+version = "1.0.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "39407670928234ebc5e6e580247dd567ad73a3578460c5990f9503df207e8f07"
+checksum = "069bdb1e05adc7a8990dce9cc75370895fbe4e3d58b9b73bf1aee56359344a55"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.16",
+ "syn 1.0.109",
 ]

 [[package]]
@@ -6965,9 +7027,9 @@ dependencies = [

 [[package]]
 name = "proc-macro2"
-version = "1.0.58"
+version = "1.0.56"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa1fb82fc0c281dd9671101b66b771ebbe1eaf967b96ac8740dcba4b70005ca8"
+checksum = "2b63bdb0cd06f1f4dedf69b254734f9b45af66e4a031e42a7480257d9898b435"
 dependencies = [
 "unicode-ident",
 ]
@@ -6993,7 +7055,7 @@ checksum = "606c4ba35817e2922a308af55ad51bab3645b59eae5c570d4a6cf07e36bd493b"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.16",
+ "syn 2.0.15",
 "version_check",
 "yansi",
 ]
@@ -7151,9 +7213,9 @@ dependencies = [

 [[package]]
 name = "quote"
-version = "1.0.27"
+version = "1.0.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f4f29d145265ec1c483c7c654450edde0bfe043d3938d6972630663356d9500"
+checksum = "4424af4bf778aae2051a77b60283332f386554255d722233d09fbfc7e30da2fc"
 dependencies = [
 "proc-macro2",
 ]
@@ -7399,7 +7461,7 @@ checksum = "6413f3de1edee53342e6138e75b56d32e7bc6e332b3bd62d497b1929d4cfbcdd"
 dependencies = [
 "pem 1.1.1",
 "ring",
- "time 0.3.21",
+ "time 0.3.20",
 "x509-parser 0.13.2",
 "yasna",
 ]
@@ -7412,7 +7474,7 @@ checksum = "ffbe84efe2f38dea12e9bfc1f65377fdf03e53a18cb3b995faedf7934c7e785b"
 dependencies = [
 "pem 1.1.1",
 "ring",
- "time 0.3.21",
+ "time 0.3.20",
 "yasna",
 ]

@@ -7471,7 +7533,7 @@ checksum = "8d2275aab483050ab2a7364c1a46604865ee7d6906684e08db0f090acf74f9e7"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.16",
+ "syn 2.0.15",
 ]

 [[package]]
@@ -7499,7 +7561,7 @@ dependencies = [
 "serde",
 "siphasher",
 "thiserror",
- "time 0.3.21",
+ "time 0.3.20",
 "toml 0.7.4",
 "url",
 "walkdir",
@@ -7515,7 +7577,7 @@ dependencies = [
 "quote",
 "refinery-core",
 "regex",
- "syn 2.0.16",
+ "syn 2.0.15",
 ]

 [[package]]
@@ -7552,9 +7614,9 @@ checksum = "a5996294f19bd3aae0453a862ad728f60e6600695733dd5df01da90c54363a3c"

 [[package]]
 name = "reqwest"
-version = "0.11.18"
+version = "0.11.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cde824a14b7c14f85caff81225f411faacc04a2013f41670f41443742b1c1c55"
+checksum = "13293b639a097af28fc8a90f22add145a9c954e49d77da06263d58cf44d5fb91"
 dependencies = [
 "base64 0.21.0",
 "bytes",
@@ -7674,7 +7736,7 @@ dependencies = [
 "serde_json",
 "state",
 "tempfile",
- "time 0.3.21",
+ "time 0.3.20",
 "tokio",
 "tokio-stream",
 "tokio-util",
@@ -7736,7 +7798,7 @@ dependencies = [
 "smallvec",
 "stable-pattern",
 "state",
- "time 0.3.21",
+ "time 0.3.20",
 "tokio",
 "uncased",
 ]
@@ -8077,6 +8139,12 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"

+[[package]]
+name = "scratch"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1792db035ce95be60c3f8853017b3999209281c24e2ba5bc8e59bf97a0c590c1"
+
 [[package]]
 name = "sct"
 version = "0.6.1"
@@ -8125,9 +8193,9 @@ dependencies = [

 [[package]]
 name = "security-framework"
-version = "2.9.0"
+version = "2.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ca2855b3715770894e67cbfa3df957790aa0c9edc3bf06efa1a84d77fa0839d1"
+checksum = "a332be01508d814fed64bf28f798a146d73792121129962fdf335bb3c49a4254"
 dependencies = [
 "bitflags",
 "core-foundation",
@@ -8138,9 +8206,9 @@ dependencies = [

 [[package]]
 name = "security-framework-sys"
-version = "2.9.0"
+version = "2.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f51d0c0d83bec45f16480d0ce0058397a69e48fcdc52d1dc8855fb68acbd31a7"
+checksum = "31c9bb296072e961fcbd8853511dd39c2d8be2deb1e17c6860b1d30732b323b4"
 dependencies = [
 "core-foundation-sys",
 "libc",
@@ -8187,9 +8255,9 @@ dependencies = [

 [[package]]
 name = "serde"
-version = "1.0.163"
+version = "1.0.162"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2113ab51b87a539ae008b5c6c02dc020ffa39afd2d83cffcb3f4eb2722cebec2"
+checksum = "71b2f6e1ab5c2b98c05f0f35b236b22e8df7ead6ffbf51d7808da7f8817e7ab6"
 dependencies = [
 "serde_derive",
 ]
@@ -8243,13 +8311,13 @@ dependencies = [

 [[package]]
 name = "serde_derive"
-version = "1.0.163"
+version = "1.0.162"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8c805777e3930c8883389c602315a24224bcc738b63905ef87cd1420353ea93e"
+checksum = "a2a0814352fd64b58489904a44ea8d90cb1a91dcb6b4f5ebabc32c8318e93cb6"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.16",
+ "syn 2.0.15",
 ]

 [[package]]
@@ -8282,7 +8350,7 @@ checksum = "bcec881020c684085e55a25f7fd888954d56609ef363479dc5a1305eb0d40cab"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.16",
+ "syn 2.0.15",
 ]

 [[package]]
@@ -8533,6 +8601,29 @@ dependencies = [
 "subtle 2.4.1",
 ]

+[[package]]
+name = "sphinx-packet"
+version = "0.1.0"
+source = "git+https://github.com/nymtech/sphinx.git#ca107d94360cdf8bbfbdb12fe5320ed74f80e40c"
+dependencies = [
+ "aes 0.7.5",
+ "arrayref",
+ "blake2 0.8.1",
+ "bs58",
+ "byteorder",
+ "chacha",
+ "curve25519-dalek 3.2.0",
+ "digest 0.9.0",
+ "hkdf 0.11.0",
+ "hmac 0.11.0",
+ "lioness",
+ "log",
+ "rand 0.7.3",
+ "rand_distr",
+ "sha2 0.9.9",
+ "subtle 2.4.1",
+]
+
 [[package]]
 name = "spin"
 version = "0.5.2"
@@ -8669,7 +8760,7 @@ dependencies = [
 "futures-executor",
 "futures-intrusive",
 "futures-util",
- "hashlink 0.8.2",
+ "hashlink 0.8.1",
 "hex",
 "indexmap",
 "itoa",
@@ -8896,9 +8987,9 @@ dependencies = [

 [[package]]
 name = "syn"
-version = "2.0.16"
+version = "2.0.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a6f671d4b5ffdb8eadec19c0ae67fe2639df8684bd7bc4b83d986b8db549cf01"
+checksum = "a34fcf3e8b60f57e6a14301a2e916d323af98b0ea63c599441eec8558660c822"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -9005,7 +9096,7 @@ dependencies = [
 "subtle 2.4.1",
 "subtle-encoding",
 "tendermint-proto",
- "time 0.3.21",
+ "time 0.3.20",
 "zeroize",
 ]

@@ -9038,7 +9129,7 @@ dependencies = [
 "serde",
 "serde_bytes",
 "subtle-encoding",
- "time 0.3.21",
+ "time 0.3.20",
 ]

 [[package]]
@@ -9066,7 +9157,7 @@ dependencies = [
 "tendermint-config",
 "tendermint-proto",
 "thiserror",
- "time 0.3.21",
+ "time 0.3.20",
 "tokio",
 "tracing",
 "url",
@@ -9106,7 +9197,7 @@ checksum = "f9456a42c5b0d803c8cd86e73dd7cc9edd429499f37a3550d286d5e86720569f"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.16",
+ "syn 2.0.15",
 ]

 [[package]]
@@ -9132,9 +9223,9 @@ dependencies = [

 [[package]]
 name = "time"
-version = "0.3.21"
+version = "0.3.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f3403384eaacbca9923fa06940178ac13e4edb725486d70e8e15881d0c836cc"
+checksum = "cd0cbfecb4d19b5ea75bb31ad904eb5b9fa13f21079c3b92017ebdf4999a5890"
 dependencies = [
 "itoa",
 "js-sys",
@@ -9145,15 +9236,15 @@ dependencies = [

 [[package]]
 name = "time-core"
-version = "0.1.1"
+version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7300fbefb4dadc1af235a9cef3737cea692a9d97e1b9cbcd4ebdae6f8868e6fb"
+checksum = "2e153e1f1acaef8acc537e68b44906d2db6436e2b35ac2c6b42640fff91f00fd"

 [[package]]
 name = "time-macros"
-version = "0.2.9"
+version = "0.2.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "372950940a5f07bf38dbe211d7283c9e6d7327df53794992d293e534c733d09b"
+checksum = "fd80a657e71da814b8e5d60d3374fc6d35045062245d80224748ae522dd76f36"
 dependencies = [
 "time-core",
 ]
@@ -9185,9 +9276,9 @@ checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"

 [[package]]
 name = "tokio"
-version = "1.28.1"
+version = "1.28.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0aa32867d44e6f2ce3385e89dceb990188b8bb0fb25b0cf576647a6f98ac5105"
+checksum = "c3c786bf8134e5a3a166db9b29ab8f48134739014a3eca7bc6bfa95d673b136f"
 dependencies = [
 "autocfg 1.1.0",
 "bytes",
@@ -9221,7 +9312,7 @@ checksum = "630bdcf245f78637c13ec01ffae6187cca34625e8c63150d424b59e55af2675e"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.16",
+ "syn 2.0.15",
 ]

 [[package]]
@@ -9393,13 +9484,14 @@ dependencies = [

 [[package]]
 name = "tonic"
-version = "0.9.2"
+version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3082666a3a6433f7f511c7192923fa1fe07c69332d3c6a2e6bb040b569199d5a"
+checksum = "8f219fad3b929bef19b1f86fbc0358d35daed8f2cac972037ac0dc10bbb8d5fb"
 dependencies = [
+ "async-stream",
 "async-trait",
 "axum",
- "base64 0.21.0",
+ "base64 0.13.1",
 "bytes",
 "futures-core",
 "futures-util",
@@ -9411,12 +9503,15 @@ dependencies = [
 "percent-encoding",
 "pin-project",
 "prost 0.11.9",
+ "prost-derive 0.11.9",
 "tokio",
 "tokio-stream",
+ "tokio-util",
 "tower",
 "tower-layer",
 "tower-service",
 "tracing",
+ "tracing-futures",
 ]

 [[package]]
@@ -9471,7 +9566,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "09d48f71a791638519505cefafe162606f706c25592e4bde4d97600c0195312e"
 dependencies = [
 "crossbeam-channel",
- "time 0.3.21",
+ "time 0.3.20",
 "tracing-subscriber",
 ]

@@ -9483,19 +9578,29 @@ checksum = "0f57e3ca2a01450b1a921183a9c9cbfda207fd822cef4ccb00a65402cbba7a74"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.16",
+ "syn 2.0.15",
 ]

 [[package]]
 name = "tracing-core"
-version = "0.1.31"
+version = "0.1.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0955b8137a1df6f1a2e9a37d8a6656291ff0297c1a97c24e0d8425fe2312f79a"
+checksum = "24eb03ba0eab1fd845050058ce5e616558e8f8d8fca633e6b163fe25c797213a"
 dependencies = [
 "once_cell",
 "valuable",
 ]

+[[package]]
+name = "tracing-futures"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97d095ae15e245a057c8e8451bab9b3ee1e1f68e9ba2b4fbc18d0ac5237835f2"
+dependencies = [
+ "pin-project",
+ "tracing",
+]
+
 [[package]]
 name = "tracing-log"
 version = "0.1.3"
@@ -9740,9 +9845,9 @@ dependencies = [

 [[package]]
 name = "uncased"
-version = "0.9.9"
+version = "0.9.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b9bc53168a4be7402ab86c3aad243a84dd7381d09be0eddc81280c1da95ca68"
+checksum = "09b01702b0fd0b3fadcf98e098780badda8742d4f4a7676615cad90e8ac73622"
 dependencies = [
 "serde",
 "version_check",
@@ -9916,7 +10021,7 @@ dependencies = [
 "proc-macro2",
 "quote",
 "regex",
- "syn 2.0.16",
+ "syn 2.0.15",
 ]

 [[package]]
@@ -9943,9 +10048,9 @@ checksum = "bc5cf98d8186244414c848017f0e2676b3fcb46807f6668a97dfe67359a3c4b7"

 [[package]]
 name = "uuid"
-version = "1.3.3"
+version = "1.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "345444e32442451b267fc254ae85a209c64be56d2890e601a0c37ff0c3c5ecd2"
+checksum = "4dad5567ad0cf5b760e5665964bec1b47dfd077ba8a2544b513f3556d3d239a2"
 dependencies = [
 "getrandom 0.2.9",
 "wasm-bindgen",
@@ -9977,7 +10082,7 @@ dependencies = [
 "rustc_version 0.4.0",
 "rustversion",
 "thiserror",
- "time 0.3.21",
+ "time 0.3.20",
 ]

 [[package]]
@@ -10232,7 +10337,7 @@ dependencies = [
 "sha2 0.10.6",
 "stun",
 "thiserror",
- "time 0.3.21",
+ "time 0.3.20",
 "tokio",
 "turn",
 "url",
@@ -10321,7 +10426,7 @@ dependencies = [
 "tokio",
 "turn",
 "url",
- "uuid 1.3.3",
+ "uuid 1.3.2",
 "waitgroup",
 "webrtc-mdns",
 "webrtc-util",
@@ -10737,7 +10842,7 @@ dependencies = [
 "ring",
 "rusticata-macros",
 "thiserror",
- "time 0.3.21",
+ "time 0.3.20",
 ]

 [[package]]
@@ -10755,7 +10860,7 @@ dependencies = [
 "oid-registry 0.6.1",
 "rusticata-macros",
 "thiserror",
- "time 0.3.21",
+ "time 0.3.20",
 ]

 [[package]]
@@ -10784,7 +10889,7 @@ version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e17bb3549cc1321ae1296b9cdc2698e2b6cb1992adfa19a8c72e5b7a738f44cd"
 dependencies = [
- "time 0.3.21",
+ "time 0.3.20",
 ]

 [[package]]
@@ -10804,7 +10909,7 @@ checksum = "ce36e65b0d2999d2aafac989fb249189a141aee1f53c612c1f37d72631959f69"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.16",
+ "syn 2.0.15",
 ]

 [[package]]
@@ -20,7 +20,6 @@ use nym_client_core::client::received_buffer::{
 use nym_client_core::config::persistence::key_pathfinder::ClientKeyPathfinder;
 use nym_credential_storage::persistent_storage::PersistentStorage;
 use nym_sphinx::anonymous_replies::requests::AnonymousSenderTag;
-use nym_sphinx::params::PacketType;
 use nym_task::connections::TransmissionLane;
 use nym_task::TaskManager;
 use nym_validator_client::nyxd::QueryNyxdClient;
@@ -64,7 +63,6 @@ impl SocketClient {
        client_state: ClientState,
        self_address: &Recipient,
        shutdown: nym_task::TaskClient,
-        packet_type: PacketType,
    ) {
        info!("Starting websocket listener...");

@@ -90,7 +88,6 @@ impl SocketClient {
            self_address,
            shared_lane_queue_lengths,
            reply_controller_sender,
-            Some(packet_type),
        );

        websocket::Listener::new(config.get_listening_ip(), config.get_listening_port())
@@ -140,8 +137,7 @@ impl SocketClient {
        }

        let base_builder = self.create_base_client_builder().await?;
-        let packet_type = self.config.get_base().get_packet_type();
-        let mut started_client = base_builder.start_base(packet_type).await?;
+        let mut started_client = base_builder.start_base().await?;
        let self_address = started_client.address;
        let client_input = started_client.client_input.register_producer();
        let client_output = started_client.client_output.register_consumer();
@@ -154,7 +150,6 @@ impl SocketClient {
            client_state,
            &self_address,
            started_client.task_manager.subscribe(),
-            packet_type,
        );

        info!("Client startup finished!");
@@ -169,8 +164,7 @@ impl SocketClient {
        }

        let base_builder = self.create_base_client_builder().await?;
-        let packet_type = self.config.get_base().get_packet_type();
-        let mut started_client = base_builder.start_base(packet_type).await?;
+        let mut started_client = base_builder.start_base().await?;
        let address = started_client.address;
        let client_input = started_client.client_input.register_producer();
        let client_output = started_client.client_output.register_consumer();
@@ -192,7 +186,6 @@ impl SocketClient {
            reconstructed_receiver,
            address,
            shutdown_notifier: started_client.task_manager,
-            packet_type,
        })
    }
 }
@@ -206,7 +199,6 @@ pub struct DirectClient {

    // we need to keep reference to this guy otherwise things will start dropping
    shutdown_notifier: TaskManager,
-    packet_type: PacketType,
 }

 impl DirectClient {
@@ -227,7 +219,7 @@ impl DirectClient {
    /// well enough in local tests)
    pub async fn send_regular_message(&mut self, recipient: Recipient, message: Vec<u8>) {
        let lane = TransmissionLane::General;
-        let input_msg = InputMessage::new_regular(recipient, message, lane, Some(self.packet_type));
+        let input_msg = InputMessage::new_regular(recipient, message, lane);

        self.client_input
            .input_sender
@@ -246,13 +238,7 @@ impl DirectClient {
        reply_surbs: u32,
    ) {
        let lane = TransmissionLane::General;
-        let input_msg = InputMessage::new_anonymous(
-            recipient,
-            message,
-            reply_surbs,
-            lane,
-            Some(self.packet_type),
-        );
+        let input_msg = InputMessage::new_anonymous(recipient, message, reply_surbs, lane);

        self.client_input
            .input_sender
@@ -266,8 +252,7 @@ impl DirectClient {
    /// well enough in local tests)
    pub async fn send_reply(&mut self, recipient_tag: AnonymousSenderTag, message: Vec<u8>) {
        let lane = TransmissionLane::General;
-        let input_msg =
-            InputMessage::new_reply(recipient_tag, message, lane, Some(self.packet_type));
+        let input_msg = InputMessage::new_reply(recipient_tag, message, lane);

        self.client_input
            .input_sender
@@ -14,7 +14,6 @@ use nym_client_core::client::{
 use nym_client_websocket_requests::{requests::ClientRequest, responses::ServerResponse};
 use nym_sphinx::addressing::clients::Recipient;
 use nym_sphinx::anonymous_replies::requests::AnonymousSenderTag;
-use nym_sphinx::params::PacketType;
 use nym_sphinx::receiver::ReconstructedMessage;
 use nym_task::connections::{
    ConnectionCommand, ConnectionCommandSender, ConnectionId, LaneQueueLengths, TransmissionLane,
@@ -42,7 +41,6 @@ pub(crate) struct HandlerBuilder {
    self_full_address: Recipient,
    lane_queue_lengths: LaneQueueLengths,
    reply_controller_sender: ReplyControllerSender,
-    packet_type: Option<PacketType>,
 }

 impl HandlerBuilder {
@@ -53,7 +51,6 @@ impl HandlerBuilder {
        self_full_address: &Recipient,
        lane_queue_lengths: LaneQueueLengths,
        reply_controller_sender: ReplyControllerSender,
-        packet_type: Option<PacketType>,
    ) -> Self {
        Self {
            msg_input,
@@ -62,7 +59,6 @@ impl HandlerBuilder {
            self_full_address: *self_full_address,
            lane_queue_lengths,
            reply_controller_sender,
-            packet_type,
        }
    }

@@ -77,7 +73,6 @@ impl HandlerBuilder {
            received_response_type: Default::default(),
            lane_queue_lengths: self.lane_queue_lengths.clone(),
            reply_controller_sender: self.reply_controller_sender.clone(),
-            packet_type: self.packet_type,
        }
    }
 }
@@ -91,7 +86,6 @@ pub(crate) struct Handler {
    received_response_type: ReceivedResponseType,
    lane_queue_lengths: LaneQueueLengths,
    reply_controller_sender: ReplyControllerSender,
-    packet_type: Option<PacketType>,
 }

 impl Drop for Handler {
@@ -166,7 +160,7 @@ impl Handler {
        });

        // the ack control is now responsible for chunking, etc.
-        let input_msg = InputMessage::new_regular(recipient, message, lane, self.packet_type);
+        let input_msg = InputMessage::new_regular(recipient, message, lane);
        self.msg_input
            .send(input_msg)
            .await
@@ -197,8 +191,7 @@ impl Handler {
            TransmissionLane::ConnectionId(id)
        });

-        let input_msg =
-            InputMessage::new_anonymous(recipient, message, reply_surbs, lane, self.packet_type);
+        let input_msg = InputMessage::new_anonymous(recipient, message, reply_surbs, lane);
        self.msg_input
            .send(input_msg)
            .await
@@ -225,7 +218,7 @@ impl Handler {
            TransmissionLane::ConnectionId(id)
        });

-        let input_msg = InputMessage::new_reply(recipient_tag, message, lane, self.packet_type);
+        let input_msg = InputMessage::new_reply(recipient_tag, message, lane);
        self.msg_input
            .send(input_msg)
            .await
@@ -91,7 +91,6 @@ impl From<Init> for OverrideConfig {
            no_cover: init_config.no_cover,
            nyxd_urls: init_config.nyxd_urls,
            enabled_credentials_mode: init_config.enabled_credentials_mode,
-            outfox: false,
        }
    }
 }
@@ -10,7 +10,6 @@ use nym_bin_common::completions::{fig_generate, ArgShell};
 use nym_config::{NymConfig, OptionalSet};
 use nym_socks5_client_core::config::old_config_v1_1_13::OldConfigV1_1_13;
 use nym_socks5_client_core::config::{BaseConfig, Config};
-use nym_sphinx::params::PacketType;
 use std::error::Error;

 pub mod init;
@@ -65,7 +64,6 @@ pub(crate) struct OverrideConfig {
    no_cover: bool,
    nyxd_urls: Option<Vec<url::Url>>,
    enabled_credentials_mode: Option<bool>,
-    outfox: bool,
 }

 pub(crate) async fn execute(args: &Cli) -> Result<(), Box<dyn Error + Send + Sync>> {
@@ -82,15 +80,9 @@ pub(crate) async fn execute(args: &Cli) -> Result<(), Box<dyn Error + Send + Syn
 }

 pub(crate) fn override_config(config: Config, args: OverrideConfig) -> Config {
-    let packet_type = if args.outfox {
-        PacketType::Outfox
-    } else {
-        PacketType::Mix
-    };
    config
        .with_base(BaseConfig::with_high_default_traffic_volume, args.fastmode)
        .with_base(BaseConfig::with_disabled_cover_traffic, args.no_cover)
-        .with_base(BaseConfig::with_packet_type, packet_type)
        .with_optional(Config::with_anonymous_replies, args.use_anonymous_replies)
        .with_optional(Config::with_port, args.port)
        .with_optional_custom_env_ext(
@@ -68,9 +68,6 @@ pub(crate) struct Run {
    /// with bandwidth credential requirement.
    #[clap(long, hide = true)]
    enabled_credentials_mode: Option<bool>,
-
-    #[clap(long, hide = true, action)]
-    outfox: bool,
 }

 impl From<Run> for OverrideConfig {
@@ -83,7 +80,6 @@ impl From<Run> for OverrideConfig {
            no_cover: run_config.no_cover,
            nyxd_urls: run_config.nyxd_urls,
            enabled_credentials_mode: run_config.enabled_credentials_mode,
-            outfox: run_config.outfox,
        }
    }
 }
@@ -1,5 +1,6 @@
 /target
 **/*.rs.bk
+Cargo.lock
 bin/
 pkg/
 wasm-pack.log
@@ -11,7 +11,7 @@ use nym_client_core::config::{
    DebugConfig as ConfigDebug, GatewayConnection as ConfigGatewayConnection,
    ReplySurbs as ConfigReplySurbs, Topology as ConfigTopology, Traffic as ConfigTraffic,
 };
-use nym_sphinx::params::{PacketSize, PacketType};
+use nym_sphinx::params::PacketSize;
 use nym_validator_client::client::IdentityKey;
 use serde::{Deserialize, Serialize};
 use std::time::Duration;
@@ -34,8 +34,6 @@ pub struct Config {
    pub(crate) gateway: Option<IdentityKey>,

    pub(crate) debug: ConfigDebug,
-
-    pub(crate) packet_type: PacketType,
 }

 #[wasm_bindgen]
@@ -44,18 +42,9 @@ impl Config {
    pub fn new(
        id: String,
        validator_server: String,
-        packet_type: Option<String>,
        gateway: Option<IdentityKey>,
        debug: Option<Debug>,
    ) -> Self {
-        let packet_type = if let Some(packet_type) = packet_type {
-            match packet_type.as_str() {
-                "outfox" => PacketType::Outfox,
-                _ => PacketType::Mix,
-            }
-        } else {
-            PacketType::Mix
-        };
        Config {
            id,
            nym_api_url: Some(
@@ -66,7 +55,6 @@ impl Config {
            disabled_credentials_mode: true,
            gateway,
            debug: debug.map(Into::into).unwrap_or_default(),
-            packet_type,
        }
    }
 }
@@ -109,7 +97,6 @@ impl From<Traffic> for ConfigTraffic {
                .disable_main_poisson_packet_distribution,
            primary_packet_size: PacketSize::RegularPacket,
            secondary_packet_size: use_extended_packet_size,
-            packet_type: None,
        }
    }
 }
@@ -23,7 +23,6 @@ use nym_client_core::client::inbound_messages::InputMessage;
 use nym_client_core::client::replies::reply_storage::browser_backend;
 use nym_client_core::config::{CoverTraffic, DebugConfig, Topology, Traffic};
 use nym_credential_storage::ephemeral_storage::EphemeralStorage;
-use nym_sphinx::params::PacketType;
 use nym_task::connections::TransmissionLane;
 use nym_task::TaskManager;
 use nym_topology::provider_trait::{HardcodedTopologyProvider, TopologyProvider};
@@ -53,7 +52,6 @@ pub struct NymClient {
    // even though we don't use graceful shutdowns, other components rely on existence of this struct
    // and if it's dropped, everything will start going offline
    _task_manager: TaskManager,
-    packet_type: Option<PacketType>,
 }

 #[wasm_bindgen]
@@ -70,7 +68,6 @@ pub struct NymClientBuilder {
    bandwidth_controller:
        Option<BandwidthController<FakeClient<DirectSigningNyxdClient>, EphemeralStorage>>,
    disabled_credentials: bool,
-    packet_type: Option<PacketType>,
 }

 #[wasm_bindgen]
@@ -89,7 +86,6 @@ impl NymClientBuilder {
            on_message,
            bandwidth_controller: None,
            disabled_credentials: true,
-            packet_type: None,
        }
    }

@@ -128,7 +124,6 @@ impl NymClientBuilder {
                },
                ..Default::default()
            },
-            packet_type: PacketType::Mix,
        };

        NymClientBuilder {
@@ -141,7 +136,6 @@ impl NymClientBuilder {
            bandwidth_controller: None,
            disabled_credentials: true,
            storage_passphrase: None,
-            packet_type: None,
        }
    }

@@ -208,8 +202,7 @@ impl NymClientBuilder {
            base_builder = base_builder.with_topology_provider(topology_provider);
        }

-        let packet_type = self.config.packet_type;
-        let mut started_client = base_builder.start_base(packet_type).await?;
+        let mut started_client = base_builder.start_base().await?;
        let self_address = started_client.address.to_string();

        let client_input = started_client.client_input.register_producer();
@@ -223,7 +216,6 @@ impl NymClientBuilder {
            client_state: Arc::new(started_client.client_state),
            _full_topology: None,
            _task_manager: started_client.task_manager,
-            packet_type: self.packet_type,
        })
    }

@@ -299,7 +291,7 @@ impl NymClient {
        let input_msgs = request
            .test_msgs
            .into_iter()
-            .map(|p| InputMessage::new_regular(recipient, p, lane, None))
+            .map(|p| InputMessage::new_regular(recipient, p, lane))
            .collect();

        self.client_input.send_messages(input_msgs)
@@ -319,7 +311,7 @@ impl NymClient {

        let lane = TransmissionLane::General;

-        let input_msg = InputMessage::new_regular(recipient, message, lane, self.packet_type);
+        let input_msg = InputMessage::new_regular(recipient, message, lane);
        self.client_input.send_message(input_msg)
    }

@@ -346,8 +338,7 @@ impl NymClient {

        let lane = TransmissionLane::General;

-        let input_msg =
-            InputMessage::new_anonymous(recipient, message, reply_surbs, lane, self.packet_type);
+        let input_msg = InputMessage::new_anonymous(recipient, message, reply_surbs, lane);
        self.client_input.send_message(input_msg)
    }

@@ -365,7 +356,7 @@ impl NymClient {

        let lane = TransmissionLane::General;

-        let input_msg = InputMessage::new_reply(sender_tag, message, lane, self.packet_type);
+        let input_msg = InputMessage::new_reply(sender_tag, message, lane);
        self.client_input.send_message(input_msg)
    }
 }
@@ -130,7 +130,7 @@ impl AsyncFileWatcher {
                Ok(event) => {
                    let now = Instant::now();
                    if self.should_propagate(&event, now) {
-                        self.last_received.insert(event.kind, now);
+                        self.last_received.insert(event.kind.clone(), now);
                        if let Err(_err) = self.event_sender.unbounded_send(event) {
                            log::error!("the file watcher receiver has been dropped!");
                        }
@@ -37,7 +37,6 @@ use nym_gateway_client::{
 use nym_sphinx::acknowledgements::AckKey;
 use nym_sphinx::addressing::clients::Recipient;
 use nym_sphinx::addressing::nodes::NodeIdentity;
-use nym_sphinx::params::PacketType;
 use nym_sphinx::receiver::{ReconstructedMessage, SphinxMessageReceiver};
 use nym_task::connections::{ConnectionCommandReceiver, ConnectionCommandSender, LaneQueueLengths};
 use nym_task::{TaskClient, TaskManager};
@@ -276,7 +275,6 @@ where
        lane_queue_lengths: LaneQueueLengths,
        client_connection_rx: ConnectionCommandReceiver,
        shutdown: TaskClient,
-        packet_type: PacketType,
    ) {
        info!("Starting real traffic stream...");

@@ -292,7 +290,7 @@ where
            lane_queue_lengths,
            client_connection_rx,
        )
-        .start_with_shutdown(shutdown, packet_type);
+        .start_with_shutdown(shutdown);
    }

    // buffer controlling all messages fetched from provider
@@ -428,7 +426,7 @@ where
        Ok(())
    }

-    // controller for sending packets to mixnet (either real traffic or cover traffic)
+    // controller for sending sphinx packets to mixnet (either real traffic or cover traffic)
    // TODO: if we want to send control messages to gateway_client, this CAN'T take the ownership
    // over it. Perhaps GatewayClient needs to be thread-shareable or have some channel for
    // requests?
@@ -479,10 +477,7 @@ where
        self.managed_keys = ManagedKeys::load_or_generate(&mut rng, &self.key_store).await;
    }

-    pub async fn start_base(
-        mut self,
-        packet_type: PacketType,
-    ) -> Result<BaseClient, ClientCoreError>
+    pub async fn start_base(mut self) -> Result<BaseClient, ClientCoreError>
    where
        <S::ReplyStore as ReplyStorageBackend>::StorageError: Sync + Send,
        S::ReplyStore: Send + Sync,
@@ -553,11 +548,11 @@ where
            task_manager.subscribe(),
        );

-        // The message_sender is the transmitter for any component generating sphinx packets
+        // The sphinx_message_sender is the transmitter for any component generating sphinx packets
        // that are to be sent to the mixnet. They are used by cover traffic stream and real
        // traffic stream.
        // The MixTrafficController then sends the actual traffic
-        let message_sender =
+        let sphinx_message_sender =
            Self::start_mix_traffic_controller(gateway_client, task_manager.subscribe());

        // Channels that the websocket listener can use to signal downstream to the real traffic
@@ -579,14 +574,13 @@ where
            shared_topology_accessor.clone(),
            ack_receiver,
            input_receiver,
-            message_sender.clone(),
+            sphinx_message_sender.clone(),
            reply_storage,
            reply_controller_sender.clone(),
            reply_controller_receiver,
            shared_lane_queue_lengths.clone(),
            client_connection_rx,
            task_manager.subscribe(),
-            packet_type,
        );

        if !self
@@ -599,7 +593,7 @@ where
                self.managed_keys.ack_key(),
                self_address,
                shared_topology_accessor.clone(),
-                message_sender,
+                sphinx_message_sender,
                task_manager.subscribe(),
            );
        }
@@ -12,15 +12,15 @@ use nym_credential_storage::ephemeral_storage::{
 };
 use nym_credential_storage::storage::Storage as CredentialStorage;

-#[cfg(all(not(target_arch = "wasm32"), feature = "fs-surb-storage"))]
+#[cfg(not(target_arch = "wasm32"))]
 use crate::client::base_client::non_wasm_helpers;
-#[cfg(all(not(target_arch = "wasm32"), feature = "fs-surb-storage"))]
+#[cfg(not(target_arch = "wasm32"))]
 use crate::client::key_manager::persistence::OnDiskKeys;
-#[cfg(all(not(target_arch = "wasm32"), feature = "fs-surb-storage"))]
+#[cfg(not(target_arch = "wasm32"))]
 use crate::config::{persistence::key_pathfinder::ClientKeyPathfinder, Config};
-#[cfg(all(not(target_arch = "wasm32"), feature = "fs-surb-storage"))]
+#[cfg(not(target_arch = "wasm32"))]
 use crate::error::ClientCoreError;
-#[cfg(all(not(target_arch = "wasm32"), feature = "fs-surb-storage"))]
+#[cfg(not(target_arch = "wasm32"))]
 use nym_credential_storage::persistent_storage::PersistentStorage as PersistentCredentialStorage;

 #[cfg(all(not(target_arch = "wasm32"), feature = "fs-surb-storage"))]
@@ -74,14 +74,14 @@ impl MixnetClientStorage for Ephemeral {
    }
 }

-#[cfg(all(not(target_arch = "wasm32"), feature = "fs-surb-storage"))]
+#[cfg(not(target_arch = "wasm32"))]
 pub struct OnDiskPersistent {
    pub(crate) key_store: OnDiskKeys,
    pub(crate) reply_store: fs_backend::Backend,
    pub(crate) credential_store: PersistentCredentialStorage,
 }

-#[cfg(all(not(target_arch = "wasm32"), feature = "fs-surb-storage"))]
+#[cfg(not(target_arch = "wasm32"))]
 impl OnDiskPersistent {
    pub fn new(
        key_store: OnDiskKeys,
@@ -116,7 +116,7 @@ impl OnDiskPersistent {
    }
 }

-#[cfg(all(not(target_arch = "wasm32"), feature = "fs-surb-storage"))]
+#[cfg(not(target_arch = "wasm32"))]
 impl MixnetClientStorage for OnDiskPersistent {
    type KeyStore = OnDiskKeys;
    type ReplyStore = fs_backend::Backend;
@@ -45,7 +45,7 @@ where
    #[cfg(target_arch = "wasm32")]
    next_delay: Pin<Box<wasm_timer::Delay>>,

-    /// Channel used for sending prepared nym packets to `MixTrafficController` that sends them
+    /// Channel used for sending prepared sphinx packets to `MixTrafficController` that sends them
    /// out to the network without any further delays.
    mix_tx: BatchMixMessageSender,

@@ -194,7 +194,6 @@ impl LoopCoverTrafficStream<OsRng> {
            self.average_ack_delay,
            self.cover_traffic.loop_cover_traffic_average_delay,
            cover_traffic_packet_size,
-            nym_sphinx::params::PacketType::Mix,
        )
        .expect("Somehow failed to generate a loop cover message with a valid topology");

@@ -4,7 +4,6 @@
 use nym_sphinx::addressing::clients::Recipient;
 use nym_sphinx::anonymous_replies::requests::AnonymousSenderTag;
 use nym_sphinx::forwarding::packet::MixPacket;
-use nym_sphinx::params::PacketType;
 use nym_task::connections::TransmissionLane;

 pub type InputMessageSender = tokio::sync::mpsc::Sender<InputMessage>;
@@ -54,49 +53,18 @@ pub enum InputMessage {
        data: Vec<u8>,
        lane: TransmissionLane,
    },
-
-    MessageWrapper {
-        message: Box<InputMessage>,
-        packet_type: PacketType,
-    },
 }

 impl InputMessage {
-    pub fn new_premade(
-        msgs: Vec<MixPacket>,
-        lane: TransmissionLane,
-        packet_type: PacketType,
-    ) -> Self {
-        let message = InputMessage::Premade { msgs, lane };
-        if packet_type == PacketType::Mix {
-            message
-        } else {
-            InputMessage::new_wrapper(message, packet_type)
-        }
+    pub fn new_premade(msgs: Vec<MixPacket>, lane: TransmissionLane) -> Self {
+        InputMessage::Premade { msgs, lane }
    }

-    pub fn new_wrapper(message: InputMessage, packet_type: PacketType) -> Self {
-        InputMessage::MessageWrapper {
-            message: Box::new(message),
-            packet_type,
-        }
-    }
-
-    pub fn new_regular(
-        recipient: Recipient,
-        data: Vec<u8>,
-        lane: TransmissionLane,
-        packet_type: Option<PacketType>,
-    ) -> Self {
-        let message = InputMessage::Regular {
+    pub fn new_regular(recipient: Recipient, data: Vec<u8>, lane: TransmissionLane) -> Self {
+        InputMessage::Regular {
            recipient,
            data,
            lane,
-        };
-        if let Some(packet_type) = packet_type {
-            InputMessage::new_wrapper(message, packet_type)
-        } else {
-            message
        }
    }

@@ -105,18 +73,12 @@ impl InputMessage {
        data: Vec<u8>,
        reply_surbs: u32,
        lane: TransmissionLane,
-        packet_type: Option<PacketType>,
    ) -> Self {
-        let message = InputMessage::Anonymous {
+        InputMessage::Anonymous {
            recipient,
            data,
            reply_surbs,
            lane,
-        };
-        if let Some(packet_type) = packet_type {
-            InputMessage::new_wrapper(message, packet_type)
-        } else {
-            message
        }
    }

@@ -124,17 +86,11 @@ impl InputMessage {
        recipient_tag: AnonymousSenderTag,
        data: Vec<u8>,
        lane: TransmissionLane,
-        packet_type: Option<PacketType>,
    ) -> Self {
-        let message = InputMessage::Reply {
+        InputMessage::Reply {
            recipient_tag,
            data,
            lane,
-        };
-        if let Some(packet_type) = packet_type {
-            InputMessage::new_wrapper(message, packet_type)
-        } else {
-            message
        }
    }

@@ -144,7 +100,6 @@ impl InputMessage {
            | InputMessage::Anonymous { lane, .. }
            | InputMessage::Reply { lane, .. }
            | InputMessage::Premade { lane, .. } => lane,
-            InputMessage::MessageWrapper { message, .. } => message.lane(),
        }
    }
 }
@@ -40,15 +40,15 @@ where
    pub fn new(
        gateway_client: GatewayClient<C, St>,
    ) -> (MixTrafficController<C, St>, BatchMixMessageSender) {
-        let (message_sender, message_receiver) =
+        let (sphinx_message_sender, sphinx_message_receiver) =
            tokio::sync::mpsc::channel(MIX_MESSAGE_RECEIVER_BUFFER_SIZE);
        (
            MixTrafficController {
                gateway_client,
-                mix_rx: message_receiver,
+                mix_rx: sphinx_message_receiver,
                consecutive_gateway_failure_count: 0,
            },
-            message_sender,
+            sphinx_message_sender,
        )
    }

@@ -71,7 +71,7 @@ impl AcknowledgementListener {
        while !shutdown.is_shutdown() {
            tokio::select! {
                acks = self.ack_receiver.next() => match acks {
-                    Some(acks) => {self.handle_ack_receiver_item(acks).await}
+                    Some(acks) => self.handle_ack_receiver_item(acks).await,
                    None => {
                        log::trace!("AcknowledgementListener: Stopping since channel closed");
                        break;
@@ -9,7 +9,6 @@ use log::*;
 use nym_sphinx::addressing::clients::Recipient;
 use nym_sphinx::anonymous_replies::requests::AnonymousSenderTag;
 use nym_sphinx::forwarding::packet::MixPacket;
-use nym_sphinx::params::PacketType;
 use nym_task::connections::TransmissionLane;
 use rand::{CryptoRng, Rng};

@@ -72,11 +71,10 @@ where
        recipient: Recipient,
        content: Vec<u8>,
        lane: TransmissionLane,
-        packet_type: PacketType,
    ) {
        if let Err(err) = self
            .message_handler
-            .try_send_plain_message(recipient, content, lane, packet_type)
+            .try_send_plain_message(recipient, content, lane)
            .await
        {
            warn!("failed to send a plain message - {err}")
@@ -89,11 +87,10 @@ where
        content: Vec<u8>,
        reply_surbs: u32,
        lane: TransmissionLane,
-        packet_type: PacketType,
    ) {
        if let Err(err) = self
            .message_handler
-            .try_send_message_with_reply_surbs(recipient, content, reply_surbs, lane, packet_type)
+            .try_send_message_with_reply_surbs(recipient, content, reply_surbs, lane)
            .await
        {
            warn!("failed to send a repliable message - {err}")
@@ -106,17 +103,14 @@ where
                recipient,
                data,
                lane,
-            } => {
-                self.handle_plain_message(recipient, data, lane, PacketType::Mix)
-                    .await
-            }
+            } => self.handle_plain_message(recipient, data, lane).await,
            InputMessage::Anonymous {
                recipient,
                data,
                reply_surbs,
                lane,
            } => {
-                self.handle_repliable_message(recipient, data, reply_surbs, lane, PacketType::Mix)
+                self.handle_repliable_message(recipient, data, reply_surbs, lane)
                    .await
            }
            InputMessage::Reply {
@@ -127,40 +121,6 @@ where
                self.handle_reply(recipient_tag, data, lane).await;
            }
            InputMessage::Premade { msgs, lane } => self.handle_premade_packets(msgs, lane).await,
-            InputMessage::MessageWrapper {
-                message,
-                packet_type,
-            } => match *message {
-                InputMessage::Regular {
-                    recipient,
-                    data,
-                    lane,
-                } => {
-                    self.handle_plain_message(recipient, data, lane, packet_type)
-                        .await
-                }
-                InputMessage::Anonymous {
-                    recipient,
-                    data,
-                    reply_surbs,
-                    lane,
-                } => {
-                    self.handle_repliable_message(recipient, data, reply_surbs, lane, packet_type)
-                        .await
-                }
-                InputMessage::Reply {
-                    recipient_tag,
-                    data,
-                    lane,
-                } => {
-                    self.handle_reply(recipient_tag, data, lane).await;
-                }
-                InputMessage::Premade { msgs, lane } => {
-                    self.handle_premade_packets(msgs, lane).await
-                }
-                // MessageWrappers can't be nested
-                InputMessage::MessageWrapper { .. } => unimplemented!(),
-            },
        };
    }

@@ -16,7 +16,7 @@ use futures::channel::mpsc;
 use log::*;
 use nym_gateway_client::AcknowledgementReceiver;
 use nym_sphinx::anonymous_replies::requests::AnonymousSenderTag;
-use nym_sphinx::params::{PacketSize, PacketType};
+use nym_sphinx::params::PacketSize;
 use nym_sphinx::{
    acknowledgements::AckKey,
    addressing::clients::Recipient,
@@ -249,11 +249,7 @@ where
        }
    }

-    pub(super) fn start_with_shutdown(
-        self,
-        shutdown: nym_task::TaskClient,
-        packet_type: PacketType,
-    ) {
+    pub(super) fn start_with_shutdown(self, shutdown: nym_task::TaskClient) {
        let mut acknowledgement_listener = self.acknowledgement_listener;
        let mut input_message_listener = self.input_message_listener;
        let mut retransmission_request_listener = self.retransmission_request_listener;
@@ -279,7 +275,7 @@ where
        let shutdown_handle = shutdown.clone();
        spawn_future(async move {
            retransmission_request_listener
-                .run_with_shutdown(shutdown_handle, packet_type)
+                .run_with_shutdown(shutdown_handle)
                .await;
            debug!("The retransmission request listener has finished execution!");
        });
@@ -11,9 +11,9 @@ use crate::client::real_messages_control::real_traffic_stream::RealMessage;
 use crate::client::replies::reply_controller::ReplyControllerSender;
 use futures::StreamExt;
 use log::*;
+use nym_sphinx::addressing::clients::Recipient;
 use nym_sphinx::chunking::fragment::Fragment;
 use nym_sphinx::preparer::PreparedFragment;
-use nym_sphinx::{addressing::clients::Recipient, params::PacketType};
 use nym_task::connections::TransmissionLane;
 use rand::{CryptoRng, Rng};
 use std::sync::{Arc, Weak};
@@ -48,20 +48,17 @@ where
        &mut self,
        packet_recipient: Recipient,
        chunk_data: Fragment,
-        packet_type: PacketType,
    ) -> Result<PreparedFragment, PreparationError> {
        debug!("retransmitting normal packet...");

-        // TODO: Figure out retransmission packet type signaling
        self.message_handler
-            .try_prepare_single_chunk_for_sending(packet_recipient, chunk_data, packet_type)
+            .try_prepare_single_chunk_for_sending(packet_recipient, chunk_data)
            .await
    }

    async fn on_retransmission_request(
        &mut self,
        weak_timed_out_ack: Weak<PendingAcknowledgement>,
-        packet_type: PacketType,
    ) {
        let timed_out_ack = match weak_timed_out_ack.upgrade() {
            Some(timed_out_ack) => timed_out_ack,
@@ -88,7 +85,6 @@ where
                self.prepare_normal_retransmission_chunk(
                    **recipient,
                    timed_out_ack.message_chunk.clone(),
-                    packet_type,
                )
                .await
            }
@@ -144,17 +140,13 @@ where
            .await
    }

-    pub(super) async fn run_with_shutdown(
-        &mut self,
-        mut shutdown: nym_task::TaskClient,
-        packet_type: PacketType,
-    ) {
+    pub(super) async fn run_with_shutdown(&mut self, mut shutdown: nym_task::TaskClient) {
        debug!("Started RetransmissionRequestListener with graceful shutdown support");

        while !shutdown.is_shutdown() {
            tokio::select! {
                timed_out_ack = self.request_receiver.next() => match timed_out_ack {
-                    Some(timed_out_ack) => self.on_retransmission_request(timed_out_ack, packet_type).await,
+                    Some(timed_out_ack) => self.on_retransmission_request(timed_out_ack).await,
                    None => {
                        log::trace!("RetransmissionRequestListener: Stopping since channel closed");
                        break;
@@ -15,7 +15,7 @@ use nym_sphinx::anonymous_replies::requests::{AnonymousSenderTag, RepliableMessa
 use nym_sphinx::anonymous_replies::{ReplySurb, SurbEncryptionKey};
 use nym_sphinx::chunking::fragment::{Fragment, FragmentIdentifier};
 use nym_sphinx::message::NymMessage;
-use nym_sphinx::params::{PacketSize, PacketType, DEFAULT_NUM_MIX_HOPS};
+use nym_sphinx::params::{PacketSize, DEFAULT_NUM_MIX_HOPS};
 use nym_sphinx::preparer::{MessagePreparer, PreparedFragment};
 use nym_sphinx::Delay;
 use nym_task::connections::TransmissionLane;
@@ -27,7 +27,7 @@ use std::time::Duration;
 use thiserror::Error;

 // TODO: move that error elsewhere since it seems to be contaminating different files
-#[derive(Debug, Error)]
+#[derive(Debug, Clone, Error)]
 pub enum PreparationError {
    #[error(transparent)]
    NymTopologyError(#[from] NymTopologyError),
@@ -417,10 +417,9 @@ where
        recipient: Recipient,
        message: Vec<u8>,
        lane: TransmissionLane,
-        packet_type: PacketType,
    ) -> Result<(), PreparationError> {
        let message = NymMessage::new_plain(message);
-        self.try_split_and_send_non_reply_message(message, recipient, lane, packet_type)
+        self.try_split_and_send_non_reply_message(message, recipient, lane)
            .await
    }

@@ -429,9 +428,7 @@ where
        message: NymMessage,
        recipient: Recipient,
        lane: TransmissionLane,
-        packet_type: PacketType,
    ) -> Result<(), PreparationError> {
-        debug!("Sending non-reply message with packet type {packet_type}");
        // TODO: I really dislike existence of this assertion, it implies code has to be re-organised
        debug_assert!(!matches!(message, NymMessage::Reply(_)));

@@ -439,11 +436,7 @@ where
        let topology_permit = self.topology_access.get_read_permit().await;
        let topology = self.get_topology(&topology_permit)?;

-        let packet_size = if packet_type == PacketType::Outfox {
-            PacketSize::OutfoxRegularPacket
-        } else {
-            self.optimal_packet_size(&message)
-        };
+        let packet_size = self.optimal_packet_size(&message);
        debug!("Using {packet_size} packets for {message}");
        let fragments = self
            .message_preparer
@@ -460,7 +453,6 @@ where
                topology,
                &self.config.ack_key,
                &recipient,
-                packet_type,
            )?;

            let real_message = RealMessage::new(
@@ -484,9 +476,7 @@ where
        &mut self,
        recipient: Recipient,
        amount: u32,
-        packet_type: PacketType,
    ) -> Result<(), PreparationError> {
-        debug!("Sending additional reply SURBs with packet type {packet_type}");
        let sender_tag = self.get_or_create_sender_tag(&recipient);
        let (reply_surbs, reply_keys) =
            self.generate_reply_surbs_with_keys(amount as usize).await?;
@@ -500,7 +490,6 @@ where
            message,
            recipient,
            TransmissionLane::AdditionalReplySurbs,
-            packet_type,
        )
        .await?;

@@ -516,9 +505,7 @@ where
        message: Vec<u8>,
        num_reply_surbs: u32,
        lane: TransmissionLane,
-        packet_type: PacketType,
    ) -> Result<(), SurbWrappedPreparationError> {
-        debug!("Sending message with reply SURBs with packet type {packet_type}");
        let sender_tag = self.get_or_create_sender_tag(&recipient);
        let (reply_surbs, reply_keys) = self
            .generate_reply_surbs_with_keys(num_reply_surbs as usize)
@@ -527,7 +514,7 @@ where
        let message =
            NymMessage::new_repliable(RepliableMessage::new_data(message, sender_tag, reply_surbs));

-        self.try_split_and_send_non_reply_message(message, recipient, lane, packet_type)
+        self.try_split_and_send_non_reply_message(message, recipient, lane)
            .await?;

        log::trace!("storing {} reply keys", reply_keys.len());
@@ -540,21 +527,13 @@ where
        &mut self,
        recipient: Recipient,
        chunk: Fragment,
-        packet_type: PacketType,
    ) -> Result<PreparedFragment, PreparationError> {
-        debug!("Sending single chunk with packet type {packet_type}");
        let topology_permit = self.topology_access.get_read_permit().await;
        let topology = self.get_topology(&topology_permit)?;

        let prepared_fragment = self
            .message_preparer
-            .prepare_chunk_for_sending(
-                chunk,
-                topology,
-                &self.config.ack_key,
-                &recipient,
-                packet_type,
-            )
+            .prepare_chunk_for_sending(chunk, topology, &self.config.ack_key, &recipient)
            .unwrap();

        Ok(prepared_fragment)
@@ -590,7 +569,6 @@ where
                        topology,
                        &self.config.ack_key,
                        reply_surb,
-                        PacketType::Mix,
                    )
                    .unwrap()
            })
@@ -610,13 +588,7 @@ where

        let prepared_fragment = self
            .message_preparer
-            .prepare_reply_chunk_for_sending(
-                chunk,
-                topology,
-                &self.config.ack_key,
-                reply_surb,
-                PacketType::Mix,
-            )
+            .prepare_reply_chunk_for_sending(chunk, topology, &self.config.ack_key, reply_surb)
            .unwrap();

        Ok(prepared_fragment)
@@ -26,7 +26,6 @@ use log::*;
 use nym_gateway_client::AcknowledgementReceiver;
 use nym_sphinx::acknowledgements::AckKey;
 use nym_sphinx::addressing::clients::Recipient;
-use nym_sphinx::params::PacketType;
 use nym_task::connections::{ConnectionCommandReceiver, LaneQueueLengths};
 use rand::{rngs::OsRng, CryptoRng, Rng};
 use std::sync::Arc;
@@ -208,7 +207,7 @@ impl RealMessagesController<OsRng> {
        }
    }

-    pub fn start_with_shutdown(self, shutdown: nym_task::TaskClient, packet_type: PacketType) {
+    pub fn start_with_shutdown(self, shutdown: nym_task::TaskClient) {
        let mut out_queue_control = self.out_queue_control;
        let ack_control = self.ack_control;
        let mut reply_control = self.reply_control;
@@ -224,6 +223,6 @@ impl RealMessagesController<OsRng> {
            debug!("The reply controller has finished execution!");
        });

-        ack_control.start_with_shutdown(shutdown, packet_type);
+        ack_control.start_with_shutdown(shutdown);
    }
 }
@@ -92,7 +92,7 @@ where
    // messages.
    sending_delay_controller: SendingDelayController,

-    /// Channel used for sending prepared packets to `MixTrafficController` that sends them
+    /// Channel used for sending prepared sphinx packets to `MixTrafficController` that sends them
    /// out to the network without any further delays.
    mix_tx: BatchMixMessageSender,

@@ -136,7 +136,7 @@ impl From<PreparedFragment> for RealMessage {

 impl RealMessage {
    pub(crate) fn packet_size(&self) -> usize {
-        self.mix_packet.packet().len()
+        self.mix_packet.sphinx_packet().len()
    }

    pub(crate) fn new(mix_packet: MixPacket, fragment_id: Option<FragmentIdentifier>) -> Self {
@@ -247,7 +247,6 @@ where
                        self.config.average_ack_delay,
                        self.config.traffic.average_packet_delay,
                        cover_traffic_packet_size,
-                        self.config.traffic.packet_type.unwrap_or_default(),
                    )
                    .expect(
                        "Somehow failed to generate a loop cover message with a valid topology",
@@ -387,7 +386,7 @@ where

            // On every iteration we get new messages from upstream. Given that these come bunched
            // in `Vec`, this ensures that on average we will fetch messages faster than we can
-            // send, which is a condition for being able to multiplex packets from multiple
+            // send, which is a condition for being able to multiplex sphinx packets from multiple
            // data streams.
            match Pin::new(&mut self.real_receiver).poll_recv(cx) {
                // in the case our real message channel stream was closed, we should also indicate we are closed
@@ -512,11 +512,7 @@ where
            let to_send = min(remaining, 100);
            if let Err(err) = self
                .message_handler
-                .try_send_additional_reply_surbs(
-                    recipient,
-                    to_send,
-                    nym_sphinx::params::PacketType::Mix,
-                )
+                .try_send_additional_reply_surbs(recipient, to_send)
                .await
            {
                warn!("failed to send additional surbs to {recipient} - {err}");
@@ -28,7 +28,7 @@ impl SizedData for RealMessage {

 impl SizedData for Fragment {
    fn data_size(&self) -> usize {
-        // note that raw `Fragment` is smaller than packet payload
+        // note that raw `Fragment` is smaller than sphinx packet payload
        // as it doesn't include surb-ack or the [shared] key materials
        self.payload_size()
    }
@@ -4,7 +4,7 @@
 use nym_config::defaults::NymNetworkDetails;
 use nym_config::{NymConfig, OptionalSet, CRED_DB_FILE_NAME};
 use nym_crypto::asymmetric::identity;
-use nym_sphinx::params::{PacketSize, PacketType};
+use nym_sphinx::params::PacketSize;
 use serde::{Deserialize, Serialize};
 use std::marker::PhantomData;
 use std::path::{Path, PathBuf};
@@ -259,11 +259,6 @@ impl<T> Config<T> {
        self
    }

-    pub fn with_packet_type(mut self, packet_type: PacketType) -> Self {
-        self.client.packet_type = Some(packet_type);
-        self
-    }
-
    pub fn set_high_default_traffic_volume(&mut self) {
        self.debug.traffic.average_packet_delay = Duration::from_millis(10);
        // basically don't really send cover messages
@@ -451,10 +446,6 @@ impl<T> Config<T> {
    pub fn get_maximum_reply_key_age(&self) -> Duration {
        self.debug.reply_surbs.maximum_reply_key_age
    }
-
-    pub fn get_packet_type(&self) -> PacketType {
-        self.client.packet_type.unwrap_or(PacketType::Mix)
-    }
 }

 impl<T: NymConfig> Default for Config<T> {
@@ -577,8 +568,6 @@ pub struct Client<T> {

    #[serde(skip)]
    pub super_struct: PhantomData<T>,
-
-    pub packet_type: Option<PacketType>,
 }

 impl<T: NymConfig> Default for Client<T> {
@@ -617,7 +606,6 @@ impl<T: NymConfig> Default for Client<T> {
            reply_surb_database_path: Default::default(),
            nym_root_directory: T::default_root_directory(),
            super_struct: Default::default(),
-            packet_type: Default::default(),
        }
    }
 }
@@ -689,8 +677,6 @@ pub struct Traffic {
    /// Note that its use decreases overall anonymity.
    /// Do not set it it unless you understand the consequences of that change.
    pub secondary_packet_size: Option<PacketSize>,
-
-    pub packet_type: Option<PacketType>,
 }

 impl Traffic {
@@ -714,7 +700,6 @@ impl Default for Traffic {
            disable_main_poisson_packet_distribution: false,
            primary_packet_size: PacketSize::RegularPacket,
            secondary_packet_size: None,
-            packet_type: None,
        }
    }
 }
@@ -125,7 +125,6 @@ impl From<OldDebugConfigV1_1_13> for DebugConfig {
                    .disable_main_poisson_packet_distribution,
                primary_packet_size: PacketSize::RegularPacket,
                secondary_packet_size: value.use_extended_packet_size.map(Into::into),
-                packet_type: None,
            },
            cover_traffic: CoverTraffic {
                loop_cover_traffic_average_delay: value.loop_cover_traffic_average_delay,
@@ -211,8 +210,8 @@ impl<T, U> From<OldConfigV1_1_13<T>> for Config<U> {
                database_path: value.client.database_path,
                reply_surb_database_path: value.client.reply_surb_database_path,
                nym_root_directory: value.client.nym_root_directory,
+
                super_struct: PhantomData,
-                packet_type: Some(nym_sphinx::params::PacketType::Mix),
            },
            logging: value.logging,
            debug: value.debug.into(),
@@ -40,17 +40,11 @@ impl ClientKeyPathfinder {
    }

    pub fn identity_key_pair_path(&self) -> nym_pemstore::KeyPairPath {
-        nym_pemstore::KeyPairPath::new(
-            self.private_identity_key().to_path_buf(),
-            self.public_identity_key().to_path_buf(),
-        )
+        nym_pemstore::KeyPairPath::new(self.private_identity_key(), self.public_identity_key())
    }

    pub fn encryption_key_pair_path(&self) -> nym_pemstore::KeyPairPath {
-        nym_pemstore::KeyPairPath::new(
-            self.private_encryption_key().to_path_buf(),
-            self.public_encryption_key().to_path_buf(),
-        )
+        nym_pemstore::KeyPairPath::new(self.private_encryption_key(), self.public_encryption_key())
    }

    pub fn any_file_exists(&self) -> bool {
@@ -571,7 +571,7 @@ impl<C, St> GatewayClient<C, St> {
    fn estimate_required_bandwidth(&self, packets: &[MixPacket]) -> i64 {
        packets
            .iter()
-            .map(|packet| packet.packet().len())
+            .map(|packet| packet.sphinx_packet().len())
            .sum::<usize>() as i64
    }

@@ -579,8 +579,6 @@ impl<C, St> GatewayClient<C, St> {
        &mut self,
        packets: Vec<MixPacket>,
    ) -> Result<(), GatewayClientError> {
-        debug!("Sending {} mix packets", packets.len());
-
        if !self.authenticated {
            return Err(GatewayClientError::NotAuthenticated);
        }
@@ -625,10 +623,9 @@ impl<C, St> GatewayClient<C, St> {
    ) -> Result<(), GatewayClientError> {
        if let Err(err) = self.send_websocket_message_without_response(msg).await {
            if err.is_closed_connection() && self.should_reconnect_on_failure {
-                debug!("Going to attempt a reconnection");
+                info!("Going to attempt a reconnection");
                self.attempt_reconnection().await
            } else {
-                warn!("{err}");
                Err(err)
            }
        } else {
@@ -655,9 +652,9 @@ impl<C, St> GatewayClient<C, St> {
        if !self.authenticated {
            return Err(GatewayClientError::NotAuthenticated);
        }
-        if (mix_packet.packet().len() as i64) > self.bandwidth_remaining {
+        if (mix_packet.sphinx_packet().len() as i64) > self.bandwidth_remaining {
            return Err(GatewayClientError::NotEnoughBandwidth(
-                mix_packet.packet().len() as i64,
+                mix_packet.sphinx_packet().len() as i64,
                self.bandwidth_remaining,
            ));
        }
@@ -50,15 +50,10 @@ impl PacketRouter {
        let ack_overhead = PacketSize::AckPacket.size() + MAX_NODE_ADDRESS_UNPADDED_LEN;

        for received_packet in unwrapped_packets {
-            if received_packet.len() == PacketSize::AckPacket.plaintext_size()
-                || received_packet.len() == PacketSize::OutfoxAckPacket.plaintext_size()
-            {
+            if received_packet.len() == PacketSize::AckPacket.plaintext_size() {
                received_acks.push(received_packet);
            } else if received_packet.len()
                == PacketSize::RegularPacket.plaintext_size() - ack_overhead
-                || received_packet.len()
-                    == PacketSize::OutfoxRegularPacket.plaintext_size() - ack_overhead
-                || received_packet.len() == PacketSize::OutfoxRegularPacket.size() - 6
            {
                trace!("routing regular packet");
                received_messages.push(received_packet);
@@ -4,11 +4,10 @@
 use futures::channel::mpsc;
 use futures::StreamExt;
 use log::*;
-use nym_sphinx::addressing::nodes::NymNodeRoutingAddress;
-use nym_sphinx::framing::codec::NymCodec;
-use nym_sphinx::framing::packet::FramedNymPacket;
-use nym_sphinx::params::PacketType;
-use nym_sphinx::NymPacket;
+use nym_sphinx::framing::codec::SphinxCodec;
+use nym_sphinx::framing::packet::FramedSphinxPacket;
+use nym_sphinx::params::PacketMode;
+use nym_sphinx::{addressing::nodes::NymNodeRoutingAddress, SphinxPacket};
 use std::collections::HashMap;
 use std::io;
 use std::net::SocketAddr;
@@ -51,8 +50,8 @@ pub trait SendWithoutResponse {
    fn send_without_response(
        &mut self,
        address: NymNodeRoutingAddress,
-        packet: NymPacket,
-        packet_type: PacketType,
+        packet: SphinxPacket,
+        packet_mode: PacketMode,
    ) -> io::Result<()>;
 }

@@ -62,12 +61,12 @@ pub struct Client {
 }

 struct ConnectionSender {
-    channel: mpsc::Sender<FramedNymPacket>,
+    channel: mpsc::Sender<FramedSphinxPacket>,
    current_reconnection_attempt: Arc<AtomicU32>,
 }

 impl ConnectionSender {
-    fn new(channel: mpsc::Sender<FramedNymPacket>) -> Self {
+    fn new(channel: mpsc::Sender<FramedSphinxPacket>) -> Self {
        ConnectionSender {
            channel,
            current_reconnection_attempt: Arc::new(AtomicU32::new(0)),
@@ -85,7 +84,7 @@ impl Client {

    async fn manage_connection(
        address: SocketAddr,
-        receiver: mpsc::Receiver<FramedNymPacket>,
+        receiver: mpsc::Receiver<FramedSphinxPacket>,
        connection_timeout: Duration,
        current_reconnection: &AtomicU32,
    ) {
@@ -97,7 +96,7 @@ impl Client {
                    debug!("Managed to establish connection to {}", address);
                    // if we managed to connect, reset the reconnection count (whatever it might have been)
                    current_reconnection.store(0, Ordering::Release);
-                    Framed::new(stream, NymCodec)
+                    Framed::new(stream, SphinxCodec)
                }
                Err(err) => {
                    debug!(
@@ -149,7 +148,11 @@ impl Client {
        }
    }

-    fn make_connection(&mut self, address: NymNodeRoutingAddress, pending_packet: FramedNymPacket) {
+    fn make_connection(
+        &mut self,
+        address: NymNodeRoutingAddress,
+        pending_packet: FramedSphinxPacket,
+    ) {
        let (mut sender, receiver) = mpsc::channel(self.config.maximum_connection_buffer_size);

        // this CAN'T fail because we just created the channel which has a non-zero capacity
@@ -197,12 +200,12 @@ impl SendWithoutResponse for Client {
    fn send_without_response(
        &mut self,
        address: NymNodeRoutingAddress,
-        packet: NymPacket,
-        packet_type: PacketType,
+        packet: SphinxPacket,
+        packet_mode: PacketMode,
    ) -> io::Result<()> {
        trace!("Sending packet to {:?}", address);
        let framed_packet =
-            FramedNymPacket::new(packet, packet_type, self.config.use_legacy_version);
+            FramedSphinxPacket::new(packet, packet_mode, self.config.use_legacy_version);

        if let Some(sender) = self.conn_new.get_mut(&address) {
            if let Err(err) = sender.channel.try_send(framed_packet) {
@@ -59,14 +59,14 @@ impl PacketForwarder {
                     trace!("Going to forward packet to {:?}", mix_packet.next_hop());

                    let next_hop = mix_packet.next_hop();
-                    let packet_type = mix_packet.packet_type();
-                    let packet = mix_packet.into_packet();
+                    let packet_mode = mix_packet.packet_mode();
+                    let sphinx_packet = mix_packet.into_sphinx_packet();
                    // we don't care about responses, we just want to fire packets
                    // as quickly as possible

                    if let Err(err) =
                        self.mixnet_client
-                            .send_without_response(next_hop, packet, packet_type)
+                            .send_without_response(next_hop, sphinx_packet, packet_mode)
                    {
                        debug!("failed to forward the packet - {err}")
                    }
@@ -3,15 +3,12 @@

 use nym_sphinx_acknowledgements::surb_ack::SurbAckRecoveryError;
 use nym_sphinx_addressing::nodes::NymNodeRoutingAddressError;
-use nym_sphinx_types::{NymPacketError, SphinxError};
+use nym_sphinx_types::Error as SphinxError;
 use thiserror::Error;

 #[derive(Error, Debug)]
 pub enum MixProcessingError {
    #[error("failed to process received packet: {0}")]
-    NymPacketProcessingError(#[from] NymPacketError),
-
-    #[error("failed to process received sphinx packet: {0}")]
    SphinxProcessingError(#[from] SphinxError),

    #[error("the forward hop address was malformed: {0}")]
@@ -7,11 +7,11 @@ use log::*;
 use nym_sphinx_acknowledgements::surb_ack::SurbAck;
 use nym_sphinx_addressing::nodes::NymNodeRoutingAddress;
 use nym_sphinx_forwarding::packet::MixPacket;
-use nym_sphinx_framing::packet::FramedNymPacket;
-use nym_sphinx_params::{PacketSize, PacketType};
+use nym_sphinx_framing::packet::FramedSphinxPacket;
+use nym_sphinx_params::{PacketMode, PacketSize};
 use nym_sphinx_types::{
-    Delay as SphinxDelay, DestinationAddressBytes, NodeAddressBytes, NymPacket, NymProcessedPacket,
-    PrivateKey, ProcessedPacket,
+    Delay as SphinxDelay, DestinationAddressBytes, NodeAddressBytes, Payload, PrivateKey,
+    ProcessedPacket, SphinxPacket,
 };
 use std::convert::TryFrom;
 use std::sync::Arc;
@@ -53,14 +53,14 @@ impl SphinxPacketProcessor {
        feature = "cpucycles",
        instrument(skip(self, packet), fields(cpucycles))
    )]
-    fn perform_initial_packet_processing(
+    fn perform_initial_sphinx_packet_processing(
        &self,
-        packet: NymPacket,
-    ) -> Result<NymProcessedPacket, MixProcessingError> {
+        packet: SphinxPacket,
+    ) -> Result<ProcessedPacket, MixProcessingError> {
        measure!({
            packet.process(&self.sphinx_key).map_err(|err| {
-                debug!("Failed to unwrap NymPacket packet: {err}");
-                MixProcessingError::NymPacketProcessingError(err)
+                debug!("Failed to unwrap Sphinx packet: {err}");
+                MixProcessingError::SphinxProcessingError(err)
            })
        })
    }
@@ -72,12 +72,17 @@ impl SphinxPacketProcessor {
    )]
    fn perform_initial_unwrapping(
        &self,
-        received: FramedNymPacket,
-    ) -> Result<NymProcessedPacket, MixProcessingError> {
+        received: FramedSphinxPacket,
+    ) -> Result<ProcessedPacket, MixProcessingError> {
        measure!({
-            let packet = received.into_inner();
+            let packet_mode = received.packet_mode();
+            let sphinx_packet = received.into_inner();

-            self.perform_initial_packet_processing(packet)
+            if packet_mode.is_old_vpn() {
+                return Err(MixProcessingError::ReceivedOldTypeVpnPacket);
+            }
+
+            self.perform_initial_sphinx_packet_processing(sphinx_packet)
        })
    }

@@ -85,14 +90,14 @@ impl SphinxPacketProcessor {
    /// and packs all the data in a way that can be easily sent to the next hop.
    fn process_forward_hop(
        &self,
-        packet: NymPacket,
+        packet: SphinxPacket,
        forward_address: NodeAddressBytes,
        delay: SphinxDelay,
-        packet_type: PacketType,
+        packet_mode: PacketMode,
    ) -> Result<MixProcessingResult, MixProcessingError> {
        let next_hop_address = NymNodeRoutingAddress::try_from(forward_address)?;

-        let mix_packet = MixPacket::new(next_hop_address, packet, packet_type);
+        let mix_packet = MixPacket::new(next_hop_address, packet, packet_mode);
        Ok(MixProcessingResult::ForwardHop(mix_packet, Some(delay)))
    }

@@ -101,17 +106,14 @@ impl SphinxPacketProcessor {
    fn split_hop_data_into_ack_and_message(
        &self,
        mut extracted_data: Vec<u8>,
-        packet_type: PacketType,
    ) -> Result<(Vec<u8>, Vec<u8>), MixProcessingError> {
-        let ack_len = SurbAck::len(Some(packet_type));
-
        // in theory it's impossible for this to fail since it managed to go into correct `match`
        // branch at the caller
-        if extracted_data.len() < ack_len {
+        if extracted_data.len() < SurbAck::len() {
            return Err(MixProcessingError::NoSurbAckInFinalHop);
        }

-        let message = extracted_data.split_off(ack_len);
+        let message = extracted_data.split_off(SurbAck::len());
        let ack_data = extracted_data;
        Ok((ack_data, message))
    }
@@ -122,30 +124,21 @@ impl SphinxPacketProcessor {
        &self,
        data: Vec<u8>,
        packet_size: PacketSize,
-        packet_type: PacketType,
+        packet_mode: PacketMode,
    ) -> Result<(Option<MixPacket>, Vec<u8>), MixProcessingError> {
        match packet_size {
-            PacketSize::AckPacket | PacketSize::OutfoxAckPacket => {
+            PacketSize::AckPacket => {
                trace!("received an ack packet!");
                Ok((None, data))
            }
            PacketSize::RegularPacket
            | PacketSize::ExtendedPacket8
            | PacketSize::ExtendedPacket16
-            | PacketSize::ExtendedPacket32
-            | PacketSize::OutfoxRegularPacket => {
+            | PacketSize::ExtendedPacket32 => {
                trace!("received a normal packet!");
-                let (ack_data, message) =
-                    self.split_hop_data_into_ack_and_message(data, packet_type)?;
-                let (ack_first_hop, ack_packet) =
-                    match SurbAck::try_recover_first_hop_packet(&ack_data, packet_type) {
-                        Ok((first_hop, packet)) => (first_hop, packet),
-                        Err(err) => {
-                            debug!("Failed to recover first hop from ack data: {err}");
-                            return Err(err.into());
-                        }
-                    };
-                let forward_ack = MixPacket::new(ack_first_hop, ack_packet, packet_type);
+                let (ack_data, message) = self.split_hop_data_into_ack_and_message(data)?;
+                let (ack_first_hop, ack_packet) = SurbAck::try_recover_first_hop_packet(&ack_data)?;
+                let forward_ack = MixPacket::new(ack_first_hop, ack_packet, packet_mode);
                Ok((Some(forward_ack), message))
            }
        }
@@ -157,12 +150,14 @@ impl SphinxPacketProcessor {
    fn process_final_hop(
        &self,
        destination: DestinationAddressBytes,
-        payload: Vec<u8>,
+        payload: Payload,
        packet_size: PacketSize,
-        packet_type: PacketType,
+        packet_mode: PacketMode,
    ) -> Result<MixProcessingResult, MixProcessingError> {
+        let packet_message = payload.recover_plaintext()?;
+
        let (forward_ack, message) =
-            self.split_into_ack_and_message(payload, packet_size, packet_type)?;
+            self.split_into_ack_and_message(packet_message, packet_size, packet_mode)?;

        Ok(MixProcessingResult::FinalHop(ProcessedFinalHop {
            destination,
@@ -175,48 +170,18 @@ impl SphinxPacketProcessor {
    /// or a final hop.
    fn perform_final_processing(
        &self,
-        packet: NymProcessedPacket,
+        packet: ProcessedPacket,
        packet_size: PacketSize,
-        packet_type: PacketType,
+        packet_mode: PacketMode,
    ) -> Result<MixProcessingResult, MixProcessingError> {
        match packet {
-            NymProcessedPacket::Sphinx(packet) => {
-                match packet {
-                    ProcessedPacket::ForwardHop(packet, address, delay) => self
-                        .process_forward_hop(
-                            NymPacket::Sphinx(*packet),
-                            address,
-                            delay,
-                            packet_type,
-                        ),
-                    // right now there's no use for the surb_id included in the header - probably it should get removed from the
-                    // sphinx all together?
-                    ProcessedPacket::FinalHop(destination, _, payload) => self.process_final_hop(
-                        destination,
-                        payload.recover_plaintext()?,
-                        packet_size,
-                        packet_type,
-                    ),
-                }
+            ProcessedPacket::ForwardHop(packet, address, delay) => {
+                self.process_forward_hop(*packet, address, delay, packet_mode)
            }
-            NymProcessedPacket::Outfox(packet) => {
-                let next_address = *packet.next_address();
-                let packet = packet.into_packet();
-                if packet.is_final_hop() {
-                    self.process_final_hop(
-                        DestinationAddressBytes::from_bytes(next_address),
-                        packet.recover_plaintext().to_vec(),
-                        packet_size,
-                        packet_type,
-                    )
-                } else {
-                    let mix_packet = MixPacket::new(
-                        NymNodeRoutingAddress::try_from_bytes(&next_address)?,
-                        NymPacket::Outfox(packet),
-                        PacketType::Outfox,
-                    );
-                    Ok(MixProcessingResult::ForwardHop(mix_packet, None))
-                }
+            // right now there's no use for the surb_id included in the header - probably it should get removed from the
+            // sphinx all together?
+            ProcessedPacket::FinalHop(destination, _, payload) => {
+                self.process_final_hop(destination, payload, packet_size, packet_mode)
            }
        }
    }
@@ -227,19 +192,19 @@ impl SphinxPacketProcessor {
    )]
    pub fn process_received(
        &self,
-        received: FramedNymPacket,
+        received: FramedSphinxPacket,
    ) -> Result<MixProcessingResult, MixProcessingError> {
        // explicit packet size will help to correctly parse final hop
        measure!({
            let packet_size = received.packet_size();
-            let packet_type = received.packet_type();
+            let packet_mode = received.packet_mode();

            // unwrap the sphinx packet and if possible and appropriate, cache keys
            let processed_packet = self.perform_initial_unwrapping(received)?;

            // for forward packets, extract next hop and set delay (but do NOT delay here)
            // for final packets, extract SURBAck
-            self.perform_final_processing(processed_packet, packet_size, packet_type)
+            self.perform_final_processing(processed_packet, packet_size, packet_mode)
        })
    }
 }
@@ -261,71 +226,31 @@ mod tests {

        let short_data = vec![42u8];
        assert!(processor
-            .split_hop_data_into_ack_and_message(short_data, PacketType::Mix)
+            .split_hop_data_into_ack_and_message(short_data)
            .is_err());

-        let sufficient_data = vec![42u8; SurbAck::len(Some(PacketType::Mix))];
+        let sufficient_data = vec![42u8; SurbAck::len()];
        let (ack, data) = processor
-            .split_hop_data_into_ack_and_message(sufficient_data.clone(), PacketType::Mix)
+            .split_hop_data_into_ack_and_message(sufficient_data.clone())
            .unwrap();
        assert_eq!(sufficient_data, ack);
        assert!(data.is_empty());

-        let long_data = vec![42u8; SurbAck::len(Some(PacketType::Mix)) * 5];
+        let long_data = vec![42u8; SurbAck::len() * 5];
        let (ack, data) = processor
-            .split_hop_data_into_ack_and_message(long_data, PacketType::Mix)
+            .split_hop_data_into_ack_and_message(long_data)
            .unwrap();
-        assert_eq!(ack.len(), SurbAck::len(Some(PacketType::Mix)));
-        assert_eq!(data.len(), SurbAck::len(Some(PacketType::Mix)) * 4)
-    }
-
-    #[tokio::test]
-    async fn splitting_hop_data_works_for_sufficiently_long_payload_outfox() {
-        let processor = fixture();
-
-        let short_data = vec![42u8];
-        assert!(processor
-            .split_hop_data_into_ack_and_message(short_data, PacketType::Outfox)
-            .is_err());
-
-        let sufficient_data = vec![42u8; SurbAck::len(Some(PacketType::Outfox))];
-        let (ack, data) = processor
-            .split_hop_data_into_ack_and_message(sufficient_data.clone(), PacketType::Outfox)
-            .unwrap();
-        assert_eq!(sufficient_data, ack);
-        assert!(data.is_empty());
-
-        let long_data = vec![42u8; SurbAck::len(Some(PacketType::Outfox)) * 5];
-        let (ack, data) = processor
-            .split_hop_data_into_ack_and_message(long_data, PacketType::Outfox)
-            .unwrap();
-        assert_eq!(ack.len(), SurbAck::len(Some(PacketType::Outfox)));
-        assert_eq!(data.len(), SurbAck::len(Some(PacketType::Outfox)) * 4)
+        assert_eq!(ack.len(), SurbAck::len());
+        assert_eq!(data.len(), SurbAck::len() * 4)
    }

    #[tokio::test]
    async fn splitting_into_ack_and_message_returns_whole_data_for_ack() {
        let processor = fixture();

-        let data = vec![42u8; SurbAck::len(Some(PacketType::Mix)) + 10];
+        let data = vec![42u8; SurbAck::len() + 10];
        let (ack, message) = processor
-            .split_into_ack_and_message(data.clone(), PacketSize::AckPacket, PacketType::Mix)
-            .unwrap();
-        assert!(ack.is_none());
-        assert_eq!(data, message)
-    }
-
-    #[tokio::test]
-    async fn splitting_into_ack_and_message_returns_whole_data_for_ack_outfox() {
-        let processor = fixture();
-
-        let data = vec![42u8; SurbAck::len(Some(PacketType::Outfox)) + 10];
-        let (ack, message) = processor
-            .split_into_ack_and_message(
-                data.clone(),
-                PacketSize::OutfoxAckPacket,
-                PacketType::Outfox,
-            )
+            .split_into_ack_and_message(data.clone(), PacketSize::AckPacket, Default::default())
            .unwrap();
        assert!(ack.is_none());
        assert_eq!(data, message)
@@ -17,7 +17,6 @@ tokio = { workspace = true, features = ["macros"]}
 nym-crypto = { path = "../crypto", features = ["asymmetric"] }
 nym-task = { path = "../task" }
 nym-topology = { path = "../topology" }
-nym-sphinx-params = { path = "../nymsphinx/params" }
 # TODO: do we need the whole nymsphinx?
 nym-sphinx = { path = "../nymsphinx" }

@@ -10,7 +10,6 @@ use nym_sphinx::addressing::clients::Recipient;
 use nym_sphinx::message::NymMessage;
 use nym_sphinx::params::{PacketSize, DEFAULT_NUM_MIX_HOPS};
 use nym_sphinx::preparer::{FragmentPreparer, PreparedFragment};
-use nym_sphinx_params::PacketType;
 use nym_topology::{gateway, mix, NymTopology};
 use rand::{CryptoRng, Rng};
 use serde::Serialize;
@@ -244,14 +243,7 @@ where

        // TODO: can we avoid this arc clone?
        let ack_key = Arc::clone(&self.ack_key);
-        Ok(self.prepare_chunk_for_sending(
-            fragment,
-            topology,
-            &ack_key,
-            &address,
-            &address,
-            PacketType::Mix,
-        )?)
+        Ok(self.prepare_chunk_for_sending(fragment, topology, &ack_key, &address, &address)?)
    }

    pub fn create_test_packet<T>(
@@ -28,6 +28,9 @@ nym-sphinx-types = { path = "types" }
 nym-crypto = { path = "../crypto", version = "0.3.0" }
 nym-topology = { path = "../topology" }

+# outfox
+nym-outfox = { path = "../../nym-outfox" }
+
 [dev-dependencies]
 nym-mixnet-contract-common = { path = "../cosmwasm-smart-contracts/mixnet-contract" }
 nym-crypto = { path = "../crypto", version = "0.3.0", features = ["asymmetric"] }
@@ -3,7 +3,9 @@

 use crate::AckKey;
 use nym_crypto::symmetric::stream_cipher::{self, encrypt, iv_from_slice, random_iv, IvSizeUser};
-use nym_sphinx_params::{AckEncryptionAlgorithm, SerializedFragmentIdentifier, FRAG_ID_LEN};
+use nym_sphinx_params::{
+    packet_sizes::PacketSize, AckEncryptionAlgorithm, SerializedFragmentIdentifier, FRAG_ID_LEN,
+};
 use rand::{CryptoRng, RngCore};

 // TODO: should those functions even exist in this file?
@@ -24,6 +26,12 @@ pub fn recover_identifier(
    key: &AckKey,
    iv_id_ciphertext: &[u8],
 ) -> Option<SerializedFragmentIdentifier> {
+    // The content of an 'ACK' packet consists of AckEncryptionAlgorithm::IV followed by
+    // serialized FragmentIdentifier
+    if iv_id_ciphertext.len() != PacketSize::AckPacket.plaintext_size() {
+        return None;
+    }
+
    let iv_size = AckEncryptionAlgorithm::iv_size();
    let iv = iv_from_slice::<AckEncryptionAlgorithm>(&iv_id_ciphertext[..iv_size]);

@@ -8,18 +8,21 @@ use nym_sphinx_addressing::nodes::{
    NymNodeRoutingAddress, NymNodeRoutingAddressError, MAX_NODE_ADDRESS_UNPADDED_LEN,
 };
 use nym_sphinx_params::packet_sizes::PacketSize;
-use nym_sphinx_params::{PacketType, DEFAULT_NUM_MIX_HOPS};
-use nym_sphinx_types::delays::{self, Delay};
-use nym_sphinx_types::{NymPacket, NymPacketError, MIN_PACKET_SIZE};
+use nym_sphinx_params::DEFAULT_NUM_MIX_HOPS;
+use nym_sphinx_types::builder::SphinxPacketBuilder;
+use nym_sphinx_types::Error as SphinxError;
+use nym_sphinx_types::{
+    delays::{self, Delay},
+    SphinxPacket,
+};
 use nym_topology::{NymTopology, NymTopologyError};
 use rand::{CryptoRng, RngCore};
 use std::convert::TryFrom;
 use std::time;
 use thiserror::Error;

-#[derive(Debug)]
 pub struct SurbAck {
-    surb_ack_packet: NymPacket,
+    surb_ack_packet: SphinxPacket,
    first_hop_address: NymNodeRoutingAddress,
    expected_total_delay: Delay,
 }
@@ -32,8 +35,8 @@ pub enum SurbAckRecoveryError {
    #[error("could not extract first hop address information - {0}")]
    InvalidAddress(#[from] NymNodeRoutingAddressError),

-    #[error("packet: {0}")]
-    NymPacket(#[from] NymPacketError),
+    #[error("the contained sphinx packet was not correctly formed - {0}")]
+    InvalidSphinxPacket(#[from] SphinxError),
 }

 impl SurbAck {
@@ -44,7 +47,6 @@ impl SurbAck {
        marshaled_fragment_id: [u8; 5],
        average_delay: time::Duration,
        topology: &NymTopology,
-        packet_type: PacketType,
    ) -> Result<Self, NymTopologyError>
    where
        R: RngCore + CryptoRng,
@@ -55,34 +57,11 @@ impl SurbAck {
        let destination = recipient.as_sphinx_destination();

        let surb_ack_payload = prepare_identifier(rng, ack_key, marshaled_fragment_id);
-        let packet_size = match packet_type {
-            PacketType::Outfox => surb_ack_payload.len().max(MIN_PACKET_SIZE),
-            PacketType::Mix => PacketSize::AckPacket.payload_size(),
-            PacketType::Vpn => PacketSize::AckPacket.payload_size(),
-        };

-        let surb_ack_packet = match packet_type {
-            PacketType::Outfox => NymPacket::outfox_build(
-                surb_ack_payload,
-                route.as_slice(),
-                &destination,
-                Some(packet_size),
-            )?,
-            PacketType::Mix => NymPacket::sphinx_build(
-                packet_size,
-                surb_ack_payload,
-                &route,
-                &destination,
-                &delays,
-            )?,
-            PacketType::Vpn => NymPacket::sphinx_build(
-                packet_size,
-                surb_ack_payload,
-                &route,
-                &destination,
-                &delays,
-            )?,
-        };
+        let surb_ack_packet = SphinxPacketBuilder::new()
+            .with_payload_size(PacketSize::AckPacket.payload_size())
+            .build_packet(surb_ack_payload, &route, &destination, &delays)
+            .unwrap();

        // in our case, the last hop is a gateway that does NOT do any delays
        let expected_total_delay = delays.iter().take(delays.len() - 1).sum();
@@ -96,50 +75,45 @@ impl SurbAck {
        })
    }

-    pub fn len(packet_type: Option<PacketType>) -> usize {
+    pub fn len() -> usize {
        // TODO: this will be variable once/if we decide to introduce optimization described
        // in common/nymsphinx/chunking/src/lib.rs:available_plaintext_size()
-        let packet_type = packet_type.unwrap_or(PacketType::Mix);
-        match packet_type {
-            PacketType::Outfox => {
-                PacketSize::OutfoxAckPacket.size() + MAX_NODE_ADDRESS_UNPADDED_LEN
-            }
-            PacketType::Mix => PacketSize::AckPacket.size() + MAX_NODE_ADDRESS_UNPADDED_LEN,
-            PacketType::Vpn => PacketSize::AckPacket.size() + MAX_NODE_ADDRESS_UNPADDED_LEN,
-        }
+        PacketSize::AckPacket.size() + MAX_NODE_ADDRESS_UNPADDED_LEN
    }

    pub fn expected_total_delay(&self) -> Delay {
        self.expected_total_delay
    }

-    pub fn prepare_for_sending(self) -> Result<(Delay, Vec<u8>), SurbAckRecoveryError> {
+    pub fn prepare_for_sending(self) -> (Delay, Vec<u8>) {
        // SURB_FIRST_HOP || SURB_ACK
        let surb_bytes: Vec<_> = self
            .first_hop_address
            .as_zero_padded_bytes(MAX_NODE_ADDRESS_UNPADDED_LEN)
            .into_iter()
-            .chain(self.surb_ack_packet.to_bytes()?.into_iter())
+            .chain(self.surb_ack_packet.to_bytes().into_iter())
            .collect();
-        Ok((self.expected_total_delay, surb_bytes))
+        (self.expected_total_delay, surb_bytes)
    }

    // partial reciprocal of `prepare_for_sending` performed by the gateway
    pub fn try_recover_first_hop_packet(
        b: &[u8],
-        packet_type: PacketType,
-    ) -> Result<(NymNodeRoutingAddress, NymPacket), SurbAckRecoveryError> {
-        let address = NymNodeRoutingAddress::try_from_bytes(b)?;
+    ) -> Result<(NymNodeRoutingAddress, SphinxPacket), SurbAckRecoveryError> {
+        if b.len() != Self::len() {
+            Err(SurbAckRecoveryError::InvalidPacketSize {
+                received: b.len(),
+                expected: Self::len(),
+            })
+        } else {
+            let address = NymNodeRoutingAddress::try_from_bytes(b)?;

-        // TODO: this will be variable once/if we decide to introduce optimization described
-        // in common/nymsphinx/chunking/src/lib.rs:available_plaintext_size()
-        let address_offset = MAX_NODE_ADDRESS_UNPADDED_LEN;
-        let packet = match packet_type {
-            PacketType::Outfox => NymPacket::outfox_from_bytes(&b[address_offset..])?,
-            PacketType::Mix => NymPacket::sphinx_from_bytes(&b[address_offset..])?,
-            PacketType::Vpn => NymPacket::sphinx_from_bytes(&b[address_offset..])?,
-        };
+            // TODO: this will be variable once/if we decide to introduce optimization described
+            // in common/nymsphinx/chunking/src/lib.rs:available_plaintext_size()
+            let address_offset = MAX_NODE_ADDRESS_UNPADDED_LEN;
+            let packet = SphinxPacket::from_bytes(&b[address_offset..])?;

-        Ok((address, packet))
+            Ok((address, packet))
+        }
    }
 }
@@ -6,8 +6,8 @@ use nym_crypto::{generic_array::typenum::Unsigned, Digest};
 use nym_sphinx_addressing::clients::Recipient;
 use nym_sphinx_addressing::nodes::{NymNodeRoutingAddress, MAX_NODE_ADDRESS_UNPADDED_LEN};
 use nym_sphinx_params::packet_sizes::PacketSize;
-use nym_sphinx_params::{PacketType, ReplySurbKeyDigestAlgorithm, DEFAULT_NUM_MIX_HOPS};
-use nym_sphinx_types::{delays, NymPacket, SURBMaterial, SphinxError, SURB};
+use nym_sphinx_params::{ReplySurbKeyDigestAlgorithm, DEFAULT_NUM_MIX_HOPS};
+use nym_sphinx_types::{delays, Error as SphinxError, SURBMaterial, SphinxPacket, SURB};
 use nym_topology::{NymTopology, NymTopologyError};
 use rand::{CryptoRng, RngCore};
 use serde::de::{Error as SerdeError, Visitor};
@@ -173,8 +173,7 @@ impl ReplySurb {
        self,
        message: M,
        packet_size: PacketSize,
-        _packet_type: PacketType,
-    ) -> Result<(NymPacket, NymNodeRoutingAddress), ReplySurbError> {
+    ) -> Result<(SphinxPacket, NymNodeRoutingAddress), ReplySurbError> {
        let message_bytes = message.as_ref();
        if message_bytes.len() != packet_size.plaintext_size() {
            return Err(ReplySurbError::UnpaddedMessageError);
@@ -188,6 +187,6 @@ impl ReplySurb {

        let first_hop_address = NymNodeRoutingAddress::try_from(first_hop).unwrap();

-        Ok((NymPacket::Sphinx(packet), first_hop_address))
+        Ok((packet, first_hop_address))
    }
 }
@@ -3,7 +3,7 @@

 use nym_crypto::shared_key::new_ephemeral_shared_key;
 use nym_crypto::symmetric::stream_cipher;
-use nym_sphinx_acknowledgements::surb_ack::{SurbAck, SurbAckRecoveryError};
+use nym_sphinx_acknowledgements::surb_ack::SurbAck;
 use nym_sphinx_acknowledgements::AckKey;
 use nym_sphinx_addressing::clients::Recipient;
 use nym_sphinx_addressing::nodes::NymNodeRoutingAddress;
@@ -11,9 +11,10 @@ use nym_sphinx_chunking::fragment::COVER_FRAG_ID;
 use nym_sphinx_forwarding::packet::MixPacket;
 use nym_sphinx_params::packet_sizes::PacketSize;
 use nym_sphinx_params::{
-    PacketEncryptionAlgorithm, PacketHkdfAlgorithm, PacketType, DEFAULT_NUM_MIX_HOPS,
+    PacketEncryptionAlgorithm, PacketHkdfAlgorithm, PacketMode, DEFAULT_NUM_MIX_HOPS,
 };
-use nym_sphinx_types::{delays, NymPacket};
+use nym_sphinx_types::builder::SphinxPacketBuilder;
+use nym_sphinx_types::{delays, Error as SphinxError};
 use nym_topology::{NymTopology, NymTopologyError};
 use rand::{CryptoRng, RngCore};
 use std::convert::TryFrom;
@@ -27,11 +28,8 @@ pub enum CoverMessageError {
    #[error("Could not construct cover message due to invalid topology - {0}")]
    InvalidTopologyError(#[from] NymTopologyError),

-    #[error("SurbAck: {0}")]
-    SurbAck(#[from] SurbAckRecoveryError),
-
-    #[error("NymPacket: {0}")]
-    NymPacket(#[from] nym_sphinx_types::NymPacketError),
+    #[error("Could not construct a valid sphinx packet - {0}")]
+    SphinxError(#[from] SphinxError),
 }

 pub fn generate_loop_cover_surb_ack<R>(
@@ -40,7 +38,6 @@ pub fn generate_loop_cover_surb_ack<R>(
    ack_key: &AckKey,
    full_address: &Recipient,
    average_ack_delay: time::Duration,
-    packet_type: PacketType,
 ) -> Result<SurbAck, CoverMessageError>
 where
    R: RngCore + CryptoRng,
@@ -52,11 +49,9 @@ where
        COVER_FRAG_ID.to_bytes(),
        average_ack_delay,
        topology,
-        packet_type,
    )?)
 }

-#[allow(clippy::too_many_arguments)]
 pub fn generate_loop_cover_packet<R>(
    rng: &mut R,
    topology: &NymTopology,
@@ -65,21 +60,14 @@ pub fn generate_loop_cover_packet<R>(
    average_ack_delay: time::Duration,
    average_packet_delay: time::Duration,
    packet_size: PacketSize,
-    packet_type: PacketType,
 ) -> Result<MixPacket, CoverMessageError>
 where
    R: RngCore + CryptoRng,
 {
    // we don't care about total ack delay - we will not be retransmitting it anyway
-    let (_, ack_bytes) = generate_loop_cover_surb_ack(
-        rng,
-        topology,
-        ack_key,
-        full_address,
-        average_ack_delay,
-        packet_type,
-    )?
-    .prepare_for_sending()?;
+    let (_, ack_bytes) =
+        generate_loop_cover_surb_ack(rng, topology, ack_key, full_address, average_ack_delay)?
+            .prepare_for_sending();

    // cover message can't be distinguishable from a normal traffic so we have to go through
    // all the effort of key generation, encryption, etc. Note here we are generating shared key
@@ -123,18 +111,15 @@ where
    let destination = full_address.as_sphinx_destination();

    // once merged, that's an easy rng injection point for sphinx packets : )
-    let packet = NymPacket::sphinx_build(
-        packet_size.payload_size(),
-        packet_payload,
-        &route,
-        &destination,
-        &delays,
-    )?;
+    let packet = SphinxPacketBuilder::new()
+        .with_payload_size(packet_size.payload_size())
+        .build_packet(packet_payload, &route, &destination, &delays)
+        .unwrap();

    let first_hop_address =
        NymNodeRoutingAddress::try_from(route.first().unwrap().address).unwrap();

-    Ok(MixPacket::new(first_hop_address, packet, PacketType::Mix))
+    Ok(MixPacket::new(first_hop_address, packet, PacketMode::Mix))
 }

 /// Helper function used to determine if given message represents a loop cover message.
@@ -12,4 +12,3 @@ nym-sphinx-addressing = { path = "../addressing" }
 nym-sphinx-params = { path = "../params" }
 nym-sphinx-types = { path = "../types" }
 nym-outfox = { path = "../../../nym-outfox" }
-thiserror = "1"
@@ -2,28 +2,42 @@
 // SPDX-License-Identifier: Apache-2.0

 use nym_sphinx_addressing::nodes::{NymNodeRoutingAddress, NymNodeRoutingAddressError};
-use nym_sphinx_params::{PacketSize, PacketType};
-use nym_sphinx_types::{NymPacket, NymPacketError};
+use nym_sphinx_params::{PacketMode, PacketSize};
+use nym_sphinx_types::SphinxPacket;
 use std::convert::TryFrom;
-use std::fmt::{self, Debug, Formatter};
-use thiserror::Error;
+use std::fmt::{self, Debug, Display, Formatter};

-#[derive(Debug, Error)]
+#[derive(Debug)]
 pub enum MixPacketFormattingError {
-    #[error("too few bytes provided to recover from bytes")]
    TooFewBytesProvided,
-    #[error("provided packet mode is invalid")]
-    InvalidPacketType,
-    #[error("received request had invalid size - received {0}")]
+    InvalidPacketMode,
    InvalidPacketSize(usize),
-    #[error("address field was incorrectly encoded")]
    InvalidAddress,
-    #[error("received sphinx packet was malformed")]
    MalformedSphinxPacket,
-    #[error("Packet: {0}")]
-    Packet(#[from] NymPacketError),
 }

+impl Display for MixPacketFormattingError {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        use MixPacketFormattingError::*;
+        match self {
+            TooFewBytesProvided => write!(f, "Too few bytes provided to recover from bytes"),
+            InvalidAddress => write!(f, "address field was incorrectly encoded"),
+            InvalidPacketSize(actual) =>
+                write!(
+                    f,
+                    "received request had invalid size. (actual: {}, but expected one of: {} (ACK), {} (REGULAR), {}, {}, {} (EXTENDED))",
+                    actual, PacketSize::AckPacket.size(), PacketSize::RegularPacket.size(),
+                    PacketSize::ExtendedPacket8.size(), PacketSize::ExtendedPacket16.size(),
+                    PacketSize::ExtendedPacket32.size()
+                ),
+            MalformedSphinxPacket => write!(f, "received sphinx packet was malformed"),
+            InvalidPacketMode => write!(f, "provided packet mode is invalid")
+        }
+    }
+}
+
+impl std::error::Error for MixPacketFormattingError {}
+
 impl From<NymNodeRoutingAddressError> for MixPacketFormattingError {
    fn from(_: NymNodeRoutingAddressError) -> Self {
        MixPacketFormattingError::InvalidAddress
@@ -32,16 +46,19 @@ impl From<NymNodeRoutingAddressError> for MixPacketFormattingError {

 pub struct MixPacket {
    next_hop: NymNodeRoutingAddress,
-    packet: NymPacket,
-    packet_type: PacketType,
+    sphinx_packet: SphinxPacket,
+    packet_mode: PacketMode,
 }

 impl Debug for MixPacket {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        write!(
            f,
-            "MixPacket to {:?} with packet_type {:?}. Packet {:?}",
-            self.next_hop, self.packet_type, self.packet
+            "MixPacket to {:?} with packet_mode {:?}. Sphinx header: {:?}, payload length: {}",
+            self.next_hop,
+            self.packet_mode,
+            self.sphinx_packet.header,
+            self.sphinx_packet.payload.len()
        )
    }
 }
@@ -49,13 +66,13 @@ impl Debug for MixPacket {
 impl MixPacket {
    pub fn new(
        next_hop: NymNodeRoutingAddress,
-        packet: NymPacket,
-        packet_type: PacketType,
+        sphinx_packet: SphinxPacket,
+        packet_mode: PacketMode,
    ) -> Self {
        MixPacket {
            next_hop,
-            packet,
-            packet_type,
+            sphinx_packet,
+            packet_mode,
        }
    }

@@ -63,52 +80,52 @@ impl MixPacket {
        self.next_hop
    }

-    pub fn packet(&self) -> &NymPacket {
-        &self.packet
+    pub fn sphinx_packet(&self) -> &SphinxPacket {
+        &self.sphinx_packet
    }

-    pub fn into_packet(self) -> NymPacket {
-        self.packet
+    pub fn into_sphinx_packet(self) -> SphinxPacket {
+        self.sphinx_packet
    }

-    pub fn packet_type(&self) -> PacketType {
-        self.packet_type
+    pub fn packet_mode(&self) -> PacketMode {
+        self.packet_mode
    }

    // the message is formatted as follows:
-    // packet_type || FIRST_HOP || packet
+    // PACKET_MODE || FIRST_HOP || SPHINX_PACKET
    pub fn try_from_bytes(b: &[u8]) -> Result<Self, MixPacketFormattingError> {
-        let packet_type = match PacketType::try_from(b[0]) {
+        let packet_mode = match PacketMode::try_from(b[0]) {
            Ok(mode) => mode,
-            Err(_) => return Err(MixPacketFormattingError::InvalidPacketType),
+            Err(_) => return Err(MixPacketFormattingError::InvalidPacketMode),
        };

        let next_hop = NymNodeRoutingAddress::try_from_bytes(&b[1..])?;
        let addr_offset = next_hop.bytes_min_len();

-        let packet_data = &b[addr_offset + 1..];
-        let packet_size = packet_data.len();
+        let sphinx_packet_data = &b[addr_offset + 1..];
+        let packet_size = sphinx_packet_data.len();
        if PacketSize::get_type(packet_size).is_err() {
            Err(MixPacketFormattingError::InvalidPacketSize(packet_size))
        } else {
-            let packet = match packet_type {
-                PacketType::Outfox => NymPacket::outfox_from_bytes(packet_data)?,
-                _ => NymPacket::sphinx_from_bytes(packet_data)?,
+            let sphinx_packet = match SphinxPacket::from_bytes(sphinx_packet_data) {
+                Ok(packet) => packet,
+                Err(_) => return Err(MixPacketFormattingError::MalformedSphinxPacket),
            };

            Ok(MixPacket {
                next_hop,
-                packet,
-                packet_type,
+                sphinx_packet,
+                packet_mode,
            })
        }
    }

-    pub fn into_bytes(self) -> Result<Vec<u8>, MixPacketFormattingError> {
-        Ok(std::iter::once(self.packet_type as u8)
+    pub fn into_bytes(self) -> Vec<u8> {
+        std::iter::once(self.packet_mode as u8)
            .chain(self.next_hop.as_bytes().into_iter())
-            .chain(self.packet.to_bytes()?.into_iter())
-            .collect())
+            .chain(self.sphinx_packet.to_bytes().into_iter())
+            .collect()
    }
 }

@@ -1,56 +1,65 @@
 // Copyright 2021-2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use crate::packet::{FramedNymPacket, Header};
+use crate::packet::{FramedSphinxPacket, Header};
 use bytes::{Buf, BufMut, BytesMut};
+use nym_sphinx_params::packet_modes::InvalidPacketMode;
 use nym_sphinx_params::packet_sizes::{InvalidPacketSize, PacketSize};
-use nym_sphinx_params::packet_types::InvalidPacketType;
-use nym_sphinx_params::PacketType;
-use nym_sphinx_types::{NymPacket, NymPacketError};
+use nym_sphinx_types::Error as SphinxError;
+use nym_sphinx_types::SphinxPacket;
 use std::io;
 use thiserror::Error;
 use tokio_util::codec::{Decoder, Encoder};

 #[derive(Error, Debug)]
-pub enum NymCodecError {
+pub enum SphinxCodecError {
    #[error("the packet size information was malformed - {0}")]
    InvalidPacketSize(#[from] InvalidPacketSize),

    #[error("the packet mode information was malformed - {0}")]
-    InvalidPacketType(#[from] InvalidPacketType),
+    InvalidPacketMode(#[from] InvalidPacketMode),
+
+    #[error("the actual sphinx packet was malformed - {0}")]
+    MalformedSphinxPacket(#[from] SphinxError),

    #[error("encountered an IO error - {0}")]
    IoError(#[from] io::Error),
+}

-    #[error("encountered a packet error - {0}")]
-    NymPacket(#[from] NymPacketError),
-
-    #[error("could not convert to bytes")]
-    ToBytes,
-
-    #[error("could not convert to bytes")]
-    FromBytes,
+impl From<SphinxCodecError> for io::Error {
+    fn from(err: SphinxCodecError) -> Self {
+        match err {
+            SphinxCodecError::InvalidPacketSize(source) => {
+                io::Error::new(io::ErrorKind::InvalidInput, source)
+            }
+            SphinxCodecError::InvalidPacketMode(source) => {
+                io::Error::new(io::ErrorKind::InvalidInput, source)
+            }
+            SphinxCodecError::MalformedSphinxPacket(source) => {
+                io::Error::new(io::ErrorKind::InvalidData, source)
+            }
+            SphinxCodecError::IoError(err) => err,
+        }
+    }
 }

 // TODO: in the future it could be extended to have state containing symmetric encryption key
 // so that all data could be encrypted easily (alternatively we could just slap TLS)
-pub struct NymCodec;
+pub struct SphinxCodec;

-impl Encoder<FramedNymPacket> for NymCodec {
-    type Error = NymCodecError;
+impl Encoder<FramedSphinxPacket> for SphinxCodec {
+    type Error = SphinxCodecError;

-    fn encode(&mut self, item: FramedNymPacket, dst: &mut BytesMut) -> Result<(), Self::Error> {
+    fn encode(&mut self, item: FramedSphinxPacket, dst: &mut BytesMut) -> Result<(), Self::Error> {
        item.header.encode(dst);
-        let packet_bytes = item.packet.to_bytes()?;
-        let encoded = packet_bytes.as_slice();
-        dst.put(encoded);
+        dst.put(item.packet.to_bytes().as_ref());
        Ok(())
    }
 }

-impl Decoder for NymCodec {
-    type Item = FramedNymPacket;
-    type Error = NymCodecError;
+impl Decoder for SphinxCodec {
+    type Item = FramedSphinxPacket;
+    type Error = SphinxCodecError;

    fn decode(&mut self, src: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
        if src.is_empty() {
@@ -67,32 +76,23 @@ impl Decoder for NymCodec {
            None => return Ok(None), // we have some data but not enough to get header back
        };

-        let packet_size = header.packet_size.size();
-        let frame_len = header.size() + packet_size;
+        let sphinx_packet_size = header.packet_size.size();
+        let frame_len = header.size() + sphinx_packet_size;

        if src.len() < frame_len {
            // we don't have enough bytes to read the rest of frame
-            src.reserve(packet_size);
+            src.reserve(sphinx_packet_size);
            return Ok(None);
        }

        // advance buffer past the header - at this point we have enough bytes
        src.advance(header.size());
-        let packet_bytes = src.split_to(packet_size);
-        let packet = if let Some(slice) = packet_bytes.get(..) {
-            // here it could be debatable whether stream is corrupt or not,
-            // but let's go with the safer approach and assume it is.
-            match header.packet_type {
-                PacketType::Outfox => NymPacket::outfox_from_bytes(slice)?,
-                PacketType::Mix => NymPacket::sphinx_from_bytes(slice)?,
-                PacketType::Vpn => NymPacket::sphinx_from_bytes(slice)?,
-            }
-        } else {
-            return Ok(None);
-        };
+        let sphinx_packet_bytes = src.split_to(sphinx_packet_size);

-        // let packet = SphinxPacket::from_bytes(&sphinx_packet_bytes)?;
-        let nymsphinx_packet = FramedNymPacket { header, packet };
+        // here it could be debatable whether stream is corrupt or not,
+        // but let's go with the safer approach and assume it is.
+        let packet = SphinxPacket::from_bytes(&sphinx_packet_bytes)?;
+        let nymsphinx_packet = FramedSphinxPacket { header, packet };

        // As per docs:
        // Before returning from the function, implementations should ensure that the buffer
@@ -104,7 +104,6 @@ impl Decoder for NymCodec {
        // reserve for that.
        // we also assume the next packet coming from the same client will use exactly the same versioning
        // as the current packet
-
        let mut allocate_for_next_packet = header.size() + PacketSize::AckPacket.size();
        if !src.is_empty() {
            match Header::decode(src) {
@@ -121,6 +120,7 @@ impl Decoder for NymCodec {
            };
        }
        src.reserve(allocate_for_next_packet);
+
        Ok(Some(nymsphinx_packet))
    }
 }
@@ -128,47 +128,13 @@ impl Decoder for NymCodec {
 #[cfg(test)]
 mod packet_encoding {
    use super::*;
+    use nym_sphinx_types::builder::SphinxPacketBuilder;
    use nym_sphinx_types::{
        crypto, Delay as SphinxDelay, Destination, DestinationAddressBytes, Node, NodeAddressBytes,
        DESTINATION_ADDRESS_LENGTH, IDENTIFIER_LENGTH, NODE_ADDRESS_LENGTH,
    };

-    fn make_valid_outfox_packet(size: PacketSize) -> NymPacket {
-        let (_, node1_pk) = crypto::keygen();
-        let node1 = Node::new(
-            NodeAddressBytes::from_bytes([5u8; NODE_ADDRESS_LENGTH]),
-            node1_pk,
-        );
-        let (_, node2_pk) = crypto::keygen();
-        let node2 = Node::new(
-            NodeAddressBytes::from_bytes([4u8; NODE_ADDRESS_LENGTH]),
-            node2_pk,
-        );
-        let (_, node3_pk) = crypto::keygen();
-        let node3 = Node::new(
-            NodeAddressBytes::from_bytes([2u8; NODE_ADDRESS_LENGTH]),
-            node3_pk,
-        );
-
-        let (_, node4_pk) = crypto::keygen();
-        let node4 = Node::new(
-            NodeAddressBytes::from_bytes([2u8; NODE_ADDRESS_LENGTH]),
-            node4_pk,
-        );
-
-        let destination = Destination::new(
-            DestinationAddressBytes::from_bytes([3u8; DESTINATION_ADDRESS_LENGTH]),
-            [4u8; IDENTIFIER_LENGTH],
-        );
-
-        let route = &[node1, node2, node3, node4];
-
-        let payload = vec![1; 48];
-
-        NymPacket::outfox_build(payload, route, &destination, Some(size.plaintext_size())).unwrap()
-    }
-
-    fn make_valid_sphinx_packet(size: PacketSize) -> NymPacket {
+    fn make_valid_sphinx_packet(size: PacketSize) -> SphinxPacket {
        let (_, node1_pk) = crypto::keygen();
        let node1 = Node::new(
            NodeAddressBytes::from_bytes([5u8; NODE_ADDRESS_LENGTH]),
@@ -195,7 +161,9 @@ mod packet_encoding {
            SphinxDelay::new_from_nanos(42),
            SphinxDelay::new_from_nanos(42),
        ];
-        NymPacket::sphinx_build(size.payload_size(), b"foomp", &route, &destination, &delays)
+        SphinxPacketBuilder::new()
+            .with_payload_size(size.payload_size())
+            .build_packet(b"foomp", &route, &destination, &delays)
            .unwrap()
    }

@@ -203,50 +171,32 @@ mod packet_encoding {
    fn whole_packet_can_be_decoded_from_a_valid_encoded_instance() {
        let header = Default::default();
        let sphinx_packet = make_valid_sphinx_packet(Default::default());
-        let sphinx_bytes = sphinx_packet.to_bytes().unwrap();
+        let sphinx_bytes = sphinx_packet.to_bytes();

-        let packet = FramedNymPacket {
+        let packet = FramedSphinxPacket {
            header,
            packet: sphinx_packet,
        };

        let mut bytes = BytesMut::new();
-        NymCodec.encode(packet, &mut bytes).unwrap();
-        let decoded = NymCodec.decode(&mut bytes).unwrap().unwrap();
+        SphinxCodec.encode(packet, &mut bytes).unwrap();
+        let decoded = SphinxCodec.decode(&mut bytes).unwrap().unwrap();

        assert_eq!(decoded.header, header);
-        assert_eq!(decoded.packet.to_bytes().unwrap(), sphinx_bytes)
-    }
-
-    #[test]
-    fn whole_outfox_can_be_decoded_from_a_valid_encoded_instance() {
-        let header = Header::outfox();
-        let packet = make_valid_outfox_packet(PacketSize::OutfoxRegularPacket);
-        let packet_bytes = packet.to_bytes().unwrap();
-
-        NymPacket::outfox_from_bytes(packet_bytes.as_slice()).unwrap();
-
-        let packet = FramedNymPacket { header, packet };
-
-        let mut bytes = BytesMut::new();
-        NymCodec.encode(packet, &mut bytes).unwrap();
-        let decoded = NymCodec.decode(&mut bytes).unwrap().unwrap();
-
-        assert_eq!(decoded.header, header);
-        assert_eq!(decoded.packet.to_bytes().unwrap(), packet_bytes)
+        assert_eq!(decoded.packet.to_bytes(), sphinx_bytes)
    }

    #[cfg(test)]
    mod decode_will_allocate_enough_bytes_for_next_call {
        use super::*;
        use nym_sphinx_params::packet_version::PacketVersion;
-        use nym_sphinx_params::PacketType;
+        use nym_sphinx_params::PacketMode;

        #[test]
        fn for_empty_bytes() {
            // empty bytes should allocate for header + ack packet
            let mut empty_bytes = BytesMut::new();
-            assert!(NymCodec.decode(&mut empty_bytes).unwrap().is_none());
+            assert!(SphinxCodec.decode(&mut empty_bytes).unwrap().is_none());
            assert_eq!(
                empty_bytes.capacity(),
                Header::LEGACY_SIZE + PacketSize::AckPacket.size()
@@ -267,11 +217,11 @@ mod packet_encoding {
                let header = Header {
                    packet_version: PacketVersion::Legacy,
                    packet_size,
-                    ..Default::default()
+                    packet_mode: Default::default(),
                };
                let mut bytes = BytesMut::new();
                header.encode(&mut bytes);
-                assert!(NymCodec.decode(&mut bytes).unwrap().is_none());
+                assert!(SphinxCodec.decode(&mut bytes).unwrap().is_none());

                assert_eq!(bytes.capacity(), Header::LEGACY_SIZE + packet_size.size())
            }
@@ -291,11 +241,11 @@ mod packet_encoding {
                let header = Header {
                    packet_version: PacketVersion::Versioned(123),
                    packet_size,
-                    ..Default::default()
+                    packet_mode: Default::default(),
                };
                let mut bytes = BytesMut::new();
                header.encode(&mut bytes);
-                assert!(NymCodec.decode(&mut bytes).unwrap().is_none());
+                assert!(SphinxCodec.decode(&mut bytes).unwrap().is_none());

                assert_eq!(
                    bytes.capacity(),
@@ -307,17 +257,18 @@ mod packet_encoding {
        #[test]
        fn for_full_frame_with_legacy_header() {
            // if full frame is used exactly, there should be enough space for header + ack packet
-            let packet = FramedNymPacket {
+            let packet = FramedSphinxPacket {
                header: Header {
                    packet_version: PacketVersion::Legacy,
-                    ..Default::default()
+                    packet_size: Default::default(),
+                    packet_mode: Default::default(),
                },
                packet: make_valid_sphinx_packet(Default::default()),
            };

            let mut bytes = BytesMut::new();
-            NymCodec.encode(packet, &mut bytes).unwrap();
-            assert!(NymCodec.decode(&mut bytes).unwrap().is_some());
+            SphinxCodec.encode(packet, &mut bytes).unwrap();
+            assert!(SphinxCodec.decode(&mut bytes).unwrap().is_some());
            assert_eq!(
                bytes.capacity(),
                Header::LEGACY_SIZE + PacketSize::AckPacket.size()
@@ -327,14 +278,14 @@ mod packet_encoding {
        #[test]
        fn for_full_frame_with_versioned_header() {
            // if full frame is used exactly, there should be enough space for header + ack packet
-            let packet = FramedNymPacket {
+            let packet = FramedSphinxPacket {
                header: Header::default(),
                packet: make_valid_sphinx_packet(Default::default()),
            };

            let mut bytes = BytesMut::new();
-            NymCodec.encode(packet, &mut bytes).unwrap();
-            assert!(NymCodec.decode(&mut bytes).unwrap().is_some());
+            SphinxCodec.encode(packet, &mut bytes).unwrap();
+            assert!(SphinxCodec.decode(&mut bytes).unwrap().is_some());
            assert_eq!(
                bytes.capacity(),
                Header::VERSIONED_SIZE + PacketSize::AckPacket.size()
@@ -353,19 +304,20 @@ mod packet_encoding {
            ];

            for packet_size in packet_sizes {
-                let first_packet = FramedNymPacket {
+                let first_packet = FramedSphinxPacket {
                    header: Header {
                        packet_version: PacketVersion::Legacy,
-                        ..Default::default()
+                        packet_size: Default::default(),
+                        packet_mode: Default::default(),
                    },
                    packet: make_valid_sphinx_packet(Default::default()),
                };

                let mut bytes = BytesMut::new();
-                NymCodec.encode(first_packet, &mut bytes).unwrap();
+                SphinxCodec.encode(first_packet, &mut bytes).unwrap();
                bytes.put_u8(packet_size as u8);
-                bytes.put_u8(PacketType::default() as u8);
-                assert!(NymCodec.decode(&mut bytes).unwrap().is_some());
+                bytes.put_u8(PacketMode::default() as u8);
+                assert!(SphinxCodec.decode(&mut bytes).unwrap().is_some());

                assert!(bytes.capacity() >= Header::LEGACY_SIZE + packet_size.size())
            }
@@ -383,53 +335,53 @@ mod packet_encoding {
            ];

            for packet_size in packet_sizes {
-                let first_packet = FramedNymPacket {
+                let first_packet = FramedSphinxPacket {
                    header: Header::default(),
                    packet: make_valid_sphinx_packet(Default::default()),
                };

                let mut bytes = BytesMut::new();
-                NymCodec.encode(first_packet, &mut bytes).unwrap();
+                SphinxCodec.encode(first_packet, &mut bytes).unwrap();
                bytes.put_u8(PacketVersion::new_versioned(123).as_u8().unwrap());
                bytes.put_u8(packet_size as u8);
-                bytes.put_u8(PacketType::default() as u8);
-                assert!(NymCodec.decode(&mut bytes).unwrap().is_some());
+                bytes.put_u8(PacketMode::default() as u8);
+                assert!(SphinxCodec.decode(&mut bytes).unwrap().is_some());

-                // assert!(bytes.capacity() >= Header::VERSIONED_SIZE + packet_size.size())
+                assert!(bytes.capacity() >= Header::VERSIONED_SIZE + packet_size.size())
            }
        }
    }

    #[test]
    fn can_decode_two_packets_immediately() {
-        let packet1 = FramedNymPacket {
+        let packet1 = FramedSphinxPacket {
            header: Header::default(),
            packet: make_valid_sphinx_packet(Default::default()),
        };

-        let packet2 = FramedNymPacket {
+        let packet2 = FramedSphinxPacket {
            header: Header::default(),
            packet: make_valid_sphinx_packet(Default::default()),
        };

        let mut bytes = BytesMut::new();

-        NymCodec.encode(packet1, &mut bytes).unwrap();
-        NymCodec.encode(packet2, &mut bytes).unwrap();
+        SphinxCodec.encode(packet1, &mut bytes).unwrap();
+        SphinxCodec.encode(packet2, &mut bytes).unwrap();

-        assert!(NymCodec.decode(&mut bytes).unwrap().is_some());
-        assert!(NymCodec.decode(&mut bytes).unwrap().is_some());
-        assert!(NymCodec.decode(&mut bytes).unwrap().is_none());
+        assert!(SphinxCodec.decode(&mut bytes).unwrap().is_some());
+        assert!(SphinxCodec.decode(&mut bytes).unwrap().is_some());
+        assert!(SphinxCodec.decode(&mut bytes).unwrap().is_none());
    }

    #[test]
    fn can_decode_two_packets_in_separate_calls() {
-        let packet1 = FramedNymPacket {
+        let packet1 = FramedSphinxPacket {
            header: Header::default(),
            packet: make_valid_sphinx_packet(Default::default()),
        };

-        let packet2 = FramedNymPacket {
+        let packet2 = FramedSphinxPacket {
            header: Header::default(),
            packet: make_valid_sphinx_packet(Default::default()),
        };
@@ -437,17 +389,18 @@ mod packet_encoding {
        let mut bytes = BytesMut::new();
        let mut bytes_tmp = BytesMut::new();

-        NymCodec.encode(packet1, &mut bytes).unwrap();
-        NymCodec.encode(packet2, &mut bytes_tmp).unwrap();
+        SphinxCodec.encode(packet1, &mut bytes).unwrap();
+        SphinxCodec.encode(packet2, &mut bytes_tmp).unwrap();

        let tmp = bytes_tmp.split_off(100);
        bytes.put(bytes_tmp);

-        assert!(NymCodec.decode(&mut bytes).unwrap().is_some());
-        assert!(NymCodec.decode(&mut bytes).unwrap().is_none());
+        assert!(SphinxCodec.decode(&mut bytes).unwrap().is_some());
+        assert!(SphinxCodec.decode(&mut bytes).unwrap().is_none());

        bytes.put(tmp);
-        assert!(NymCodec.decode(&mut bytes).unwrap().is_some());
-        assert!(NymCodec.decode(&mut bytes).unwrap().is_none());
+
+        assert!(SphinxCodec.decode(&mut bytes).unwrap().is_some());
+        assert!(SphinxCodec.decode(&mut bytes).unwrap().is_none());
    }
 }
@@ -1,57 +1,47 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use crate::codec::NymCodecError;
+use crate::codec::SphinxCodecError;
 use bytes::{BufMut, BytesMut};
 use nym_sphinx_params::packet_sizes::PacketSize;
 use nym_sphinx_params::packet_version::PacketVersion;
-use nym_sphinx_params::PacketType;
-use nym_sphinx_types::NymPacket;
+use nym_sphinx_params::PacketMode;
+use nym_sphinx_types::SphinxPacket;
 use std::convert::TryFrom;

-#[derive(Debug)]
-pub struct FramedNymPacket {
+pub struct FramedSphinxPacket {
    /// Contains any metadata helping receiver to handle the underlying packet.
    pub(crate) header: Header,

    /// The actual SphinxPacket being sent.
-    pub(crate) packet: NymPacket,
+    pub(crate) packet: SphinxPacket,
 }

-impl FramedNymPacket {
-    pub fn new(packet: NymPacket, packet_type: PacketType, use_legacy_version: bool) -> Self {
+impl FramedSphinxPacket {
+    pub fn new(packet: SphinxPacket, packet_mode: PacketMode, use_legacy_version: bool) -> Self {
        // If this fails somebody is using the library in a super incorrect way, because they
        // already managed to somehow create a sphinx packet
        let packet_size = PacketSize::get_type(packet.len()).unwrap();

-        let use_legacy = if packet_type == PacketType::Outfox {
-            false
-        } else {
-            use_legacy_version
-        };
-
-        let header = Header {
-            packet_version: PacketVersion::new(use_legacy),
-            packet_size,
-            packet_type,
-        };
-
-        FramedNymPacket { header, packet }
-    }
-
-    pub fn header(&self) -> Header {
-        self.header
+        FramedSphinxPacket {
+            header: Header {
+                packet_version: PacketVersion::new(use_legacy_version),
+                packet_size,
+                packet_mode,
+            },
+            packet,
+        }
    }

    pub fn packet_size(&self) -> PacketSize {
        self.header.packet_size
    }

-    pub fn packet_type(&self) -> PacketType {
-        self.header.packet_type
+    pub fn packet_mode(&self) -> PacketMode {
+        self.header.packet_mode
    }

-    pub fn into_inner(self) -> NymPacket {
+    pub fn into_inner(self) -> SphinxPacket {
        self.packet
    }
 }
@@ -74,23 +64,15 @@ pub struct Header {
    ///
    /// TODO: ask @AP whether this can be sent like this - could it introduce some anonymity issues?
    /// (note: this will be behind some encryption, either something implemented by us or some SSL action)
-    // Note: currently packet_type is deprecated but is still left as a concept behind to not break
+    // Note: currently packet_mode is deprecated but is still left as a concept behind to not break
    // compatibility with existing network
-    pub(crate) packet_type: PacketType,
+    pub(crate) packet_mode: PacketMode,
 }

 impl Header {
    pub(crate) const LEGACY_SIZE: usize = 2;
    pub(crate) const VERSIONED_SIZE: usize = 3;

-    pub fn outfox() -> Header {
-        Header {
-            packet_version: PacketVersion::default(),
-            packet_size: PacketSize::OutfoxRegularPacket,
-            packet_type: PacketType::Outfox,
-        }
-    }
-
    pub(crate) fn size(&self) -> usize {
        if self.packet_version.is_legacy() {
            Self::LEGACY_SIZE
@@ -108,12 +90,12 @@ impl Header {
        }

        dst.put_u8(self.packet_size as u8);
-        dst.put_u8(self.packet_type as u8);
+        dst.put_u8(self.packet_mode as u8);
        // reserve bytes for the actual packet
        dst.reserve(self.packet_size.size());
    }

-    pub(crate) fn decode(src: &mut BytesMut) -> Result<Option<Self>, NymCodecError> {
+    pub(crate) fn decode(src: &mut BytesMut) -> Result<Option<Self>, SphinxCodecError> {
        if src.len() < Self::LEGACY_SIZE {
            // can't do anything if we don't have enough bytes - but reserve enough for the next call
            src.reserve(Self::LEGACY_SIZE);
@@ -125,7 +107,7 @@ impl Header {
            Ok(Some(Header {
                packet_version,
                packet_size: PacketSize::try_from(src[0])?,
-                packet_type: PacketType::try_from(src[1])?,
+                packet_mode: PacketMode::try_from(src[1])?,
            }))
        } else if src.len() < Self::VERSIONED_SIZE {
            // we're missing that 1 byte to read the full header...
@@ -135,7 +117,7 @@ impl Header {
            Ok(Some(Header {
                packet_version,
                packet_size: PacketSize::try_from(src[1])?,
-                packet_type: PacketType::try_from(src[2])?,
+                packet_mode: PacketMode::try_from(src[2])?,
            }))
        }
    }
@@ -166,7 +148,7 @@ mod header_encoding {
            [
                PacketVersion::new_versioned(123).as_u8().unwrap(),
                unknown_packet_size,
-                PacketType::default() as u8,
+                PacketMode::default() as u8,
            ]
            .as_ref(),
        );
@@ -174,12 +156,12 @@ mod header_encoding {
    }

    #[test]
-    fn decoding_will_fail_for_unknown_packet_type() {
-        let unknown_packet_type: u8 = 255;
+    fn decoding_will_fail_for_unknown_packet_mode() {
+        let unknown_packet_mode: u8 = 255;
        // make sure this is still 'unknown' for if we make changes in the future
-        assert!(PacketType::try_from(unknown_packet_type).is_err());
+        assert!(PacketMode::try_from(unknown_packet_mode).is_err());

-        let mut bytes = BytesMut::from([PacketSize::default() as u8, unknown_packet_type].as_ref());
+        let mut bytes = BytesMut::from([PacketSize::default() as u8, unknown_packet_mode].as_ref());
        assert!(Header::decode(&mut bytes).is_err())
    }

@@ -209,7 +191,7 @@ mod header_encoding {
            let header = Header {
                packet_version: PacketVersion::Legacy,
                packet_size,
-                ..Default::default()
+                packet_mode: Default::default(),
            };
            let mut bytes = BytesMut::new();
            header.encode(&mut bytes);
@@ -230,7 +212,7 @@ mod header_encoding {
            let header = Header {
                packet_version: PacketVersion::Versioned(123),
                packet_size,
-                ..Default::default()
+                packet_mode: Default::default(),
            };
            let mut bytes = BytesMut::new();
            header.encode(&mut bytes);
@@ -8,11 +8,11 @@ use nym_crypto::ctr;
 type Aes128Ctr = ctr::Ctr64BE<Aes128>;

 // Re-export for ease of use
+pub use packet_modes::PacketMode;
 pub use packet_sizes::PacketSize;
-pub use packet_types::PacketType;

+pub mod packet_modes;
 pub mod packet_sizes;
-pub mod packet_types;
 pub mod packet_version;

 // If somebody can provide an argument why it might be reasonable to have more than 255 mix hops,
@@ -29,7 +29,7 @@ pub type SerializedFragmentIdentifier = [u8; FRAG_ID_LEN];
 // when packet header gets serialized, the following bytes (in that order) are put onto the wire:
 // - packet_version (starting with v1.1.0)
 // - packet_size indicator
-// - packet_type
+// - packet_mode
 // it also just so happens that the only valid values for packet_size indicator include values 1-6
 // therefore if we receive byte `7` (or larger than that) we'll know we received a versioned packet,
 // otherwise we should treat it as legacy
@@ -0,0 +1,46 @@
+// Copyright 2021-2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use std::convert::TryFrom;
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+#[error("{received} is not a valid packet mode tag")]
+pub struct InvalidPacketMode {
+    received: u8,
+}
+
+#[repr(u8)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Default)]
+pub enum PacketMode {
+    /// Represents 'normal' packet sent through the network that should be delayed by an appropriate
+    /// value at each hop.
+    #[default]
+    Mix = 0,
+
+    /// Represents a VPN packet that should not be delayed and ideally cached pre-computed keys
+    /// should be used for unwrapping data. Note that it does not offer the same level of anonymity.
+    Vpn = 1,
+}
+
+impl PacketMode {
+    pub fn is_mix(self) -> bool {
+        self == PacketMode::Mix
+    }
+
+    pub fn is_old_vpn(self) -> bool {
+        self == PacketMode::Vpn
+    }
+}
+
+impl TryFrom<u8> for PacketMode {
+    type Error = InvalidPacketMode;
+
+    fn try_from(value: u8) -> Result<Self, Self::Error> {
+        match value {
+            _ if value == (PacketMode::Mix as u8) => Ok(Self::Mix),
+            _ if value == (PacketMode::Vpn as u8) => Ok(Self::Vpn),
+            v => Err(InvalidPacketMode { received: v }),
+        }
+    }
+}
@@ -1,11 +1,9 @@
 // Copyright 2021-2023 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use crate::{PacketType, FRAG_ID_LEN};
+use crate::FRAG_ID_LEN;
 use nym_sphinx_types::header::HEADER_SIZE;
-use nym_sphinx_types::{
-    MIN_PACKET_SIZE, MIX_PARAMS_LEN, OUTFOX_PACKET_OVERHEAD, PAYLOAD_OVERHEAD_SIZE,
-};
+use nym_sphinx_types::PAYLOAD_OVERHEAD_SIZE;
 use serde::{Deserialize, Serialize};
 use std::cmp::Ordering;
 use std::convert::TryFrom;
@@ -14,24 +12,20 @@ use std::str::FromStr;
 use thiserror::Error;

 // each sphinx packet contains mandatory header and payload padding + markers
-const SPHINX_PACKET_OVERHEAD: usize = HEADER_SIZE + PAYLOAD_OVERHEAD_SIZE;
+const PACKET_OVERHEAD: usize = HEADER_SIZE + PAYLOAD_OVERHEAD_SIZE;

 // it's up to the smart people to figure those values out : )
-
+const REGULAR_PACKET_SIZE: usize = 2 * 1024 + PACKET_OVERHEAD;
 // TODO: even though we have 16B IV, is having just 5B (FRAG_ID_LEN) of the ID possibly insecure?

 // TODO: I'm not entirely sure if we can easily extract `<AckEncryptionAlgorithm as NewStreamCipher>::NonceSize`
 // into a const usize before relevant stuff is stabilised in rust...
 const ACK_IV_SIZE: usize = 16;

-const ACK_PACKET_SIZE: usize = ACK_IV_SIZE + FRAG_ID_LEN + SPHINX_PACKET_OVERHEAD;
-const REGULAR_PACKET_SIZE: usize = 2 * 1024 + SPHINX_PACKET_OVERHEAD;
-const EXTENDED_PACKET_SIZE_8: usize = 8 * 1024 + SPHINX_PACKET_OVERHEAD;
-const EXTENDED_PACKET_SIZE_16: usize = 16 * 1024 + SPHINX_PACKET_OVERHEAD;
-const EXTENDED_PACKET_SIZE_32: usize = 32 * 1024 + SPHINX_PACKET_OVERHEAD;
-
-const OUTFOX_ACK_PACKET_SIZE: usize = MIN_PACKET_SIZE + OUTFOX_PACKET_OVERHEAD;
-const OUTFOX_REGULAR_PACKET_SIZE: usize = 2 * 1024 + OUTFOX_PACKET_OVERHEAD;
+const ACK_PACKET_SIZE: usize = ACK_IV_SIZE + FRAG_ID_LEN + PACKET_OVERHEAD;
+const EXTENDED_PACKET_SIZE_8: usize = 8 * 1024 + PACKET_OVERHEAD;
+const EXTENDED_PACKET_SIZE_16: usize = 16 * 1024 + PACKET_OVERHEAD;
+const EXTENDED_PACKET_SIZE_32: usize = 32 * 1024 + PACKET_OVERHEAD;

 #[derive(Debug, Error)]
 pub enum InvalidPacketSize {
@@ -68,13 +62,6 @@ pub enum PacketSize {
    // for example for streaming fast and furious in compressed XviD quality
    #[serde(rename = "extended16")]
    ExtendedPacket16 = 5,
-
-    #[serde(rename = "outfox_regular")]
-    OutfoxRegularPacket = 6,
-
-    // for sending SURB-ACKs
-    #[serde(rename = "outfox_ack")]
-    OutfoxAckPacket = 7,
 }

 impl PartialOrd for PacketSize {
@@ -101,8 +88,6 @@ impl FromStr for PacketSize {
            "extended8" => Ok(Self::ExtendedPacket8),
            "extended16" => Ok(Self::ExtendedPacket16),
            "extended32" => Ok(Self::ExtendedPacket32),
-            "outfox_regular" => Ok(Self::OutfoxRegularPacket),
-            "outfox_ack" => Ok(Self::OutfoxAckPacket),
            s => Err(InvalidPacketSize::UnknownExtendedPacketVariant {
                received: s.to_string(),
            }),
@@ -118,8 +103,6 @@ impl Display for PacketSize {
            PacketSize::ExtendedPacket32 => write!(f, "extended32"),
            PacketSize::ExtendedPacket8 => write!(f, "extended8"),
            PacketSize::ExtendedPacket16 => write!(f, "extended16"),
-            PacketSize::OutfoxRegularPacket => write!(f, "outfox_regular"),
-            PacketSize::OutfoxAckPacket => write!(f, "outfox_ack"),
        }
    }
 }
@@ -144,8 +127,6 @@ impl TryFrom<u8> for PacketSize {
            _ if value == (PacketSize::ExtendedPacket8 as u8) => Ok(Self::ExtendedPacket8),
            _ if value == (PacketSize::ExtendedPacket16 as u8) => Ok(Self::ExtendedPacket16),
            _ if value == (PacketSize::ExtendedPacket32 as u8) => Ok(Self::ExtendedPacket32),
-            _ if value == (PacketSize::OutfoxRegularPacket as u8) => Ok(Self::OutfoxRegularPacket),
-            _ if value == (PacketSize::OutfoxAckPacket as u8) => Ok(Self::OutfoxAckPacket),
            v => Err(InvalidPacketSize::UnknownPacketTag { received: v }),
        }
    }
@@ -159,41 +140,15 @@ impl PacketSize {
            PacketSize::ExtendedPacket8 => EXTENDED_PACKET_SIZE_8,
            PacketSize::ExtendedPacket16 => EXTENDED_PACKET_SIZE_16,
            PacketSize::ExtendedPacket32 => EXTENDED_PACKET_SIZE_32,
-            PacketSize::OutfoxRegularPacket => OUTFOX_REGULAR_PACKET_SIZE,
-            PacketSize::OutfoxAckPacket => OUTFOX_ACK_PACKET_SIZE,
-        }
-    }
-
-    pub const fn header_size(&self) -> usize {
-        match self {
-            PacketSize::RegularPacket
-            | PacketSize::AckPacket
-            | PacketSize::ExtendedPacket8
-            | PacketSize::ExtendedPacket16
-            | PacketSize::ExtendedPacket32 => HEADER_SIZE,
-            PacketSize::OutfoxRegularPacket | PacketSize::OutfoxAckPacket => MIX_PARAMS_LEN,
-        }
-    }
-
-    pub const fn payload_overhead(&self) -> usize {
-        match self {
-            PacketSize::RegularPacket
-            | PacketSize::AckPacket
-            | PacketSize::ExtendedPacket8
-            | PacketSize::ExtendedPacket16
-            | PacketSize::ExtendedPacket32 => PAYLOAD_OVERHEAD_SIZE,
-            PacketSize::OutfoxRegularPacket | PacketSize::OutfoxAckPacket => {
-                OUTFOX_PACKET_OVERHEAD - MIX_PARAMS_LEN // Mix params are calculated into the total overhead so we take them out here
-            }
        }
    }

    pub const fn plaintext_size(self) -> usize {
-        self.size() - self.header_size() - self.payload_overhead()
+        self.size() - HEADER_SIZE - PAYLOAD_OVERHEAD_SIZE
    }

    pub const fn payload_size(self) -> usize {
-        self.size() - self.header_size()
+        self.size() - HEADER_SIZE
    }

    pub fn get_type(size: usize) -> Result<Self, InvalidPacketSize> {
@@ -207,12 +162,6 @@ impl PacketSize {
            Ok(PacketSize::ExtendedPacket16)
        } else if PacketSize::ExtendedPacket32.size() == size {
            Ok(PacketSize::ExtendedPacket32)
-        } else if PacketSize::OutfoxRegularPacket.size() == size
-            || PacketSize::OutfoxRegularPacket.size() == size + 6
-        {
-            Ok(PacketSize::OutfoxRegularPacket)
-        } else if PacketSize::OutfoxAckPacket.size() == size {
-            Ok(PacketSize::OutfoxAckPacket)
        } else {
            Err(InvalidPacketSize::UnknownPacketSize { received: size })
        }
@@ -220,10 +169,7 @@ impl PacketSize {

    pub fn is_extended_size(&self) -> bool {
        match self {
-            PacketSize::RegularPacket
-            | PacketSize::AckPacket
-            | PacketSize::OutfoxAckPacket
-            | PacketSize::OutfoxRegularPacket => false,
+            PacketSize::RegularPacket | PacketSize::AckPacket => false,
            PacketSize::ExtendedPacket8
            | PacketSize::ExtendedPacket16
            | PacketSize::ExtendedPacket32 => true,
@@ -238,16 +184,8 @@ impl PacketSize {
        }
    }

-    pub fn get_type_from_plaintext(
-        plaintext_size: usize,
-        packet_type: PacketType,
-    ) -> Result<Self, InvalidPacketSize> {
-        let overhead = match packet_type {
-            PacketType::Mix => SPHINX_PACKET_OVERHEAD,
-            PacketType::Vpn => SPHINX_PACKET_OVERHEAD,
-            PacketType::Outfox => OUTFOX_PACKET_OVERHEAD,
-        };
-        let packet_size = plaintext_size + overhead;
+    pub fn get_type_from_plaintext(plaintext_size: usize) -> Result<Self, InvalidPacketSize> {
+        let packet_size = plaintext_size + PACKET_OVERHEAD;
        Self::get_type(packet_size)
    }
 }
@@ -1,76 +0,0 @@
-// Copyright 2021-2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use serde::{Deserialize, Serialize};
-use std::convert::TryFrom;
-use std::fmt;
-use thiserror::Error;
-
-use crate::PacketSize;
-
-#[derive(Error, Debug)]
-#[error("{received} is not a valid packet mode tag")]
-pub struct InvalidPacketType {
-    received: u8,
-}
-
-#[repr(u8)]
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Default, Serialize, Deserialize)]
-pub enum PacketType {
-    /// Represents 'normal' packet sent through the network that should be delayed by an appropriate
-    /// value at each hop.
-    #[default]
-    Mix = 0,
-
-    /// Represents a packet that should be sent through the network as fast as possible.
-    Vpn = 1,
-
-    /// Abusing this to add Outfox support
-    Outfox = 2,
-}
-
-impl fmt::Display for PacketType {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            PacketType::Mix => write!(f, "Mix"),
-            PacketType::Vpn => write!(f, "Vpn"),
-            PacketType::Outfox => write!(f, "Outfox"),
-        }
-    }
-}
-
-impl PacketType {
-    pub fn is_mix(self) -> bool {
-        self == PacketType::Mix
-    }
-
-    pub fn is_outfox(self) -> bool {
-        self == PacketType::Outfox
-    }
-}
-
-impl TryFrom<u8> for PacketType {
-    type Error = InvalidPacketType;
-
-    fn try_from(value: u8) -> Result<Self, Self::Error> {
-        match value {
-            _ if value == (PacketType::Mix as u8) => Ok(Self::Mix),
-            _ if value == (PacketType::Outfox as u8) => Ok(Self::Outfox),
-            v => Err(InvalidPacketType { received: v }),
-        }
-    }
-}
-
-impl From<PacketSize> for PacketType {
-    fn from(s: PacketSize) -> Self {
-        match s {
-            PacketSize::RegularPacket => PacketType::Mix,
-            PacketSize::AckPacket => PacketType::Mix,
-            PacketSize::ExtendedPacket32 => PacketType::Mix,
-            PacketSize::ExtendedPacket8 => PacketType::Mix,
-            PacketSize::ExtendedPacket16 => PacketType::Mix,
-            PacketSize::OutfoxRegularPacket => PacketType::Outfox,
-            PacketSize::OutfoxAckPacket => PacketType::Outfox,
-        }
-    }
-}
@@ -1,11 +1,9 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use serde::{Deserialize, Serialize};
-
 use crate::{PacketSize, CURRENT_PACKET_VERSION_NUMBER};

-#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum PacketVersion {
    // this will allow updated mixnodes to still understand packets from before the update
    Legacy,
@@ -21,4 +21,4 @@ pub use nym_sphinx_types::*;
 pub use nym_sphinx_framing as framing;

 // TEMP UNTIL FURTHER REFACTORING
-pub use preparer::payload::NymPayloadBuilder;
+pub use preparer::payload::NymsphinxPayloadBuilder;
@@ -11,14 +11,12 @@ use nym_sphinx_anonymous_replies::requests::{
    ReplyMessageContent,
 };
 use nym_sphinx_chunking::fragment::Fragment;
-use nym_sphinx_params::{PacketSize, PacketType, ReplySurbKeyDigestAlgorithm};
+use nym_sphinx_params::{PacketSize, ReplySurbKeyDigestAlgorithm};
 use rand::Rng;
 use std::fmt::{Display, Formatter};
 use thiserror::Error;

 pub(crate) const ACK_OVERHEAD: usize = MAX_NODE_ADDRESS_UNPADDED_LEN + PacketSize::AckPacket.size();
-pub(crate) const OUTFOX_ACK_OVERHEAD: usize =
-    MAX_NODE_ADDRESS_UNPADDED_LEN + PacketSize::OutfoxAckPacket.size();

 #[derive(Debug, Error)]
 pub enum NymMessageError {
@@ -189,15 +187,8 @@ impl NymMessage {
            NymMessage::Reply(_) => ReplySurbKeyDigestAlgorithm::output_size(),
        };

-        let packet_type = PacketType::from(packet_size);
-
        // each packet will contain an ack + variant specific data (as described above)
-        match packet_type {
-            PacketType::Outfox => {
-                packet_size.plaintext_size() - OUTFOX_ACK_OVERHEAD - variant_overhead
-            }
-            _ => packet_size.plaintext_size() - ACK_OVERHEAD - variant_overhead,
-        }
+        packet_size.plaintext_size() - ACK_OVERHEAD - variant_overhead
    }

    /// Length of the actual (from the **message** point of view) data that is available in each packet.
@@ -1,8 +1,8 @@
 // Copyright 2021-2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use crate::message::{NymMessage, ACK_OVERHEAD, OUTFOX_ACK_OVERHEAD};
-use crate::NymPayloadBuilder;
+use crate::message::{NymMessage, ACK_OVERHEAD};
+use crate::NymsphinxPayloadBuilder;
 use nym_crypto::asymmetric::encryption;
 use nym_crypto::Digest;
 use nym_sphinx_acknowledgements::surb_ack::SurbAck;
@@ -13,8 +13,9 @@ use nym_sphinx_anonymous_replies::reply_surb::ReplySurb;
 use nym_sphinx_chunking::fragment::{Fragment, FragmentIdentifier};
 use nym_sphinx_forwarding::packet::MixPacket;
 use nym_sphinx_params::packet_sizes::PacketSize;
-use nym_sphinx_params::{PacketType, ReplySurbKeyDigestAlgorithm, DEFAULT_NUM_MIX_HOPS};
-use nym_sphinx_types::{delays, Delay, NymPacket};
+use nym_sphinx_params::{ReplySurbKeyDigestAlgorithm, DEFAULT_NUM_MIX_HOPS};
+use nym_sphinx_types::builder::SphinxPacketBuilder;
+use nym_sphinx_types::{delays, Delay};
 use nym_topology::{NymTopology, NymTopologyError};
 use rand::{CryptoRng, Rng};
 use std::convert::TryFrom;
@@ -76,7 +77,6 @@ pub trait FragmentPreparer {
        fragment_id: FragmentIdentifier,
        topology: &NymTopology,
        ack_key: &AckKey,
-        packet_type: PacketType,
    ) -> Result<SurbAck, NymTopologyError> {
        let ack_delay = self.average_ack_delay();

@@ -87,7 +87,6 @@ pub trait FragmentPreparer {
            fragment_id.to_bytes(),
            ack_delay,
            topology,
-            packet_type,
        )
    }

@@ -108,20 +107,15 @@ pub trait FragmentPreparer {
        ack_key: &AckKey,
        reply_surb: ReplySurb,
        packet_sender: &Recipient,
-        packet_type: PacketType,
    ) -> Result<PreparedFragment, NymTopologyError> {
        // each reply attaches the digest of the encryption key so that the recipient could
        // lookup correct key for decryption,
        let reply_overhead = ReplySurbKeyDigestAlgorithm::output_size();
-        let expected_plaintext = match packet_type {
-            PacketType::Outfox => fragment.serialized_size() + OUTFOX_ACK_OVERHEAD + reply_overhead,
-            _ => fragment.serialized_size() + ACK_OVERHEAD + reply_overhead,
-        };
+        let expected_plaintext = fragment.serialized_size() + ACK_OVERHEAD + reply_overhead;

        // the reason we're unwrapping (or rather 'expecting') here rather than handling the error
        // more gracefully is that this error should never be reached as it implies incorrect chunking
-        // reply packets are always Sphinx
-        let packet_size = PacketSize::get_type_from_plaintext(expected_plaintext, PacketType::Mix)
+        let packet_size = PacketSize::get_type_from_plaintext(expected_plaintext)
            .expect("the message has been incorrectly fragmented");

        // this is not going to be accurate by any means. but that's the best estimation we can do
@@ -132,34 +126,24 @@ pub trait FragmentPreparer {
        let fragment_identifier = fragment.fragment_identifier();

        // create an ack
-        let surb_ack = self.generate_surb_ack(
-            packet_sender,
-            fragment_identifier,
-            topology,
-            ack_key,
-            packet_type,
-        )?;
+        let surb_ack =
+            self.generate_surb_ack(packet_sender, fragment_identifier, topology, ack_key)?;
        let ack_delay = surb_ack.expected_total_delay();

-        let packet_payload = match NymPayloadBuilder::new(fragment, surb_ack)
-            .build_reply(reply_surb.encryption_key())
-        {
-            Ok(payload) => payload,
-            Err(_e) => return Err(NymTopologyError::PayloadBuilder),
-        };
+        let packet_payload = NymsphinxPayloadBuilder::new(fragment, surb_ack)
+            .build_reply(reply_surb.encryption_key());

        // the unwrap here is fine as the failures can only originate from attempting to use invalid payload lengths
        // and we just very carefully constructed a (presumably) valid one
-        let (sphinx_packet, first_hop_address) = reply_surb
-            .apply_surb(packet_payload, packet_size, packet_type)
-            .unwrap();
+        let (sphinx_packet, first_hop_address) =
+            reply_surb.apply_surb(packet_payload, packet_size).unwrap();

        Ok(PreparedFragment {
            // the round-trip delay is the sum of delays of all hops on the forward route as
            // well as the total delay of the ack packet.
            // we don't know the delays inside the reply surbs so we use best-effort estimation from our poisson distribution
            total_delay: expected_forward_delay + ack_delay,
-            mix_packet: MixPacket::new(first_hop_address, sphinx_packet, packet_type),
+            mix_packet: MixPacket::new(first_hop_address, sphinx_packet, Default::default()),
            fragment_identifier,
        })
    }
@@ -188,42 +172,27 @@ pub trait FragmentPreparer {
        ack_key: &AckKey,
        packet_sender: &Recipient,
        packet_recipient: &Recipient,
-        packet_type: PacketType,
    ) -> Result<PreparedFragment, NymTopologyError> {
        // each plain or repliable packet (i.e. not a reply) attaches an ephemeral public key so that the recipient
        // could perform diffie-hellman with its own keys followed by a kdf to re-derive
        // the packet encryption key
        let non_reply_overhead = encryption::PUBLIC_KEY_SIZE;
-        let expected_plaintext = match packet_type {
-            PacketType::Outfox => {
-                fragment.serialized_size() + OUTFOX_ACK_OVERHEAD + non_reply_overhead
-            }
-            _ => fragment.serialized_size() + ACK_OVERHEAD + non_reply_overhead,
-        };
+        let expected_plaintext = fragment.serialized_size() + ACK_OVERHEAD + non_reply_overhead;

        // the reason we're unwrapping (or rather 'expecting') here rather than handling the error
        // more gracefully is that this error should never be reached as it implies incorrect chunking
-        let packet_size = PacketSize::get_type_from_plaintext(expected_plaintext, packet_type)
+        let packet_size = PacketSize::get_type_from_plaintext(expected_plaintext)
            .expect("the message has been incorrectly fragmented");

        let fragment_identifier = fragment.fragment_identifier();

        // create an ack
-        let surb_ack = self.generate_surb_ack(
-            packet_sender,
-            fragment_identifier,
-            topology,
-            ack_key,
-            packet_type,
-        )?;
+        let surb_ack =
+            self.generate_surb_ack(packet_sender, fragment_identifier, topology, ack_key)?;
        let ack_delay = surb_ack.expected_total_delay();

-        let packet_payload = match NymPayloadBuilder::new(fragment, surb_ack)
-            .build_regular(self.rng(), packet_recipient.encryption_key())
-        {
-            Ok(payload) => payload,
-            Err(_e) => return Err(NymTopologyError::PayloadBuilder),
-        };
+        let packet_payload = NymsphinxPayloadBuilder::new(fragment, surb_ack)
+            .build_regular(self.rng(), packet_recipient.encryption_key());

        // generate pseudorandom route for the packet
        let hops = self.num_mix_hops();
@@ -237,28 +206,10 @@ pub trait FragmentPreparer {

        // create the actual sphinx packet here. With valid route and correct payload size,
        // there's absolutely no reason for this call to fail.
-        let packet = match packet_type {
-            PacketType::Outfox => NymPacket::outfox_build(
-                packet_payload,
-                route.as_slice(),
-                &destination,
-                Some(packet_size.plaintext_size()),
-            )?,
-            PacketType::Mix => NymPacket::sphinx_build(
-                packet_size.payload_size(),
-                packet_payload,
-                &route,
-                &destination,
-                &delays,
-            )?,
-            PacketType::Vpn => NymPacket::sphinx_build(
-                packet_size.payload_size(),
-                packet_payload,
-                &route,
-                &destination,
-                &delays,
-            )?,
-        };
+        let sphinx_packet = SphinxPacketBuilder::new()
+            .with_payload_size(packet_size.payload_size())
+            .build_packet(packet_payload, &route, &destination, &delays)
+            .unwrap();

        // from the previously constructed route extract the first hop
        let first_hop_address =
@@ -269,7 +220,7 @@ pub trait FragmentPreparer {
            // well as the total delay of the ack packet.
            // note that the last hop of the packet is a gateway that does not do any delays
            total_delay: delays.iter().take(delays.len() - 1).sum::<Delay>() + ack_delay,
-            mix_packet: MixPacket::new(first_hop_address, packet, packet_type),
+            mix_packet: MixPacket::new(first_hop_address, sphinx_packet, Default::default()),
            fragment_identifier,
        })
    }
@@ -366,18 +317,11 @@ where
        topology: &NymTopology,
        ack_key: &AckKey,
        reply_surb: ReplySurb,
-        packet_type: PacketType,
    ) -> Result<PreparedFragment, NymTopologyError> {
        let sender = self.sender_address;

        <Self as FragmentPreparer>::prepare_reply_chunk_for_sending(
-            self,
-            fragment,
-            topology,
-            ack_key,
-            reply_surb,
-            &sender,
-            packet_type,
+            self, fragment, topology, ack_key, reply_surb, &sender,
        )
    }

@@ -387,7 +331,6 @@ where
        topology: &NymTopology,
        ack_key: &AckKey,
        packet_recipient: &Recipient,
-        packet_type: PacketType,
    ) -> Result<PreparedFragment, NymTopologyError> {
        let sender = self.sender_address;

@@ -398,7 +341,6 @@ where
            ack_key,
            &sender,
            packet_recipient,
-            packet_type,
        )
    }

@@ -408,17 +350,9 @@ where
        fragment_id: FragmentIdentifier,
        topology: &NymTopology,
        ack_key: &AckKey,
-        packet_type: PacketType,
    ) -> Result<SurbAck, NymTopologyError> {
        let sender = self.sender_address;
-        <Self as FragmentPreparer>::generate_surb_ack(
-            self,
-            &sender,
-            fragment_id,
-            topology,
-            ack_key,
-            packet_type,
-        )
+        <Self as FragmentPreparer>::generate_surb_ack(self, &sender, fragment_id, topology, ack_key)
    }

    pub fn pad_and_split_message(
@@ -6,7 +6,7 @@ use nym_crypto::asymmetric::encryption;
 use nym_crypto::shared_key::new_ephemeral_shared_key;
 use nym_crypto::symmetric::stream_cipher;
 use nym_crypto::symmetric::stream_cipher::CipherKey;
-use nym_sphinx_acknowledgements::surb_ack::{SurbAck, SurbAckRecoveryError};
+use nym_sphinx_acknowledgements::surb_ack::SurbAck;
 use nym_sphinx_anonymous_replies::SurbEncryptionKey;
 use nym_sphinx_chunking::fragment::Fragment;
 use nym_sphinx_params::{
@@ -14,25 +14,25 @@ use nym_sphinx_params::{
 };
 use rand::{CryptoRng, RngCore};

-pub struct NymPayloadBuilder {
+pub struct NymsphinxPayloadBuilder {
    fragment: Fragment,
    surb_ack: SurbAck,
 }

-impl NymPayloadBuilder {
+impl NymsphinxPayloadBuilder {
    pub fn new(fragment: Fragment, surb_ack: SurbAck) -> Self {
-        NymPayloadBuilder { fragment, surb_ack }
+        NymsphinxPayloadBuilder { fragment, surb_ack }
    }

    fn build<C>(
        self,
        packet_encryption_key: &CipherKey<C>,
        variant_data: impl IntoIterator<Item = u8>,
-    ) -> Result<NymPayload, SurbAckRecoveryError>
+    ) -> NymsphinxPayload
    where
        C: StreamCipher + KeyIvInit,
    {
-        let (_, surb_ack_bytes) = self.surb_ack.prepare_for_sending()?;
+        let (_, surb_ack_bytes) = self.surb_ack.prepare_for_sending();

        let mut fragment_data = self.fragment.into_bytes();
        stream_cipher::encrypt_in_place::<C>(
@@ -46,20 +46,16 @@ impl NymPayloadBuilder {
        // where variant-specific data is as follows:
        // for replies it would be the digest of the encryption key used
        // for 'regular' messages it would be the public component used in DH later used in the KDF
-
-        Ok(NymPayload(
+        NymsphinxPayload(
            surb_ack_bytes
                .into_iter()
                .chain(variant_data.into_iter())
                .chain(fragment_data.into_iter())
                .collect(),
-        ))
+        )
    }

-    pub fn build_reply(
-        self,
-        packet_encryption_key: &SurbEncryptionKey,
-    ) -> Result<NymPayload, SurbAckRecoveryError> {
+    pub fn build_reply(self, packet_encryption_key: &SurbEncryptionKey) -> NymsphinxPayload {
        let key_digest = packet_encryption_key.compute_digest();
        self.build::<ReplySurbEncryptionAlgorithm>(
            packet_encryption_key.inner(),
@@ -71,7 +67,7 @@ impl NymPayloadBuilder {
        self,
        rng: &mut R,
        recipient_encryption_key: &encryption::PublicKey,
-    ) -> Result<NymPayload, SurbAckRecoveryError>
+    ) -> NymsphinxPayload
    where
        R: RngCore + CryptoRng,
    {
@@ -92,9 +88,9 @@ impl NymPayloadBuilder {
 // the actual byte data that will be put into the sphinx packet paylaod.
 // no more transformations are going to happen to it
 // TODO: use that fact for some better compile time assertions
-pub struct NymPayload(Vec<u8>);
+pub struct NymsphinxPayload(Vec<u8>);

-impl AsRef<[u8]> for NymPayload {
+impl AsRef<[u8]> for NymsphinxPayload {
    fn as_ref(&self) -> &[u8] {
        &self.0
    }
@@ -7,6 +7,8 @@ use nym_crypto::asymmetric::encryption;
 use nym_crypto::shared_key::recompute_shared_key;
 use nym_crypto::symmetric::stream_cipher;
 use nym_crypto::symmetric::stream_cipher::CipherKey;
+use nym_outfox::error::OutfoxError;
+use nym_outfox::lion::lion_transform_decrypt;
 use nym_sphinx_anonymous_replies::requests::AnonymousSenderTag;
 use nym_sphinx_anonymous_replies::SurbEncryptionKey;
 use nym_sphinx_chunking::fragment::Fragment;
@@ -74,6 +76,49 @@ pub enum MessageRecoveryError {

    #[error("Failed to recover message fragment - {0}")]
    FragmentRecoveryError(#[from] ChunkingError),
+
+    #[error("Outfox: {source}")]
+    OutfoxRecoveryError {
+        #[from]
+        source: OutfoxError,
+    },
+}
+
+#[derive(Default)]
+pub struct OutfoxMessageReceiver {
+    reconstructor: MessageReconstructor,
+}
+
+impl OutfoxMessageReceiver {
+    pub fn new() -> Self {
+        Default::default()
+    }
+}
+
+impl MessageReceiver for OutfoxMessageReceiver {
+    fn new() -> Self {
+        Self::default()
+    }
+
+    fn reconstructor(&mut self) -> &mut MessageReconstructor {
+        &mut self.reconstructor
+    }
+
+    fn num_mix_hops(&self) -> u8 {
+        DEFAULT_NUM_MIX_HOPS
+    }
+
+    fn decrypt_raw_message<C>(
+        &self,
+        message: &mut [u8],
+        key: &CipherKey<C>,
+    ) -> Result<(), MessageRecoveryError>
+    where
+        C: StreamCipher + KeyIvInit,
+    {
+        lion_transform_decrypt(message, key)?;
+        Ok(())
+    }
 }

 pub trait MessageReceiver {
@@ -9,5 +9,6 @@ repository = { workspace = true }

 [dependencies]
 sphinx-packet = { version = "0.1.0" }
-nym-outfox = { path = "../../../nym-outfox" }
-thiserror = "1"
+
+#[patch.crates-io]
+#sphinx-packet = { path = "../../../../sphinx" }
@@ -1,12 +1,7 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-pub use nym_outfox::{
-    constants::MIN_PACKET_SIZE, constants::MIX_PARAMS_LEN, constants::OUTFOX_PACKET_OVERHEAD,
-    error::OutfoxError,
-};
 // re-exporting types and constants available in sphinx
-use nym_outfox::packet::{OutfoxPacket, OutfoxProcessedPacket};
 pub use sphinx_packet::{
    constants::{
        self, DESTINATION_ADDRESS_LENGTH, IDENTIFIER_LENGTH, MAX_PATH_LENGTH, NODE_ADDRESS_LENGTH,
@@ -14,123 +9,9 @@ pub use sphinx_packet::{
    },
    crypto::{self, EphemeralSecret, PrivateKey, PublicKey, SharedSecret},
    header::{self, delays, delays::Delay, ProcessedHeader, SphinxHeader, HEADER_SIZE},
-    packet::builder::DEFAULT_PAYLOAD_SIZE,
+    packet::builder::{self, DEFAULT_PAYLOAD_SIZE},
    payload::{Payload, PAYLOAD_OVERHEAD_SIZE},
    route::{Destination, DestinationAddressBytes, Node, NodeAddressBytes, SURBIdentifier},
    surb::{SURBMaterial, SURB},
-    Error as SphinxError, ProcessedPacket,
+    Error, ProcessedPacket, Result, SphinxPacket,
 };
-use sphinx_packet::{SphinxPacket, SphinxPacketBuilder};
-use std::{array::TryFromSliceError, fmt};
-use thiserror::Error;
-
-#[derive(Error, Debug)]
-pub enum NymPacketError {
-    #[error("Sphinx error: {0}")]
-    Sphinx(#[from] sphinx_packet::Error),
-
-    #[error("Outfox error: {0}")]
-    Outfox(#[from] nym_outfox::error::OutfoxError),
-
-    #[error("{0}")]
-    FromSlice(#[from] TryFromSliceError),
-}
-
-#[allow(clippy::large_enum_variant)]
-pub enum NymPacket {
-    Sphinx(SphinxPacket),
-    Outfox(OutfoxPacket),
-}
-
-pub enum NymProcessedPacket {
-    Sphinx(ProcessedPacket),
-    Outfox(OutfoxProcessedPacket),
-}
-
-impl fmt::Debug for NymPacket {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match &self {
-            NymPacket::Sphinx(packet) => f
-                .debug_struct("NymPacket::Sphinx")
-                .field("len", &packet.len())
-                .finish(),
-            NymPacket::Outfox(packet) => f
-                .debug_struct("NymPacket::Outfox")
-                .field("len", &packet.len())
-                .finish(),
-        }
-    }
-}
-
-impl NymPacket {
-    pub fn sphinx_build<M: AsRef<[u8]>>(
-        size: usize,
-        message: M,
-        route: &[Node],
-        destination: &Destination,
-        delays: &[Delay],
-    ) -> Result<NymPacket, NymPacketError> {
-        Ok(NymPacket::Sphinx(
-            SphinxPacketBuilder::new()
-                .with_payload_size(size)
-                .build_packet(message, route, destination, delays)?,
-        ))
-    }
-    pub fn sphinx_from_bytes(bytes: &[u8]) -> Result<NymPacket, NymPacketError> {
-        Ok(NymPacket::Sphinx(SphinxPacket::from_bytes(bytes)?))
-    }
-
-    pub fn outfox_build<M: AsRef<[u8]>>(
-        payload: M,
-        route: &[Node],
-        destination: &Destination,
-        size: Option<usize>,
-    ) -> Result<NymPacket, NymPacketError> {
-        Ok(NymPacket::Outfox(OutfoxPacket::build(
-            payload,
-            route.try_into()?,
-            destination,
-            size,
-        )?))
-    }
-
-    pub fn outfox_from_bytes(bytes: &[u8]) -> Result<NymPacket, NymPacketError> {
-        Ok(NymPacket::Outfox(OutfoxPacket::try_from(bytes)?))
-    }
-
-    pub fn len(&self) -> usize {
-        match self {
-            NymPacket::Sphinx(packet) => packet.len(),
-            NymPacket::Outfox(packet) => packet.len(),
-        }
-    }
-
-    pub fn is_empty(&self) -> bool {
-        self.len() == 0
-    }
-
-    pub fn to_bytes(&self) -> Result<Vec<u8>, NymPacketError> {
-        match self {
-            NymPacket::Sphinx(packet) => Ok(packet.to_bytes()),
-            NymPacket::Outfox(packet) => Ok(packet.to_bytes()?),
-        }
-    }
-
-    pub fn process(
-        self,
-        node_secret_key: &PrivateKey,
-    ) -> Result<NymProcessedPacket, NymPacketError> {
-        match self {
-            NymPacket::Sphinx(packet) => {
-                Ok(NymProcessedPacket::Sphinx(packet.process(node_secret_key)?))
-            }
-            NymPacket::Outfox(mut packet) => {
-                let next_address = packet.decode_next_layer(node_secret_key)?;
-                Ok(NymProcessedPacket::Outfox(OutfoxProcessedPacket::new(
-                    packet,
-                    next_address,
-                )))
-            }
-        }
-    }
-}
@@ -5,7 +5,7 @@ use crate::config::{Config, Socks5};
 use crate::error::Socks5ClientCoreError;
 use crate::socks::{
    authentication::{AuthenticationMethods, Authenticator, User},
-    server::NymSocksServer,
+    server::SphinxSocksServer,
 };
 use futures::channel::mpsc;
 use futures::StreamExt;
@@ -19,7 +19,6 @@ use nym_client_core::client::replies::reply_storage::ReplyStorageBackend;
 use nym_client_core::config::DebugConfig;
 use nym_credential_storage::storage::Storage as CredentialStorage;
 use nym_sphinx::addressing::clients::Recipient;
-use nym_sphinx::params::PacketType;
 use nym_task::{TaskClient, TaskManager};
 use std::error::Error;

@@ -65,7 +64,6 @@ where
        NymClient { config, storage }
    }

-    #[allow(clippy::too_many_arguments)]
    pub fn start_socks5_listener(
        socks5_config: &Socks5,
        debug_config: DebugConfig,
@@ -74,7 +72,6 @@ where
        client_status: ClientState,
        self_address: Recipient,
        shutdown: TaskClient,
-        packet_type: PacketType,
    ) {
        info!("Starting socks5 listener...");
        let auth_methods = vec![AuthenticationMethods::NoAuth as u8];
@@ -100,7 +97,7 @@ where
            .unwrap_or(debug_config.traffic.primary_packet_size);

        let authenticator = Authenticator::new(auth_methods, allowed_users);
-        let mut sphinx_socks = NymSocksServer::new(
+        let mut sphinx_socks = SphinxSocksServer::new(
            socks5_config.get_listening_port(),
            authenticator,
            socks5_config.get_provider_mix_address(),
@@ -115,7 +112,6 @@ where
                socks5_config.get_per_request_surbs(),
            ),
            shutdown.clone(),
-            packet_type,
        );
        nym_task::spawn_with_report_error(
            async move {
@@ -207,18 +203,12 @@ where
            reply_storage_backend,
        );

-        let packet_type = self.config.get_base().get_packet_type();
-        let mut started_client = base_builder.start_base(packet_type).await?;
+        let mut started_client = base_builder.start_base().await?;
        let self_address = started_client.address;
        let client_input = started_client.client_input.register_producer();
        let client_output = started_client.client_output.register_consumer();
        let client_state = started_client.client_state;

-        info!(
-            "Running with {:?} packets",
-            self.config.get_base().get_packet_type()
-        );
-
        Self::start_socks5_listener(
            self.config.get_socks5(),
            *self.config.get_debug_settings(),
@@ -227,7 +217,6 @@ where
            client_state,
            self_address,
            started_client.task_manager.subscribe(),
-            self.config.get_base().get_packet_type(),
        );

        info!("Client startup finished!");
@@ -18,7 +18,6 @@ use nym_socks5_requests::{
 };
 use nym_sphinx::addressing::clients::Recipient;
 use nym_sphinx::params::PacketSize;
-use nym_sphinx::params::PacketType;
 use nym_task::connections::{LaneQueueLengths, TransmissionLane};
 use nym_task::TaskClient;
 use pin_project::pin_project;
@@ -186,7 +185,6 @@ pub(crate) struct SocksClient {
    started_proxy: bool,
    lane_queue_lengths: LaneQueueLengths,
    shutdown_listener: TaskClient,
-    packet_type: Option<PacketType>,
 }

 impl Drop for SocksClient {
@@ -215,7 +213,6 @@ impl SocksClient {
        self_address: &Recipient,
        lane_queue_lengths: LaneQueueLengths,
        mut shutdown_listener: TaskClient,
-        packet_type: Option<PacketType>,
    ) -> Self {
        // If this task fails and exits, we don't want to send shutdown signal
        shutdown_listener.mark_as_success();
@@ -236,7 +233,6 @@ impl SocksClient {
            started_proxy: false,
            lane_queue_lengths,
            shutdown_listener,
-            packet_type,
        }
    }

@@ -353,7 +349,6 @@ impl SocksClient {
            msg.into_bytes(),
            self.config.connection_start_surbs,
            TransmissionLane::ConnectionId(self.connection_id),
-            self.packet_type,
        );
        self.input_sender
            .send(input_message)
@@ -376,7 +371,6 @@ impl SocksClient {
            self.service_provider,
            msg.into_bytes(),
            TransmissionLane::ConnectionId(self.connection_id),
-            self.packet_type,
        );
        self.input_sender
            .send(input_message)
@@ -414,7 +408,6 @@ impl SocksClient {
        let request_version = self.config.request_version();

        let recipient = self.service_provider;
-        let packet_type = self.packet_type;
        let (stream, _) = ProxyRunner::new(
            stream,
            local_stream_remote,
@@ -446,15 +439,9 @@ impl SocksClient {
                    provider_message.into_bytes(),
                    per_request_surbs,
                    lane,
-                    packet_type,
                )
            } else {
-                InputMessage::new_regular(
-                    recipient,
-                    provider_message.into_bytes(),
-                    lane,
-                    packet_type,
-                )
+                InputMessage::new_regular(recipient, provider_message.into_bytes(), lane)
            }
        })
        .await
@@ -10,7 +10,6 @@ use nym_client_core::client::{
 };
 use nym_socks5_proxy_helpers::connection_controller::Controller;
 use nym_sphinx::addressing::clients::Recipient;
-use nym_sphinx::params::PacketType;
 use nym_task::connections::{ConnectionCommandSender, LaneQueueLengths};
 use nym_task::TaskClient;
 use std::net::SocketAddr;
@@ -18,7 +17,7 @@ use tap::TapFallible;
 use tokio::net::TcpListener;

 /// A Socks5 server that listens for connections.
-pub struct NymSocksServer {
+pub struct SphinxSocksServer {
    authenticator: Authenticator,
    listening_address: SocketAddr,
    service_provider: Recipient,
@@ -26,12 +25,10 @@ pub struct NymSocksServer {
    client_config: client::Config,
    lane_queue_lengths: LaneQueueLengths,
    shutdown: TaskClient,
-    packet_type: PacketType,
 }

-impl NymSocksServer {
+impl SphinxSocksServer {
    /// Create a new SphinxSocks instance
-    #[allow(clippy::too_many_arguments)]
    pub(crate) fn new(
        port: u16,
        authenticator: Authenticator,
@@ -40,13 +37,12 @@ impl NymSocksServer {
        lane_queue_lengths: LaneQueueLengths,
        client_config: client::Config,
        shutdown: TaskClient,
-        packet_type: PacketType,
    ) -> Self {
        // hardcode ip as we (presumably) ONLY want to listen locally. If we change it, we can
        // just modify the config
        let ip = "127.0.0.1";
        info!("Listening on {}:{}", ip, port);
-        NymSocksServer {
+        SphinxSocksServer {
            authenticator,
            listening_address: format!("{ip}:{port}").parse().unwrap(),
            service_provider,
@@ -54,7 +50,6 @@ impl NymSocksServer {
            client_config,
            lane_queue_lengths,
            shutdown,
-            packet_type,
        }
    }

@@ -109,7 +104,6 @@ impl NymSocksServer {
                        &self.self_address,
                        self.lane_queue_lengths.clone(),
                        self.shutdown.clone(),
-                        Some(self.packet_type)
                    );

                    tokio::spawn(async move {
@@ -125,8 +119,8 @@ impl NymSocksServer {
                    });
                },
                _ = self.shutdown.recv() => {
-                    log::trace!("NymSocksServer: Received shutdown");
-                    log::debug!("NymSocksServer: Exiting");
+                    log::trace!("SphinxSocksServer: Received shutdown");
+                    log::debug!("SphinxSocksServer: Exiting");
                    return Ok(());
                }
            }
@@ -1,13 +1,10 @@
 // Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use std::array::TryFromSliceError;
-
 use crate::MixLayer;
-use nym_sphinx_types::NymPacketError;
 use thiserror::Error;

-#[derive(Debug, Error)]
+#[derive(Debug, Clone, Error)]
 pub enum NymTopologyError {
    #[error("The provided network topology is empty - there are no mixnodes and no gateways on it - the network request(s) probably failed")]
    EmptyNetworkTopology,
@@ -36,16 +33,4 @@ pub enum NymTopologyError {
        total_nodes: usize,
        layer_distribution: Vec<(MixLayer, usize)>,
    },
-    // We can't import SurbAckRecoveryError due to cyclic dependency, this is a bit dirty
-    #[error("Could not build payload")]
-    PayloadBuilder,
-
-    #[error("Outfox: {0}")]
-    Outfox(#[from] nym_sphinx_types::OutfoxError),
-
-    #[error("{0}")]
-    FromSlice(#[from] TryFromSliceError),
-
-    #[error("{0}")]
-    PacketError(#[from] NymPacketError),
 }
@@ -2,16 +2,6 @@
 # It is not intended for manual editing.
 version = 3

-[[package]]
-name = "aead"
-version = "0.5.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d122413f284cf2d62fb1b7db97e02edb8cda96d769b16e443a4f6195e35662b0"
-dependencies = [
- "crypto-common",
- "generic-array 0.14.6",
-]
-
 [[package]]
 name = "aes"
 version = "0.7.5"
@@ -19,7 +9,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9e8b47f52ea9bae42228d07ec09eb676433d7c4ed1ebdf0f1d1c29ed446f1ab8"
 dependencies = [
 "cfg-if",
- "cipher 0.3.0",
+ "cipher",
 "cpufeatures",
 "ctr",
 "opaque-debug 0.3.0",
@@ -48,12 +38,6 @@ version = "0.3.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6b4930d2cb77ce62f89ee5d5289b4ac049559b1c45539271f5ed4fdc7db34545"

-[[package]]
-name = "arrayvec"
-version = "0.7.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8da52d66c7071e2e3fa2a1e5c6d088fec47b593032b254f5e980de8ea54454d6"
-
 [[package]]
 name = "autocfg"
 version = "1.1.0"
@@ -102,20 +86,6 @@ dependencies = [
 "opaque-debug 0.2.3",
 ]

-[[package]]
-name = "blake3"
-version = "1.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "42ae2468a89544a466886840aa467a25b766499f4f04bf7d9fcd10ecee9fccef"
-dependencies = [
- "arrayref",
- "arrayvec",
- "cc",
- "cfg-if",
- "constant_time_eq",
- "digest 0.10.7",
-]
-
 [[package]]
 name = "block-buffer"
 version = "0.9.0"
@@ -189,30 +159,6 @@ dependencies = [
 "keystream",
 ]

-[[package]]
-name = "chacha20"
-version = "0.9.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c3613f74bd2eac03dad61bd53dbe620703d4371614fe0bc3b9f04dd36fe4e818"
-dependencies = [
- "cfg-if",
- "cipher 0.4.4",
- "cpufeatures",
-]
-
-[[package]]
-name = "chacha20poly1305"
-version = "0.10.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "10cd79432192d1c0f4e1a0fef9527696cc039165d729fb41b3f4f4f354c2dc35"
-dependencies = [
- "aead",
- "chacha20",
- "cipher 0.4.4",
- "poly1305",
- "zeroize",
-]
-
 [[package]]
 name = "cipher"
 version = "0.3.0"
@@ -222,17 +168,6 @@ dependencies = [
 "generic-array 0.14.6",
 ]

-[[package]]
-name = "cipher"
-version = "0.4.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "773f3b9af64447d2ce9850330c473515014aa235e6a783b02db81ff39e4a3dad"
-dependencies = [
- "crypto-common",
- "inout",
- "zeroize",
-]
-
 [[package]]
 name = "coconut-test"
 version = "0.1.0"
@@ -264,12 +199,6 @@ version = "0.9.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "520fbf3c07483f94e3e3ca9d0cfd913d7718ef2483d2cfd91c0d9e91474ab913"

-[[package]]
-name = "constant_time_eq"
-version = "0.2.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "13418e745008f7349ec7e449155f419a61b92b58a99cc3616942b926825ec76b"
-
 [[package]]
 name = "cosmwasm-crypto"
 version = "1.2.5"
@@ -355,49 +284,6 @@ dependencies = [
 "libc",
 ]

-[[package]]
-name = "crossbeam-channel"
-version = "0.5.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a33c2bf77f2df06183c3aa30d1e96c0695a313d4f9c453cc3762a6db39f99200"
-dependencies = [
- "cfg-if",
- "crossbeam-utils",
-]
-
-[[package]]
-name = "crossbeam-deque"
-version = "0.8.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ce6fd6f855243022dcecf8702fef0c297d4338e226845fe067f6341ad9fa0cef"
-dependencies = [
- "cfg-if",
- "crossbeam-epoch",
- "crossbeam-utils",
-]
-
-[[package]]
-name = "crossbeam-epoch"
-version = "0.9.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46bd5f3f85273295a9d14aedfb86f6aadbff6d8f5295c4a9edb08e819dcf5695"
-dependencies = [
- "autocfg",
- "cfg-if",
- "crossbeam-utils",
- "memoffset",
- "scopeguard",
-]
-
-[[package]]
-name = "crossbeam-utils"
-version = "0.8.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c063cd8cc95f5c377ed0d4b49a4b21f632396ff690e8470c29b3359b346984b"
-dependencies = [
- "cfg-if",
-]
-
 [[package]]
 name = "crunchy"
 version = "0.2.2"
@@ -423,7 +309,6 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
 dependencies = [
 "generic-array 0.14.6",
- "rand_core 0.6.4",
 "typenum",
 ]

@@ -453,7 +338,7 @@ version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "049bb91fb4aaf0e3c7efa6cd5ef877dbbbd15b39dad06d9948de4ec8a75761ea"
 dependencies = [
- "cipher 0.3.0",
+ "cipher",
 ]

 [[package]]
@@ -1002,10 +887,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c05aeb6a22b8f62540c194aac980f2115af067bfe15a0734d7277a768d396b31"
 dependencies = [
 "cfg-if",
- "js-sys",
 "libc",
 "wasi 0.11.0+wasi-snapshot-preview1",
- "wasm-bindgen",
 ]

 [[package]]
@@ -1053,15 +936,6 @@ dependencies = [
 "ahash",
 ]

-[[package]]
-name = "hermit-abi"
-version = "0.2.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ee512640fe35acbfb4bb779db6f0d80704c2cacfa2e39b601ef3e3f47d1ae4c7"
-dependencies = [
- "libc",
-]
-
 [[package]]
 name = "hermit-abi"
 version = "0.3.1"
@@ -1129,15 +1003,6 @@ dependencies = [
 "unicode-normalization",
 ]

-[[package]]
-name = "inout"
-version = "0.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a0c10553d664a4d0bcff9f4215d0aac67a639cc68ef660840afe309b807bc9f5"
-dependencies = [
- "generic-array 0.14.6",
-]
-
 [[package]]
 name = "instant"
 version = "0.1.12"
@@ -1153,7 +1018,7 @@ version = "1.0.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9c66c74d2ae7e79a5a8f7ac924adbe38ee42a859c6539ad869eb51f0b52dc220"
 dependencies = [
- "hermit-abi 0.3.1",
+ "hermit-abi",
 "libc",
 "windows-sys 0.48.0",
 ]
@@ -1284,15 +1149,6 @@ version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"

-[[package]]
-name = "memoffset"
-version = "0.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d61c719bcfbcf5d62b3a09efa6088de8c54bc0bfcd3ea7ae39fcc186108b8de1"
-dependencies = [
- "autocfg",
-]
-
 [[package]]
 name = "mixnet-vesting-integration-tests"
 version = "0.1.0"
@@ -1319,16 +1175,6 @@ dependencies = [
 "libm",
 ]

-[[package]]
-name = "num_cpus"
-version = "1.15.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fac9e2da13b5eb447a6ce3d392f23a29d8694bff781bf03a16cd9ac8697593b"
-dependencies = [
- "hermit-abi 0.2.6",
- "libc",
-]
-
 [[package]]
 name = "nym-coconut-bandwidth"
 version = "0.1.0"
@@ -1509,23 +1355,6 @@ dependencies = [
 "serde",
 ]

-[[package]]
-name = "nym-outfox"
-version = "0.1.0"
-dependencies = [
- "blake3",
- "chacha20",
- "chacha20poly1305",
- "curve25519-dalek",
- "getrandom 0.2.8",
- "log",
- "rand 0.7.3",
- "rayon",
- "sphinx-packet",
- "thiserror",
- "zeroize",
-]
-
 [[package]]
 name = "nym-pemstore"
 version = "0.2.0"
@@ -1565,9 +1394,7 @@ dependencies = [
 name = "nym-sphinx-types"
 version = "0.2.0"
 dependencies = [
- "nym-outfox",
 "sphinx-packet",
- "thiserror",
 ]

 [[package]]
@@ -1667,17 +1494,6 @@ version = "0.3.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6ac9a59f73473f1b8d852421e59e64809f025994837ef743615c6d0c5b305160"

-[[package]]
-name = "poly1305"
-version = "0.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8159bd90725d2df49889a078b54f4f79e87f1f8a8444194cdca81d38f5393abf"
-dependencies = [
- "cpufeatures",
- "opaque-debug 0.3.0",
- "universal-hash",
-]
-
 [[package]]
 name = "ppv-lite86"
 version = "0.2.17"
@@ -1836,28 +1652,6 @@ dependencies = [
 "rand_core 0.5.1",
 ]

-[[package]]
-name = "rayon"
-version = "1.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d2df5196e37bcc87abebc0053e20787d73847bb33134a69841207dd0a47f03b"
-dependencies = [
- "either",
- "rayon-core",
-]
-
-[[package]]
-name = "rayon-core"
-version = "1.11.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4b8f95bd6966f5c87776639160a66bd8ab9895d9d4ab01ddba9fc60661aebe8d"
-dependencies = [
- "crossbeam-channel",
- "crossbeam-deque",
- "crossbeam-utils",
- "num_cpus",
-]
-
 [[package]]
 name = "redox_syscall"
 version = "0.3.5"
@@ -1990,12 +1784,6 @@ dependencies = [
 "syn 1.0.109",
 ]

-[[package]]
-name = "scopeguard"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
-
 [[package]]
 name = "sec1"
 version = "0.3.0"
@@ -2327,16 +2115,6 @@ dependencies = [
 "tinyvec",
 ]

-[[package]]
-name = "universal-hash"
-version = "0.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc1de2c688dc15305988b563c3854064043356019f97a4b46276fe734c4f07ea"
-dependencies = [
- "crypto-common",
- "subtle 2.4.1",
-]
-
 [[package]]
 name = "url"
 version = "2.3.1"
@@ -5,7 +5,6 @@ use crate::authentication::encrypted_address::EncryptedAddressBytes;
 use crate::iv::IV;
 use crate::registration::handshake::SharedKeys;
 use crate::{GatewayMacSize, PROTOCOL_VERSION};
-use log::error;
 use nym_coconut_interface::Credential;
 use nym_crypto::generic_array::typenum::Unsigned;
 use nym_crypto::hmac::recompute_keyed_hmac_and_verify_tag;
@@ -291,13 +290,7 @@ impl BinaryRequest {
    pub fn into_encrypted_tagged_bytes(self, shared_key: &SharedKeys) -> Vec<u8> {
        match self {
            BinaryRequest::ForwardSphinx(mix_packet) => {
-                let forwarding_data = match mix_packet.into_bytes() {
-                    Ok(mix_packet) => mix_packet,
-                    Err(e) => {
-                        error!("Could not convert packet to bytes: {e}");
-                        return vec![];
-                    }
-                };
+                let forwarding_data = mix_packet.into_bytes();

                // TODO: it could be theoretically slightly more efficient if the data wasn't taken
                // by reference because then it makes a copy for encryption rather than do it in place
@@ -283,7 +283,7 @@ where
        &self,
        mix_packet: MixPacket,
    ) -> Result<ServerResponse, RequestHandlingError> {
-        let consumed_bandwidth = mix_packet.packet().len() as i64;
+        let consumed_bandwidth = mix_packet.sphinx_packet().len() as i64;

        let available_bandwidth = self.get_available_bandwidth().await?;

@@ -309,10 +309,7 @@ where
    async fn handle_binary(&self, bin_msg: Vec<u8>) -> Message {
        // this function decrypts the request and checks the MAC
        match BinaryRequest::try_from_encrypted_tagged_bytes(bin_msg, &self.client.shared_keys) {
-            Err(e) => {
-                error!("{e}");
-                RequestHandlingError::InvalidBinaryRequest(e).into_error_message()
-            }
+            Err(e) => RequestHandlingError::InvalidBinaryRequest(e).into_error_message(),
            Ok(request) => match request {
                // currently only a single type exists
                BinaryRequest::ForwardSphinx(mix_packet) => self
@@ -11,8 +11,8 @@ use log::*;
 use nym_mixnet_client::forwarder::MixForwardingSender;
 use nym_mixnode_common::packet_processor::processor::ProcessedFinalHop;
 use nym_sphinx::forwarding::packet::MixPacket;
-use nym_sphinx::framing::codec::NymCodec;
-use nym_sphinx::framing::packet::FramedNymPacket;
+use nym_sphinx::framing::codec::SphinxCodec;
+use nym_sphinx::framing::packet::FramedSphinxPacket;
 use nym_sphinx::DestinationAddressBytes;
 use nym_task::TaskClient;
 use std::collections::HashMap;
@@ -155,7 +155,7 @@ impl<St: Storage> ConnectionHandler<St> {
        self.forward_ack(forward_ack, client_address);
    }

-    async fn handle_received_packet(&mut self, framed_sphinx_packet: FramedNymPacket) {
+    async fn handle_received_packet(&mut self, framed_sphinx_packet: FramedSphinxPacket) {
        //
        // TODO: here be replay attack detection - it will require similar key cache to the one in
        // packet processor for vpn packets,
@@ -182,7 +182,7 @@ impl<St: Storage> ConnectionHandler<St> {
    ) {
        debug!("Starting connection handler for {:?}", remote);
        shutdown.mark_as_success();
-        let mut framed_conn = Framed::new(conn, NymCodec);
+        let mut framed_conn = Framed::new(conn, SphinxCodec);
        while !shutdown.is_shutdown() {
            tokio::select! {
                biased;
@@ -5,7 +5,7 @@ use nym_crypto::asymmetric::encryption;
 use nym_mixnode_common::packet_processor::error::MixProcessingError;
 pub use nym_mixnode_common::packet_processor::processor::MixProcessingResult;
 use nym_mixnode_common::packet_processor::processor::{ProcessedFinalHop, SphinxPacketProcessor};
-use nym_sphinx::framing::packet::FramedNymPacket;
+use nym_sphinx::framing::packet::FramedSphinxPacket;
 use thiserror::Error;

 #[derive(Error, Debug)]
@@ -32,7 +32,7 @@ impl PacketProcessor {

    pub(crate) fn process_received(
        &self,
-        received: FramedNymPacket,
+        received: FramedSphinxPacket,
    ) -> Result<ProcessedFinalHop, GatewayProcessingError> {
        match self.inner_processor.process_received(received)? {
            MixProcessingResult::ForwardHop(..) => {
@@ -51,7 +51,6 @@ nym-mixnet-client = { path = "../common/client-libs/mixnet-client" }
 nym-mixnode-common = { path = "../common/mixnode-common" }
 nym-nonexhaustive-delayqueue = { path = "../common/nonexhaustive-delayqueue" }
 nym-sphinx = { path = "../common/nymsphinx" }
-nym-sphinx-params = { path = "../common/nymsphinx/params" }
 nym-pemstore = { path = "../common/pemstore", version = "0.2.0" }
 nym-task = { path = "../common/task" }
 nym-types = { path = "../common/types" }
@@ -51,14 +51,9 @@ fn test_function() {
 async fn main() {
    cfg_if::cfg_if! {
        if #[cfg(feature = "cpucycles")] {
-            let home_dir = dirs::home_dir().expect("Could not get $HOME");
-            let logs_dir = home_dir.join(".nym").join("logs");
-            let logs_dir_str = logs_dir.to_str().expect("Could not construct logs path");
-            setup_tracing!(logs_dir_str);
-            info!("CPU cycles measurement is ON")
+            setup_tracing!("/tmp/tracing.log");
        } else {
            setup_logging();
-            info!("CPU cycles measurement is OFF")
        }
    }

@@ -9,8 +9,8 @@ use crate::node::TaskClient;
 use futures::StreamExt;
 use nym_mixnode_common::measure;
 use nym_sphinx::forwarding::packet::MixPacket;
-use nym_sphinx::framing::codec::NymCodec;
-use nym_sphinx::framing::packet::FramedNymPacket;
+use nym_sphinx::framing::codec::SphinxCodec;
+use nym_sphinx::framing::packet::FramedSphinxPacket;
 use nym_sphinx::Delay as SphinxDelay;
 use std::net::SocketAddr;
 use tokio::net::TcpStream;
@@ -54,7 +54,7 @@ impl ConnectionHandler {
        feature = "cpucycles",
        instrument(skip(self, framed_sphinx_packet), fields(cpucycles))
    )]
-    fn handle_received_packet(&self, framed_sphinx_packet: FramedNymPacket) {
+    fn handle_received_packet(&self, framed_sphinx_packet: FramedSphinxPacket) {
        //
        // TODO: here be replay attack detection - it will require similar key cache to the one in
        // packet processor for vpn packets,
@@ -86,7 +86,7 @@ impl ConnectionHandler {
    ) {
        debug!("Starting connection handler for {:?}", remote);
        shutdown.mark_as_success();
-        let mut framed_conn = Framed::new(conn, NymCodec);
+        let mut framed_conn = Framed::new(conn, SphinxCodec);
        while !shutdown.is_shutdown() {
            tokio::select! {
                biased;
@@ -108,7 +108,7 @@ impl ConnectionHandler {
                        }
                        Some(Err(err)) => {
                            error!(
-                                "{remote:?} - The socket connection got corrupted with error: {err}. Closing the socket",
+                                "The socket connection got corrupted with error: {err}. Closing the socket",
                            );
                            return;
                        }
@@ -6,7 +6,7 @@ use nym_crypto::asymmetric::encryption;
 use nym_mixnode_common::packet_processor::error::MixProcessingError;
 pub use nym_mixnode_common::packet_processor::processor::MixProcessingResult;
 use nym_mixnode_common::packet_processor::processor::SphinxPacketProcessor;
-use nym_sphinx::framing::packet::FramedNymPacket;
+use nym_sphinx::framing::packet::FramedSphinxPacket;

 // PacketProcessor contains all data required to correctly unwrap and forward sphinx packets
 #[derive(Clone)]
@@ -31,7 +31,7 @@ impl PacketProcessor {

    pub(crate) fn process_received(
        &self,
-        received: FramedNymPacket,
+        received: FramedSphinxPacket,
    ) -> Result<MixProcessingResult, MixProcessingError> {
        self.node_stats_update_sender.report_received();
        self.inner_processor.process_received(received)
@@ -58,12 +58,12 @@ where

    fn forward_packet(&mut self, packet: MixPacket) {
        let next_hop = packet.next_hop();
-        let packet_type = packet.packet_type();
-        let packet = packet.into_packet();
+        let packet_mode = packet.packet_mode();
+        let sphinx_packet = packet.into_sphinx_packet();

-        if let Err(err) = self
-            .mixnet_client
-            .send_without_response(next_hop, packet, packet_type)
+        if let Err(err) =
+            self.mixnet_client
+                .send_without_response(next_hop, sphinx_packet, packet_mode)
        {
            if err.kind() == io::ErrorKind::WouldBlock {
                // we only know for sure if we dropped a packet if our sending queue was full
@@ -134,38 +134,38 @@ mod tests {
    use std::sync::{Arc, Mutex};
    use std::time::Duration;

-    use nym_sphinx::NymPacket;
    use nym_task::TaskManager;

    use nym_sphinx::addressing::nodes::NymNodeRoutingAddress;
    use nym_sphinx_params::packet_sizes::PacketSize;
-    use nym_sphinx_params::PacketType;
+    use nym_sphinx_params::PacketMode;
+    use nym_sphinx_types::builder::SphinxPacketBuilder;
    use nym_sphinx_types::{
        crypto, Delay as SphinxDelay, Destination, DestinationAddressBytes, Node, NodeAddressBytes,
-        DESTINATION_ADDRESS_LENGTH, IDENTIFIER_LENGTH, NODE_ADDRESS_LENGTH,
+        SphinxPacket, DESTINATION_ADDRESS_LENGTH, IDENTIFIER_LENGTH, NODE_ADDRESS_LENGTH,
    };

    #[derive(Default)]
    struct TestClient {
-        pub packets_sent: Arc<Mutex<Vec<(NymNodeRoutingAddress, NymPacket, PacketType)>>>,
+        pub packets_sent: Arc<Mutex<Vec<(NymNodeRoutingAddress, SphinxPacket, PacketMode)>>>,
    }

    impl nym_mixnet_client::SendWithoutResponse for TestClient {
        fn send_without_response(
            &mut self,
            address: NymNodeRoutingAddress,
-            packet: NymPacket,
-            packet_type: PacketType,
+            packet: SphinxPacket,
+            packet_mode: PacketMode,
        ) -> io::Result<()> {
            self.packets_sent
                .lock()
                .unwrap()
-                .push((address, packet, packet_type));
+                .push((address, packet, packet_mode));
            Ok(())
        }
    }

-    fn make_valid_sphinx_packet(size: PacketSize) -> NymPacket {
+    fn make_valid_sphinx_packet(size: PacketSize) -> SphinxPacket {
        let (_, node1_pk) = crypto::keygen();
        let node1 = Node::new(
            NodeAddressBytes::from_bytes([5u8; NODE_ADDRESS_LENGTH]),
@@ -192,45 +192,12 @@ mod tests {
            SphinxDelay::new_from_nanos(42),
            SphinxDelay::new_from_nanos(42),
        ];
-        NymPacket::sphinx_build(size.payload_size(), b"foomp", &route, &destination, &delays)
+        SphinxPacketBuilder::new()
+            .with_payload_size(size.payload_size())
+            .build_packet(b"foomp", &route, &destination, &delays)
            .unwrap()
    }

-    fn make_valid_outfox_packet(size: PacketSize) -> NymPacket {
-        let (_, node1_pk) = crypto::keygen();
-        let node1 = Node::new(
-            NodeAddressBytes::from_bytes([5u8; NODE_ADDRESS_LENGTH]),
-            node1_pk,
-        );
-        let (_, node2_pk) = crypto::keygen();
-        let node2 = Node::new(
-            NodeAddressBytes::from_bytes([4u8; NODE_ADDRESS_LENGTH]),
-            node2_pk,
-        );
-        let (_, node3_pk) = crypto::keygen();
-        let node3 = Node::new(
-            NodeAddressBytes::from_bytes([2u8; NODE_ADDRESS_LENGTH]),
-            node3_pk,
-        );
-
-        let (_, node4_pk) = crypto::keygen();
-        let node4 = Node::new(
-            NodeAddressBytes::from_bytes([2u8; NODE_ADDRESS_LENGTH]),
-            node4_pk,
-        );
-
-        let destination = Destination::new(
-            DestinationAddressBytes::from_bytes([3u8; DESTINATION_ADDRESS_LENGTH]),
-            [4u8; IDENTIFIER_LENGTH],
-        );
-
-        let route = &[node1, node2, node3, node4];
-
-        let payload = vec![1; 48];
-
-        NymPacket::outfox_build(payload, route, &destination, Some(size.plaintext_size())).unwrap()
-    }
-
    #[tokio::test]
    async fn packets_received_are_forwarded() {
        // Wire up the DelayForwarder
@@ -252,50 +219,7 @@ mod tests {
        let mix_packet = MixPacket::new(
            next_hop,
            make_valid_sphinx_packet(PacketSize::default()),
-            PacketType::default(),
-        );
-        let forward_instant = None;
-        packet_sender
-            .unbounded_send((mix_packet, forward_instant))
-            .unwrap();
-
-        // Give the the worker a chance to act
-        tokio::time::sleep(Duration::from_millis(10)).await;
-
-        // The client should have forwarded the packet straight away
-        assert_eq!(
-            client_packets_sent
-                .lock()
-                .unwrap()
-                .iter()
-                .map(|(a, _, _)| *a)
-                .collect::<Vec<_>>(),
-            vec![next_hop]
-        );
-    }
-
-    #[tokio::test]
-    async fn outfox_packets_received_are_forwarded() {
-        // Wire up the DelayForwarder
-        let (stats_sender, _stats_receiver) = mpsc::unbounded();
-        let node_stats_update_sender = UpdateSender::new(stats_sender);
-        let client = TestClient::default();
-        let client_packets_sent = client.packets_sent.clone();
-        let shutdown = TaskManager::default();
-        let mut delay_forwarder =
-            DelayForwarder::new(client, node_stats_update_sender, shutdown.subscribe());
-        let packet_sender = delay_forwarder.sender();
-
-        // Spawn the worker, listening on packet_sender channel
-        tokio::spawn(async move { delay_forwarder.run().await });
-
-        // Send a `MixPacket` down the channel without any delay attached.
-        let next_hop =
-            NymNodeRoutingAddress::from(SocketAddr::new(IpAddr::V4(Ipv4Addr::new(1, 2, 3, 4)), 42));
-        let mix_packet = MixPacket::new(
-            next_hop,
-            make_valid_outfox_packet(PacketSize::default()),
-            PacketType::default(),
+            PacketMode::default(),
        );
        let forward_instant = None;
        packet_sender
@@ -1,86 +0,0 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use nym_sphinx::forwarding::packet::MixPacket;
-use nym_sphinx::message::NymMessage;
-use nym_sphinx::params::{PacketSize, PacketType};
-use nym_sphinx::{
-    acknowledgements::AckKey, addressing::clients::Recipient, preparer::MessagePreparer,
-};
-use nym_topology::NymTopology;
-use rand_07::rngs::OsRng;
-use std::time::Duration;
-
-const DEFAULT_AVERAGE_PACKET_DELAY: Duration = Duration::from_millis(200);
-const DEFAULT_AVERAGE_ACK_DELAY: Duration = Duration::from_millis(200);
-
-#[derive(Clone)]
-pub(crate) struct Chunker {
-    rng: OsRng,
-    packet_size: PacketSize,
-    message_preparer: MessagePreparer<OsRng>,
-}
-
-impl Chunker {
-    pub(crate) fn new(tested_mix_me: Recipient) -> Self {
-        Chunker {
-            rng: OsRng,
-            // no point in using anything else for monitoring
-            // unless we should make it variable so mixnodes wouldn't know if
-            // non-default packet is for measurement or not
-            packet_size: PacketSize::RegularPacket,
-            message_preparer: MessagePreparer::new(
-                OsRng,
-                tested_mix_me,
-                DEFAULT_AVERAGE_PACKET_DELAY,
-                DEFAULT_AVERAGE_ACK_DELAY,
-            ),
-        }
-    }
-
-    pub(crate) fn prepare_packets_from(
-        &mut self,
-        message: Vec<u8>,
-        topology: &NymTopology,
-        packet_sender: Recipient,
-        packet_type: PacketType,
-    ) -> Vec<MixPacket> {
-        // I really dislike how we have to overwrite the parameter of the `MessagePreparer` on each run
-        // but without some significant API changes in the `MessagePreparer` this was the easiest
-        // way to being able to have variable sender address.
-        self.message_preparer.set_sender_address(packet_sender);
-        self.prepare_packets(message, topology, packet_sender, packet_type)
-    }
-
-    fn prepare_packets(
-        &mut self,
-        message: Vec<u8>,
-        topology: &NymTopology,
-        packet_sender: Recipient,
-        packet_type: PacketType,
-    ) -> Vec<MixPacket> {
-        let ack_key: AckKey = AckKey::new(&mut self.rng);
-
-        let split_message = self
-            .message_preparer
-            .pad_and_split_message(NymMessage::new_plain(message), self.packet_size);
-
-        let mut mix_packets = Vec::with_capacity(split_message.len());
-        for message_chunk in split_message {
-            // don't bother with acks etc. for time being
-            let prepared_fragment = self
-                .message_preparer
-                .prepare_chunk_for_sending(
-                    message_chunk,
-                    topology,
-                    &ack_key,
-                    &packet_sender,
-                    packet_type,
-                )
-                .unwrap();
-
-            mix_packets.push(prepared_fragment.mix_packet);
-        }
-        mix_packets
-    }
-}
@@ -21,7 +21,6 @@ use nym_bandwidth_controller::BandwidthController;
 use nym_credential_storage::persistent_storage::PersistentStorage;
 use nym_crypto::asymmetric::{encryption, identity};
 use nym_sphinx::acknowledgements::AckKey;
-use nym_sphinx::params::PacketType;
 use nym_sphinx::receiver::MessageReceiver;
 use nym_task::TaskManager;
 use std::sync::Arc;
@@ -130,7 +129,6 @@ impl<'a> NetworkMonitorBuilder<'a> {
            received_processor,
            summary_producer,
            self.node_status_storage,
-            PacketType::Mix,
        );

        NetworkMonitorRunnables {
@@ -10,7 +10,6 @@ use crate::network_monitor::test_route::TestRoute;
 use crate::storage::NymApiStorage;
 use crate::support::config::Config;
 use log::{debug, error, info};
-use nym_sphinx::params::PacketType;
 use nym_sphinx::receiver::MessageReceiver;
 use nym_task::TaskClient;
 use std::collections::{HashMap, HashSet};
@@ -45,8 +44,6 @@ pub(super) struct Monitor<R: MessageReceiver + Send + 'static> {
    /// The minimum number of test routes that need to be constructed (and working) in order for
    /// a monitor test run to be valid.
    minimum_test_routes: usize,
-
-    packet_type: PacketType,
 }

 impl<R: MessageReceiver + Send> Monitor<R> {
@@ -57,7 +54,6 @@ impl<R: MessageReceiver + Send> Monitor<R> {
        received_processor: ReceivedProcessor<R>,
        summary_producer: SummaryProducer,
        node_status_storage: NymApiStorage,
-        packet_type: PacketType,
    ) -> Self {
        Monitor {
            test_nonce: 1,
@@ -72,7 +68,6 @@ impl<R: MessageReceiver + Send> Monitor<R> {
            route_test_packets: config.get_route_test_packets(),
            test_routes: config.get_test_routes(),
            minimum_test_routes: config.get_minimum_test_routes(),
-            packet_type,
        }
    }

@@ -130,11 +125,8 @@ impl<R: MessageReceiver + Send> Monitor<R> {
        for route in routes {
            let mut packet_preparer = self.packet_preparer.clone();
            let route = route.clone();
-            let gateway_packets = packet_preparer.prepare_test_route_viability_packets(
-                &route,
-                self.route_test_packets,
-                self.packet_type,
-            );
+            let gateway_packets = packet_preparer
+                .prepare_test_route_viability_packets(&route, self.route_test_packets);
            packets.push(gateway_packets);
        }

@@ -241,7 +233,7 @@ impl<R: MessageReceiver + Send> Monitor<R> {
        info!("Generating test mix packets for all the network nodes...");
        let prepared_packets = self
            .packet_preparer
-            .prepare_test_packets(self.test_nonce, routes, self.packet_type)
+            .prepare_test_packets(self.test_nonce, routes)
            .await;

        let total_sent = prepared_packets
@@ -12,7 +12,7 @@ use nym_node_tester_utils::NodeTester;
 use nym_sphinx::acknowledgements::AckKey;
 use nym_sphinx::addressing::clients::Recipient;
 use nym_sphinx::forwarding::packet::MixPacket;
-use nym_sphinx::params::{PacketSize, PacketType};
+use nym_sphinx::params::PacketSize;
 use nym_topology::{gateway, mix};
 use rand_07::{rngs::ThreadRng, seq::SliceRandom, thread_rng, Rng};
 use std::collections::{HashMap, HashSet};
@@ -290,8 +290,6 @@ impl PacketPreparer {
        &mut self,
        route: &TestRoute,
        num: usize,
-        // TODO: Maybe do this
-        _packet_type: PacketType,
    ) -> GatewayPackets {
        let mut tester = self.ephemeral_mix_tester(route);
        let topology = route.topology();
@@ -361,8 +359,6 @@ impl PacketPreparer {
        &mut self,
        test_nonce: u64,
        test_routes: &[TestRoute],
-        // TODO: Maybe do this
-        _packet_type: PacketType,
    ) -> PreparedPackets {
        // only test mixnodes that are rewarded, i.e. that will be rewarded in this interval.
        // (remember that "idle" nodes are still part of that set)
@@ -3659,10 +3659,8 @@ dependencies = [
 "chacha20poly1305",
 "curve25519-dalek",
 "getrandom 0.2.8",
- "log",
- "rand 0.7.3",
 "rayon",
- "sphinx-packet",
+ "sphinx-packet 0.1.0 (git+https://github.com/nymtech/sphinx.git)",
 "thiserror",
 "zeroize",
 ]
@@ -3753,6 +3751,7 @@ version = "0.1.0"
 dependencies = [
 "log",
 "nym-crypto",
+ "nym-outfox",
 "nym-sphinx-acknowledgements",
 "nym-sphinx-addressing",
 "nym-sphinx-anonymous-replies",
@@ -3847,7 +3846,6 @@ dependencies = [
 "nym-sphinx-addressing",
 "nym-sphinx-params",
 "nym-sphinx-types",
- "thiserror",
 ]

 [[package]]
@@ -3884,9 +3882,7 @@ dependencies = [
 name = "nym-sphinx-types"
 version = "0.2.0"
 dependencies = [
- "nym-outfox",
- "sphinx-packet",
- "thiserror",
+ "sphinx-packet 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 ]

 [[package]]
@@ -5514,6 +5510,29 @@ dependencies = [
 "subtle 2.4.1",
 ]

+[[package]]
+name = "sphinx-packet"
+version = "0.1.0"
+source = "git+https://github.com/nymtech/sphinx.git#ca107d94360cdf8bbfbdb12fe5320ed74f80e40c"
+dependencies = [
+ "aes 0.7.5",
+ "arrayref",
+ "blake2",
+ "bs58",
+ "byteorder",
+ "chacha",
+ "curve25519-dalek",
+ "digest 0.9.0",
+ "hkdf 0.11.0",
+ "hmac 0.11.0",
+ "lioness",
+ "log",
+ "rand 0.7.3",
+ "rand_distr",
+ "sha2 0.9.9",
+ "subtle 2.4.1",
+]
+
 [[package]]
 name = "spin"
 version = "0.5.2"
@@ -15,9 +15,9 @@ chacha20poly1305 = "0.10.1"
 # Need this star over here to pull in js into getrandom
 getrandom = { version = "*", features = ["js"] }
 thiserror = "1"
-sphinx-packet = "0.1.0"
-rand = "0.7.3"
-log = "0.4"
+
+sphinx-packet = { git = "https://github.com/nymtech/sphinx.git" }
+

 [dev-dependencies]
 criterion = "0.4"
@@ -1,22 +0,0 @@
-pub const GROUPELEMENTBYTES: u8 = 32;
-pub const TAGBYTES: u8 = 16;
-pub const MIX_PARAMS_LEN: usize = DEFAULT_HOPS + 2;
-pub const MIN_MESSAGE_LEN: usize = 24 * 2;
-pub(crate) const CONTEXT: &str = "LIONKEYS";
-pub(crate) const TAG_LEN: usize = 24;
-pub const DEFAULT_ROUTING_INFO_SIZE: u8 = 32;
-pub const DEFAULT_HOPS: usize = 4;
-pub const ROUTING_INFORMATION_LENGTH_BY_STAGE: [u8; DEFAULT_HOPS] =
-    [DEFAULT_ROUTING_INFO_SIZE; DEFAULT_HOPS];
-pub const MIN_PACKET_SIZE: usize = 48;
-
-pub const OUTFOX_PACKET_OVERHEAD: usize = MIX_PARAMS_LEN
-    + (groupelementbytes() + tagbytes() + DEFAULT_ROUTING_INFO_SIZE as usize) * DEFAULT_HOPS;
-
-pub const fn groupelementbytes() -> usize {
-    GROUPELEMENTBYTES as usize
-}
-
-pub const fn tagbytes() -> usize {
-    TAGBYTES as usize
-}
@@ -1,9 +1,10 @@
-use crate::constants::MIN_MESSAGE_LEN;
-use crate::constants::MIX_PARAMS_LEN;
+use std::array::TryFromSliceError;
+
+use crate::lion::MIN_MESSAGE_LEN;
 use chacha20::cipher::InvalidLength;
 use thiserror::Error;

-#[derive(Debug, Error, Clone)]
+#[derive(Debug, Error)]
 pub enum OutfoxError {
    #[error("Lengths mismatch, expected: {expected}, got: {got}")]
    LenMismatch { expected: usize, got: usize },
@@ -19,10 +20,8 @@ pub enum OutfoxError {
    #[error("Message length must be greater then {MIN_MESSAGE_LEN} bytes")]
    InvalidMessageLength,
    #[error("{source}")]
-    TryFromSlice {
+    TryFromSluce {
        #[from]
-        source: std::array::TryFromSliceError,
+        source: TryFromSliceError,
    },
-    #[error("Header length must be {MIX_PARAMS_LEN}, got {0}")]
-    InvalidHeaderLength(usize),
 }
@@ -62,85 +62,58 @@ use chacha20poly1305::Tag;
 use curve25519_dalek::constants::ED25519_BASEPOINT_TABLE;
 use curve25519_dalek::montgomery::MontgomeryPoint;
 use curve25519_dalek::scalar::Scalar;
+use sphinx_packet::route::Node;

 use std::convert::TryInto;

+const GROUPELEMENTBYTES: usize = 32;
+const TAGBYTES: usize = 16;
+
 use std::ops::Range;
 use std::u8;

-use crate::constants::groupelementbytes;
-use crate::constants::tagbytes;
-use crate::constants::DEFAULT_HOPS;
-use crate::constants::DEFAULT_ROUTING_INFO_SIZE;
-use crate::constants::GROUPELEMENTBYTES;
-use crate::constants::MIX_PARAMS_LEN;
-use crate::constants::ROUTING_INFORMATION_LENGTH_BY_STAGE;
-use crate::constants::TAGBYTES;
 use crate::error::OutfoxError;
 use crate::lion::*;
-use std::convert::TryFrom;

 /// A structure that holds mix packet construction parameters. These incluse the length
 /// of the routing information at each hop, the number of hops, and the payload length.
-#[derive(Eq, PartialEq, Debug)]
 pub struct MixCreationParameters {
    /// The routing length is inner first, so \[0\] is the innermost routing length, etc (in bytes)
-    /// In our stratified topology this will always be 4
-    pub routing_information_length_by_stage: [u8; DEFAULT_HOPS],
+    pub routing_information_length_by_stage: Vec<usize>,
    /// The payload length (in bytes)
-    pub payload_length_bytes: u16,
-}
-
-impl TryFrom<&[u8]> for MixCreationParameters {
-    type Error = OutfoxError;
-
-    fn try_from(v: &[u8]) -> Result<Self, Self::Error> {
-        if v.len() != MIX_PARAMS_LEN {
-            return Err(OutfoxError::InvalidHeaderLength(v.len()));
-        }
-        let (routing, payload) = v.split_at(DEFAULT_HOPS);
-        Ok(MixCreationParameters {
-            routing_information_length_by_stage: routing.try_into()?,
-            payload_length_bytes: u16::from_le_bytes(payload.try_into()?),
-        })
-    }
+    pub payload_length_bytes: usize,
 }

 impl MixCreationParameters {
-    pub fn to_bytes(&self) -> Vec<u8> {
-        let mut bytes = Vec::with_capacity(5);
-        bytes.extend_from_slice(self.routing_information_length_by_stage.as_slice());
-        bytes.extend_from_slice(&self.payload_length_bytes.to_le_bytes());
-        bytes
-    }
-
-    pub fn payload_length_bytes(&self) -> usize {
-        self.payload_length_bytes as usize
-    }
-
    /// Create a set of parameters for a mix packet format.
-    pub fn new(payload_length_bytes: u16) -> MixCreationParameters {
+    pub fn new(payload_length_bytes: usize) -> MixCreationParameters {
        MixCreationParameters {
-            routing_information_length_by_stage: [DEFAULT_ROUTING_INFO_SIZE; DEFAULT_HOPS],
+            routing_information_length_by_stage: Vec::new(),
            payload_length_bytes,
        }
    }

+    /// Add another outer layer containing some byte length of routing data.
+    pub fn add_outer_layer(&mut self, routing_information_length_bytes: usize) {
+        self.routing_information_length_by_stage
+            .push(routing_information_length_bytes);
+    }
+
    /// The length of the buffer needed to build a packet.
    pub fn total_packet_length(&self) -> usize {
-        let mut len = self.payload_length_bytes();
-        for stage_len in ROUTING_INFORMATION_LENGTH_BY_STAGE.iter() {
-            len += *stage_len as usize + groupelementbytes() + tagbytes()
+        let mut len = self.payload_length_bytes;
+        for stage_len in &self.routing_information_length_by_stage {
+            len += stage_len + GROUPELEMENTBYTES + TAGBYTES
        }
        len
    }

    /// Get the mix packet parameters for a single stage of mixing.
    pub fn get_stage_params(&self, layer_number: usize) -> (Range<usize>, MixStageParameters) {
-        assert!(layer_number < ROUTING_INFORMATION_LENGTH_BY_STAGE.len());
+        assert!(layer_number < self.routing_information_length_by_stage.len());

        let mut remaining_header_length_bytes = 0;
-        for (i, stage_len) in ROUTING_INFORMATION_LENGTH_BY_STAGE.iter().enumerate() {
+        for (i, stage_len) in self.routing_information_length_by_stage.iter().enumerate() {
            if i == layer_number {
                let params = MixStageParameters {
                    routing_information_length_bytes: *stage_len,
@@ -153,7 +126,7 @@ impl MixCreationParameters {

                return (total_size - inner_size..total_size, params);
            } else {
-                remaining_header_length_bytes += (stage_len + GROUPELEMENTBYTES + TAGBYTES) as u16;
+                remaining_header_length_bytes += stage_len + GROUPELEMENTBYTES + TAGBYTES;
            }
        }

@@ -164,70 +137,57 @@ impl MixCreationParameters {
 /// A structure representing the parameters of a single stage of mixing.
 pub struct MixStageParameters {
    /// The routing information length for this stage of mixing
-    pub routing_information_length_bytes: u8,
+    pub routing_information_length_bytes: usize,
    /// The reamining header length for this stage of mixing
-    pub remaining_header_length_bytes: u16,
+    pub remaining_header_length_bytes: usize,
    /// The payload length
-    pub payload_length_bytes: u16,
+    pub payload_length_bytes: usize,
 }

 impl MixStageParameters {
-    pub fn routing_information_length_bytes(&self) -> usize {
-        self.routing_information_length_bytes as usize
-    }
-
-    pub fn remaining_header_length_bytes(&self) -> usize {
-        self.remaining_header_length_bytes as usize
-    }
-
-    pub fn payload_length_bytes(&self) -> usize {
-        self.payload_length_bytes as usize
-    }
-
    pub fn incoming_packet_length(&self) -> usize {
-        groupelementbytes() + tagbytes() + self.outgoing_packet_length()
+        GROUPELEMENTBYTES + TAGBYTES + self.outgoing_packet_length()
    }

    pub fn outgoing_packet_length(&self) -> usize {
-        self.routing_information_length_bytes()
-            + self.remaining_header_length_bytes()
-            + self.payload_length_bytes()
+        self.routing_information_length_bytes
+            + self.remaining_header_length_bytes
+            + self.payload_length_bytes
    }

    pub fn pub_element_range(&self) -> Range<usize> {
-        0..groupelementbytes()
+        0..GROUPELEMENTBYTES
    }

    pub fn tag_range(&self) -> Range<usize> {
-        groupelementbytes()..groupelementbytes() + tagbytes()
+        GROUPELEMENTBYTES..GROUPELEMENTBYTES + TAGBYTES
    }

    pub fn routing_data_range(&self) -> Range<usize> {
-        groupelementbytes() + tagbytes()
-            ..groupelementbytes() + tagbytes() + self.routing_information_length_bytes()
+        GROUPELEMENTBYTES + TAGBYTES
+            ..GROUPELEMENTBYTES + TAGBYTES + self.routing_information_length_bytes
    }

    pub fn header_range(&self) -> Range<usize> {
-        groupelementbytes() + tagbytes()
-            ..groupelementbytes()
-                + tagbytes()
-                + self.routing_information_length_bytes()
-                + self.remaining_header_length_bytes()
+        GROUPELEMENTBYTES + TAGBYTES
+            ..GROUPELEMENTBYTES
+                + TAGBYTES
+                + self.routing_information_length_bytes
+                + self.remaining_header_length_bytes
    }

    pub fn payload_range(&self) -> Range<usize> {
-        self.incoming_packet_length() - self.payload_length_bytes()..self.incoming_packet_length()
+        self.incoming_packet_length() - self.payload_length_bytes..self.incoming_packet_length()
    }

    pub fn encode_mix_layer(
        &self,
        buffer: &mut [u8],
        user_secret_key: &[u8],
-        node_pub_key: &[u8],
-        destination: &[u8; 32],
+        node: &Node,
    ) -> Result<MontgomeryPoint, OutfoxError> {
-        let routing_data = destination;
-        let mix_public_key = MontgomeryPoint(node_pub_key.try_into()?);
+        let routing_data = node.address.as_bytes().to_vec();
+        let mix_public_key = MontgomeryPoint(*node.pub_key.as_bytes());
        let user_secret_key = Scalar::from_bytes_mod_order(user_secret_key.try_into()?);

        if buffer.len() != self.incoming_packet_length() {
@@ -237,10 +197,10 @@ impl MixStageParameters {
            });
        }

-        if routing_data.len() != self.routing_information_length_bytes() {
+        if routing_data.len() != self.routing_information_length_bytes {
            return Err(OutfoxError::LenMismatch {
                expected: routing_data.len(),
-                got: self.routing_information_length_bytes(),
+                got: self.routing_information_length_bytes,
            });
        }

@@ -248,7 +208,7 @@ impl MixStageParameters {
        let shared_key = user_secret_key * mix_public_key;

        // Copy rounting data into buffer
-        buffer[self.routing_data_range()].copy_from_slice(routing_data);
+        buffer[self.routing_data_range()].copy_from_slice(&routing_data);

        // Perform the AEAD
        let header_aead_key = ChaCha20Poly1305::new_from_slice(&shared_key.0[..])?;
@@ -274,7 +234,7 @@ impl MixStageParameters {
        &self,
        buffer: &mut [u8],
        mix_secret_key: &[u8],
-    ) -> Result<Vec<u8>, OutfoxError> {
+    ) -> Result<MontgomeryPoint, OutfoxError> {
        // Check the length of the incoming buffer is correct.

        let mix_secret_key = Scalar::from_bytes_mod_order(mix_secret_key.try_into()?);
@@ -306,32 +266,9 @@ impl MixStageParameters {
            )
            .map_err(|e| OutfoxError::ChaCha20Poly1305Error(e.to_string()))?;

-        let routing_data = buffer[self.routing_data_range()].to_vec();
        // Do a round of LION on the payload
        lion_transform_decrypt(&mut buffer[self.payload_range()], &shared_key.0)?;

-        Ok(routing_data)
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::MixCreationParameters;
-    use std::convert::TryFrom;
-
-    #[test]
-    fn test_to_bytes() {
-        let mix_params = MixCreationParameters::new(1024);
-        assert_eq!(mix_params.to_bytes(), vec![32, 32, 32, 32, 0, 4])
-    }
-
-    #[test]
-    fn test_from_bytes() {
-        let params_bytes = vec![32, 32, 32, 32, 0, 4];
-        let mix_params = MixCreationParameters::new(1024);
-        assert_eq!(
-            mix_params,
-            MixCreationParameters::try_from(params_bytes.as_slice()).unwrap()
-        )
+        Ok(shared_key)
    }
 }
@@ -1,4 +1,3 @@
-pub mod constants;
 pub mod error;
 pub mod format;
 pub mod lion;
@@ -36,9 +36,12 @@ use chacha20::XChaCha20;
 use chacha20::XNonce;
 use zeroize::Zeroize;

-use crate::constants::{CONTEXT, MIN_MESSAGE_LEN, TAG_LEN};
 use crate::error::OutfoxError;

+pub const MIN_MESSAGE_LEN: usize = 24 * 2;
+const CONTEXT: &str = "LIONKEYS";
+const TAG_LEN: usize = 24;
+
 /// The lion transform encryption function.
 ///
 /// The `key` must be 32 bytes, and the `message` >= 48. The message is
@@ -1,143 +1,38 @@
-use std::{
-    array::TryFromSliceError,
-    collections::VecDeque,
-    convert::{TryFrom, TryInto},
-    iter::FromIterator,
-    ops::Range,
-};
+use std::ops::Range;

 use crate::{
-    constants::{DEFAULT_HOPS, MIN_PACKET_SIZE, MIX_PARAMS_LEN},
    error::OutfoxError,
    format::{MixCreationParameters, MixStageParameters},
 };

-use rand::{rngs::OsRng, RngCore};
-use sphinx_packet::{
-    crypto::PrivateKey,
-    packet::builder::DEFAULT_PAYLOAD_SIZE,
-    route::{Destination, Node},
-};
+use sphinx_packet::{packet::builder::DEFAULT_PAYLOAD_SIZE, route::Node};

-#[derive(Debug)]
 pub struct OutfoxPacket {
    mix_params: MixCreationParameters,
    payload: Vec<u8>,
 }

-pub struct OutfoxProcessedPacket {
-    packet: OutfoxPacket,
-    next_address: [u8; 32],
-}
-
-impl OutfoxProcessedPacket {
-    pub fn new(packet: OutfoxPacket, next_address: [u8; 32]) -> Self {
-        OutfoxProcessedPacket {
-            packet,
-            next_address,
-        }
-    }
-
-    pub fn into_packet(self) -> OutfoxPacket {
-        self.packet
-    }
-
-    pub fn next_address(&self) -> &[u8; 32] {
-        &self.next_address
-    }
-}
-
-impl TryFrom<&[u8]> for OutfoxPacket {
-    type Error = OutfoxError;
-
-    fn try_from(v: &[u8]) -> Result<Self, Self::Error> {
-        let (header, payload) = v.split_at(MIX_PARAMS_LEN);
-        Ok(OutfoxPacket {
-            mix_params: MixCreationParameters::try_from(header)?,
-            payload: payload.to_vec(),
-        })
-    }
-}
+pub const DEFAULT_ROUTING_INFO_SIZE: usize = 32;

 impl OutfoxPacket {
-    pub fn recover_plaintext(&self) -> Vec<u8> {
-        let plaintext = self.payload()[self.payload_range()].to_vec();
-        if plaintext.starts_with(&[0]) {
-            let mut plaintext = VecDeque::from_iter(plaintext);
-            while let Some(0) = plaintext.front() {
-                plaintext.pop_front();
-            }
-            return plaintext.make_contiguous().to_vec();
-        }
-        plaintext
-    }
-
-    pub fn len(&self) -> usize {
-        self.mix_params().total_packet_length() + MIX_PARAMS_LEN
-    }
-
-    pub fn is_empty(&self) -> bool {
-        self.len() == 0
-    }
-
-    pub fn to_bytes(&self) -> Result<Vec<u8>, OutfoxError> {
-        let mut bytes = vec![];
-        bytes.extend(self.mix_params.to_bytes());
-        bytes.extend(self.payload.as_slice());
-        Ok(bytes)
-    }
-
-    pub fn build<M: AsRef<[u8]>>(
-        payload: M,
-        route: &[Node; 4],
-        destination: &Destination,
-        packet_size: Option<usize>,
+    pub fn build(
+        payload: &[u8],
+        route: &[Node; 3],
+        user_secret_key: &[u8],
    ) -> Result<OutfoxPacket, OutfoxError> {
-        let mut secret_key = [0; 32];
-        OsRng.fill_bytes(&mut secret_key);
-        let packet_size = packet_size.unwrap_or(DEFAULT_PAYLOAD_SIZE);
-        let packet_size = if packet_size < MIN_PACKET_SIZE {
-            MIN_PACKET_SIZE
-        } else {
-            packet_size
-        };
-        let mix_params = MixCreationParameters::new(packet_size as u16);
+        let mut mix_params = MixCreationParameters::new(DEFAULT_PAYLOAD_SIZE);

-        let padding = mix_params.total_packet_length() - payload.as_ref().len();
+        for node in route.iter() {
+            mix_params.add_outer_layer(node.address.as_bytes_ref().len());
+        }
+
+        let padding = mix_params.total_packet_length() - payload.len();
        let mut buffer = vec![0; padding];
-        buffer.extend_from_slice(payload.as_ref());
+        buffer.extend_from_slice(payload);

-        // Last node in the route is a gateway, it will decrypt last, and get the final destination address
-        let (range, stage_params) = mix_params.get_stage_params(0);
-        stage_params.encode_mix_layer(
-            &mut buffer[range],
-            &secret_key,
-            route.last().unwrap().pub_key.as_bytes(),
-            destination.address.as_bytes_ref(),
-        )?;
-
-        let route = route.iter().rev().collect::<Vec<&Node>>();
-
-        // We've reversed the route, and we iterate pairs of node, first node in the pair is the destination, and the second(last) is the processing node
-        // Route: [N1, N2, N3, G]
-        // Reverse: [G, N3, N2, N1]
-        // Pairs: [(G, N3), (N3, N2), (N2, N1)]
-        // We iterate over pairs, and encode the mix layer for each pair
-        // For the first pair, we encode the mix layer for N3, and the destination is G
-        // For the second pair, we encode the mix layer for N2, and the destination is N3
-        // For the third pair, we encode the mix layer for N1, and the destination is N2
-        // Entry gateway will simply forward the packet to N1 and processing will continue from there
-        for (idx, nodes) in route.windows(2).enumerate() {
-            let (range, stage_params) = mix_params.get_stage_params(idx + 1);
-            // We know that we'll always get 4 nodes, so we can unwrap here
-            let processing_node = nodes.last().unwrap();
-            let destination_node = nodes.first().unwrap();
-            stage_params.encode_mix_layer(
-                &mut buffer[range],
-                &secret_key,
-                processing_node.pub_key.as_bytes(),
-                destination_node.address.as_bytes_ref(),
-            )?;
+        for (idx, node) in route.iter().rev().enumerate() {
+            let (range, stage_params) = mix_params.get_stage_params(idx);
+            stage_params.encode_mix_layer(&mut buffer[range], user_secret_key, node)?;
        }

        Ok(OutfoxPacket {
@@ -159,7 +54,7 @@ impl OutfoxPacket {
    }

    pub fn payload_range(&self) -> Range<usize> {
-        self.stage_params(DEFAULT_HOPS - 1).1.payload_range()
+        self.stage_params(2).1.payload_range()
    }

    pub fn payload_mut(&mut self) -> &mut [u8] {
@@ -170,52 +65,9 @@ impl OutfoxPacket {
        &mut self,
        layer: usize,
        mix_secret_key: &[u8; 32],
-    ) -> Result<Vec<u8>, OutfoxError> {
+    ) -> Result<(), OutfoxError> {
        let (range, params) = self.stage_params(layer);
-        let routing_data =
-            params.decode_mix_layer(&mut self.payload_mut()[range], mix_secret_key)?;
-        Ok(routing_data)
-    }
-
-    pub fn update_routing_information(&mut self, layer: usize) -> Result<(), TryFromSliceError> {
-        let mut routing_info = self
-            .mix_params()
-            .routing_information_length_by_stage
-            .to_vec();
-        routing_info.push(0);
-        routing_info.swap_remove(layer);
-        self.mix_params.routing_information_length_by_stage = routing_info.as_slice().try_into()?;
+        params.decode_mix_layer(&mut self.payload_mut()[range], mix_secret_key)?;
        Ok(())
    }
-
-    pub fn is_final_hop(&self) -> bool {
-        self.mix_params()
-            .routing_information_length_by_stage
-            .iter()
-            .all(|x| x == &0)
-    }
-
-    pub fn decode_next_layer(
-        &mut self,
-        mix_secret_key: &PrivateKey,
-    ) -> Result<[u8; 32], OutfoxError> {
-        let mix_secret_key = mix_secret_key.to_bytes();
-        let routing_lenght_by_stage = self
-            .mix_params()
-            .routing_information_length_by_stage
-            .as_slice();
-        let mut layer = DEFAULT_HOPS - 1;
-        for (i, length) in routing_lenght_by_stage.iter().rev().enumerate() {
-            if length == &32 {
-                layer = DEFAULT_HOPS - 1 - i;
-                break;
-            }
-        }
-        self.decode_mix_layer(layer, &mix_secret_key)?;
-        self.update_routing_information(layer)?;
-        let (range, stage_params) = self.mix_params().get_stage_params(layer);
-        let routing_bytes = &self.payload()[range][stage_params.routing_data_range()];
-        let routing_address: [u8; 32] = routing_bytes.try_into()?;
-        Ok(routing_address)
-    }
 }
@@ -3,27 +3,25 @@ extern crate nym_outfox;
 #[cfg(test)]
 mod tests {

-    use std::iter::repeat_with;
-
-    pub fn randombytes(n: usize) -> Vec<u8> {
-        repeat_with(|| fastrand::u8(..)).take(n).collect()
-    }
-
    use curve25519_dalek::constants::ED25519_BASEPOINT_TABLE;
    use curve25519_dalek::scalar::Scalar;
    use nym_outfox::packet::OutfoxPacket;
    use sphinx_packet::constants::NODE_ADDRESS_LENGTH;
    use sphinx_packet::crypto::PublicKey;
-    use sphinx_packet::route::Destination;
-    use sphinx_packet::route::DestinationAddressBytes;
+    use sphinx_packet::packet::builder::DEFAULT_PAYLOAD_SIZE;
    use sphinx_packet::route::Node;
    use sphinx_packet::route::NodeAddressBytes;
-    use std::convert::TryFrom;
    use std::convert::TryInto;

    use nym_outfox::format::*;
    use nym_outfox::lion::*;

+    use std::iter::repeat_with;
+
+    pub fn randombytes(n: usize) -> Vec<u8> {
+        repeat_with(|| fastrand::u8(..)).take(n).collect()
+    }
+
    #[test]
    fn test_encode_decode() {
        let mix_params = MixStageParameters {
@@ -39,7 +37,6 @@ mod tests {
        let mix_public_key = (&ED25519_BASEPOINT_TABLE * &mix_secret_scalar).to_montgomery();

        let routing = [0; 32];
-        let destination = [0; 32];

        let buffer = randombytes(mix_params.incoming_packet_length());

@@ -51,12 +48,7 @@ mod tests {
        let node = Node::new(node_address_bytes, mix_public_key);

        let _ = mix_params
-            .encode_mix_layer(
-                &mut new_buffer[..],
-                &user_secret,
-                node.pub_key.as_bytes(),
-                &destination,
-            )
+            .encode_mix_layer(&mut new_buffer[..], &user_secret, &node)
            .unwrap();

        assert!(new_buffer[mix_params.payload_range()] != buffer[mix_params.payload_range()]);
@@ -89,6 +81,8 @@ mod tests {

    #[test]
    fn test_packet_params() {
+        let user_secret = randombytes(32);
+
        let (node1_pk, node1_pub) = sphinx_packet::crypto::keygen();
        let node1 = Node::new(
            NodeAddressBytes::from_bytes([0u8; NODE_ADDRESS_LENGTH]),
@@ -105,41 +99,16 @@ mod tests {
            node3_pub,
        );

-        let (gateway_pk, gateway_pub) = sphinx_packet::crypto::keygen();
-        let gateway = Node::new(
-            NodeAddressBytes::from_bytes([3u8; NODE_ADDRESS_LENGTH]),
-            gateway_pub,
-        );
+        let route = [node1, node2, node3];

-        let destination = Destination::new(
-            DestinationAddressBytes::from_bytes([9u8; NODE_ADDRESS_LENGTH]),
-            [0u8; 16],
-        );
+        let payload = randombytes(DEFAULT_PAYLOAD_SIZE);

-        let route = [node1, node2.clone(), node3.clone(), gateway.clone()];
+        let mut packet = OutfoxPacket::build(&payload, &route, &user_secret).unwrap();

-        let payload = randombytes(21);
+        packet.decode_mix_layer(2, &node1_pk.to_bytes()).unwrap();
+        packet.decode_mix_layer(1, &node2_pk.to_bytes()).unwrap();
+        packet.decode_mix_layer(0, &node3_pk.to_bytes()).unwrap();

-        let packet =
-            OutfoxPacket::build(&payload, &route, &destination, Some(payload.len())).unwrap();
-        let packet_bytes = packet.to_bytes().unwrap();
-        println!(
-            "packet bytes length, {}, declared {}",
-            packet_bytes.len(),
-            packet.len()
-        );
-
-        let mut packet = OutfoxPacket::try_from(packet_bytes.as_slice()).unwrap();
-
-        let next_address = packet.decode_next_layer(&node1_pk).unwrap();
-        assert_eq!(next_address, node2.address.as_bytes());
-        let next_address = packet.decode_next_layer(&node2_pk).unwrap();
-        assert_eq!(next_address, node3.address.as_bytes());
-        let next_address = packet.decode_next_layer(&node3_pk).unwrap();
-        assert_eq!(next_address, gateway.address.as_bytes());
-        let destination_address = packet.decode_next_layer(&gateway_pk).unwrap();
-        assert_eq!(destination_address, destination.address.as_bytes());
-
-        assert_eq!(payload, packet.recover_plaintext());
+        assert_eq!(payload, &packet.payload()[packet.payload_range()]);
    }
 }
@@ -120,12 +120,6 @@ version = "0.3.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a4c527152e37cf757a3f78aae5a06fbeefdb07ccc535c980a3208ee3060dd544"

-[[package]]
-name = "arrayvec"
-version = "0.7.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8da52d66c7071e2e3fa2a1e5c6d088fec47b593032b254f5e980de8ea54454d6"
-
 [[package]]
 name = "async-trait"
 version = "0.1.64"
@@ -295,20 +289,6 @@ dependencies = [
 "digest 0.10.6",
 ]

-[[package]]
-name = "blake3"
-version = "1.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "42ae2468a89544a466886840aa467a25b766499f4f04bf7d9fcd10ecee9fccef"
-dependencies = [
- "arrayref",
- "arrayvec",
- "cc",
- "cfg-if",
- "constant_time_eq",
- "digest 0.10.6",
-]
-
 [[package]]
 name = "block"
 version = "0.1.6"
@@ -510,30 +490,6 @@ dependencies = [
 "keystream",
 ]

-[[package]]
-name = "chacha20"
-version = "0.9.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c3613f74bd2eac03dad61bd53dbe620703d4371614fe0bc3b9f04dd36fe4e818"
-dependencies = [
- "cfg-if",
- "cipher 0.4.4",
- "cpufeatures",
-]
-
-[[package]]
-name = "chacha20poly1305"
-version = "0.10.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "10cd79432192d1c0f4e1a0fef9527696cc039165d729fb41b3f4f4f354c2dc35"
-dependencies = [
- "aead",
- "chacha20",
- "cipher 0.4.4",
- "poly1305",
- "zeroize",
-]
-
 [[package]]
 name = "cipher"
 version = "0.3.0"
@@ -551,7 +507,6 @@ checksum = "773f3b9af64447d2ce9850330c473515014aa235e6a783b02db81ff39e4a3dad"
 dependencies = [
 "crypto-common",
 "inout",
- "zeroize",
 ]

 [[package]]
@@ -685,12 +640,6 @@ version = "0.9.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "520fbf3c07483f94e3e3ca9d0cfd913d7718ef2483d2cfd91c0d9e91474ab913"

-[[package]]
-name = "constant_time_eq"
-version = "0.2.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "13418e745008f7349ec7e449155f419a61b92b58a99cc3616942b926825ec76b"
-
 [[package]]
 name = "convert_case"
 version = "0.4.0"
@@ -866,30 +815,6 @@ dependencies = [
 "crossbeam-utils",
 ]

-[[package]]
-name = "crossbeam-deque"
-version = "0.8.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ce6fd6f855243022dcecf8702fef0c297d4338e226845fe067f6341ad9fa0cef"
-dependencies = [
- "cfg-if",
- "crossbeam-epoch",
- "crossbeam-utils",
-]
-
-[[package]]
-name = "crossbeam-epoch"
-version = "0.9.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46bd5f3f85273295a9d14aedfb86f6aadbff6d8f5295c4a9edb08e819dcf5695"
-dependencies = [
- "autocfg",
- "cfg-if",
- "crossbeam-utils",
- "memoffset 0.8.0",
- "scopeguard",
-]
-
 [[package]]
 name = "crossbeam-utils"
 version = "0.8.14"
@@ -1504,7 +1429,7 @@ version = "0.3.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1e1c54951450cbd39f3dbcf1005ac413b49487dabf18a720ad2383eccfeffb92"
 dependencies = [
- "memoffset 0.6.5",
+ "memoffset",
 "rustc_version 0.3.3",
 ]

@@ -2764,15 +2689,6 @@ dependencies = [
 "autocfg",
 ]

-[[package]]
-name = "memoffset"
-version = "0.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d61c719bcfbcf5d62b3a09efa6088de8c54bc0bfcd3ea7ae39fcc186108b8de1"
-dependencies = [
- "autocfg",
-]
-
 [[package]]
 name = "mime"
 version = "0.3.16"
@@ -3172,23 +3088,6 @@ dependencies = [
 "url",
 ]

-[[package]]
-name = "nym-outfox"
-version = "0.1.0"
-dependencies = [
- "blake3",
- "chacha20",
- "chacha20poly1305",
- "curve25519-dalek",
- "getrandom 0.2.8",
- "log",
- "rand 0.7.3",
- "rayon",
- "sphinx-packet",
- "thiserror",
- "zeroize",
-]
-
 [[package]]
 name = "nym-pemstore"
 version = "0.2.0"
@@ -3209,9 +3108,7 @@ dependencies = [
 name = "nym-sphinx-types"
 version = "0.2.0"
 dependencies = [
- "nym-outfox",
 "sphinx-packet",
- "thiserror",
 ]

 [[package]]
@@ -3886,17 +3783,6 @@ dependencies = [
 "miniz_oxide",
 ]

-[[package]]
-name = "poly1305"
-version = "0.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8159bd90725d2df49889a078b54f4f79e87f1f8a8444194cdca81d38f5393abf"
-dependencies = [
- "cpufeatures",
- "opaque-debug 0.3.0",
- "universal-hash",
-]
-
 [[package]]
 name = "polyval"
 version = "0.6.0"
@@ -4149,28 +4035,6 @@ dependencies = [
 "cty",
 ]

-[[package]]
-name = "rayon"
-version = "1.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d2df5196e37bcc87abebc0053e20787d73847bb33134a69841207dd0a47f03b"
-dependencies = [
- "either",
- "rayon-core",
-]
-
-[[package]]
-name = "rayon-core"
-version = "1.11.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4b8f95bd6966f5c87776639160a66bd8ab9895d9d4ab01ddba9fc60661aebe8d"
-dependencies = [
- "crossbeam-channel",
- "crossbeam-deque",
- "crossbeam-utils",
- "num_cpus",
-]
-
 [[package]]
 name = "redox_syscall"
 version = "0.2.16"
@@ -472,8 +472,7 @@ where
            base_builder = base_builder.with_topology_provider(topology_provider);
        }

-        let packet_type = self.config.packet_type();
-        let started_client = base_builder.start_base(packet_type).await?;
+        let started_client = base_builder.start_base().await?;
        let nym_address = started_client.address;

        Ok((started_client, nym_address))
@@ -510,7 +509,6 @@ where
            .clone()
            .ok_or(Error::Socks5Config { set: false })?;
        let debug_config = self.config.debug_config;
-        let packet_type = self.config.packet_type();
        let (mut started_client, nym_address) = self.connect_to_mixnet_common().await?;
        let (socks5_status_tx, mut socks5_status_rx) = mpsc::channel(128);

@@ -526,7 +524,6 @@ where
            client_state.clone(),
            nym_address,
            started_client.task_manager.subscribe(),
-            packet_type,
        );
        started_client
            .task_manager
@@ -591,7 +588,6 @@ where
            client_state,
            reconstructed_receiver,
            task_manager: started_client.task_manager,
-            packet_type: None,
        })
    }
 }
@@ -1,6 +1,5 @@
 use nym_client_core::config::DebugConfig;
 use nym_network_defaults::NymNetworkDetails;
-use nym_sphinx::params::PacketType;

 #[derive(Clone, Debug, Default)]
 pub enum KeyMode {
@@ -35,12 +34,4 @@ pub struct Config {
    /// Flags controlling all sorts of internal client behaviour.
    /// Changing these risk compromising network anonymity!
    pub debug_config: DebugConfig,
-
-    pub packet_type: PacketType,
-}
-
-impl Config {
-    pub fn packet_type(&self) -> PacketType {
-        self.packet_type
-    }
 }
@@ -3,8 +3,7 @@ use nym_client_core::client::{
    inbound_messages::InputMessage,
    received_buffer::ReconstructedMessagesReceiver,
 };
-use nym_sphinx::addressing::clients::Recipient;
-use nym_sphinx::{params::PacketType, receiver::ReconstructedMessage};
+use nym_sphinx::{addressing::clients::Recipient, receiver::ReconstructedMessage};
 use nym_task::{
    connections::{ConnectionCommandSender, LaneQueueLengths, TransmissionLane},
    TaskManager,
@@ -39,7 +38,6 @@ pub struct MixnetClient {

    /// The task manager that controlls all the spawned tasks that the clients uses to do it's job.
    pub(crate) task_manager: TaskManager,
-    pub(crate) packet_type: Option<PacketType>,
 }

 impl MixnetClient {
@@ -153,11 +151,9 @@ impl MixnetClient {
        let lane = TransmissionLane::General;
        let input_msg = match surbs {
            IncludedSurbs::Amount(surbs) => {
-                InputMessage::new_anonymous(address, message, surbs, lane, self.packet_type)
-            }
-            IncludedSurbs::ExposeSelfAddress => {
-                InputMessage::new_regular(address, message, lane, self.packet_type)
+                InputMessage::new_anonymous(address, message, surbs, lane)
            }
+            IncludedSurbs::ExposeSelfAddress => InputMessage::new_regular(address, message, lane),
        };
        self.send(input_msg).await
    }