diff --git a/CLAUDE.md b/CLAUDE.md
index 2c571c3470..2d3c2502fb 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -197,3 +197,57 @@ Format and clippy checks across the entire codebase.
 - **`program-tests/`**: Integration tests requiring Solana runtime, depend on `light-test-utils`
 - **`sdk-tests/`**: SDK-specific integration tests
 - **Special case**: `zero-copy-derive-test` in `program-tests/` only to break cyclic dependencies
+
+### Test Assertion Pattern
+
+When testing account state, use borsh deserialization with a single `assert_eq` against an expected reference account:
+
+```rust
+use borsh::BorshDeserialize;
+use light_ctoken_types::state::{
+    AccountState, CToken, ExtensionStruct, PausableAccountExtension,
+    PermanentDelegateAccountExtension,
+};
+
+// Deserialize the account
+let ctoken = CToken::deserialize(&mut &account.data[..])
+    .expect("Failed to deserialize CToken account");
+
+// Extract runtime-specific values from deserialized account
+let compression_info = ctoken
+    .extensions
+    .as_ref()
+    .and_then(|exts| {
+        exts.iter().find_map(|e| match e {
+            ExtensionStruct::Compressible(info) => Some(info.clone()),
+            _ => None,
+        })
+    })
+    .expect("Should have Compressible extension");
+
+// Build expected account for comparison
+let expected_ctoken = CToken {
+    mint: mint_pubkey.to_bytes().into(),
+    owner: payer.pubkey().to_bytes().into(),
+    amount: 0,
+    delegate: None,
+    state: AccountState::Frozen,
+    is_native: None,
+    delegated_amount: 0,
+    close_authority: None,
+    extensions: Some(vec![
+        ExtensionStruct::Compressible(compression_info),
+        ExtensionStruct::PausableAccount(PausableAccountExtension),
+        ExtensionStruct::PermanentDelegateAccount(PermanentDelegateAccountExtension),
+    ]),
+};
+
+// Single assert comparing full account state
+assert_eq!(ctoken, expected_ctoken, "CToken account should match expected");
+```
+
+**Benefits:**
+- Type-safe assertions using actual struct fields instead of magic byte offsets
+- Maintainable - if account layout changes, deserialization handles it
+- Readable - clear field names vs `account.data[108]`
+- Single assertion point for the entire account state
diff --git a/Cargo.lock b/Cargo.lock
index 45c2f9d0b8..a6fd3e4ff5 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -175,9 +175,9 @@ dependencies = [
 
 [[package]]
 name = "aho-corasick"
-version = "1.1.3"
+version = "1.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916"
+checksum = "ddd31a130427c27518df266943a5308ed92d4b226cc639f5a8f1002816174301"
 dependencies = [
  "memchr",
 ]
@@ -188,7 +188,7 @@ version = "1.1.0"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -307,7 +307,7 @@ dependencies = [
  "solana-sdk",
  "solana-security-txt",
  "spl-token 7.0.0",
- "spl-token-2022 7.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "spl-token-2022 7.0.0",
  "zerocopy",
 ]
 
@@ -495,22 +495,22 @@ dependencies = [
 
 [[package]]
 name = "anstyle-query"
-version = "1.1.4"
+version = "1.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e231f6134f61b71076a3eab506c379d4f36122f2af15a9ff04415ea4c3339e2"
+checksum = "40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc"
 dependencies = [
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
 name = "anstyle-wincon"
-version = "3.0.10"
+version = "3.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3e0633414522a32ffaac8ac6cc8f748e090c5717661fddeea04219e2344f5f2a"
+checksum = "291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d"
 dependencies = [
  "anstyle",
  "once_cell_polyfill",
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -571,7 +571,7 @@ dependencies = [
  "ark-std 0.5.0",
  "educe 0.6.0",
  "fnv",
- "hashbrown 0.15.5",
+ "hashbrown 0.15.2",
  "itertools 0.13.0",
  "num-bigint 0.4.6",
  "num-integer",
@@ -636,7 +636,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "62945a2f7e6de02a31fe400aa489f0e0f5b2502e69f95f853adb82a96c7a6b60"
 dependencies = [
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -662,7 +662,7 @@ dependencies = [
  "num-traits",
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -690,7 +690,7 @@ dependencies = [
  "ark-std 0.5.0",
  "educe 0.6.0",
  "fnv",
- "hashbrown 0.15.5",
+ "hashbrown 0.15.2",
 ]
 
 [[package]]
@@ -737,7 +737,7 @@ checksum = "213888f660fddcca0d257e88e54ac05bca01885f258ccdf695bafd77031bb69d"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -843,9 +843,9 @@ dependencies = [
 
 [[package]]
 name = "async-compression"
-version = "0.4.32"
+version = "0.4.36"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a89bce6054c720275ac2432fbba080a66a2106a44a1b804553930ca6909f4e0"
+checksum = "98ec5f6c2f8bc326c994cb9e241cc257ddaba9afa8555a43cffbb5dd86efaa37"
 dependencies = [
  "compression-codecs",
  "compression-core",
@@ -884,7 +884,7 @@ checksum = "c7c24de15d275a1ecfd47a380fb4d5ec9bfe0933f309ed5e705b775596a3574d"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -895,7 +895,7 @@ checksum = "9035ad2d096bed7955a320ee7e2230574d28fd3c3a0f186cbea1ff3c7eed5dbb"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -994,11 +994,11 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
 [[package]]
 name = "bitflags"
-version = "2.9.4"
+version = "2.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2261d10cca569e4643e526d8dc2e62e433cc8aba21ab764233731f8d369bf394"
+checksum = "812e12b5285cc515a9c72a5c1d3b6d46a19dac5acfef5265968c166106e31dd3"
 dependencies = [
- "serde",
+ "serde_core",
 ]
 
 [[package]]
@@ -1057,11 +1057,11 @@ dependencies = [
 
 [[package]]
 name = "borsh"
-version = "1.5.7"
+version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ad8646f98db542e39fc66e68a20b2144f6a732636df7c2354e74645faaa433ce"
+checksum = "d1da5ab77c1437701eeff7c88d968729e7766172279eab0676857b3d63af7a6f"
 dependencies = [
- "borsh-derive 1.5.7",
+ "borsh-derive 1.6.0",
  "cfg_aliases",
 ]
 
@@ -1080,15 +1080,15 @@ dependencies = [
 
 [[package]]
 name = "borsh-derive"
-version = "1.5.7"
+version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fdd1d3c0c2f5833f22386f252fe8ed005c7f59fdcddeef025c01b4c3b9fd9ac3"
+checksum = "0686c856aa6aac0c4498f936d7d6a02df690f614c03e4d906d1018062b5c5e2c"
 dependencies = [
  "once_cell",
  "proc-macro-crate 3.4.0",
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -1145,9 +1145,9 @@ dependencies = [
 
 [[package]]
 name = "bumpalo"
-version = "3.19.0"
+version = "3.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46c5e41b57b8bba42a04676d81cb89e9ee8e859a1a66f80a5a72e1cb76b34d43"
+checksum = "5dd9dc738b7a8311c7ade152424974d8115f2cdad61e8dab8dac9f2362298510"
 
 [[package]]
 name = "bv"
@@ -1182,7 +1182,7 @@ checksum = "f9abbd1bc6865053c427f7198e6af43bfdedc55ab791faed4fbd361d789575ff"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -1193,21 +1193,20 @@ checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
 
 [[package]]
 name = "bytes"
-version = "1.10.1"
+version = "1.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d71b6127be86fdcfddb610f7182ac57211d4b18a3e9c82eb2d17662f2227ad6a"
+checksum = "b35204fbdc0b3f4446b89fc1ac2cf84a8a68971995d0bf2e925ec7cd960f9cb3"
 dependencies = [
  "serde",
 ]
 
 [[package]]
 name = "caps"
-version = "0.5.5"
+version = "0.5.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "190baaad529bcfbde9e1a19022c42781bdb6ff9de25721abdb8fd98c0807730b"
+checksum = "fd1ddba47aba30b6a889298ad0109c3b8dcb0e8fc993b459daa7067d46f865e0"
 dependencies = [
  "libc",
- "thiserror 1.0.69",
 ]
 
 [[package]]
@@ -1222,9 +1221,9 @@ dependencies = [
 
 [[package]]
 name = "cc"
-version = "1.2.41"
+version = "1.2.49"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ac9fe6cdbb24b6ade63616c0a0688e45bb56732262c158df3c0c4bea4ca47cb7"
+checksum = "90583009037521a116abf44494efecd645ba48b6622457080f080b85544e2215"
 dependencies = [
  "find-msvc-tools",
  "jobserver",
@@ -1240,9 +1239,9 @@ checksum = "6d43a04d8753f35258c91f8ec639f792891f748a1edbd759cf1dcea3382ad83c"
 
 [[package]]
 name = "cfg-if"
-version = "1.0.3"
+version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2fd1289c04a9ea8cb22300a459a72a385d7c73d3259e2ed7dcb2af674838cfa9"
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
 
 [[package]]
 name = "cfg_aliases"
@@ -1258,7 +1257,7 @@ checksum = "45565fc9416b9896014f5732ac776f810ee53a66730c17e4020c3ec064a8f88f"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -1272,7 +1271,7 @@ dependencies = [
  "num-traits",
  "serde",
  "wasm-bindgen",
- "windows-link 0.2.1",
+ "windows-link",
 ]
 
 [[package]]
@@ -1331,7 +1330,7 @@ dependencies = [
  "heck 0.5.0",
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -1422,6 +1421,7 @@ dependencies = [
  "account-compression",
  "anchor-lang",
  "anchor-spl 0.31.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "borsh 0.10.4",
  "forester-utils",
  "light-batched-merkle-tree",
  "light-client",
@@ -1430,7 +1430,6 @@ dependencies = [
  "light-compressible",
  "light-ctoken-interface",
  "light-ctoken-sdk",
- "light-ctoken-types",
  "light-program-test",
  "light-prover-client",
  "light-registry",
@@ -1446,15 +1445,15 @@ dependencies = [
  "solana-system-interface 1.0.0",
  "spl-pod",
  "spl-token 7.0.0",
- "spl-token-2022 7.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "spl-token-2022 7.0.0",
  "tokio",
 ]
 
 [[package]]
 name = "compression-codecs"
-version = "0.4.31"
+version = "0.4.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ef8a506ec4b81c460798f572caead636d57d3d7e940f998160f52bd254bf2d23"
+checksum = "b0f7ac3e5b97fdce45e8922fb05cae2c37f7bbd63d30dd94821dacfd8f3f2bf2"
 dependencies = [
  "brotli",
  "compression-core",
@@ -1464,9 +1463,9 @@ dependencies = [
 
 [[package]]
 name = "compression-core"
-version = "0.4.29"
+version = "0.4.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e47641d3deaf41fb1538ac1f54735925e275eaf3bf4d55c81b137fba797e5cbb"
+checksum = "75984efb6ed102a0d42db99afb6c1948f0380d1d91808d5529916e6c08b49d8d"
 
 [[package]]
 name = "concurrent-queue"
@@ -1615,9 +1614,9 @@ checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5"
 
 [[package]]
 name = "crypto-common"
-version = "0.1.6"
+version = "0.1.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
+checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a"
 dependencies = [
  "generic-array",
  "rand_core 0.6.4",
@@ -1754,7 +1753,7 @@ checksum = "f46882e17999c6cc590af592290432be3bce0428cb0d5f8b6715e4dc7b383eb3"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -1778,7 +1777,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "strsim 0.11.1",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -1789,7 +1788,7 @@ checksum = "d38308df82d1080de0afee5d069fa14b0326a88c14f15c5ccda35b4a6c414c81"
 dependencies = [
  "darling_core",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -1841,9 +1840,9 @@ dependencies = [
 
 [[package]]
 name = "deranged"
-version = "0.5.4"
+version = "0.5.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a41953f86f8a05768a6cda24def994fd2f424b04ec5c719cf89989779f199071"
+checksum = "ececcb659e7ba858fb4f10388c250a7252eb0a27373f1a72b8748afdd248e587"
 dependencies = [
  "powerfmt",
  "serde_core",
@@ -1948,7 +1947,7 @@ checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -1971,7 +1970,7 @@ checksum = "a6cbae11b3de8fce2a456e8ea3dada226b35fe791f0dc1d360c0941f0bb681f3"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -2060,10 +2059,10 @@ version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1d7bc049e1bd8cdeb31b68bbd586a9464ecf9f3944af3958a7a9d0f8b9799417"
 dependencies = [
- "enum-ordinalize 4.3.0",
+ "enum-ordinalize 4.3.2",
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -2104,7 +2103,7 @@ checksum = "685adfa4d6f3d765a26bc5dbc936577de9abf756c1feeb3089b01dd395034842"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -2117,27 +2116,27 @@ dependencies = [
  "num-traits",
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
 name = "enum-ordinalize"
-version = "4.3.0"
+version = "4.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fea0dcfa4e54eeb516fe454635a95753ddd39acda650ce703031c6973e315dd5"
+checksum = "4a1091a7bb1f8f2c4b28f1fe2cef4980ca2d410a3d727d67ecc3178c9b0800f0"
 dependencies = [
  "enum-ordinalize-derive",
 ]
 
 [[package]]
 name = "enum-ordinalize-derive"
-version = "4.3.1"
+version = "4.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0d28318a75d4aead5c4db25382e8ef717932d0346600cacae6357eb5941bc5ff"
+checksum = "8ca9601fb2d62598ee17836250842873a413586e5d7ed88b356e38ddbb0ec631"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -2257,9 +2256,9 @@ checksum = "28dea519a9695b9977216879a3ebfddf92f1c08c05d984f8996aecd6ecdc811d"
 
 [[package]]
 name = "find-msvc-tools"
-version = "0.1.4"
+version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "52051878f80a721bb68ebfbc930e07b65ba72f2da88968ea5c06fd6ca3d3a127"
+checksum = "3a3076410a55c90011c298b04d0cfa770b00fa04e1e3c97d3f6c9de105a03844"
 
 [[package]]
 name = "five8"
@@ -2267,7 +2266,16 @@ version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a75b8549488b4715defcb0d8a8a1c1c76a80661b5fa106b4ca0e7fce59d7d875"
 dependencies = [
- "five8_core",
+ "five8_core 0.1.2",
+]
+
+[[package]]
+name = "five8"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "23f76610e969fa1784327ded240f1e28a3fd9520c9cec93b636fcf62dd37f772"
+dependencies = [
+ "five8_core 1.0.0",
 ]
 
 [[package]]
@@ -2276,7 +2284,16 @@ version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "26dec3da8bc3ef08f2c04f61eab298c3ab334523e55f076354d6d6f613799a7b"
 dependencies = [
- "five8_core",
+ "five8_core 0.1.2",
+]
+
+[[package]]
+name = "five8_const"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a0f1728185f277989ca573a402716ae0beaaea3f76a8ff87ef9dd8fb19436c5"
+dependencies = [
+ "five8_core 1.0.0",
 ]
 
 [[package]]
@@ -2285,11 +2302,17 @@ version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2551bf44bc5f776c15044b9b94153a00198be06743e262afaaa61f11ac7523a5"
 
+[[package]]
+name = "five8_core"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "059c31d7d36c43fe39d89e55711858b4da8be7eb6dabac23c7289b1a19489406"
+
 [[package]]
 name = "flate2"
-version = "1.1.4"
+version = "1.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc5a4e564e38c699f2880d3fda590bedc2e69f3f84cd48b457bd892ce61d0aa9"
+checksum = "bfe33edd8e85a12a67454e37f8c75e730830d83e313556ab9ebf9ee7fbeb3bfb"
 dependencies = [
  "crc32fast",
  "miniz_oxide",
@@ -2301,6 +2324,12 @@ version = "1.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
 
+[[package]]
+name = "foldhash"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"
+
 [[package]]
 name = "foreign-types"
 version = "0.3.2"
@@ -2359,7 +2388,7 @@ dependencies = [
  "photon-api",
  "prometheus",
  "rand 0.8.5",
- "reqwest 0.12.24",
+ "reqwest 0.12.26",
  "scopeguard",
  "serde",
  "serde_json",
@@ -2492,7 +2521,7 @@ checksum = "162ee34ebcb7c64a8abebc059ce0fee27c2262618d7b60ed8faf72fef13c3650"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -2533,9 +2562,9 @@ dependencies = [
 
 [[package]]
 name = "generic-array"
-version = "0.14.9"
+version = "0.14.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4bb6743198531e02858aeaea5398fcc883e71851fcbcb5a2f773e2fb6cb1edf2"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
 dependencies = [
  "typenum",
  "version_check",
@@ -2667,10 +2696,10 @@ dependencies = [
  "futures-sink",
  "futures-util",
  "http 0.2.12",
- "indexmap 2.11.4",
+ "indexmap 2.12.1",
  "slab",
  "tokio",
- "tokio-util 0.7.16",
+ "tokio-util 0.7.17",
  "tracing",
 ]
 
@@ -2685,11 +2714,11 @@ dependencies = [
  "fnv",
  "futures-core",
  "futures-sink",
- "http 1.3.1",
- "indexmap 2.11.4",
+ "http 1.4.0",
+ "indexmap 2.12.1",
  "slab",
  "tokio",
- "tokio-util 0.7.16",
+ "tokio-util 0.7.17",
  "tracing",
 ]
 
@@ -2725,18 +2754,20 @@ checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"
 
 [[package]]
 name = "hashbrown"
-version = "0.15.5"
+version = "0.15.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1"
+checksum = "bf151400ff0baff5465007dd2f3e717f3fe502074ca563069ce3a6629d07b289"
 dependencies = [
  "allocator-api2",
+ "equivalent",
+ "foldhash",
 ]
 
 [[package]]
 name = "hashbrown"
-version = "0.16.0"
+version = "0.16.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5419bdc4f6a9207fbeba6d11b604d481addf78ecd10c11ad51e76c2f6482748d"
+checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"
 
 [[package]]
 name = "headers"
@@ -2747,7 +2778,7 @@ dependencies = [
  "base64 0.22.1",
  "bytes",
  "headers-core",
- "http 1.3.1",
+ "http 1.4.0",
  "httpdate",
  "mime",
  "sha1",
@@ -2759,7 +2790,7 @@ version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "54b4a22553d4242c49fddb9ba998a99962b5cc6f22cb5a3482bec22522403ce4"
 dependencies = [
- "http 1.3.1",
+ "http 1.4.0",
 ]
 
 [[package]]
@@ -2860,12 +2891,11 @@ dependencies = [
 
 [[package]]
 name = "http"
-version = "1.3.1"
+version = "1.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f4a85d31aea989eead29a3aaf9e1115a180df8282431156e533de47660892565"
+checksum = "e3ba2a386d7f85a81f119ad7498ebe444d2e22c2af0b86b069416ace48b3311a"
 dependencies = [
  "bytes",
- "fnv",
  "itoa",
 ]
 
@@ -2887,7 +2917,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1efedce1fb8e6913f23e0c92de8e62cd5b772a67e7b3946df930a62566c93184"
 dependencies = [
  "bytes",
- "http 1.3.1",
+ "http 1.4.0",
 ]
 
 [[package]]
@@ -2898,7 +2928,7 @@ checksum = "b021d93e26becf5dc7e1b75b1bed1fd93124b374ceb73f43d4d4eafec896a64a"
 dependencies = [
  "bytes",
  "futures-core",
- "http 1.3.1",
+ "http 1.4.0",
  "http-body 1.0.1",
  "pin-project-lite",
 ]
@@ -2947,16 +2977,16 @@ dependencies = [
 
 [[package]]
 name = "hyper"
-version = "1.7.0"
+version = "1.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eb3aa54a13a0dfe7fbe3a59e0c76093041720fdc77b110cc0fc260fafb4dc51e"
+checksum = "2ab2d4f250c3d7b1c9fcdff1cece94ea4e2dfbec68614f7b87cb205f24ca9d11"
 dependencies = [
  "atomic-waker",
  "bytes",
  "futures-channel",
  "futures-core",
  "h2 0.4.12",
- "http 1.3.1",
+ "http 1.4.0",
  "http-body 1.0.1",
  "httparse",
  "itoa",
@@ -2987,15 +3017,15 @@ version = "0.27.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e3c93eb611681b207e1fe55d5a71ecf91572ec8a6705cdb6857f7d8d5242cf58"
 dependencies = [
- "http 1.3.1",
- "hyper 1.7.0",
+ "http 1.4.0",
+ "hyper 1.8.1",
  "hyper-util",
- "rustls 0.23.32",
+ "rustls 0.23.35",
  "rustls-pki-types",
  "tokio",
  "tokio-rustls 0.26.4",
  "tower-service",
- "webpki-roots 1.0.3",
+ "webpki-roots 1.0.4",
 ]
 
 [[package]]
@@ -3019,7 +3049,7 @@ checksum = "70206fc6890eaca9fde8a0bf71caa2ddfc9fe045ac9e5c70df101a7dbde866e0"
 dependencies = [
  "bytes",
  "http-body-util",
- "hyper 1.7.0",
+ "hyper 1.8.1",
  "hyper-util",
  "native-tls",
  "tokio",
@@ -3029,18 +3059,18 @@ dependencies = [
 
 [[package]]
 name = "hyper-util"
-version = "0.1.17"
+version = "0.1.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c6995591a8f1380fcb4ba966a252a4b29188d51d2b89e3a252f5305be65aea8"
+checksum = "727805d60e7938b76b826a6ef209eb70eaa1812794f9424d4a4e2d740662df5f"
 dependencies = [
  "base64 0.22.1",
  "bytes",
  "futures-channel",
  "futures-core",
  "futures-util",
- "http 1.3.1",
+ "http 1.4.0",
  "http-body 1.0.1",
- "hyper 1.7.0",
+ "hyper 1.8.1",
  "ipnet",
  "libc",
  "percent-encoding",
@@ -3079,9 +3109,9 @@ dependencies = [
 
 [[package]]
 name = "icu_collections"
-version = "2.0.0"
+version = "2.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "200072f5d0e3614556f94a9930d5dc3e0662a652823904c3a75dc3b0af7fee47"
+checksum = "4c6b649701667bbe825c3b7e6388cb521c23d88644678e83c0c4d0a621a34b43"
 dependencies = [
  "displaydoc",
  "potential_utf",
@@ -3092,9 +3122,9 @@ dependencies = [
 
 [[package]]
 name = "icu_locale_core"
-version = "2.0.0"
+version = "2.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0cde2700ccaed3872079a65fb1a78f6c0a36c91570f28755dda67bc8f7d9f00a"
+checksum = "edba7861004dd3714265b4db54a3c390e880ab658fec5f7db895fae2046b5bb6"
 dependencies = [
  "displaydoc",
  "litemap",
@@ -3105,11 +3135,10 @@ dependencies = [
 
 [[package]]
 name = "icu_normalizer"
-version = "2.0.0"
+version = "2.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "436880e8e18df4d7bbc06d58432329d6458cc84531f7ac5f024e93deadb37979"
+checksum = "5f6c8828b67bf8908d82127b2054ea1b4427ff0230ee9141c54251934ab1b599"
 dependencies = [
- "displaydoc",
  "icu_collections",
  "icu_normalizer_data",
  "icu_properties",
@@ -3120,42 +3149,38 @@ dependencies = [
 
 [[package]]
 name = "icu_normalizer_data"
-version = "2.0.0"
+version = "2.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "00210d6893afc98edb752b664b8890f0ef174c8adbb8d0be9710fa66fbbf72d3"
+checksum = "7aedcccd01fc5fe81e6b489c15b247b8b0690feb23304303a9e560f37efc560a"
 
 [[package]]
 name = "icu_properties"
-version = "2.0.1"
+version = "2.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "016c619c1eeb94efb86809b015c58f479963de65bdb6253345c1a1276f22e32b"
+checksum = "020bfc02fe870ec3a66d93e677ccca0562506e5872c650f893269e08615d74ec"
 dependencies = [
- "displaydoc",
  "icu_collections",
  "icu_locale_core",
  "icu_properties_data",
  "icu_provider",
- "potential_utf",
  "zerotrie",
  "zerovec",
 ]
 
 [[package]]
 name = "icu_properties_data"
-version = "2.0.1"
+version = "2.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "298459143998310acd25ffe6810ed544932242d3f07083eee1084d83a71bd632"
+checksum = "616c294cf8d725c6afcd8f55abc17c56464ef6211f9ed59cccffe534129c77af"
 
 [[package]]
 name = "icu_provider"
-version = "2.0.0"
+version = "2.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "03c80da27b5f4187909049ee2d72f276f0d9f99a42c306bd0131ecfe04d8e5af"
+checksum = "85962cf0ce02e1e0a629cc34e7ca3e373ce20dda4c4d7294bbd0bf1fdb59e614"
 dependencies = [
  "displaydoc",
  "icu_locale_core",
- "stable_deref_trait",
- "tinystr",
  "writeable",
  "yoke",
  "zerofrom",
@@ -3203,12 +3228,12 @@ dependencies = [
 
 [[package]]
 name = "indexmap"
-version = "2.11.4"
+version = "2.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4b0f83760fb341a774ed326568e19f5a863af4a952def8c39f9ab92fd95b88e5"
+checksum = "0ad4bb2b565bca0645f4d68c5c9af97fba094e9791da685bf83cb5f3ce74acf2"
 dependencies = [
  "equivalent",
- "hashbrown 0.16.0",
+ "hashbrown 0.16.1",
  "serde",
  "serde_core",
 ]
@@ -3243,9 +3268,9 @@ checksum = "469fb0b9cefa57e3ef31275ee7cacb78f2fdca44e4765491884a2b119d4eb130"
 
 [[package]]
 name = "iri-string"
-version = "0.7.8"
+version = "0.7.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dbc5ebe9c3a1a7a5127f920a418f7585e9e758e911d0466ed004f393b0e380b2"
+checksum = "4f867b9d1d896b67beb18518eda36fdb77a32ea590de864f1325b294a6d14397"
 dependencies = [
  "memchr",
  "serde",
@@ -3253,9 +3278,9 @@ dependencies = [
 
 [[package]]
 name = "is_terminal_polyfill"
-version = "1.70.1"
+version = "1.70.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7943c866cc5cd64cbc25b2e01621d07fa8eb2a1a23160ee81ce38704e97b8ecf"
+checksum = "a6cb138bb79a146c1bd460005623e142ef0181e3d0219cb493e02f7d08a35695"
 
 [[package]]
 name = "itertools"
@@ -3301,26 +3326,26 @@ checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
 
 [[package]]
 name = "jiff"
-version = "0.2.15"
+version = "0.2.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "be1f93b8b1eb69c77f24bbb0afdf66f54b632ee39af40ca21c4365a1d7347e49"
+checksum = "49cce2b81f2098e7e3efc35bc2e0a6b7abec9d34128283d7a26fa8f32a6dbb35"
 dependencies = [
  "jiff-static",
  "log",
  "portable-atomic",
  "portable-atomic-util",
- "serde",
+ "serde_core",
 ]
 
 [[package]]
 name = "jiff-static"
-version = "0.2.15"
+version = "0.2.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "03343451ff899767262ec32146f6d559dd759fdadf42ff0e227c7c48f72594b4"
+checksum = "980af8b43c3ad5d8d349ace167ec8170839f753a42d233ba19e08afe1850fa69"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -3357,9 +3382,9 @@ dependencies = [
 
 [[package]]
 name = "js-sys"
-version = "0.3.81"
+version = "0.3.83"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec48937a97411dcb524a265206ccd4c90bb711fca92b2792c407f268825b9305"
+checksum = "464a3709c7f55f1f721e5389aa6ea4e3bc6aba669353300af094b29ffbdde1d8"
 dependencies = [
  "once_cell",
  "wasm-bindgen",
@@ -3407,9 +3432,9 @@ checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
 
 [[package]]
 name = "libc"
-version = "0.2.177"
+version = "0.2.178"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2874a2af47a2325c2001a6e6fad9b16a53b802102b528163885171cf92b15976"
+checksum = "37c93d8daa9d8a012fd8ab92f088405fb202ea0b6ab73ee2482ae66af4f42091"
 
 [[package]]
 name = "libm"
@@ -3419,13 +3444,13 @@ checksum = "f9fbbcab51052fe104eb5e5d351cf728d30a5be1fe14d9be8a3b097481fb97de"
 
 [[package]]
 name = "libredox"
-version = "0.1.10"
+version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "416f7e718bdb06000964960ffa43b4335ad4012ae8b99060261aa4a8088d5ccb"
+checksum = "df15f6eac291ed1cf25865b1ee60399f57e7c227e7f51bdbd4c5270396a9ed50"
 dependencies = [
- "bitflags 2.9.4",
+ "bitflags 2.10.0",
  "libc",
- "redox_syscall",
+ "redox_syscall 0.6.0",
 ]
 
 [[package]]
@@ -3561,6 +3586,7 @@ dependencies = [
  "lazy_static",
  "light-compressed-account",
  "light-concurrent-merkle-tree",
+ "light-ctoken-interface",
  "light-ctoken-sdk",
  "light-event",
  "light-hasher",
@@ -3656,8 +3682,7 @@ dependencies = [
  "solana-security-txt",
  "spl-pod",
  "spl-token 7.0.0",
- "spl-token-2022 7.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "spl-token-2022 7.0.0 (git+https://github.com/Lightprotocol/token-2022?rev=06d12f50a06db25d73857d253b9a82857d6f4cdf)",
+ "spl-token-2022 7.0.0",
  "tinyvec",
  "zerocopy",
 ]
@@ -3751,7 +3776,7 @@ dependencies = [
  "solana-pubkey 2.4.0",
  "solana-sysvar",
  "spl-pod",
- "spl-token-2022 7.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "spl-token-2022 7.0.0",
  "spl-token-metadata-interface 0.6.0",
  "thiserror 2.0.17",
  "tinyvec",
@@ -3784,7 +3809,7 @@ dependencies = [
  "solana-program-error 2.2.2",
  "solana-pubkey 2.4.0",
  "spl-pod",
- "spl-token-2022 7.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "spl-token-2022 7.0.0",
  "thiserror 2.0.17",
 ]
 
@@ -3891,7 +3916,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "solana-pubkey 2.4.0",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -3954,7 +3979,7 @@ checksum = "0a8be18fe4de58a6f754caa74a3fbc6d8a758a26f1f3c24d5b0f5b55df5f5408"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -4004,7 +4029,7 @@ dependencies = [
  "num-traits",
  "photon-api",
  "rand 0.8.5",
- "reqwest 0.12.24",
+ "reqwest 0.12.26",
  "serde",
  "serde_json",
  "solana-account",
@@ -4017,7 +4042,7 @@ dependencies = [
  "solana-transaction",
  "solana-transaction-status",
  "solana-transaction-status-client-types",
- "spl-token-2022 7.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "spl-token-2022 7.0.0",
  "tabled",
  "tokio",
 ]
@@ -4064,6 +4089,7 @@ dependencies = [
  "light-merkle-tree-metadata",
  "light-program-profiler",
  "light-system-program-anchor",
+ "light-zero-copy",
  "solana-account-info",
  "solana-instruction",
  "solana-pubkey 2.4.0",
@@ -4117,7 +4143,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "solana-pubkey 2.4.0",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -4243,11 +4269,13 @@ dependencies = [
  "num-bigint 0.4.6",
  "num-traits",
  "rand 0.8.5",
- "reqwest 0.12.24",
+ "reqwest 0.12.26",
  "solana-banks-client",
  "solana-sdk",
+ "solana-system-interface 1.0.0",
+ "spl-pod",
  "spl-token 7.0.0",
- "spl-token-2022 7.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "spl-token-2022 7.0.0",
  "thiserror 2.0.17",
 ]
 
@@ -4270,8 +4298,9 @@ dependencies = [
  "solana-pubkey 2.4.0",
  "solana-signature",
  "solana-signer",
+ "solana-system-interface 1.0.0",
  "spl-pod",
- "spl-token-2022 7.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "spl-token-2022 7.0.0",
 ]
 
 [[package]]
@@ -4307,7 +4336,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "rand 0.8.5",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -4318,9 +4347,9 @@ checksum = "df1d3c3b53da64cf5760482273a98e575c651a67eec7f77df96b5b642de8f039"
 
 [[package]]
 name = "litemap"
-version = "0.8.0"
+version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "241eaef5fd12c88705a01fc1066c48c4b36e0dd4377dcdc7ec3942cea7a69956"
+checksum = "6373607a59f0be73a39b6fe456b8192fcc3585f602af20751600e974dd455e77"
 
 [[package]]
 name = "litesvm"
@@ -4333,7 +4362,7 @@ dependencies = [
  "agave-reserved-account-keys",
  "ansi_term",
  "bincode",
- "indexmap 2.11.4",
+ "indexmap 2.12.1",
  "itertools 0.14.0",
  "log",
  "solana-account",
@@ -4396,9 +4425,9 @@ dependencies = [
 
 [[package]]
 name = "log"
-version = "0.4.28"
+version = "0.4.29"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34080505efa8e45a4b816c349525ebe327ceaa8559756f0356cba97ef3bf7432"
+checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897"
 
 [[package]]
 name = "lru-slab"
@@ -4495,13 +4524,13 @@ dependencies = [
 
 [[package]]
 name = "mio"
-version = "1.0.4"
+version = "1.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78bed444cc8a2160f01cbcf811ef18cac863ad68ae8ca62092e8db51d51c761c"
+checksum = "a69bcab0ad47271a0234d9422b131806bf3968021e5dc9328caf2d4cd58557fc"
 dependencies = [
  "libc",
  "wasi 0.11.1+wasi-snapshot-preview1",
- "windows-sys 0.59.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -4540,7 +4569,7 @@ version = "0.30.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "74523f3a35e05aba87a1d978330aef40f67b0304ac79c1c00b294c9830543db6"
 dependencies = [
- "bitflags 2.9.4",
+ "bitflags 2.10.0",
  "cfg-if",
  "cfg_aliases",
  "libc",
@@ -4650,7 +4679,7 @@ checksum = "ed3955f1a9c7c0c15e092f9c887db08b1fc683305fdf6eb6684f22555355e202"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -4706,9 +4735,9 @@ dependencies = [
 
 [[package]]
 name = "num_enum"
-version = "0.7.4"
+version = "0.7.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a973b4e44ce6cad84ce69d797acf9a044532e4184c4f267913d1b546a0727b7a"
+checksum = "b1207a7e20ad57b847bbddc6776b968420d38292bbfe2089accff5e19e82454c"
 dependencies = [
  "num_enum_derive",
  "rustversion",
@@ -4716,14 +4745,14 @@ dependencies = [
 
 [[package]]
 name = "num_enum_derive"
-version = "0.7.4"
+version = "0.7.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77e878c846a8abae00dd069496dbe8751b16ac1c3d6bd2a7283a938e8228f90d"
+checksum = "ff32365de1b6743cb203b710788263c44a03de03802daf96092f2da4fe6ba4d7"
 dependencies = [
  "proc-macro-crate 3.4.0",
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -4749,9 +4778,9 @@ checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
 
 [[package]]
 name = "once_cell_polyfill"
-version = "1.70.1"
+version = "1.70.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a4895175b425cb1f87721b59f0f286c2092bd4af812243672510e1ac53e2e0ad"
+checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe"
 
 [[package]]
 name = "opaque-debug"
@@ -4761,11 +4790,11 @@ checksum = "c08d65885ee38876c4f86fa503fb49d7b507c2b62552df7c70b2fce627e06381"
 
 [[package]]
 name = "openssl"
-version = "0.10.73"
+version = "0.10.75"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8505734d46c8ab1e19a1dce3aef597ad87dcb4c37e7188231769bd6bd51cebf8"
+checksum = "08838db121398ad17ab8531ce9de97b244589089e290a384c900cb9ff7434328"
 dependencies = [
- "bitflags 2.9.4",
+ "bitflags 2.10.0",
  "cfg-if",
  "foreign-types",
  "libc",
@@ -4782,7 +4811,7 @@ checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -4793,18 +4822,18 @@ checksum = "d05e27ee213611ffe7d6348b942e8f942b37114c00cc03cec254295a4a17852e"
 
 [[package]]
 name = "openssl-src"
-version = "300.5.3+3.5.4"
+version = "300.5.4+3.5.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc6bad8cd0233b63971e232cc9c5e83039375b8586d2312f31fda85db8f888c2"
+checksum = "a507b3792995dae9b0df8a1c1e3771e8418b7c2d9f0baeba32e6fe8b06c7cb72"
 dependencies = [
  "cc",
 ]
 
 [[package]]
 name = "openssl-sys"
-version = "0.9.109"
+version = "0.9.111"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90096e2e47630d78b7d1c20952dc621f957103f8bc2c8359ec81290d75238571"
+checksum = "82cab2d520aa75e3c58898289429321eb788c3106963d0dc886ec7a5f4adc321"
 dependencies = [
  "cc",
  "libc",
@@ -4873,9 +4902,9 @@ checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1"
 dependencies = [
  "cfg-if",
  "libc",
- "redox_syscall",
+ "redox_syscall 0.5.18",
  "smallvec",
- "windows-link 0.2.1",
+ "windows-link",
 ]
 
 [[package]]
@@ -4949,7 +4978,7 @@ dependencies = [
 name = "photon-api"
 version = "0.53.0"
 dependencies = [
- "reqwest 0.12.24",
+ "reqwest 0.12.26",
  "serde",
  "serde_derive",
  "serde_json",
@@ -4975,7 +5004,7 @@ checksum = "6e918e4ff8c4549eb882f14b3a4bc8c8bc93de829416eacf579f1207a8fbf861"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -5025,7 +5054,7 @@ version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cb0225638cadcbebae8932cb7f49cb5da7c15c21beb19f048f05a5ca7d93f065"
 dependencies = [
- "five8_const",
+ "five8_const 0.1.4",
  "pinocchio",
  "sha2-const-stable",
 ]
@@ -5043,7 +5072,7 @@ dependencies = [
 [[package]]
 name = "pinocchio-token-interface"
 version = "0.0.0"
-source = "git+https://github.com/Lightprotocol/token?rev=5d2768b98075ba03dfc5d6e6dd8567ba065c84ba#5d2768b98075ba03dfc5d6e6dd8567ba065c84ba"
+source = "git+https://github.com/Lightprotocol/token?rev=5825b1dd933c2ab77b4c4a954aa20bb8a23b31f8#5825b1dd933c2ab77b4c4a954aa20bb8a23b31f8"
 dependencies = [
  "pinocchio",
  "pinocchio-pubkey",
@@ -5052,7 +5081,7 @@ dependencies = [
 [[package]]
 name = "pinocchio-token-program"
 version = "0.1.0"
-source = "git+https://github.com/Lightprotocol/token?rev=5d2768b98075ba03dfc5d6e6dd8567ba065c84ba#5d2768b98075ba03dfc5d6e6dd8567ba065c84ba"
+source = "git+https://github.com/Lightprotocol/token?rev=5825b1dd933c2ab77b4c4a954aa20bb8a23b31f8#5825b1dd933c2ab77b4c4a954aa20bb8a23b31f8"
 dependencies = [
  "pinocchio",
  "pinocchio-log",
@@ -5123,9 +5152,9 @@ dependencies = [
 
 [[package]]
 name = "potential_utf"
-version = "0.1.3"
+version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "84df19adbe5b5a0782edcab45899906947ab039ccf4573713735ee7de1e6b08a"
+checksum = "b73949432f5e2a09657003c25bca5e19a0e9c84f8058ca374f49e0ebe605af77"
 dependencies = [
  "zerovec",
 ]
@@ -5158,7 +5187,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b"
 dependencies = [
  "proc-macro2",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -5176,7 +5205,7 @@ version = "3.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "219cb19e96be00ab2e37d6e299658a0cfa83e52429179969b0f0121b4ac46983"
 dependencies = [
- "toml_edit 0.23.7",
+ "toml_edit 0.23.10+spec-1.0.0",
 ]
 
 [[package]]
@@ -5198,14 +5227,14 @@ dependencies = [
  "proc-macro-error-attr2",
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.101"
+version = "1.0.103"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "89ae43fd86e4158d6db51ad8e2b80f313af9cc74f5c0e03ccb87de09998732de"
+checksum = "5ee95bc4ef87b8d5ba32e8b7714ccc834865276eab0aed5c9958d00ec45f49e8"
 dependencies = [
  "unicode-ident",
 ]
@@ -5262,7 +5291,7 @@ checksum = "9e2e25ee72f5b24d773cae88422baddefff7714f97aab68d96fe2b6fc4a28fb2"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -5292,7 +5321,7 @@ dependencies = [
  "quinn-proto",
  "quinn-udp",
  "rustc-hash 2.1.1",
- "rustls 0.23.32",
+ "rustls 0.23.35",
  "socket2 0.6.1",
  "thiserror 2.0.17",
  "tokio",
@@ -5313,7 +5342,7 @@ dependencies = [
  "rand 0.9.2",
  "ring",
  "rustc-hash 2.1.1",
- "rustls 0.23.32",
+ "rustls 0.23.35",
  "rustls-pki-types",
  "rustls-platform-verifier",
  "slab",
@@ -5339,9 +5368,9 @@ dependencies = [
 
 [[package]]
 name = "quote"
-version = "1.0.41"
+version = "1.0.42"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ce25767e7b499d1b604768e7cde645d14cc8584231ea6b295e9c9eb22c02e1d1"
+checksum = "a338cc41d27e6cc6dce6cefc13a0729dfbb81c262b1f519331575dd80ef3067f"
 dependencies = [
  "proc-macro2",
 ]
@@ -5464,7 +5493,7 @@ version = "11.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "498cd0dc59d73224351ee52a95fee0f1a617a2eae0e7d9d720cc622c73a54186"
 dependencies = [
- "bitflags 2.9.4",
+ "bitflags 2.10.0",
 ]
 
 [[package]]
@@ -5493,7 +5522,16 @@ version = "0.5.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d"
 dependencies = [
- "bitflags 2.9.4",
+ "bitflags 2.10.0",
+]
+
+[[package]]
+name = "redox_syscall"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec96166dafa0886eb81fe1c0a388bece180fbef2135f97c1e2cf8302e74b43b5"
+dependencies = [
+ "bitflags 2.10.0",
 ]
 
 [[package]]
@@ -5535,7 +5573,7 @@ checksum = "b7186006dcb21920990093f30e3dea63b7d6e977bf1256be20c3563a5db070da"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -5641,11 +5679,10 @@ dependencies = [
 
 [[package]]
 name = "reqwest"
-version = "0.12.24"
+version = "0.12.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9d0946410b9f7b082a427e4ef5c8ff541a88b357bc6c637c40db3a68ac70a36f"
+checksum = "3b4c14b2d9afca6a60277086b0cc6a6ae0b568f6f7916c943a8cdc79f8be240f"
 dependencies = [
- "async-compression",
  "base64 0.22.1",
  "bytes",
  "encoding_rs",
@@ -5653,10 +5690,10 @@ dependencies = [
  "futures-core",
  "futures-util",
  "h2 0.4.12",
- "http 1.3.1",
+ "http 1.4.0",
  "http-body 1.0.1",
  "http-body-util",
- "hyper 1.7.0",
+ "hyper 1.8.1",
  "hyper-rustls 0.27.7",
  "hyper-tls 0.6.0",
  "hyper-util",
@@ -5668,7 +5705,7 @@ dependencies = [
  "percent-encoding",
  "pin-project-lite",
  "quinn",
- "rustls 0.23.32",
+ "rustls 0.23.35",
  "rustls-pki-types",
  "serde",
  "serde_json",
@@ -5677,7 +5714,6 @@ dependencies = [
  "tokio",
  "tokio-native-tls",
  "tokio-rustls 0.26.4",
- "tokio-util 0.7.16",
  "tower",
  "tower-http",
  "tower-service",
@@ -5685,7 +5721,7 @@ dependencies = [
  "wasm-bindgen",
  "wasm-bindgen-futures",
  "web-sys",
- "webpki-roots 1.0.3",
+ "webpki-roots 1.0.4",
 ]
 
 [[package]]
@@ -5696,8 +5732,8 @@ checksum = "57f17d28a6e6acfe1733fe24bcd30774d13bffa4b8a22535b4c8c98423088d4e"
 dependencies = [
  "anyhow",
  "async-trait",
- "http 1.3.1",
- "reqwest 0.12.24",
+ "http 1.4.0",
+ "reqwest 0.12.26",
  "serde",
  "thiserror 1.0.69",
  "tower-service",
@@ -5780,7 +5816,7 @@ version = "1.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cd15f8a2c5551a84d56efdc1cd049089e409ac19a3072d5037a17fd70719ff3e"
 dependencies = [
- "bitflags 2.9.4",
+ "bitflags 2.10.0",
  "errno",
  "libc",
  "linux-raw-sys",
@@ -5801,23 +5837,23 @@ dependencies = [
 
 [[package]]
 name = "rustls"
-version = "0.23.32"
+version = "0.23.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd3c25631629d034ce7cd9940adc9d45762d46de2b0f57193c4443b92c6d4d40"
+checksum = "533f54bc6a7d4f647e46ad909549eda97bf5afc1585190ef692b4286b198bd8f"
 dependencies = [
  "once_cell",
  "ring",
  "rustls-pki-types",
- "rustls-webpki 0.103.7",
+ "rustls-webpki 0.103.8",
  "subtle",
  "zeroize",
 ]
 
 [[package]]
 name = "rustls-native-certs"
-version = "0.8.1"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7fcff2dd52b58a8d98a70243663a0d234c4e2b79235637849d15913394a247d3"
+checksum = "9980d917ebb0c0536119ba501e90834767bffc3d60641457fd84a1f3fd337923"
 dependencies = [
  "openssl-probe",
  "rustls-pki-types",
@@ -5836,9 +5872,9 @@ dependencies = [
 
 [[package]]
 name = "rustls-pki-types"
-version = "1.12.0"
+version = "1.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "229a4a4c221013e7e1f1a043678c5cc39fe5171437c88fb47151a21e6f5b5c79"
+checksum = "21e6f2ab2928ca4291b86736a8bd920a277a399bba1589409d72154ff87c1282"
 dependencies = [
  "web-time",
  "zeroize",
@@ -5846,23 +5882,23 @@ dependencies = [
 
 [[package]]
 name = "rustls-platform-verifier"
-version = "0.6.1"
+version = "0.6.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "be59af91596cac372a6942530653ad0c3a246cdd491aaa9dcaee47f88d67d5a0"
+checksum = "1d99feebc72bae7ab76ba994bb5e121b8d83d910ca40b36e0921f53becc41784"
 dependencies = [
  "core-foundation 0.10.1",
  "core-foundation-sys",
  "jni",
  "log",
  "once_cell",
- "rustls 0.23.32",
+ "rustls 0.23.35",
  "rustls-native-certs",
  "rustls-platform-verifier-android",
- "rustls-webpki 0.103.7",
+ "rustls-webpki 0.103.8",
  "security-framework 3.5.1",
  "security-framework-sys",
  "webpki-root-certs",
- "windows-sys 0.59.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -5883,9 +5919,9 @@ dependencies = [
 
 [[package]]
 name = "rustls-webpki"
-version = "0.103.7"
+version = "0.103.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e10b3f4191e8a80e6b43eebabfac91e5dcecebb27a71f04e820c47ec41d314bf"
+checksum = "2ffdfa2f5286e2247234e03f680868ac2815974dc39e00ea15adc445d0aafe52"
 dependencies = [
  "ring",
  "rustls-pki-types",
@@ -5945,9 +5981,9 @@ dependencies = [
 
 [[package]]
 name = "schemars"
-version = "1.0.4"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "82d20c4491bc164fa2f6c5d44565947a52ad80b9505d8e36f8d54c27c739fcd0"
+checksum = "9558e172d4e8533736ba97870c4b2cd63f84b382a3d6eb063da41b91cce17289"
 dependencies = [
  "dyn-clone",
  "ref-cast",
@@ -6045,6 +6081,7 @@ dependencies = [
  "borsh 0.10.4",
  "light-client",
  "light-compressed-account",
+ "light-compressible",
  "light-compressible-client",
  "light-ctoken-interface",
  "light-ctoken-sdk",
@@ -6056,7 +6093,7 @@ dependencies = [
  "solana-program",
  "solana-sdk",
  "spl-pod",
- "spl-token-2022 7.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "spl-token-2022 7.0.0",
  "tokio",
 ]
 
@@ -6161,7 +6198,7 @@ version = "2.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "897b2245f0b511c87893af39b033e5ca9cce68824c4d7e7630b5a1d339658d02"
 dependencies = [
- "bitflags 2.9.4",
+ "bitflags 2.10.0",
  "core-foundation 0.9.4",
  "core-foundation-sys",
  "libc",
@@ -6174,7 +6211,7 @@ version = "3.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b3297343eaf830f66ede390ea39da1d462b6b0c1b000f420d0a83f898bbbe6ef"
 dependencies = [
- "bitflags 2.9.4",
+ "bitflags 2.10.0",
  "core-foundation 0.10.1",
  "core-foundation-sys",
  "libc",
@@ -6243,7 +6280,7 @@ checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -6270,9 +6307,9 @@ dependencies = [
 
 [[package]]
 name = "serde_spanned"
-version = "1.0.3"
+version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e24345aa0fe688594e73770a5f6d1b216508b4f93484c0026d521acd30134392"
+checksum = "f8bbf91e5a4d6315eee45e704372590b30e260ee83af6639d64557f51b067776"
 dependencies = [
  "serde_core",
 ]
@@ -6291,17 +6328,17 @@ dependencies = [
 
 [[package]]
 name = "serde_with"
-version = "3.15.0"
+version = "3.16.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6093cd8c01b25262b84927e0f7151692158fab02d961e04c979d3903eba7ecc5"
+checksum = "4fa237f2807440d238e0364a218270b98f767a00d3dada77b1c53ae88940e2e7"
 dependencies = [
  "base64 0.22.1",
  "chrono",
  "hex",
  "indexmap 1.9.3",
- "indexmap 2.11.4",
+ "indexmap 2.12.1",
  "schemars 0.9.0",
- "schemars 1.0.4",
+ "schemars 1.1.0",
  "serde_core",
  "serde_json",
  "serde_with_macros",
@@ -6310,14 +6347,14 @@ dependencies = [
 
 [[package]]
 name = "serde_with_macros"
-version = "3.15.0"
+version = "3.16.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a7e6c180db0816026a61afa1cff5344fb7ebded7e4d3062772179f2501481c27"
+checksum = "52a8e3ca0ca629121f70ab50f95249e5a6f925cc0f6ffe8256c45b728875706c"
 dependencies = [
  "darling",
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -6326,7 +6363,7 @@ version = "0.9.34+deprecated"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6a8b1a1a2ebf674015cc02edccce75287f1a0130d394307b36743c2f5d504b47"
 dependencies = [
- "indexmap 2.11.4",
+ "indexmap 2.12.1",
  "itoa",
  "ryu",
  "serde",
@@ -6355,7 +6392,7 @@ checksum = "5d69265a08751de7844521fd15003ae0a888e035773ba05695c5c759a6f89eef"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -6420,9 +6457,9 @@ dependencies = [
 
 [[package]]
 name = "shell-words"
-version = "1.1.0"
+version = "1.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "24188a676b6ae68c3b2cb3a01be17fbf7240ce009799bb56d5b1409051e78fde"
+checksum = "dc6fe69c597f9c37bfeeeeeb33da3530379845f10be461a66d16d03eca2ded77"
 
 [[package]]
 name = "shlex"
@@ -6442,9 +6479,9 @@ dependencies = [
 
 [[package]]
 name = "signal-hook-registry"
-version = "1.4.6"
+version = "1.4.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b2a4719bff48cee6b39d12c020eeb490953ad2443b7055bd0b21fca26bd8c28b"
+checksum = "7664a098b8e616bdfcc2dc0e9ac44eb231eedf41db4e9fe95d8d32ec728dedad"
 dependencies = [
  "libc",
 ]
@@ -6457,9 +6494,9 @@ checksum = "74233d3b3b2f6d4b006dc19dee745e73e2a6bfb6f93607cd3b02bd5b00797d7c"
 
 [[package]]
 name = "simd-adler32"
-version = "0.3.7"
+version = "0.3.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d66dc143e6b11c1eddc06d5c423cfc97062865baf299914ab64caa38182078fe"
+checksum = "e320a6c5ad31d271ad523dcf3ad13e2767ad8b1cb8f047f75a8aeaf8da139da2"
 
 [[package]]
 name = "siphasher"
@@ -6597,17 +6634,26 @@ dependencies = [
 
 [[package]]
 name = "solana-address"
-version = "1.0.0"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a2ecac8e1b7f74c2baa9e774c42817e3e75b20787134b76cc4d45e8a604488f5"
+dependencies = [
+ "solana-address 2.0.0",
+]
+
+[[package]]
+name = "solana-address"
+version = "2.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0a7a457086457ea9db9a5199d719dc8734dc2d0342fad0d8f77633c31eb62f19"
+checksum = "e37320fd2945c5d654b2c6210624a52d66c3f1f73b653ed211ab91a703b35bdd"
 dependencies = [
- "five8",
- "five8_const",
+ "five8 1.0.0",
+ "five8_const 1.0.0",
  "solana-atomic-u64 3.0.0",
- "solana-define-syscall 3.0.0",
+ "solana-define-syscall 4.0.1",
  "solana-program-error 3.0.0",
  "solana-sanitize 3.0.1",
- "solana-sha256-hasher 3.0.0",
+ "solana-sha256-hasher 3.1.0",
 ]
 
 [[package]]
@@ -6651,7 +6697,7 @@ version = "2.3.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "68548570c38a021c724b5aa0112f45a54bdf7ff1b041a042848e034a95a96994"
 dependencies = [
- "borsh 1.5.7",
+ "borsh 1.6.0",
  "futures",
  "solana-account",
  "solana-banks-interface",
@@ -6750,7 +6796,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "718333bcd0a1a7aed6655aa66bef8d7fb047944922b2d3a18f49cbc13e73d004"
 dependencies = [
  "borsh 0.10.4",
- "borsh 1.5.7",
+ "borsh 1.6.0",
 ]
 
 [[package]]
@@ -6937,7 +6983,7 @@ dependencies = [
  "dashmap 5.5.3",
  "futures",
  "futures-util",
- "indexmap 2.11.4",
+ "indexmap 2.12.1",
  "indicatif",
  "log",
  "quinn",
@@ -7064,7 +7110,7 @@ version = "2.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8432d2c4c22d0499aa06d62e4f7e333f81777b3d7c96050ae9e5cb71a8c3aee4"
 dependencies = [
- "borsh 1.5.7",
+ "borsh 1.6.0",
  "serde",
  "serde_derive",
  "solana-instruction",
@@ -7103,7 +7149,7 @@ dependencies = [
  "bincode",
  "crossbeam-channel",
  "futures-util",
- "indexmap 2.11.4",
+ "indexmap 2.12.1",
  "log",
  "rand 0.8.5",
  "rayon",
@@ -7170,6 +7216,12 @@ version = "3.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f9697086a4e102d28a156b8d6b521730335d6951bd39a5e766512bbe09007cee"
 
+[[package]]
+name = "solana-define-syscall"
+version = "4.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "57e5b1c0bc1d4a4d10c88a4100499d954c09d3fecfae4912c1a074dff68b1738"
+
 [[package]]
 name = "solana-derivation-path"
 version = "2.2.1"
@@ -7378,10 +7430,10 @@ version = "2.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b5b96e9f0300fa287b545613f007dfe20043d7812bee255f418c1eb649c93b63"
 dependencies = [
- "borsh 1.5.7",
+ "borsh 1.6.0",
  "bytemuck",
  "bytemuck_derive",
- "five8",
+ "five8 0.2.1",
  "js-sys",
  "serde",
  "serde_derive",
@@ -7392,14 +7444,9 @@ dependencies = [
 
 [[package]]
 name = "solana-hash"
-version = "3.0.0"
+version = "4.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a063723b9e84c14d8c0d2cdf0268207dc7adecf546e31251f9e07c7b00b566c"
-dependencies = [
- "five8",
- "solana-atomic-u64 3.0.0",
- "solana-sanitize 3.0.1",
-]
+checksum = "6a5d48a6ee7b91fc7b998944ab026ed7b3e2fc8ee3bc58452644a86c2648152f"
 
 [[package]]
 name = "solana-inflation"
@@ -7413,17 +7460,18 @@ dependencies = [
 
 [[package]]
 name = "solana-instruction"
-version = "2.3.0"
+version = "2.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "47298e2ce82876b64f71e9d13a46bc4b9056194e7f9937ad3084385befa50885"
+checksum = "bab5682934bd1f65f8d2c16f21cb532526fcc1a09f796e2cacdb091eee5774ad"
 dependencies = [
  "bincode",
- "borsh 1.5.7",
+ "borsh 1.6.0",
  "getrandom 0.2.16",
  "js-sys",
  "num-traits",
  "serde",
  "serde_derive",
+ "serde_json",
  "solana-define-syscall 2.3.0",
  "solana-pubkey 2.4.0",
  "wasm-bindgen",
@@ -7435,7 +7483,7 @@ version = "2.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e0e85a6fad5c2d0c4f5b91d34b8ca47118fc593af706e523cdbedf846a954f57"
 dependencies = [
- "bitflags 2.9.4",
+ "bitflags 2.10.0",
  "solana-account-info",
  "solana-instruction",
  "solana-program-error 2.2.2",
@@ -7466,7 +7514,7 @@ checksum = "bd3f04aa1a05c535e93e121a95f66e7dcccf57e007282e8255535d24bf1e98bb"
 dependencies = [
  "ed25519-dalek",
  "ed25519-dalek-bip32",
- "five8",
+ "five8 0.2.1",
  "rand 0.7.3",
  "solana-derivation-path",
  "solana-pubkey 2.4.0",
@@ -7619,7 +7667,7 @@ dependencies = [
  "crossbeam-channel",
  "gethostname",
  "log",
- "reqwest 0.12.24",
+ "reqwest 0.12.26",
  "solana-cluster-type",
  "solana-sha256-hasher 2.3.0",
  "solana-time-utils",
@@ -7735,7 +7783,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "004f2d2daf407b3ec1a1ca5ec34b3ccdfd6866dd2d3c7d0715004a96e4b6d127"
 dependencies = [
  "bincode",
- "bitflags 2.9.4",
+ "bitflags 2.10.0",
  "cfg_eval",
  "serde",
  "serde_derive",
@@ -7843,7 +7891,7 @@ dependencies = [
  "bincode",
  "blake3",
  "borsh 0.10.4",
- "borsh 1.5.7",
+ "borsh 1.6.0",
  "bs58",
  "bytemuck",
  "console_error_panic_hook",
@@ -7932,7 +7980,7 @@ version = "2.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9ee2e0217d642e2ea4bee237f37bd61bb02aec60da3647c48ff88f6556ade775"
 dependencies = [
- "borsh 1.5.7",
+ "borsh 1.6.0",
  "num-traits",
  "serde",
  "serde_derive",
@@ -8023,12 +8071,12 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9b62adb9c3261a052ca1f999398c388f1daf558a1b492f60a6d9e64857db4ff1"
 dependencies = [
  "borsh 0.10.4",
- "borsh 1.5.7",
+ "borsh 1.6.0",
  "bytemuck",
  "bytemuck_derive",
  "curve25519-dalek 4.1.3",
- "five8",
- "five8_const",
+ "five8 0.2.1",
+ "five8_const 0.1.4",
  "getrandom 0.2.16",
  "js-sys",
  "num-traits",
@@ -8049,7 +8097,7 @@ version = "3.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8909d399deb0851aa524420beeb5646b115fd253ef446e35fe4504c904da3941"
 dependencies = [
- "solana-address",
+ "solana-address 1.1.0",
 ]
 
 [[package]]
@@ -8092,7 +8140,7 @@ dependencies = [
  "log",
  "quinn",
  "quinn-proto",
- "rustls 0.23.32",
+ "rustls 0.23.35",
  "solana-connection-cache",
  "solana-keypair",
  "solana-measure",
@@ -8226,7 +8274,7 @@ dependencies = [
  "futures",
  "indicatif",
  "log",
- "reqwest 0.12.24",
+ "reqwest 0.12.26",
  "reqwest-middleware",
  "semver",
  "serde",
@@ -8261,7 +8309,7 @@ checksum = "2dbc138685c79d88a766a8fd825057a74ea7a21e1dd7f8de275ada899540fff7"
 dependencies = [
  "anyhow",
  "jsonrpc-core",
- "reqwest 0.12.24",
+ "reqwest 0.12.26",
  "reqwest-middleware",
  "serde",
  "serde_derive",
@@ -8436,7 +8484,7 @@ dependencies = [
  "bs58",
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -8464,7 +8512,7 @@ version = "2.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "baa3120b6cdaa270f39444f5093a90a7b03d296d362878f7a6991d6de3bbe496"
 dependencies = [
- "borsh 1.5.7",
+ "borsh 1.6.0",
  "libsecp256k1",
  "solana-define-syscall 2.3.0",
  "thiserror 2.0.17",
@@ -8486,9 +8534,12 @@ dependencies = [
 
 [[package]]
 name = "solana-security-txt"
-version = "1.1.1"
+version = "1.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "468aa43b7edb1f9b7b7b686d5c3aeb6630dc1708e86e31343499dd5c4d775183"
+checksum = "156bb61a96c605fa124e052d630dba2f6fb57e08c7d15b757e1e958b3ed7b3fe"
+dependencies = [
+ "hashbrown 0.15.2",
+]
 
 [[package]]
 name = "solana-seed-derivable"
@@ -8552,13 +8603,13 @@ dependencies = [
 
 [[package]]
 name = "solana-sha256-hasher"
-version = "3.0.0"
+version = "3.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a9b912ba6f71cb202c0c3773ec77bf898fa9fe0c78691a2d6859b3b5b8954719"
+checksum = "db7dc3011ea4c0334aaaa7e7128cb390ecf546b28d412e9bf2064680f57f588f"
 dependencies = [
  "sha2 0.10.9",
- "solana-define-syscall 3.0.0",
- "solana-hash 3.0.0",
+ "solana-define-syscall 4.0.1",
+ "solana-hash 4.0.1",
 ]
 
 [[package]]
@@ -8588,7 +8639,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "64c8ec8e657aecfc187522fc67495142c12f35e55ddeca8698edbb738b8dbd8c"
 dependencies = [
  "ed25519-dalek",
- "five8",
+ "five8 0.2.1",
  "rand 0.8.5",
  "serde",
  "serde-big-array",
@@ -8650,7 +8701,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5269e89fde216b4d7e1d1739cf5303f8398a1ff372a81232abbee80e554a838c"
 dependencies = [
  "borsh 0.10.4",
- "borsh 1.5.7",
+ "borsh 1.6.0",
  "num-traits",
  "serde",
  "serde_derive",
@@ -8707,7 +8758,7 @@ dependencies = [
  "futures-util",
  "governor 0.6.3",
  "histogram",
- "indexmap 2.11.4",
+ "indexmap 2.12.1",
  "itertools 0.12.1",
  "libc",
  "log",
@@ -8717,7 +8768,7 @@ dependencies = [
  "quinn",
  "quinn-proto",
  "rand 0.8.5",
- "rustls 0.23.32",
+ "rustls 0.23.35",
  "smallvec",
  "socket2 0.5.10",
  "solana-keypair",
@@ -8736,7 +8787,7 @@ dependencies = [
  "solana-transaction-metrics-tracker",
  "thiserror 2.0.17",
  "tokio",
- "tokio-util 0.7.16",
+ "tokio-util 0.7.17",
  "x509-parser",
 ]
 
@@ -8940,7 +8991,7 @@ version = "2.3.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "14494aa87a75a883d1abcfee00f1278a28ecc594a2f030084879eb40570728f6"
 dependencies = [
- "rustls 0.23.32",
+ "rustls 0.23.35",
  "solana-keypair",
  "solana-pubkey 2.4.0",
  "solana-signer",
@@ -8956,7 +9007,7 @@ dependencies = [
  "async-trait",
  "bincode",
  "futures-util",
- "indexmap 2.11.4",
+ "indexmap 2.12.1",
  "indicatif",
  "log",
  "rayon",
@@ -9063,7 +9114,7 @@ dependencies = [
  "agave-reserved-account-keys",
  "base64 0.22.1",
  "bincode",
- "borsh 1.5.7",
+ "borsh 1.6.0",
  "bs58",
  "log",
  "serde",
@@ -9344,7 +9395,7 @@ version = "6.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "76fee7d65013667032d499adc3c895e286197a35a0d3a4643c80e7fd3e9969e3"
 dependencies = [
- "borsh 1.5.7",
+ "borsh 1.6.0",
  "num-derive 0.4.2",
  "num-traits",
  "solana-program",
@@ -9360,7 +9411,7 @@ version = "7.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ae179d4a26b3c7a20c839898e6aed84cb4477adf108a366c95532f058aea041b"
 dependencies = [
- "borsh 1.5.7",
+ "borsh 1.6.0",
  "num-derive 0.4.2",
  "num-traits",
  "solana-program",
@@ -9400,7 +9451,7 @@ checksum = "d9e8418ea6269dcfb01c712f0444d2c75542c04448b480e87de59d2865edc750"
 dependencies = [
  "quote",
  "spl-discriminator-syn",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -9412,7 +9463,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "sha2 0.10.9",
- "syn 2.0.106",
+ "syn 2.0.111",
  "thiserror 1.0.69",
 ]
 
@@ -9426,19 +9477,7 @@ dependencies = [
  "solana-program",
  "solana-zk-sdk",
  "spl-pod",
- "spl-token-confidential-transfer-proof-extraction 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "spl-elgamal-registry"
-version = "0.1.1"
-source = "git+https://github.com/Lightprotocol/token-2022?rev=06d12f50a06db25d73857d253b9a82857d6f4cdf#06d12f50a06db25d73857d253b9a82857d6f4cdf"
-dependencies = [
- "bytemuck",
- "solana-program",
- "solana-zk-sdk",
- "spl-pod",
- "spl-token-confidential-transfer-proof-extraction 0.2.1 (git+https://github.com/Lightprotocol/token-2022?rev=06d12f50a06db25d73857d253b9a82857d6f4cdf)",
+ "spl-token-confidential-transfer-proof-extraction 0.2.1",
 ]
 
 [[package]]
@@ -9494,7 +9533,7 @@ version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d994afaf86b779104b4a95ba9ca75b8ced3fdb17ee934e38cb69e72afbe17799"
 dependencies = [
- "borsh 1.5.7",
+ "borsh 1.6.0",
  "bytemuck",
  "bytemuck_derive",
  "num-derive 0.4.2",
@@ -9545,7 +9584,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "sha2 0.10.9",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -9557,7 +9596,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "sha2 0.10.9",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -9661,12 +9700,12 @@ dependencies = [
  "solana-program",
  "solana-security-txt",
  "solana-zk-sdk",
- "spl-elgamal-registry 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "spl-elgamal-registry 0.1.1",
  "spl-memo",
  "spl-pod",
  "spl-token 7.0.0",
- "spl-token-confidential-transfer-ciphertext-arithmetic 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "spl-token-confidential-transfer-proof-extraction 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "spl-token-confidential-transfer-ciphertext-arithmetic 0.2.1",
+ "spl-token-confidential-transfer-proof-extraction 0.2.1",
  "spl-token-confidential-transfer-proof-generation 0.2.0",
  "spl-token-group-interface 0.5.0",
  "spl-token-metadata-interface 0.6.0",
@@ -9689,40 +9728,13 @@ dependencies = [
  "solana-program",
  "solana-security-txt",
  "solana-zk-sdk",
- "spl-elgamal-registry 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "spl-memo",
- "spl-pod",
- "spl-token 7.0.0",
- "spl-token-confidential-transfer-ciphertext-arithmetic 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "spl-token-confidential-transfer-proof-extraction 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "spl-token-confidential-transfer-proof-generation 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "spl-token-group-interface 0.5.0",
- "spl-token-metadata-interface 0.6.0",
- "spl-transfer-hook-interface 0.9.0",
- "spl-type-length-value 0.7.0",
- "thiserror 2.0.17",
-]
-
-[[package]]
-name = "spl-token-2022"
-version = "7.0.0"
-source = "git+https://github.com/Lightprotocol/token-2022?rev=06d12f50a06db25d73857d253b9a82857d6f4cdf#06d12f50a06db25d73857d253b9a82857d6f4cdf"
-dependencies = [
- "arrayref",
- "bytemuck",
- "num-derive 0.4.2",
- "num-traits",
- "num_enum",
- "solana-program",
- "solana-security-txt",
- "solana-zk-sdk",
- "spl-elgamal-registry 0.1.1 (git+https://github.com/Lightprotocol/token-2022?rev=06d12f50a06db25d73857d253b9a82857d6f4cdf)",
+ "spl-elgamal-registry 0.1.1",
  "spl-memo",
  "spl-pod",
  "spl-token 7.0.0",
- "spl-token-confidential-transfer-ciphertext-arithmetic 0.2.1 (git+https://github.com/Lightprotocol/token-2022?rev=06d12f50a06db25d73857d253b9a82857d6f4cdf)",
- "spl-token-confidential-transfer-proof-extraction 0.2.1 (git+https://github.com/Lightprotocol/token-2022?rev=06d12f50a06db25d73857d253b9a82857d6f4cdf)",
- "spl-token-confidential-transfer-proof-generation 0.3.0 (git+https://github.com/Lightprotocol/token-2022?rev=06d12f50a06db25d73857d253b9a82857d6f4cdf)",
+ "spl-token-confidential-transfer-ciphertext-arithmetic 0.2.1",
+ "spl-token-confidential-transfer-proof-extraction 0.2.1",
+ "spl-token-confidential-transfer-proof-generation 0.3.0",
  "spl-token-group-interface 0.5.0",
  "spl-token-metadata-interface 0.6.0",
  "spl-transfer-hook-interface 0.9.0",
@@ -9786,17 +9798,6 @@ dependencies = [
  "solana-zk-sdk",
 ]
 
-[[package]]
-name = "spl-token-confidential-transfer-ciphertext-arithmetic"
-version = "0.2.1"
-source = "git+https://github.com/Lightprotocol/token-2022?rev=06d12f50a06db25d73857d253b9a82857d6f4cdf#06d12f50a06db25d73857d253b9a82857d6f4cdf"
-dependencies = [
- "base64 0.22.1",
- "bytemuck",
- "solana-curve25519",
- "solana-zk-sdk",
-]
-
 [[package]]
 name = "spl-token-confidential-transfer-ciphertext-arithmetic"
 version = "0.3.1"
@@ -9823,19 +9824,6 @@ dependencies = [
  "thiserror 2.0.17",
 ]
 
-[[package]]
-name = "spl-token-confidential-transfer-proof-extraction"
-version = "0.2.1"
-source = "git+https://github.com/Lightprotocol/token-2022?rev=06d12f50a06db25d73857d253b9a82857d6f4cdf#06d12f50a06db25d73857d253b9a82857d6f4cdf"
-dependencies = [
- "bytemuck",
- "solana-curve25519",
- "solana-program",
- "solana-zk-sdk",
- "spl-pod",
- "thiserror 2.0.17",
-]
-
 [[package]]
 name = "spl-token-confidential-transfer-proof-extraction"
 version = "0.3.0"
@@ -9878,16 +9866,6 @@ dependencies = [
  "thiserror 2.0.17",
 ]
 
-[[package]]
-name = "spl-token-confidential-transfer-proof-generation"
-version = "0.3.0"
-source = "git+https://github.com/Lightprotocol/token-2022?rev=06d12f50a06db25d73857d253b9a82857d6f4cdf#06d12f50a06db25d73857d253b9a82857d6f4cdf"
-dependencies = [
- "curve25519-dalek 4.1.3",
- "solana-zk-sdk",
- "thiserror 2.0.17",
-]
-
 [[package]]
 name = "spl-token-confidential-transfer-proof-generation"
 version = "0.4.1"
@@ -9943,7 +9921,7 @@ version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dfb9c89dbc877abd735f05547dcf9e6e12c00c11d6d74d8817506cab4c99fdbb"
 dependencies = [
- "borsh 1.5.7",
+ "borsh 1.6.0",
  "num-derive 0.4.2",
  "num-traits",
  "solana-borsh",
@@ -9964,7 +9942,7 @@ version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "304d6e06f0de0c13a621464b1fd5d4b1bebf60d15ca71a44d3839958e0da16ee"
 dependencies = [
- "borsh 1.5.7",
+ "borsh 1.6.0",
  "num-derive 0.4.2",
  "num-traits",
  "solana-borsh",
@@ -10119,9 +10097,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "2.0.106"
+version = "2.0.111"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ede7c438028d4436d71104916910f5bb611972c5cfd7f89b8300a8186e6fada6"
+checksum = "390cc9a294ab71bdb1aa2e99d13be9c753cd2d7bd6560c77118597410c4d2e87"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -10163,7 +10141,7 @@ checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -10183,7 +10161,7 @@ version = "0.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3c879d448e9d986b661742763247d3693ed13609438cf3d006f51f5368a5ba6b"
 dependencies = [
- "bitflags 2.9.4",
+ "bitflags 2.10.0",
  "core-foundation 0.9.4",
  "system-configuration-sys 0.6.0",
 ]
@@ -10319,7 +10297,7 @@ dependencies = [
  "proc-macro-error2",
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -10330,9 +10308,9 @@ checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
 
 [[package]]
 name = "target-triple"
-version = "0.1.4"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ac9aa371f599d22256307c24a9d748c041e548cbf599f35d890f9d365361790"
+checksum = "591ef38edfb78ca4771ee32cf494cb8771944bee237a9b91fc9c1424ac4b777b"
 
 [[package]]
 name = "tarpc"
@@ -10435,7 +10413,7 @@ checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -10446,7 +10424,7 @@ checksum = "3ff15c8ecd7de3849db632e14d18d2571fa09dfc5ed93479bc4485c7a517c913"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -10510,9 +10488,9 @@ dependencies = [
 
 [[package]]
 name = "tinystr"
-version = "0.8.1"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5d4f6d1145dcb577acf783d4e601bc1d76a13337bb54e6233add580b07344c8b"
+checksum = "42d3e9c45c09de15d06dd8acf5f4e0e399e85927b7f00711024eb7ae10fa4869"
 dependencies = [
  "displaydoc",
  "zerovec",
@@ -10558,7 +10536,7 @@ checksum = "af407857209536a95c8e56f8231ef2c2e2aff839b22e07a1ffcbc617e9db9fa5"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -10593,7 +10571,7 @@ dependencies = [
  "rand 0.9.2",
  "socket2 0.6.1",
  "tokio",
- "tokio-util 0.7.16",
+ "tokio-util 0.7.17",
  "whoami",
 ]
 
@@ -10613,7 +10591,7 @@ version = "0.26.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1729aa945f29d91ba541258c8df89027d5792d85a8841fb65e8bf0f4ede4ef61"
 dependencies = [
- "rustls 0.23.32",
+ "rustls 0.23.35",
  "tokio",
 ]
 
@@ -10676,9 +10654,9 @@ dependencies = [
 
 [[package]]
 name = "tokio-util"
-version = "0.7.16"
+version = "0.7.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "14307c986784f72ef81c89db7d9e28d6ac26d16213b109ea501696195e6e3ce5"
+checksum = "2efa149fe76073d6e8fd97ef4f4eca7b67f599660115591483572e406e165594"
 dependencies = [
  "bytes",
  "futures-core",
@@ -10710,14 +10688,14 @@ dependencies = [
 
 [[package]]
 name = "toml"
-version = "0.9.8"
+version = "0.9.9+spec-1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f0dc8b1fb61449e27716ec0e1bdf0f6b8f3e8f6b05391e8497b8b6d7804ea6d8"
+checksum = "eb5238e643fc34a1d5d7e753e1532a91912d74b63b92b3ea51fde8d1b7bc79dd"
 dependencies = [
- "indexmap 2.11.4",
+ "indexmap 2.12.1",
  "serde_core",
- "serde_spanned 1.0.3",
- "toml_datetime 0.7.3",
+ "serde_spanned 1.0.4",
+ "toml_datetime 0.7.4+spec-1.0.0",
  "toml_parser",
  "toml_writer",
  "winnow",
@@ -10734,9 +10712,9 @@ dependencies = [
 
 [[package]]
 name = "toml_datetime"
-version = "0.7.3"
+version = "0.7.4+spec-1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2cdb639ebbc97961c51720f858597f7f24c4fc295327923af55b74c3c724533"
+checksum = "fe3cea6b2aa3b910092f6abd4053ea464fab5f9c170ba5e9a6aead16ec4af2b6"
 dependencies = [
  "serde_core",
 ]
@@ -10747,7 +10725,7 @@ version = "0.22.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "41fe8c660ae4257887cf66394862d21dbca4a6ddd26f04a3560410406a2f819a"
 dependencies = [
- "indexmap 2.11.4",
+ "indexmap 2.12.1",
  "serde",
  "serde_spanned 0.6.9",
  "toml_datetime 0.6.11",
@@ -10757,21 +10735,21 @@ dependencies = [
 
 [[package]]
 name = "toml_edit"
-version = "0.23.7"
+version = "0.23.10+spec-1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6485ef6d0d9b5d0ec17244ff7eb05310113c3f316f2d14200d4de56b3cb98f8d"
+checksum = "84c8b9f757e028cee9fa244aea147aab2a9ec09d5325a9b01e0a49730c2b5269"
 dependencies = [
- "indexmap 2.11.4",
- "toml_datetime 0.7.3",
+ "indexmap 2.12.1",
+ "toml_datetime 0.7.4+spec-1.0.0",
  "toml_parser",
  "winnow",
 ]
 
 [[package]]
 name = "toml_parser"
-version = "1.0.4"
+version = "1.0.5+spec-1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0cbe268d35bdb4bb5a56a2de88d0ad0eb70af5384a99d648cd4b3d04039800e"
+checksum = "4c03bee5ce3696f31250db0bbaff18bc43301ce0e8db2ed1f07cbb2acf89984c"
 dependencies = [
  "winnow",
 ]
@@ -10784,9 +10762,9 @@ checksum = "5d99f8c9a7727884afe522e9bd5edbfc91a3312b36a77b5fb8926e4c31a41801"
 
 [[package]]
 name = "toml_writer"
-version = "1.0.4"
+version = "1.0.5+spec-1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "df8b2b54733674ad286d16267dcfc7a71ed5c776e4ac7aa3c3e2561f7c637bf2"
+checksum = "a9cd6190959dce0994aa8970cd32ab116d1851ead27e866039acaf2524ce44fa"
 
 [[package]]
 name = "tower"
@@ -10805,17 +10783,22 @@ dependencies = [
 
 [[package]]
 name = "tower-http"
-version = "0.6.6"
+version = "0.6.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "adc82fd73de2a9722ac5da747f12383d2bfdb93591ee6c58486e0097890f05f2"
+checksum = "d4e6559d53cc268e5031cd8429d05415bc4cb4aefc4aa5d6cc35fbf5b924a1f8"
 dependencies = [
- "bitflags 2.9.4",
+ "async-compression",
+ "bitflags 2.10.0",
  "bytes",
+ "futures-core",
  "futures-util",
- "http 1.3.1",
+ "http 1.4.0",
  "http-body 1.0.1",
+ "http-body-util",
  "iri-string",
  "pin-project-lite",
+ "tokio",
+ "tokio-util 0.7.17",
  "tower",
  "tower-layer",
  "tower-service",
@@ -10835,9 +10818,9 @@ checksum = "8df9b6e13f2d32c91b9bd719c00d1958837bc7dec474d94952798cc8e69eeec3"
 
 [[package]]
 name = "tracing"
-version = "0.1.41"
+version = "0.1.43"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "784e0ac535deb450455cbfa28a6f0df145ea1bb7ae51b821cf5e7927fdcfbdd0"
+checksum = "2d15d90a0b5c19378952d479dc858407149d7bb45a14de0142f6c534b16fc647"
 dependencies = [
  "log",
  "pin-project-lite",
@@ -10847,32 +10830,32 @@ dependencies = [
 
 [[package]]
 name = "tracing-appender"
-version = "0.2.3"
+version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3566e8ce28cc0a3fe42519fc80e6b4c943cc4c8cef275620eb8dac2d3d4e06cf"
+checksum = "786d480bce6247ab75f005b14ae1624ad978d3029d9113f0a22fa1ac773faeaf"
 dependencies = [
  "crossbeam-channel",
- "thiserror 1.0.69",
+ "thiserror 2.0.17",
  "time",
  "tracing-subscriber",
 ]
 
 [[package]]
 name = "tracing-attributes"
-version = "0.1.30"
+version = "0.1.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "81383ab64e72a7a8b8e13130c49e3dab29def6d0c7d76a03087b3cf71c5c6903"
+checksum = "7490cfa5ec963746568740651ac6781f701c9c5ea257c58e057f3ba8cf69e8da"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
 name = "tracing-core"
-version = "0.1.34"
+version = "0.1.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b9d12581f227e93f094d3af2ae690a574abb8a2b9b7a96e7cfe9647b2b617678"
+checksum = "7a04e24fab5c89c6a36eb8558c9656f30d81de51dfa4d3b45f26b21d61fa0a6c"
 dependencies = [
  "once_cell",
  "valuable",
@@ -10914,9 +10897,9 @@ dependencies = [
 
 [[package]]
 name = "tracing-subscriber"
-version = "0.3.20"
+version = "0.3.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2054a14f5307d601f88daf0553e1cbf472acc4f2c51afab632431cdcd72124d5"
+checksum = "2f30143827ddab0d256fd843b7a66d164e9f271cfa0dde49142c5ca0ca291f1e"
 dependencies = [
  "matchers",
  "nu-ansi-term",
@@ -10941,9 +10924,9 @@ checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b"
 
 [[package]]
 name = "trybuild"
-version = "1.0.112"
+version = "1.0.114"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4d66678374d835fe847e0dc8348fde2ceb5be4a7ec204437d8367f0d8df266a5"
+checksum = "3e17e807bff86d2a06b52bca4276746584a78375055b6e45843925ce2802b335"
 dependencies = [
  "glob",
  "serde",
@@ -10951,7 +10934,7 @@ dependencies = [
  "serde_json",
  "target-triple",
  "termcolor",
- "toml 0.9.8",
+ "toml 0.9.9+spec-1.0.0",
 ]
 
 [[package]]
@@ -10995,24 +10978,24 @@ checksum = "5c1cb5db39152898a79168971543b1cb5020dff7fe43c8dc468b0885f5e29df5"
 
 [[package]]
 name = "unicode-ident"
-version = "1.0.19"
+version = "1.0.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f63a545481291138910575129486daeaf8ac54aee4387fe7906919f7830c7d9d"
+checksum = "9312f7c4f6ff9069b165498234ce8be658059c6728633667c526e27dc2cf1df5"
 
 [[package]]
 name = "unicode-normalization"
-version = "0.1.24"
+version = "0.1.25"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5033c97c4262335cded6d6fc3e5c18ab755e1a3dc96376350f3d8e9f009ad956"
+checksum = "5fd4f6878c9cb28d874b009da9e8d183b5abc80117c40bbd187a1fde336be6e8"
 dependencies = [
  "tinyvec",
 ]
 
 [[package]]
 name = "unicode-properties"
-version = "0.1.3"
+version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e70f2a8b45122e719eb623c01822704c4e0907e7e426a05927e1a1cfff5b75d0"
+checksum = "7df058c713841ad818f1dc5d3fd88063241cc61f49f5fbea4b951e8cf5a8d71d"
 
 [[package]]
 name = "unicode-segmentation"
@@ -11111,13 +11094,13 @@ checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
 
 [[package]]
 name = "uuid"
-version = "1.18.1"
+version = "1.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2f87b8aa10b915a06587d0dec516c282ff295b475d94abf425d62b57710070a2"
+checksum = "e2e054861b4bd027cd373e18e8d8d8e6548085000e41290d95ce0c373a654b4a"
 dependencies = [
  "getrandom 0.3.4",
  "js-sys",
- "serde",
+ "serde_core",
  "wasm-bindgen",
 ]
 
@@ -11179,7 +11162,7 @@ dependencies = [
  "bytes",
  "futures-util",
  "headers",
- "http 1.3.1",
+ "http 1.4.0",
  "http-body 1.0.1",
  "http-body-util",
  "log",
@@ -11192,7 +11175,7 @@ dependencies = [
  "serde_json",
  "serde_urlencoded",
  "tokio",
- "tokio-util 0.7.16",
+ "tokio-util 0.7.17",
  "tower-service",
  "tracing",
 ]
@@ -11226,9 +11209,9 @@ checksum = "b8dad83b4f25e74f184f64c43b150b91efe7647395b42289f38e50566d82855b"
 
 [[package]]
 name = "wasm-bindgen"
-version = "0.2.104"
+version = "0.2.106"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c1da10c01ae9f1ae40cbfac0bac3b1e724b320abfcf52229f80b547c0d250e2d"
+checksum = "0d759f433fa64a2d763d1340820e46e111a7a5ab75f993d1852d70b03dbb80fd"
 dependencies = [
  "cfg-if",
  "once_cell",
@@ -11237,25 +11220,11 @@ dependencies = [
  "wasm-bindgen-shared",
 ]
 
-[[package]]
-name = "wasm-bindgen-backend"
-version = "0.2.104"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "671c9a5a66f49d8a47345ab942e2cb93c7d1d0339065d4f8139c486121b43b19"
-dependencies = [
- "bumpalo",
- "log",
- "proc-macro2",
- "quote",
- "syn 2.0.106",
- "wasm-bindgen-shared",
-]
-
 [[package]]
 name = "wasm-bindgen-futures"
-version = "0.4.54"
+version = "0.4.56"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7e038d41e478cc73bae0ff9b36c60cff1c98b8f38f8d7e8061e79ee63608ac5c"
+checksum = "836d9622d604feee9e5de25ac10e3ea5f2d65b41eac0d9ce72eb5deae707ce7c"
 dependencies = [
  "cfg-if",
  "js-sys",
@@ -11266,9 +11235,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.104"
+version = "0.2.106"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ca60477e4c59f5f2986c50191cd972e3a50d8a95603bc9434501cf156a9a119"
+checksum = "48cb0d2638f8baedbc542ed444afc0644a29166f1595371af4fecf8ce1e7eeb3"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
@@ -11276,31 +11245,31 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.104"
+version = "0.2.106"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9f07d2f20d4da7b26400c9f4a0511e6e0345b040694e8a75bd41d578fa4421d7"
+checksum = "cefb59d5cd5f92d9dcf80e4683949f15ca4b511f4ac0a6e14d4e1ac60c6ecd40"
 dependencies = [
+ "bumpalo",
  "proc-macro2",
  "quote",
- "syn 2.0.106",
- "wasm-bindgen-backend",
+ "syn 2.0.111",
  "wasm-bindgen-shared",
 ]
 
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.104"
+version = "0.2.106"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bad67dc8b2a1a6e5448428adec4c3e84c43e561d8c9ee8a9e5aabeb193ec41d1"
+checksum = "cbc538057e648b67f72a982e708d485b2efa771e1ac05fec311f9f63e5800db4"
 dependencies = [
  "unicode-ident",
 ]
 
 [[package]]
 name = "web-sys"
-version = "0.3.81"
+version = "0.3.83"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9367c417a924a74cae129e6a2ae3b47fabb1f8995595ab474029da749a8be120"
+checksum = "9b32828d774c412041098d182a8b38b16ea816958e07cf40eec2bc080ae137ac"
 dependencies = [
  "js-sys",
  "wasm-bindgen",
@@ -11318,9 +11287,9 @@ dependencies = [
 
 [[package]]
 name = "webpki-root-certs"
-version = "1.0.3"
+version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "05d651ec480de84b762e7be71e6efa7461699c19d9e2c272c8d93455f567786e"
+checksum = "ee3e3b5f5e80bc89f30ce8d0343bf4e5f12341c51f3e26cbeecbc7c85443e85b"
 dependencies = [
  "rustls-pki-types",
 ]
@@ -11342,9 +11311,9 @@ checksum = "5f20c57d8d7db6d3b86154206ae5d8fba62dd39573114de97c2cb0578251f8e1"
 
 [[package]]
 name = "webpki-roots"
-version = "1.0.3"
+version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32b130c0d2d49f8b6889abc456e795e82525204f27c42cf767cf0d7734e089b8"
+checksum = "b2878ef029c47c6e8cf779119f20fcf52bde7ad42a731b2a304bc221df17571e"
 dependencies = [
  "rustls-pki-types",
 ]
@@ -11399,9 +11368,9 @@ checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb"
 dependencies = [
  "windows-implement",
  "windows-interface",
- "windows-link 0.2.1",
- "windows-result 0.4.1",
- "windows-strings 0.5.1",
+ "windows-link",
+ "windows-result",
+ "windows-strings",
 ]
 
 [[package]]
@@ -11412,7 +11381,7 @@ checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -11423,15 +11392,9 @@ checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
-[[package]]
-name = "windows-link"
-version = "0.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e6ad25900d524eaabdbbb96d20b4311e1e7ae1699af4fb28c17ae66c80d798a"
-
 [[package]]
 name = "windows-link"
 version = "0.2.1"
@@ -11440,22 +11403,13 @@ checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
 
 [[package]]
 name = "windows-registry"
-version = "0.5.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b8a9ed28765efc97bbc954883f4e6796c33a06546ebafacbabee9696967499e"
-dependencies = [
- "windows-link 0.1.3",
- "windows-result 0.3.4",
- "windows-strings 0.4.2",
-]
-
-[[package]]
-name = "windows-result"
-version = "0.3.4"
+version = "0.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "56f42bd332cc6c8eac5af113fc0c1fd6a8fd2aa08a0119358686e5160d0586c6"
+checksum = "02752bf7fbdcce7f2a27a742f798510f3e5ad88dbe84871e5168e2120c3d5720"
 dependencies = [
- "windows-link 0.1.3",
+ "windows-link",
+ "windows-result",
+ "windows-strings",
 ]
 
 [[package]]
@@ -11464,16 +11418,7 @@ version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5"
 dependencies = [
- "windows-link 0.2.1",
-]
-
-[[package]]
-name = "windows-strings"
-version = "0.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "56e6c93f3a0c3b36176cb1327a4958a0353d5d166c2a35cb268ace15e91d3b57"
-dependencies = [
- "windows-link 0.1.3",
+ "windows-link",
 ]
 
 [[package]]
@@ -11482,7 +11427,7 @@ version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091"
 dependencies = [
- "windows-link 0.2.1",
+ "windows-link",
 ]
 
 [[package]]
@@ -11536,7 +11481,7 @@ version = "0.61.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
 dependencies = [
- "windows-link 0.2.1",
+ "windows-link",
 ]
 
 [[package]]
@@ -11591,7 +11536,7 @@ version = "0.53.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4945f9f551b88e0d65f3db0bc25c33b8acea4d9e41163edf90dcd0b19f9069f3"
 dependencies = [
- "windows-link 0.2.1",
+ "windows-link",
  "windows_aarch64_gnullvm 0.53.1",
  "windows_aarch64_msvc 0.53.1",
  "windows_i686_gnu 0.53.1",
@@ -11784,9 +11729,9 @@ checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650"
 
 [[package]]
 name = "winnow"
-version = "0.7.13"
+version = "0.7.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "21a0236b59786fed61e2a80582dd500fe61f18b5dca67a4a067d0bc9039339cf"
+checksum = "5a5364e9d77fcdeeaa6062ced926ee3381faa2ee02d3eb83a5c27a8825540829"
 dependencies = [
  "memchr",
 ]
@@ -11809,9 +11754,9 @@ checksum = "f17a85883d4e6d00e8a97c586de764dabcc06133f7f1d55dce5cdc070ad7fe59"
 
 [[package]]
 name = "writeable"
-version = "0.6.1"
+version = "0.6.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ea2f10b9bb0928dfb1b42b65e1f9e36f7f54dbdf08457afefb38afcdec4fa2bb"
+checksum = "9edde0db4769d2dc68579893f2306b26c6ecfbe0ef499b013d731b7b9247e0b9"
 
 [[package]]
 name = "wyz"
@@ -11882,11 +11827,10 @@ dependencies = [
 
 [[package]]
 name = "yoke"
-version = "0.8.0"
+version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f41bb01b8226ef4bfd589436a297c53d118f65921786300e427be8d487695cc"
+checksum = "72d6e5c6afb84d73944e5cedb052c4680d5657337201555f9f2a16b7406d4954"
 dependencies = [
- "serde",
  "stable_deref_trait",
  "yoke-derive",
  "zerofrom",
@@ -11894,13 +11838,13 @@ dependencies = [
 
 [[package]]
 name = "yoke-derive"
-version = "0.8.0"
+version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38da3c9736e16c5d3c8c597a9aaa5d1fa565d0532ae05e27c24aa62fb32c0ab6"
+checksum = "b659052874eb698efe5b9e8cf382204678a0086ebf46982b79d6ca3182927e5d"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
  "synstructure 0.13.2",
 ]
 
@@ -11918,22 +11862,22 @@ dependencies = [
 
 [[package]]
 name = "zerocopy"
-version = "0.8.27"
+version = "0.8.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0894878a5fa3edfd6da3f88c4805f4c8558e2b996227a3d864f47fe11e38282c"
+checksum = "fd74ec98b9250adb3ca554bdde269adf631549f51d8a8f8f0a10b50f1cb298c3"
 dependencies = [
  "zerocopy-derive",
 ]
 
 [[package]]
 name = "zerocopy-derive"
-version = "0.8.27"
+version = "0.8.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "88d2b8d9c68ad2b9e4340d7832716a4d21a22a1154777ad56ea55c51a9cf3831"
+checksum = "d8a8d209fdf45cf5138cbb5a506f6b52522a25afccc534d1475dad8e31105c6a"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -11953,7 +11897,7 @@ checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
  "synstructure 0.13.2",
 ]
 
@@ -11974,14 +11918,14 @@ checksum = "ce36e65b0d2999d2aafac989fb249189a141aee1f53c612c1f37d72631959f69"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
 name = "zerotrie"
-version = "0.2.2"
+version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "36f0bbd478583f79edad978b407914f61b2972f5af6fa089686016be8f9af595"
+checksum = "2a59c17a5562d507e4b54960e8569ebee33bee890c70aa3fe7b97e85a9fd7851"
 dependencies = [
  "displaydoc",
  "yoke",
@@ -11990,9 +11934,9 @@ dependencies = [
 
 [[package]]
 name = "zerovec"
-version = "0.11.4"
+version = "0.11.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e7aa2bd55086f1ab526693ecbe444205da57e25f4489879da80635a46d90e73b"
+checksum = "6c28719294829477f525be0186d13efa9a3c602f7ec202ca9e353d310fb9a002"
 dependencies = [
  "yoke",
  "zerofrom",
@@ -12001,13 +11945,13 @@ dependencies = [
 
 [[package]]
 name = "zerovec-derive"
-version = "0.11.1"
+version = "0.11.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b96237efa0c878c64bd89c436f661be4e46b2f3eff1ebb976f7ef2321d2f58f"
+checksum = "eadce39539ca5cb3985590102671f2567e659fca9666581ad3411d59207951f3"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.111",
 ]
 
 [[package]]
diff --git a/Cargo.toml b/Cargo.toml
index e336030c5f..f0633163db 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -232,7 +232,7 @@ groth16-solana = { version = "0.2.0" }
 bytemuck = { version = "1.19.0" }
 arrayvec = "0.7"
 tinyvec = "1.10.0"
-pinocchio-token-program = { git= "https://github.com/Lightprotocol/token", rev="5d2768b98075ba03dfc5d6e6dd8567ba065c84ba" }
+pinocchio-token-program = { git= "https://github.com/Lightprotocol/token", rev="5825b1dd933c2ab77b4c4a954aa20bb8a23b31f8" }
 # Math and crypto
 num-bigint = "0.4.6"
 tabled = "0.20"
diff --git a/forester/src/compressible/bootstrap.rs b/forester/src/compressible/bootstrap.rs
index a2ab22df44..6064129250 100644
--- a/forester/src/compressible/bootstrap.rs
+++ b/forester/src/compressible/bootstrap.rs
@@ -1,10 +1,7 @@
 use std::sync::Arc;
 
 use borsh::BorshDeserialize;
-use light_ctoken_interface::{
-    state::{extensions::ExtensionStruct, CToken},
-    COMPRESSIBLE_TOKEN_ACCOUNT_SIZE, CTOKEN_PROGRAM_ID,
-};
+use light_ctoken_interface::{state::CToken, BASE_TOKEN_ACCOUNT_SIZE, CTOKEN_PROGRAM_ID};
 use serde_json::json;
 use solana_sdk::pubkey::Pubkey;
 use tokio::sync::oneshot;
@@ -116,14 +113,9 @@ fn process_account(
         }
     };
 
-    // Check for Compressible extension
-    let has_compressible = ctoken.extensions.as_ref().is_some_and(|exts| {
-        exts.iter()
-            .any(|ext| matches!(ext, ExtensionStruct::Compressible(_)))
-    });
-
-    if !has_compressible {
-        debug!("Skipping account {} without Compressible extension", pubkey);
+    // Check if account is a valid CToken account (account_type == 2)
+    if !ctoken.is_ctoken_account() {
+        debug!("Skipping account {} without compressible config", pubkey);
         return Ok(false);
     }
 
@@ -207,7 +199,7 @@ async fn bootstrap_with_v2_api(
                 "encoding": "base64",
                 "commitment": "confirmed",
                 "filters": [
-                    {"dataSize": COMPRESSIBLE_TOKEN_ACCOUNT_SIZE}
+                    {"dataSize": BASE_TOKEN_ACCOUNT_SIZE}
                 ],
                 "limit": PAGE_SIZE
             }
@@ -325,7 +317,7 @@ async fn bootstrap_with_standard_api(
                 "encoding": "base64",
                 "commitment": "confirmed",
                 "filters": [
-                    {"dataSize": COMPRESSIBLE_TOKEN_ACCOUNT_SIZE}
+                    {"dataSize": BASE_TOKEN_ACCOUNT_SIZE}
                 ]
             }
         ]
diff --git a/forester/src/compressible/compressor.rs b/forester/src/compressible/compressor.rs
index fe9bbafec6..129125ffa9 100644
--- a/forester/src/compressible/compressor.rs
+++ b/forester/src/compressible/compressor.rs
@@ -121,26 +121,11 @@ impl<R: Rpc> Compressor<R> {
             let mint = Pubkey::new_from_array(account_state.account.mint.to_bytes());
             let mint_index = packed_accounts.insert_or_get(mint);
 
-            // Get compressible extension to extract rent_sponsor and compress_to_pubkey
-            let compressible_ext = account_state
-                .account
-                .extensions
-                .as_ref()
-                .and_then(|exts| {
-                    exts.iter().find_map(|ext| {
-                        if let light_ctoken_interface::state::ExtensionStruct::Compressible(comp) =
-                            ext
-                        {
-                            Some(comp)
-                        } else {
-                            None
-                        }
-                    })
-                })
-                .ok_or_else(|| anyhow::anyhow!("Account missing compressible extension"))?;
+            // Get compression info from embedded field
+            let compression = &account_state.account.compression;
 
             // Determine owner based on compress_to_pubkey flag
-            let compressed_token_owner = if compressible_ext.info.compress_to_pubkey != 0 {
+            let compressed_token_owner = if compression.compress_to_pubkey != 0 {
                 account_state.pubkey // Use account pubkey for PDAs
             } else {
                 Pubkey::new_from_array(account_state.account.owner.to_bytes()) // Use original owner
@@ -148,15 +133,26 @@ impl<R: Rpc> Compressor<R> {
 
             let owner_index = packed_accounts.insert_or_get(compressed_token_owner);
 
-            // Extract rent_sponsor from extension
-            let rent_sponsor = Pubkey::new_from_array(compressible_ext.info.rent_sponsor);
+            // Extract rent_sponsor from compression info
+            let rent_sponsor = Pubkey::new_from_array(compression.rent_sponsor);
             let rent_sponsor_index = packed_accounts.insert_or_get(rent_sponsor);
 
+            // Handle delegate if present
+            let delegate_index = account_state
+                .account
+                .delegate
+                .map(|delegate| {
+                    let delegate_pubkey = Pubkey::new_from_array(delegate.to_bytes());
+                    packed_accounts.insert_or_get(delegate_pubkey)
+                })
+                .unwrap_or(0);
+
             indices_vec.push(CompressAndCloseIndices {
                 source_index,
                 mint_index,
                 owner_index,
                 rent_sponsor_index,
+                delegate_index,
             });
         }
 
diff --git a/forester/src/compressible/state.rs b/forester/src/compressible/state.rs
index 021b8cd10f..26471c4588 100644
--- a/forester/src/compressible/state.rs
+++ b/forester/src/compressible/state.rs
@@ -2,11 +2,8 @@ use std::sync::Arc;
 
 use borsh::BorshDeserialize;
 use dashmap::DashMap;
-use light_ctoken_interface::{
-    state::{extensions::ExtensionStruct, CToken},
-    COMPRESSIBLE_TOKEN_ACCOUNT_SIZE, COMPRESSIBLE_TOKEN_RENT_EXEMPTION,
-};
-use solana_sdk::pubkey::Pubkey;
+use light_ctoken_interface::state::CToken;
+use solana_sdk::{pubkey::Pubkey, rent::Rent};
 use tracing::{debug, warn};
 
 use super::types::CompressibleAccountState;
@@ -14,29 +11,20 @@ use crate::Result;
 
 /// Calculate the slot at which an account becomes compressible
 /// Returns the last funded slot; accounts are compressible when current_slot > this value
-fn calculate_compressible_slot(account: &CToken, lamports: u64) -> Result<u64> {
+fn calculate_compressible_slot(
+    account: &CToken,
+    lamports: u64,
+    account_size: usize,
+) -> Result<u64> {
     use light_compressible::rent::SLOTS_PER_EPOCH;
 
-    // Find the Compressible extension
-    let compressible_ext = account
-        .extensions
-        .as_ref()
-        .and_then(|exts| {
-            exts.iter().find_map(|ext| match ext {
-                ExtensionStruct::Compressible(comp) => Some(comp),
-                _ => None,
-            })
-        })
-        .ok_or_else(|| anyhow::anyhow!("Account missing Compressible extension"))?;
-
-    // Calculate last funded epoch
-    let last_funded_epoch = compressible_ext
-        .info
-        .get_last_funded_epoch(
-            COMPRESSIBLE_TOKEN_ACCOUNT_SIZE,
-            lamports,
-            COMPRESSIBLE_TOKEN_RENT_EXEMPTION,
-        )
+    // Calculate rent exemption dynamically
+    let rent_exemption = Rent::default().minimum_balance(account_size);
+
+    // Calculate last funded epoch using embedded compression info
+    let last_funded_epoch = account
+        .compression
+        .get_last_funded_epoch(account_size as u64, lamports, rent_exemption)
         .map_err(|e| {
             anyhow::anyhow!(
                 "Failed to calculate last funded epoch for account with {} lamports: {:?}",
@@ -73,17 +61,14 @@ impl CompressibleAccountTracker {
         self.accounts.remove(pubkey).map(|(_, v)| v)
     }
 
-    /// Get all accounts with compressible extension
+    /// Get all accounts with compressible configuration
     pub fn get_compressible_accounts(&self) -> Vec<CompressibleAccountState> {
         self.accounts
             .iter()
             .filter(|entry| {
                 let state = entry.value();
-                // Check if account has compressible extension
-                state.account.extensions.as_ref().is_some_and(|exts| {
-                    exts.iter()
-                        .any(|ext| matches!(ext, ExtensionStruct::Compressible(_)))
-                })
+                // Check if account is a valid CToken (account_type == 2)
+                state.account.is_ctoken_account()
             })
             .map(|entry| entry.value().clone())
             .collect()
@@ -124,16 +109,17 @@ impl CompressibleAccountTracker {
             .map_err(|e| anyhow::anyhow!("Failed to deserialize CToken with borsh: {:?}", e))?;
 
         // Calculate compressible slot
-        let compressible_slot = match calculate_compressible_slot(&ctoken, lamports) {
-            Ok(slot) => slot,
-            Err(e) => {
-                warn!(
+        let compressible_slot =
+            match calculate_compressible_slot(&ctoken, lamports, account_data.len()) {
+                Ok(slot) => slot,
+                Err(e) => {
+                    warn!(
                     "Failed to calculate compressible slot for account {}: {}. Skipping account.",
                     pubkey, e
                 );
-                return Ok(());
-            }
-        };
+                    return Ok(());
+                }
+            };
 
         // Create state with full CToken account
         let state = CompressibleAccountState {
diff --git a/forester/src/compressible/subscriber.rs b/forester/src/compressible/subscriber.rs
index 7f73f4bc68..b4fe333ea0 100644
--- a/forester/src/compressible/subscriber.rs
+++ b/forester/src/compressible/subscriber.rs
@@ -1,7 +1,7 @@
 use std::{str::FromStr, sync::Arc};
 
 use futures::StreamExt;
-use light_ctoken_interface::{COMPRESSIBLE_TOKEN_ACCOUNT_SIZE, CTOKEN_PROGRAM_ID};
+use light_ctoken_interface::{BASE_TOKEN_ACCOUNT_SIZE, CTOKEN_PROGRAM_ID};
 use solana_account_decoder::UiAccountEncoding;
 use solana_client::{
     nonblocking::pubsub_client::PubsubClient,
@@ -59,9 +59,7 @@ impl AccountSubscriber {
             .program_subscribe(
                 &program_id,
                 Some(RpcProgramAccountsConfig {
-                    filters: Some(vec![RpcFilterType::DataSize(
-                        COMPRESSIBLE_TOKEN_ACCOUNT_SIZE,
-                    )]),
+                    filters: Some(vec![RpcFilterType::DataSize(BASE_TOKEN_ACCOUNT_SIZE)]),
                     account_config: RpcAccountInfoConfig {
                         encoding: Some(UiAccountEncoding::Base64),
                         commitment: Some(CommitmentConfig::confirmed()),
diff --git a/forester/tests/test_compressible_ctoken.rs b/forester/tests/test_compressible_ctoken.rs
index 77d5fd0f60..f4e77808be 100644
--- a/forester/tests/test_compressible_ctoken.rs
+++ b/forester/tests/test_compressible_ctoken.rs
@@ -538,22 +538,10 @@ async fn run_bootstrap_test(
                 account_state.pubkey
             );
 
-            // Verify account has compressible extension
-            let has_compressible = account_state
-                .account
-                .extensions
-                .as_ref()
-                .is_some_and(|exts| {
-                    exts.iter().any(|ext| {
-                        matches!(
-                            ext,
-                            light_ctoken_interface::state::extensions::ExtensionStruct::Compressible(_)
-                        )
-                    })
-                });
+            // Verify account is a valid CToken
             assert!(
-                has_compressible,
-                "Account {} should have Compressible extension",
+                account_state.account.is_ctoken_account(),
+                "Account {} should be a valid CToken account",
                 account_state.pubkey
             );
 
diff --git a/js/compressed-token/src/v3/actions/decompress-interface.ts b/js/compressed-token/src/v3/actions/decompress-interface.ts
index b62be19cd3..ef8aa7a968 100644
--- a/js/compressed-token/src/v3/actions/decompress-interface.ts
+++ b/js/compressed-token/src/v3/actions/decompress-interface.ts
@@ -15,6 +15,7 @@ import {
 import {
     createAssociatedTokenAccountIdempotentInstruction,
     getAssociatedTokenAddress,
+    getMint,
 } from '@solana/spl-token';
 import BN from 'bn.js';
 import { createDecompressInterfaceInstruction } from '../instructions/create-decompress-interface-instruction';
@@ -163,6 +164,18 @@ export async function decompressInterface(
         computeUnits += 50_000;
     }
 
+    // Fetch decimals for SPL destinations
+    let decimals = 0;
+    if (isSplDestination) {
+        const mintInfo = await getMint(
+            rpc,
+            mint,
+            undefined,
+            splInterfaceInfo.tokenProgram,
+        );
+        decimals = mintInfo.decimals;
+    }
+
     // Add decompressInterface instruction
     instructions.push(
         createDecompressInterfaceInstruction(
@@ -172,6 +185,7 @@ export async function decompressInterface(
             decompressAmount,
             validityProof,
             splInterfaceInfo,
+            decimals,
         ),
     );
 
diff --git a/js/compressed-token/src/v3/actions/load-ata.ts b/js/compressed-token/src/v3/actions/load-ata.ts
index d6a9f7868a..548f569405 100644
--- a/js/compressed-token/src/v3/actions/load-ata.ts
+++ b/js/compressed-token/src/v3/actions/load-ata.ts
@@ -18,6 +18,7 @@ import {
     TOKEN_2022_PROGRAM_ID,
     getAssociatedTokenAddressSync,
     createAssociatedTokenAccountIdempotentInstruction,
+    getMint,
 } from '@solana/spl-token';
 import {
     AccountInterface,
@@ -195,6 +196,7 @@ export async function createLoadAtaInstructionsFromInterface(
         splBalance > BigInt(0) ||
         t22Balance > BigInt(0);
 
+    let decimals = 0;
     if (needsSplInfo) {
         try {
             const splInterfaceInfos =
@@ -203,6 +205,15 @@ export async function createLoadAtaInstructionsFromInterface(
             splInterfaceInfo = splInterfaceInfos.find(
                 (info: SplInterfaceInfo) => info.isInitialized,
             );
+            if (splInterfaceInfo) {
+                const mintInfo = await getMint(
+                    rpc,
+                    mint,
+                    undefined,
+                    splInterfaceInfo.tokenProgram,
+                );
+                decimals = mintInfo.decimals;
+            }
         } catch {
             // No SPL interface exists
         }
@@ -234,6 +245,7 @@ export async function createLoadAtaInstructionsFromInterface(
                     mint,
                     splBalance,
                     splInterfaceInfo,
+                    decimals,
                     payer,
                 ),
             );
@@ -249,6 +261,7 @@ export async function createLoadAtaInstructionsFromInterface(
                     mint,
                     t22Balance,
                     splInterfaceInfo,
+                    decimals,
                     payer,
                 ),
             );
@@ -276,6 +289,8 @@ export async function createLoadAtaInstructionsFromInterface(
                         ctokenAtaAddress,
                         coldBalance,
                         proof,
+                        undefined,
+                        decimals,
                     ),
                 );
             }
@@ -317,6 +332,8 @@ export async function createLoadAtaInstructionsFromInterface(
                             ctokenAtaAddress,
                             coldBalance,
                             proof,
+                            undefined,
+                            decimals,
                         ),
                     );
                 } else if (ataType === 'spl' && splInterfaceInfo) {
@@ -341,6 +358,7 @@ export async function createLoadAtaInstructionsFromInterface(
                             coldBalance,
                             proof,
                             splInterfaceInfo,
+                            decimals,
                         ),
                     );
                 } else if (ataType === 'token2022' && splInterfaceInfo) {
@@ -365,6 +383,7 @@ export async function createLoadAtaInstructionsFromInterface(
                             coldBalance,
                             proof,
                             splInterfaceInfo,
+                            decimals,
                         ),
                     );
                 }
diff --git a/js/compressed-token/src/v3/actions/transfer-interface.ts b/js/compressed-token/src/v3/actions/transfer-interface.ts
index 4675f584ca..40626b8ef8 100644
--- a/js/compressed-token/src/v3/actions/transfer-interface.ts
+++ b/js/compressed-token/src/v3/actions/transfer-interface.ts
@@ -18,6 +18,7 @@ import {
     TOKEN_PROGRAM_ID,
     TOKEN_2022_PROGRAM_ID,
     getAssociatedTokenAddressSync,
+    getMint,
 } from '@solana/spl-token';
 import BN from 'bn.js';
 import { getAtaProgramId } from '../ata-utils';
@@ -264,6 +265,21 @@ export async function transferInterface(
         : [];
     const splInterfaceInfo = splInterfaceInfos.find(info => info.isInitialized);
 
+    // Fetch mint decimals if we need to wrap
+    let decimals = 0;
+    if (
+        splInterfaceInfo &&
+        (splBalance > BigInt(0) || t22Balance > BigInt(0))
+    ) {
+        const mintInfo = await getMint(
+            rpc,
+            mint,
+            undefined,
+            splInterfaceInfo.tokenProgram,
+        );
+        decimals = mintInfo.decimals;
+    }
+
     // Wrap SPL tokens if balance exists (only when wrap=true)
     if (wrap && splAta && splBalance > BigInt(0) && splInterfaceInfo) {
         instructions.push(
@@ -274,6 +290,7 @@ export async function transferInterface(
                 mint,
                 splBalance,
                 splInterfaceInfo,
+                decimals,
                 payer.publicKey,
             ),
         );
@@ -290,6 +307,7 @@ export async function transferInterface(
                 mint,
                 t22Balance,
                 splInterfaceInfo,
+                decimals,
                 payer.publicKey,
             ),
         );
@@ -316,6 +334,8 @@ export async function transferInterface(
                 ctokenAtaAddress,
                 compressedBalance,
                 proof,
+                undefined,
+                decimals,
             ),
         );
     }
diff --git a/js/compressed-token/src/v3/actions/unwrap.ts b/js/compressed-token/src/v3/actions/unwrap.ts
index 3a1bb0541d..0d8f61ee67 100644
--- a/js/compressed-token/src/v3/actions/unwrap.ts
+++ b/js/compressed-token/src/v3/actions/unwrap.ts
@@ -11,6 +11,7 @@ import {
     sendAndConfirmTx,
     dedupeSigner,
 } from '@lightprotocol/stateless.js';
+import { getMint } from '@solana/spl-token';
 import BN from 'bn.js';
 import { createUnwrapInstruction } from '../instructions/unwrap';
 import {
@@ -94,6 +95,14 @@ export async function unwrap(
         );
     }
 
+    // Get mint info to get decimals
+    const mintInfo = await getMint(
+        rpc,
+        mint,
+        undefined,
+        resolvedSplInterfaceInfo.tokenProgram,
+    );
+
     // Build unwrap instruction
     const ix = createUnwrapInstruction(
         ctokenAta,
@@ -102,6 +111,7 @@ export async function unwrap(
         mint,
         unwrapAmount,
         resolvedSplInterfaceInfo,
+        mintInfo.decimals,
         payer.publicKey,
     );
 
diff --git a/js/compressed-token/src/v3/actions/wrap.ts b/js/compressed-token/src/v3/actions/wrap.ts
index 0025deb035..98fe068179 100644
--- a/js/compressed-token/src/v3/actions/wrap.ts
+++ b/js/compressed-token/src/v3/actions/wrap.ts
@@ -11,6 +11,7 @@ import {
     sendAndConfirmTx,
     dedupeSigner,
 } from '@lightprotocol/stateless.js';
+import { getMint } from '@solana/spl-token';
 import { createWrapInstruction } from '../instructions/wrap';
 import {
     getSplInterfaceInfos,
@@ -76,6 +77,14 @@ export async function wrap(
         }
     }
 
+    // Get mint info to get decimals
+    const mintInfo = await getMint(
+        rpc,
+        mint,
+        undefined,
+        resolvedSplInterfaceInfo.tokenProgram,
+    );
+
     // Build wrap instruction
     const ix = createWrapInstruction(
         source,
@@ -84,6 +93,7 @@ export async function wrap(
         mint,
         amount,
         resolvedSplInterfaceInfo,
+        mintInfo.decimals,
         payer.publicKey,
     );
 
diff --git a/js/compressed-token/src/v3/instructions/create-decompress-interface-instruction.ts b/js/compressed-token/src/v3/instructions/create-decompress-interface-instruction.ts
index f7dc5a555c..e50e914634 100644
--- a/js/compressed-token/src/v3/instructions/create-decompress-interface-instruction.ts
+++ b/js/compressed-token/src/v3/instructions/create-decompress-interface-instruction.ts
@@ -96,7 +96,7 @@ function buildInputTokenData(
  *
  * Supports decompressing to both c-token accounts and SPL token accounts:
  * - For c-token destinations: No splInterfaceInfo needed
- * - For SPL destinations: Provide splInterfaceInfo (token pool info)
+ * - For SPL destinations: Provide splInterfaceInfo (token pool info) and decimals
  *
  * @param payer                        Fee payer public key
  * @param inputCompressedTokenAccounts Input compressed token accounts
@@ -104,6 +104,7 @@ function buildInputTokenData(
  * @param amount                       Amount to decompress
  * @param validityProof                Validity proof (contains compressedProof and rootIndices)
  * @param splInterfaceInfo             Optional: SPL interface info for SPL destinations
+ * @param decimals                     Mint decimals (required for SPL destinations)
  * @returns TransactionInstruction
  */
 export function createDecompressInterfaceInstruction(
@@ -112,7 +113,8 @@ export function createDecompressInterfaceInstruction(
     toAddress: PublicKey,
     amount: bigint,
     validityProof: ValidityProofWithContext,
-    splInterfaceInfo?: SplInterfaceInfo,
+    splInterfaceInfo: SplInterfaceInfo | undefined,
+    decimals: number,
 ): TransactionInstruction {
     if (inputCompressedTokenAccounts.length === 0) {
         throw new Error('No input compressed token accounts provided');
@@ -245,7 +247,7 @@ export function createDecompressInterfaceInstruction(
             poolAccountIndex: splInterfaceInfo ? poolAccountIndex : 0,
             poolIndex: splInterfaceInfo ? poolIndex : 0,
             bump: splInterfaceInfo ? poolBump : 0,
-            decimals: 0,
+            decimals,
         },
     ];
 
diff --git a/js/compressed-token/src/v3/instructions/unwrap.ts b/js/compressed-token/src/v3/instructions/unwrap.ts
index 2e2726720c..95d0d71ba0 100644
--- a/js/compressed-token/src/v3/instructions/unwrap.ts
+++ b/js/compressed-token/src/v3/instructions/unwrap.ts
@@ -20,6 +20,7 @@ import {
  * @param mint             Mint address
  * @param amount           Amount to unwrap,
  * @param splInterfaceInfo SPL interface info for the decompression
+ * @param decimals         Mint decimals (required for transfer_checked)
  * @param payer            Fee payer (defaults to owner if not provided)
  * @returns TransactionInstruction to unwrap tokens
  */
@@ -30,6 +31,7 @@ export function createUnwrapInstruction(
     mint: PublicKey,
     amount: bigint,
     splInterfaceInfo: SplInterfaceInfo,
+    decimals: number,
     payer: PublicKey = owner,
 ): TransactionInstruction {
     const MINT_INDEX = 0;
@@ -56,6 +58,7 @@ export function createUnwrapInstruction(
             POOL_INDEX,
             splInterfaceInfo.poolIndex,
             splInterfaceInfo.bump,
+            decimals,
         ),
     ];
 
diff --git a/js/compressed-token/src/v3/instructions/wrap.ts b/js/compressed-token/src/v3/instructions/wrap.ts
index 208b454035..c6271e15d8 100644
--- a/js/compressed-token/src/v3/instructions/wrap.ts
+++ b/js/compressed-token/src/v3/instructions/wrap.ts
@@ -20,6 +20,7 @@ import {
  * @param mint              Mint address
  * @param amount            Amount to wrap,
  * @param splInterfaceInfo  SPL interface info for the compression
+ * @param decimals          Mint decimals (required for transfer_checked)
  * @param payer             Fee payer (defaults to owner)
  * @returns Instruction to wrap tokens
  */
@@ -30,6 +31,7 @@ export function createWrapInstruction(
     mint: PublicKey,
     amount: bigint,
     splInterfaceInfo: SplInterfaceInfo,
+    decimals: number,
     payer: PublicKey = owner,
 ): TransactionInstruction {
     const MINT_INDEX = 0;
@@ -49,6 +51,7 @@ export function createWrapInstruction(
             POOL_INDEX,
             splInterfaceInfo.poolIndex,
             splInterfaceInfo.bump,
+            decimals,
         ),
         createDecompressCtoken(
             amount,
diff --git a/js/compressed-token/src/v3/layout/layout-transfer2.ts b/js/compressed-token/src/v3/layout/layout-transfer2.ts
index e98bc5ce2f..71f2100dea 100644
--- a/js/compressed-token/src/v3/layout/layout-transfer2.ts
+++ b/js/compressed-token/src/v3/layout/layout-transfer2.ts
@@ -214,6 +214,7 @@ export function createCompressSpl(
     poolAccountIndex: number,
     poolIndex: number,
     bump: number,
+    decimals: number,
 ): Compression {
     return {
         mode: COMPRESSION_MODE_COMPRESS,
@@ -224,7 +225,7 @@ export function createCompressSpl(
         poolAccountIndex,
         poolIndex,
         bump,
-        decimals: 0,
+        decimals,
     };
 }
 
@@ -293,6 +294,7 @@ export function createDecompressSpl(
     poolAccountIndex: number,
     poolIndex: number,
     bump: number,
+    decimals: number,
 ): Compression {
     return {
         mode: COMPRESSION_MODE_DECOMPRESS,
@@ -303,6 +305,6 @@ export function createDecompressSpl(
         poolAccountIndex,
         poolIndex,
         bump,
-        decimals: 0,
+        decimals,
     };
 }
diff --git a/js/compressed-token/src/v3/unified/index.ts b/js/compressed-token/src/v3/unified/index.ts
index 5571c1f918..22b7d98a9c 100644
--- a/js/compressed-token/src/v3/unified/index.ts
+++ b/js/compressed-token/src/v3/unified/index.ts
@@ -17,6 +17,7 @@ import {
     createLoadAtaInstructions as _createLoadAtaInstructions,
     loadAta as _loadAta,
 } from '../actions/load-ata';
+import { checkAtaAddress } from '../ata-utils';
 import { transferInterface as _transferInterface } from '../actions/transfer-interface';
 import { _getOrCreateAtaInterface } from '../actions/get-or-create-ata-interface';
 import { getAtaProgramId } from '../ata-utils';
diff --git a/js/compressed-token/tests/e2e/decompress2.test.ts b/js/compressed-token/tests/e2e/decompress2.test.ts
index ee918a83b3..57a5b7b161 100644
--- a/js/compressed-token/tests/e2e/decompress2.test.ts
+++ b/js/compressed-token/tests/e2e/decompress2.test.ts
@@ -431,6 +431,8 @@ describe('decompressInterface', () => {
                 ctokenAta,
                 BigInt(1000),
                 proof,
+                undefined,
+                TEST_TOKEN_DECIMALS,
             );
 
             // Verify instruction structure
@@ -472,6 +474,8 @@ describe('decompressInterface', () => {
                     BigInt(1000),
                     // Minimal mock - instruction throws before using proof
                     { compressedProof: null, rootIndices: [] } as any,
+                    undefined,
+                    TEST_TOKEN_DECIMALS,
                 ),
             ).toThrow('No input compressed token accounts provided');
         });
@@ -527,6 +531,8 @@ describe('decompressInterface', () => {
                 ctokenAta,
                 BigInt(1000),
                 proof,
+                undefined,
+                TEST_TOKEN_DECIMALS,
             );
 
             // Instruction should be valid
@@ -576,6 +582,8 @@ describe('decompressInterface', () => {
                 ctokenAta,
                 BigInt(1000),
                 proof,
+                undefined,
+                TEST_TOKEN_DECIMALS,
             );
 
             // Fee payer should be writable
diff --git a/js/compressed-token/tests/e2e/wrap.test.ts b/js/compressed-token/tests/e2e/wrap.test.ts
index 03638dfab4..4a8f67ed6c 100644
--- a/js/compressed-token/tests/e2e/wrap.test.ts
+++ b/js/compressed-token/tests/e2e/wrap.test.ts
@@ -100,6 +100,7 @@ describe('createWrapInstruction', () => {
             mint,
             BigInt(1000),
             tokenPoolInfo!,
+            TEST_TOKEN_DECIMALS,
         );
 
         expect(ix).toBeDefined();
@@ -131,6 +132,7 @@ describe('createWrapInstruction', () => {
             mint,
             BigInt(500),
             tokenPoolInfo!,
+            TEST_TOKEN_DECIMALS,
             feePayer.publicKey,
         );
 
@@ -164,6 +166,7 @@ describe('createWrapInstruction', () => {
             mint,
             BigInt(100),
             tokenPoolInfo!,
+            TEST_TOKEN_DECIMALS,
             // payer not provided - defaults to owner
         );
 
diff --git a/js/compressed-token/tests/unit/layout-transfer2.test.ts b/js/compressed-token/tests/unit/layout-transfer2.test.ts
index 6afa983a13..4cce2e10a9 100644
--- a/js/compressed-token/tests/unit/layout-transfer2.test.ts
+++ b/js/compressed-token/tests/unit/layout-transfer2.test.ts
@@ -263,6 +263,7 @@ describe('layout-transfer2', () => {
                 3, // poolAccountIndex
                 0, // poolIndex
                 255, // bump
+                9, // decimals
             );
 
             expect(compression.mode).toBe(COMPRESSION_MODE_COMPRESS);
@@ -273,7 +274,7 @@ describe('layout-transfer2', () => {
             expect(compression.poolAccountIndex).toBe(3);
             expect(compression.poolIndex).toBe(0);
             expect(compression.bump).toBe(255);
-            expect(compression.decimals).toBe(0);
+            expect(compression.decimals).toBe(9);
         });
 
         it('should handle different index values', () => {
@@ -285,6 +286,7 @@ describe('layout-transfer2', () => {
                 20, // poolAccountIndex
                 3, // poolIndex
                 254, // bump
+                6, // decimals
             );
 
             expect(compression.mint).toBe(5);
@@ -305,6 +307,7 @@ describe('layout-transfer2', () => {
                 3,
                 0,
                 255,
+                9,
             );
 
             expect(compression.amount).toBe(largeAmount);
@@ -366,6 +369,7 @@ describe('layout-transfer2', () => {
                 2, // poolAccountIndex
                 0, // poolIndex
                 253, // bump
+                9, // decimals
             );
 
             expect(decompression.mode).toBe(COMPRESSION_MODE_DECOMPRESS);
@@ -376,7 +380,7 @@ describe('layout-transfer2', () => {
             expect(decompression.poolAccountIndex).toBe(2);
             expect(decompression.poolIndex).toBe(0);
             expect(decompression.bump).toBe(253);
-            expect(decompression.decimals).toBe(0);
+            expect(decompression.decimals).toBe(9);
         });
 
         it('should handle different pool configurations', () => {
@@ -387,6 +391,7 @@ describe('layout-transfer2', () => {
                 5, // poolAccountIndex
                 2, // poolIndex
                 200, // bump
+                6, // decimals
             );
 
             expect(decompression.poolAccountIndex).toBe(5);
@@ -402,13 +407,13 @@ describe('layout-transfer2', () => {
         });
 
         it('should set correct modes in factory functions', () => {
-            const compress = createCompressSpl(100n, 0, 1, 2, 3, 0, 255);
+            const compress = createCompressSpl(100n, 0, 1, 2, 3, 0, 255, 9);
             expect(compress.mode).toBe(COMPRESSION_MODE_COMPRESS);
 
             const decompressCtoken = createDecompressCtoken(100n, 0, 1);
             expect(decompressCtoken.mode).toBe(COMPRESSION_MODE_DECOMPRESS);
 
-            const decompressSpl = createDecompressSpl(100n, 0, 1, 2, 0, 255);
+            const decompressSpl = createDecompressSpl(100n, 0, 1, 2, 0, 255, 9);
             expect(decompressSpl.mode).toBe(COMPRESSION_MODE_DECOMPRESS);
         });
     });
@@ -416,7 +421,7 @@ describe('layout-transfer2', () => {
     describe('encoding roundtrip integration', () => {
         it('should encode complex wrap instruction correctly', () => {
             const compressions = [
-                createCompressSpl(1000n, 0, 2, 1, 4, 0, 255),
+                createCompressSpl(1000n, 0, 2, 1, 4, 0, 255, 9),
                 createDecompressCtoken(1000n, 0, 3, 6),
             ];
 
diff --git a/program-libs/compressible/src/compression_info.rs b/program-libs/compressible/src/compression_info.rs
index 78ab0d9c62..4bb20e196b 100644
--- a/program-libs/compressible/src/compression_info.rs
+++ b/program-libs/compressible/src/compression_info.rs
@@ -23,6 +23,7 @@ use crate::{
     Copy,
     PartialEq,
     Eq,
+    Default,
     AnchorSerialize,
     AnchorDeserialize,
     ZeroCopy,
diff --git a/program-libs/ctoken-interface/src/constants.rs b/program-libs/ctoken-interface/src/constants.rs
index a024d0892a..4ecbae37a8 100644
--- a/program-libs/ctoken-interface/src/constants.rs
+++ b/program-libs/ctoken-interface/src/constants.rs
@@ -1,27 +1,21 @@
 use light_macros::pubkey_array;
 
-use crate::state::extensions::CompressibleExtension;
-
 pub const CPI_AUTHORITY: [u8; 32] = pubkey_array!("GXtd2izAiMJPwMEjfgTRH3d7k9mjn4Jq3JrWFv9gySYy");
 pub const CTOKEN_PROGRAM_ID: [u8; 32] =
     pubkey_array!("cTokenmWW8bLPjZEBAUgYy3zKxQZW6VKi7bqNFEVv3m");
 
 /// Account size constants
-/// Size of a basic SPL token account
-pub const BASE_TOKEN_ACCOUNT_SIZE: u64 = 165;
-
-/// Extension metadata overhead: AccountType (1) + Option discriminator (1) + Vec length (4) + Extension enum variant (1)
-pub const EXTENSION_METADATA: u64 = 7;
+/// Size of a CToken account with embedded compression info (no extensions).
+/// CTokenZeroCopy includes: SPL token layout (165) + account_type (1) + decimal_option_prefix (1)
+/// + decimals (1) + compression_only (1) + CompressionInfo (88) + has_extensions (1)
+pub use crate::state::BASE_TOKEN_ACCOUNT_SIZE;
 
-/// Size of a token account with compressible extension 261 bytes.
-/// CompressibleExtension = compression_only (1 byte) + CompressionInfo (88 bytes) = 89 bytes
-pub const COMPRESSIBLE_TOKEN_ACCOUNT_SIZE: u64 =
-    BASE_TOKEN_ACCOUNT_SIZE + CompressibleExtension::LEN as u64 + EXTENSION_METADATA;
+/// Extension metadata overhead: Vec length (4) - added when any extensions are present
+/// Note: The Option discriminator is the has_extensions bool in the base struct
+pub const EXTENSION_METADATA: u64 = 4;
 
-/// Rent exemption threshold for compressible token accounts (in lamports)
-/// This value determines when an account has sufficient rent to be considered not compressible
-/// Calculation: (account_size + 128) * 3480 * 2 = (261 + 128) * 6960 = 2707440
-pub const COMPRESSIBLE_TOKEN_RENT_EXEMPTION: u64 = 2707440;
+/// Size of CompressedOnly extension (16 bytes for two u64 fields: delegated_amount and withheld_transfer_fee)
+pub const COMPRESSED_ONLY_EXTENSION_SIZE: u64 = 16;
 
 /// Size of a Token-2022 mint account
 pub const MINT_ACCOUNT_SIZE: u64 = 82;
@@ -30,3 +24,16 @@ pub const NATIVE_MINT: [u8; 32] = pubkey_array!("So11111111111111111111111111111
 
 pub const CMINT_ADDRESS_TREE: [u8; 32] =
     pubkey_array!("amt2kaJA14v3urZbZvnc5v2np8jqvc4Z8zDep5wbtzx");
+
+/// Size of TransferFeeAccountExtension: 1 discriminant + 8 withheld_amount
+pub const TRANSFER_FEE_ACCOUNT_EXTENSION_LEN: u64 = 9;
+
+/// Size of TransferHookAccountExtension: 1 discriminant + 1 transferring
+pub const TRANSFER_HOOK_ACCOUNT_EXTENSION_LEN: u64 = 2;
+
+/// Instruction discriminator for Transfer2
+pub const TRANSFER2: u8 = 101;
+
+/// Pool PDA seeds
+pub const POOL_SEED: &[u8] = b"pool";
+pub const RESTRICTED_POOL_SEED: &[u8] = b"restricted";
diff --git a/program-libs/ctoken-interface/src/discriminator.rs b/program-libs/ctoken-interface/src/discriminator.rs
new file mode 100644
index 0000000000..5d3a8fd41b
--- /dev/null
+++ b/program-libs/ctoken-interface/src/discriminator.rs
@@ -0,0 +1,7 @@
+//! Instruction discriminators for the compressed token program.
+
+/// Instruction discriminator for CreateTokenPool
+pub const CREATE_TOKEN_POOL: [u8; 8] = [23, 169, 27, 122, 147, 169, 209, 152];
+
+/// Instruction discriminator for AddTokenPool
+pub const ADD_TOKEN_POOL: [u8; 8] = [114, 143, 210, 73, 96, 115, 1, 228];
diff --git a/program-libs/ctoken-interface/src/error.rs b/program-libs/ctoken-interface/src/error.rs
index 188f336091..e679a6e748 100644
--- a/program-libs/ctoken-interface/src/error.rs
+++ b/program-libs/ctoken-interface/src/error.rs
@@ -110,8 +110,8 @@ pub enum CTokenError {
     InstructionDataExpectedDelegate,
     #[error("ZeroCopyExpectedDelegate")]
     ZeroCopyExpectedDelegate,
-    #[error("TokenDataTlvUnimplemented")]
-    TokenDataTlvUnimplemented,
+    #[error("Unsupported TLV extension type - only CompressedOnly is currently implemented")]
+    UnsupportedTlvExtensionType,
     #[error("InvalidAccountState")]
     InvalidAccountState,
     #[error("BorshFailed")]
@@ -147,6 +147,30 @@ pub enum CTokenError {
 
     #[error("Failed to deserialize CMint account data")]
     CMintDeserializationFailed,
+
+    #[error("CompressedOnly tokens cannot have compressed outputs - must decompress only")]
+    CompressedOnlyBlocksTransfer,
+
+    #[error("Output TLV data count must match number of compressed outputs")]
+    OutTlvOutputCountMismatch,
+
+    #[error("in_lamports field is not yet implemented")]
+    InLamportsUnimplemented,
+
+    #[error("out_lamports field is not yet implemented")]
+    OutLamportsUnimplemented,
+
+    #[error("TLV extension length mismatch - exactly one extension required")]
+    TlvExtensionLengthMismatch,
+
+    #[error("InvalidAccountType")]
+    InvalidAccountType,
+
+    #[error("Duplicate compression_index found in input TLV data")]
+    DuplicateCompressionIndex,
+
+    #[error("Decompress destination CToken is not a fresh account")]
+    DecompressDestinationNotFresh,
 }
 
 impl From<CTokenError> for u32 {
@@ -186,7 +210,7 @@ impl From<CTokenError> for u32 {
             CTokenError::InvalidExtensionConfig => 18032,
             CTokenError::InstructionDataExpectedDelegate => 18033,
             CTokenError::ZeroCopyExpectedDelegate => 18034,
-            CTokenError::TokenDataTlvUnimplemented => 18035,
+            CTokenError::UnsupportedTlvExtensionType => 18035,
             CTokenError::InvalidAccountState => 18036,
             CTokenError::BorshFailed => 18037,
             CTokenError::TooManyInputAccounts => 18038,
@@ -199,6 +223,14 @@ impl From<CTokenError> for u32 {
             CTokenError::CMintNotInitialized => 18045,
             CTokenError::CMintBorrowFailed => 18046,
             CTokenError::CMintDeserializationFailed => 18047,
+            CTokenError::CompressedOnlyBlocksTransfer => 18048,
+            CTokenError::OutTlvOutputCountMismatch => 18049,
+            CTokenError::InLamportsUnimplemented => 18050,
+            CTokenError::OutLamportsUnimplemented => 18051,
+            CTokenError::TlvExtensionLengthMismatch => 18052,
+            CTokenError::InvalidAccountType => 18053,
+            CTokenError::DuplicateCompressionIndex => 18054,
+            CTokenError::DecompressDestinationNotFresh => 18055,
             CTokenError::HasherError(e) => u32::from(e),
             CTokenError::ZeroCopyError(e) => u32::from(e),
             CTokenError::CompressedAccountError(e) => u32::from(e),
diff --git a/program-libs/ctoken-interface/src/instructions/create_associated_token_account.rs b/program-libs/ctoken-interface/src/instructions/create_associated_token_account.rs
index 167e573edc..8103232998 100644
--- a/program-libs/ctoken-interface/src/instructions/create_associated_token_account.rs
+++ b/program-libs/ctoken-interface/src/instructions/create_associated_token_account.rs
@@ -1,14 +1,23 @@
 use light_zero_copy::ZeroCopy;
 
 use crate::{
-    instructions::extensions::compressible::CompressibleExtensionInstructionData,
-    AnchorDeserialize, AnchorSerialize,
+    instructions::create_ctoken_account::CompressToPubkey, AnchorDeserialize, AnchorSerialize,
 };
 
 #[repr(C)]
 #[derive(Debug, Clone, AnchorSerialize, AnchorDeserialize, ZeroCopy)]
 pub struct CreateAssociatedTokenAccountInstructionData {
     pub bump: u8,
+    /// Version of the compressed token account when ctoken account is
+    /// compressed and closed. (The version specifies the hashing scheme.)
+    pub token_account_version: u8,
+    /// Rent payment in epochs.
+    /// Paid once at initialization.
+    pub rent_payment: u8,
+    /// If true, the compressed token account cannot be transferred,
+    /// only decompressed. Used for delegated compress operations.
+    pub compression_only: u8,
+    pub write_top_up: u32,
     /// Optional compressible configuration for the token account
-    pub compressible_config: Option<CompressibleExtensionInstructionData>,
+    pub compressible_config: Option<CompressToPubkey>,
 }
diff --git a/program-libs/ctoken-interface/src/instructions/create_ctoken_account.rs b/program-libs/ctoken-interface/src/instructions/create_ctoken_account.rs
index a398f91ccf..1d0b8d115e 100644
--- a/program-libs/ctoken-interface/src/instructions/create_ctoken_account.rs
+++ b/program-libs/ctoken-interface/src/instructions/create_ctoken_account.rs
@@ -1,16 +1,120 @@
+use std::mem::MaybeUninit;
+
 use light_compressed_account::Pubkey;
-use light_zero_copy::ZeroCopy;
+use light_zero_copy::{ZeroCopy, ZeroCopyMut};
+use pinocchio::pubkey::pubkey_eq;
+use solana_pubkey::MAX_SEEDS;
+use tinyvec::ArrayVec;
 
-use crate::{
-    instructions::extensions::compressible::CompressibleExtensionInstructionData,
-    AnchorDeserialize, AnchorSerialize,
-};
+use crate::{AnchorDeserialize, AnchorSerialize, CTokenError};
 
 #[repr(C)]
 #[derive(Debug, Clone, AnchorSerialize, AnchorDeserialize, ZeroCopy)]
 pub struct CreateTokenAccountInstructionData {
     /// The owner of the token account
     pub owner: Pubkey,
+    /// Version of the compressed token account when ctoken account is
+    /// compressed and closed. (The version specifies the hashing scheme.)
+    pub token_account_version: u8,
+    /// Rent payment in epochs.
+    /// Paid once at initialization.
+    pub rent_payment: u8,
+    /// If true, the compressed token account cannot be transferred,
+    /// only decompressed. Used for delegated compress operations.
+    pub compression_only: u8,
+    pub write_top_up: u32,
     /// Optional compressible configuration for the token account
-    pub compressible_config: Option<CompressibleExtensionInstructionData>,
+    pub compressible_config: Option<CompressToPubkey>,
+}
+
+#[derive(
+    Debug, Clone, PartialEq, Eq, AnchorSerialize, AnchorDeserialize, ZeroCopy, ZeroCopyMut,
+)]
+#[repr(C)]
+pub struct CompressToPubkey {
+    pub bump: u8,
+    pub program_id: [u8; 32],
+    pub seeds: Vec<Vec<u8>>,
+}
+
+impl CompressToPubkey {
+    pub fn check_seeds(&self, pubkey: &pinocchio::pubkey::Pubkey) -> Result<(), CTokenError> {
+        if self.seeds.len() >= MAX_SEEDS {
+            return Err(CTokenError::TooManySeeds(MAX_SEEDS - 1));
+        }
+        let mut references = ArrayVec::<[&[u8]; MAX_SEEDS]>::new();
+        for seed in self.seeds.iter() {
+            references.push(seed.as_slice());
+        }
+        let derived_pubkey = derive_address(references.as_slice(), self.bump, &self.program_id)?;
+        if !pubkey_eq(&derived_pubkey, pubkey) {
+            Err(CTokenError::InvalidAccountData)
+        } else {
+            Ok(())
+        }
+    }
+}
+
+// Taken from pinocchio 0.9.2.
+// Modifications:
+// -  seeds: &[&[u8]; N], ->  seeds: &[&[u8]],
+// - if seeds.len() > MAX_SEEDS CTokenError::InvalidAccountData
+pub fn derive_address(
+    seeds: &[&[u8]],
+    bump: u8,
+    program_id: &pinocchio::pubkey::Pubkey,
+) -> Result<pinocchio::pubkey::Pubkey, CTokenError> {
+    const PDA_MARKER: &[u8; 21] = b"ProgramDerivedAddress";
+    // Must be strictly less than MAX_SEEDS because we need space for:
+    // seeds + bump + program_id + PDA_MARKER in a [MAX_SEEDS + 2] array
+    if seeds.len() >= MAX_SEEDS {
+        return Err(CTokenError::TooManySeeds(MAX_SEEDS - 1));
+    }
+    const UNINIT: MaybeUninit<&[u8]> = MaybeUninit::<&[u8]>::uninit();
+    let mut data = [UNINIT; MAX_SEEDS + 2];
+    let mut i = 0;
+
+    while i < seeds.len() {
+        // SAFETY: `data` is guaranteed to have enough space for `N` seeds,
+        // so `i` will always be within bounds.
+        unsafe {
+            data.get_unchecked_mut(i).write(seeds.get_unchecked(i));
+        }
+        i += 1;
+    }
+
+    // TODO: replace this with `as_slice` when the MSRV is upgraded
+    // to `1.84.0+`.
+    let bump_seed = [bump];
+
+    // SAFETY: `data` is guaranteed to have enough space for `MAX_SEEDS + 2`
+    // elements, and `MAX_SEEDS` is as large as `N`.
+    unsafe {
+        data.get_unchecked_mut(i).write(&bump_seed);
+        i += 1;
+
+        data.get_unchecked_mut(i).write(program_id.as_ref());
+        data.get_unchecked_mut(i + 1).write(PDA_MARKER.as_ref());
+    }
+
+    #[cfg(target_os = "solana")]
+    {
+        use pinocchio::syscalls::sol_sha256;
+        let mut pda = MaybeUninit::<[u8; 32]>::uninit();
+
+        // SAFETY: `data` has `i + 2` elements initialized.
+        unsafe {
+            sol_sha256(
+                data.as_ptr() as *const u8,
+                (i + 2) as u64,
+                pda.as_mut_ptr() as *mut u8,
+            );
+        }
+
+        // SAFETY: `pda` has been initialized by the syscall.
+        unsafe { Ok(pda.assume_init()) }
+    }
+
+    #[cfg(not(target_os = "solana"))]
+    unreachable!("deriving a pda is only available on target `solana`");
 }
diff --git a/program-libs/ctoken-interface/src/instructions/extensions/compressed_only.rs b/program-libs/ctoken-interface/src/instructions/extensions/compressed_only.rs
new file mode 100644
index 0000000000..fa27f4f84d
--- /dev/null
+++ b/program-libs/ctoken-interface/src/instructions/extensions/compressed_only.rs
@@ -0,0 +1,19 @@
+use light_zero_copy::ZeroCopy;
+
+use crate::{AnchorDeserialize, AnchorSerialize};
+
+/// CompressedOnly extension instruction data for compressed token accounts.
+/// This extension marks a compressed account as decompress-only (cannot be transferred).
+#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, AnchorSerialize, AnchorDeserialize, ZeroCopy)]
+#[repr(C)]
+pub struct CompressedOnlyExtensionInstructionData {
+    /// The delegated amount from the source CToken account's delegate field.
+    /// When decompressing, the decompression amount must match this value.
+    pub delegated_amount: u64,
+    /// Withheld transfer fee amount
+    pub withheld_transfer_fee: u64,
+    /// Whether the source CToken account was frozen when compressed.
+    pub is_frozen: bool,
+    /// Index of the compression operation that consumes this input.
+    pub compression_index: u8,
+}
diff --git a/program-libs/ctoken-interface/src/instructions/extensions/compressible.rs b/program-libs/ctoken-interface/src/instructions/extensions/compressible.rs
deleted file mode 100644
index 1a6c92c67f..0000000000
--- a/program-libs/ctoken-interface/src/instructions/extensions/compressible.rs
+++ /dev/null
@@ -1,118 +0,0 @@
-use std::mem::MaybeUninit;
-
-use light_zero_copy::{ZeroCopy, ZeroCopyMut};
-use pinocchio::pubkey::Pubkey;
-use solana_pubkey::MAX_SEEDS;
-use tinyvec::ArrayVec;
-
-use crate::{AnchorDeserialize, AnchorSerialize, CTokenError};
-
-#[derive(
-    Debug, Clone, PartialEq, Eq, AnchorSerialize, AnchorDeserialize, ZeroCopy, ZeroCopyMut,
-)]
-#[repr(C)]
-pub struct CompressibleExtensionInstructionData {
-    /// Version of the compressed token account when ctoken account is
-    /// compressed and closed. (The version specifies the hashing scheme.)
-    pub token_account_version: u8,
-    /// Rent payment in epochs.
-    /// Paid once at initialization.
-    pub rent_payment: u8,
-    /// Placeholder for future use. If true, the compressed token account cannot be transferred,
-    /// only decompressed. Currently unused - always set to 0.
-    pub compression_only: u8,
-    pub write_top_up: u32,
-    pub compress_to_account_pubkey: Option<CompressToPubkey>,
-}
-
-#[derive(
-    Debug, Clone, PartialEq, Eq, AnchorSerialize, AnchorDeserialize, ZeroCopy, ZeroCopyMut,
-)]
-#[repr(C)]
-pub struct CompressToPubkey {
-    pub bump: u8,
-    pub program_id: [u8; 32],
-    pub seeds: Vec<Vec<u8>>,
-}
-
-impl CompressToPubkey {
-    pub fn check_seeds(&self, pubkey: &Pubkey) -> Result<(), CTokenError> {
-        if self.seeds.len() >= MAX_SEEDS {
-            return Err(CTokenError::TooManySeeds(MAX_SEEDS - 1));
-        }
-        let mut references = ArrayVec::<[&[u8]; MAX_SEEDS]>::new();
-        for seed in self.seeds.iter() {
-            references.push(seed.as_slice());
-        }
-        let derived_pubkey = derive_address(references.as_slice(), self.bump, &self.program_id)?;
-        if derived_pubkey != *pubkey {
-            Err(CTokenError::InvalidAccountData)
-        } else {
-            Ok(())
-        }
-    }
-}
-
-// Taken from pinocchio 0.9.2.
-// Modifications:
-// -  seeds: &[&[u8]; N], ->  seeds: &[&[u8]],
-// - if seeds.len() > MAX_SEEDS CTokenError::InvalidAccountData
-pub fn derive_address(
-    seeds: &[&[u8]],
-    bump: u8,
-    program_id: &Pubkey,
-) -> Result<Pubkey, CTokenError> {
-    const PDA_MARKER: &[u8; 21] = b"ProgramDerivedAddress";
-    // Must be strictly less than MAX_SEEDS because we need space for:
-    // seeds + bump + program_id + PDA_MARKER in a [MAX_SEEDS + 2] array
-    if seeds.len() >= MAX_SEEDS {
-        return Err(CTokenError::TooManySeeds(MAX_SEEDS - 1));
-    }
-    const UNINIT: MaybeUninit<&[u8]> = MaybeUninit::<&[u8]>::uninit();
-    let mut data = [UNINIT; MAX_SEEDS + 2];
-    let mut i = 0;
-
-    while i < seeds.len() {
-        // SAFETY: `data` is guaranteed to have enough space for `N` seeds,
-        // so `i` will always be within bounds.
-        unsafe {
-            data.get_unchecked_mut(i).write(seeds.get_unchecked(i));
-        }
-        i += 1;
-    }
-
-    // TODO: replace this with `as_slice` when the MSRV is upgraded
-    // to `1.84.0+`.
-    let bump_seed = [bump];
-
-    // SAFETY: `data` is guaranteed to have enough space for `MAX_SEEDS + 2`
-    // elements, and `MAX_SEEDS` is as large as `N`.
-    unsafe {
-        data.get_unchecked_mut(i).write(&bump_seed);
-        i += 1;
-
-        data.get_unchecked_mut(i).write(program_id.as_ref());
-        data.get_unchecked_mut(i + 1).write(PDA_MARKER.as_ref());
-    }
-
-    #[cfg(target_os = "solana")]
-    {
-        use pinocchio::syscalls::sol_sha256;
-        let mut pda = MaybeUninit::<[u8; 32]>::uninit();
-
-        // SAFETY: `data` has `i + 2` elements initialized.
-        unsafe {
-            sol_sha256(
-                data.as_ptr() as *const u8,
-                (i + 2) as u64,
-                pda.as_mut_ptr() as *mut u8,
-            );
-        }
-
-        // SAFETY: `pda` has been initialized by the syscall.
-        unsafe { Ok(pda.assume_init()) }
-    }
-
-    #[cfg(not(target_os = "solana"))]
-    unreachable!("deriving a pda is only available on target `solana`");
-}
diff --git a/program-libs/ctoken-interface/src/instructions/extensions/mod.rs b/program-libs/ctoken-interface/src/instructions/extensions/mod.rs
index dc05a512d2..9b21a3e855 100644
--- a/program-libs/ctoken-interface/src/instructions/extensions/mod.rs
+++ b/program-libs/ctoken-interface/src/instructions/extensions/mod.rs
@@ -1,8 +1,11 @@
-pub mod compressible;
+pub mod compressed_only;
+pub mod pausable;
+pub mod permanent_delegate;
 pub mod token_metadata;
-pub use compressible::{CompressToPubkey, CompressibleExtensionInstructionData};
-use light_compressible::compression_info::CompressionInfo;
+pub use compressed_only::CompressedOnlyExtensionInstructionData;
 use light_zero_copy::ZeroCopy;
+pub use pausable::PausableExtensionInstructionData;
+pub use permanent_delegate::PermanentDelegateExtensionInstructionData;
 pub use token_metadata::{TokenMetadataInstructionData, ZTokenMetadataInstructionData};
 
 use crate::{AnchorDeserialize, AnchorSerialize};
@@ -37,15 +40,10 @@ pub enum ExtensionInstructionData {
     Placeholder24,
     Placeholder25,
     Placeholder26,
-    /// Reserved for PausableAccount extension
-    Placeholder27,
-    /// Reserved for PermanentDelegateAccount extension
-    Placeholder28,
+    PausableAccount(PausableExtensionInstructionData),
+    PermanentDelegateAccount(PermanentDelegateExtensionInstructionData),
     Placeholder29,
     Placeholder30,
-    /// Reserved for CompressedOnly extension
-    Placeholder31,
-    /// Compressible extension - reuses CompressionInfo from light_compressible
-    /// Position 32 matches ExtensionStruct::Compressible
-    Compressible(CompressionInfo),
+    /// CompressedOnly extension for compressed token accounts
+    CompressedOnly(CompressedOnlyExtensionInstructionData),
 }
diff --git a/program-libs/ctoken-interface/src/instructions/extensions/pausable.rs b/program-libs/ctoken-interface/src/instructions/extensions/pausable.rs
new file mode 100644
index 0000000000..46ca814e90
--- /dev/null
+++ b/program-libs/ctoken-interface/src/instructions/extensions/pausable.rs
@@ -0,0 +1,11 @@
+use light_zero_copy::{ZeroCopy, ZeroCopyMut};
+
+use crate::{AnchorDeserialize, AnchorSerialize};
+
+/// Instruction data for PausableAccount extension.
+/// PausableAccount is a marker extension with no persisted data.
+#[derive(
+    Debug, Clone, Copy, PartialEq, Eq, AnchorSerialize, AnchorDeserialize, ZeroCopy, ZeroCopyMut,
+)]
+#[repr(C)]
+pub struct PausableExtensionInstructionData;
diff --git a/program-libs/ctoken-interface/src/instructions/extensions/permanent_delegate.rs b/program-libs/ctoken-interface/src/instructions/extensions/permanent_delegate.rs
new file mode 100644
index 0000000000..7e9261f98c
--- /dev/null
+++ b/program-libs/ctoken-interface/src/instructions/extensions/permanent_delegate.rs
@@ -0,0 +1,12 @@
+use light_zero_copy::{ZeroCopy, ZeroCopyMut};
+
+use crate::{AnchorDeserialize, AnchorSerialize};
+
+/// Instruction data for PermanentDelegateAccount extension.
+/// This is a marker extension - no instruction data needed since
+/// the permanent delegate is looked up from the mint at runtime.
+#[derive(
+    Debug, Clone, Copy, PartialEq, Eq, AnchorSerialize, AnchorDeserialize, ZeroCopy, ZeroCopyMut,
+)]
+#[repr(C)]
+pub struct PermanentDelegateExtensionInstructionData;
diff --git a/program-libs/ctoken-interface/src/instructions/mint_action/compress_and_close_cmint.rs b/program-libs/ctoken-interface/src/instructions/mint_action/compress_and_close_cmint.rs
index a5b1e1dbdc..3f3bbd0b17 100644
--- a/program-libs/ctoken-interface/src/instructions/mint_action/compress_and_close_cmint.rs
+++ b/program-libs/ctoken-interface/src/instructions/mint_action/compress_and_close_cmint.rs
@@ -7,7 +7,6 @@ use crate::{AnchorDeserialize, AnchorSerialize};
 ///
 /// ## Requirements
 /// - CMint must exist (cmint_decompressed = true) - unless idempotent is set
-/// - CMint must have Compressible extension
 /// - is_compressible() must return true (rent expired)
 /// - Cannot be combined with DecompressMint in same instruction
 ///
@@ -17,6 +16,27 @@ use crate::{AnchorDeserialize, AnchorSerialize};
 #[repr(C)]
 #[derive(Debug, Clone, Copy, AnchorSerialize, AnchorDeserialize, ZeroCopy)]
 pub struct CompressAndCloseCMintAction {
-    /// If non-zero, succeed silently when CMint doesn't exist (cmint_decompressed = false)
+    /// If non-zero, succeed silently when CMint doesn't exist or cannot be compressed.
+    /// Useful for foresters to handle already-compressed mints without failing.
     pub idempotent: u8,
 }
+
+impl CompressAndCloseCMintAction {
+    /// Returns true if this action should succeed silently when:
+    /// - CMint doesn't exist (already compressed)
+    /// - CMint cannot be compressed (rent not expired)
+    #[inline(always)]
+    pub fn is_idempotent(&self) -> bool {
+        self.idempotent != 0
+    }
+}
+
+impl ZCompressAndCloseCMintAction<'_> {
+    /// Returns true if this action should succeed silently when:
+    /// - CMint doesn't exist (already compressed)
+    /// - CMint cannot be compressed (rent not expired)
+    #[inline(always)]
+    pub fn is_idempotent(&self) -> bool {
+        self.idempotent != 0
+    }
+}
diff --git a/program-libs/ctoken-interface/src/instructions/mint_action/instruction_data.rs b/program-libs/ctoken-interface/src/instructions/mint_action/instruction_data.rs
index 6499133276..9f4cab62f6 100644
--- a/program-libs/ctoken-interface/src/instructions/mint_action/instruction_data.rs
+++ b/program-libs/ctoken-interface/src/instructions/mint_action/instruction_data.rs
@@ -1,4 +1,5 @@
 use light_compressed_account::{instruction_data::compressed_proof::CompressedProof, Pubkey};
+use light_compressible::compression_info::CompressionInfo;
 use light_zero_copy::ZeroCopy;
 
 use super::{
@@ -9,8 +10,8 @@ use super::{
 use crate::{
     instructions::extensions::{ExtensionInstructionData, ZExtensionInstructionData},
     state::{
-        AdditionalMetadata, BaseMint, CompressedMint, CompressedMintMetadata,
-        CompressibleExtension, ExtensionStruct, TokenMetadata,
+        AdditionalMetadata, BaseMint, CompressedMint, CompressedMintMetadata, ExtensionStruct,
+        TokenMetadata,
     },
     AnchorDeserialize, AnchorSerialize, CTokenError,
 };
@@ -118,12 +119,12 @@ impl TryFrom<CompressedMint> for CompressedMintInstructionData {
 
     fn try_from(mint: CompressedMint) -> Result<Self, Self::Error> {
         let extensions = match mint.extensions {
-            Some(exts) => {
-                let converted_exts: Result<Vec<_>, Self::Error> = exts
-                    .into_iter()
-                    .map(|ext| match ext {
+            Some(exts) if !exts.is_empty() => {
+                let mut extension_list = Vec::with_capacity(exts.len());
+                for ext in exts {
+                    match ext {
                         ExtensionStruct::TokenMetadata(token_metadata) => {
-                            Ok(ExtensionInstructionData::TokenMetadata(
+                            extension_list.push(ExtensionInstructionData::TokenMetadata(
                                 crate::instructions::extensions::token_metadata::TokenMetadataInstructionData {
                                     update_authority: if token_metadata.update_authority == [0u8;32] {None}else {Some(token_metadata.update_authority)},
                                     name: token_metadata.name,
@@ -131,19 +132,16 @@ impl TryFrom<CompressedMint> for CompressedMintInstructionData {
                                     uri: token_metadata.uri,
                                     additional_metadata: Some(token_metadata.additional_metadata),
                                 },
-                            ))
-                        }
-                        ExtensionStruct::Compressible(compressible_ext) => {
-                            Ok(ExtensionInstructionData::Compressible(compressible_ext.info))
+                            ));
                         }
                         _ => {
-                            Err(CTokenError::UnsupportedExtension)
+                            return Err(CTokenError::UnsupportedExtension);
                         }
-                    })
-                    .collect();
-                Some(converted_exts?)
+                    }
+                }
+                Some(extension_list)
             }
-            None => None,
+            _ => None,
         };
 
         Ok(Self {
@@ -165,7 +163,7 @@ impl<'a> TryFrom<&ZCompressedMintInstructionData<'a>> for CompressedMint {
     ) -> Result<Self, Self::Error> {
         let extensions = match &instruction_data.extensions {
             Some(exts) => {
-                let converted_exts: Result<Vec<_>, Self::Error> = exts
+                let converted_exts: Vec<_> = exts
                     .iter()
                     .map(|ext| match ext {
                         ZExtensionInstructionData::TokenMetadata(token_metadata_data) => {
@@ -192,41 +190,14 @@ impl<'a> TryFrom<&ZCompressedMintInstructionData<'a>> for CompressedMint {
                                     .unwrap_or_else(Vec::new),
                             }))
                         }
-                        ZExtensionInstructionData::Compressible(compression_info) => {
-                            // Convert zero-copy CompressionInfo to owned CompressibleExtension
-                            Ok(ExtensionStruct::Compressible(CompressibleExtension {
-                                compression_only: false,
-                                info: light_compressible::compression_info::CompressionInfo {
-                                    config_account_version: compression_info
-                                        .config_account_version
-                                        .into(),
-                                    compress_to_pubkey: compression_info.compress_to_pubkey,
-                                    account_version: compression_info.account_version,
-                                    lamports_per_write: compression_info.lamports_per_write.into(),
-                                    compression_authority: compression_info.compression_authority,
-                                    rent_sponsor: compression_info.rent_sponsor,
-                                    last_claimed_slot: compression_info.last_claimed_slot.into(),
-                                    rent_config: light_compressible::rent::RentConfig {
-                                        base_rent: compression_info.rent_config.base_rent.into(),
-                                        compression_cost: compression_info
-                                            .rent_config
-                                            .compression_cost
-                                            .into(),
-                                        lamports_per_byte_per_epoch: compression_info
-                                            .rent_config
-                                            .lamports_per_byte_per_epoch,
-                                        max_funded_epochs: compression_info
-                                            .rent_config
-                                            .max_funded_epochs,
-                                        max_top_up: compression_info.rent_config.max_top_up.into(),
-                                    },
-                                },
-                            }))
-                        }
                         _ => Err(CTokenError::UnsupportedExtension),
                     })
-                    .collect();
-                Some(converted_exts?)
+                    .collect::<Result<Vec<_>, _>>()?;
+                if converted_exts.is_empty() {
+                    None
+                } else {
+                    Some(converted_exts)
+                }
             }
             None => None,
         };
@@ -241,9 +212,12 @@ impl<'a> TryFrom<&ZCompressedMintInstructionData<'a>> for CompressedMint {
             },
             metadata: CompressedMintMetadata {
                 version: instruction_data.metadata.version,
-                cmint_decompressed: instruction_data.metadata.cmint_decompressed(),
+                cmint_decompressed: instruction_data.metadata.cmint_decompressed != 0,
                 mint: instruction_data.metadata.mint,
             },
+            reserved: [0u8; 49],
+            account_type: crate::state::mint::ACCOUNT_TYPE_MINT,
+            compression: CompressionInfo::default(),
             extensions,
         })
     }
diff --git a/program-libs/ctoken-interface/src/instructions/transfer2/compression.rs b/program-libs/ctoken-interface/src/instructions/transfer2/compression.rs
index 1be28e39bb..081940068a 100644
--- a/program-libs/ctoken-interface/src/instructions/transfer2/compression.rs
+++ b/program-libs/ctoken-interface/src/instructions/transfer2/compression.rs
@@ -18,6 +18,20 @@ pub enum CompressionMode {
     CompressAndClose,
 }
 
+impl ZCompressionMode {
+    pub fn is_compress(&self) -> bool {
+        matches!(self, ZCompressionMode::Compress)
+    }
+
+    pub fn is_decompress(&self) -> bool {
+        matches!(self, ZCompressionMode::Decompress)
+    }
+
+    pub fn is_compress_and_close(&self) -> bool {
+        matches!(self, ZCompressionMode::CompressAndClose)
+    }
+}
+
 pub const COMPRESS: u8 = 0u8;
 pub const DECOMPRESS: u8 = 1u8;
 pub const COMPRESS_AND_CLOSE: u8 = 2u8;
@@ -68,8 +82,8 @@ pub struct Compression {
     /// compressed account index for CompressAndClose
     pub pool_index: u8, // This account is not necessary to decompress ctokens because there are no token pools
     pub bump: u8, // This account is not necessary to decompress ctokens because there are no token pools
-    /// Placeholder for future use (decimals for spl token operations, or flags).
-    /// Currently unused - always set to 0.
+    /// decimals for spl token Compression/Decompression (used in transfer_checked)
+    /// rent_sponsor_is_signer flag for CompressAndClose (non-zero = true)
     pub decimals: u8,
 }
 
@@ -95,6 +109,7 @@ impl ZCompression<'_> {
 }
 
 impl Compression {
+    #[allow(clippy::too_many_arguments)]
     pub fn compress_and_close_ctoken(
         amount: u64,
         mint: u8,
@@ -117,6 +132,7 @@ impl Compression {
         }
     }
 
+    #[allow(clippy::too_many_arguments)]
     pub fn compress_spl(
         amount: u64,
         mint: u8,
@@ -125,6 +141,7 @@ impl Compression {
         pool_account_index: u8,
         pool_index: u8,
         bump: u8,
+        decimals: u8,
     ) -> Self {
         Compression {
             amount,
@@ -135,7 +152,7 @@ impl Compression {
             pool_account_index,
             pool_index,
             bump,
-            decimals: 0,
+            decimals,
         }
     }
     pub fn compress_ctoken(amount: u64, mint: u8, source: u8, authority: u8) -> Self {
@@ -159,6 +176,7 @@ impl Compression {
         pool_account_index: u8,
         pool_index: u8,
         bump: u8,
+        decimals: u8,
     ) -> Self {
         Compression {
             amount,
@@ -169,7 +187,7 @@ impl Compression {
             pool_account_index,
             pool_index,
             bump,
-            decimals: 0,
+            decimals,
         }
     }
 
diff --git a/program-libs/ctoken-interface/src/instructions/transfer2/instruction_data.rs b/program-libs/ctoken-interface/src/instructions/transfer2/instruction_data.rs
index 342ce06be0..e120d610f8 100644
--- a/program-libs/ctoken-interface/src/instructions/transfer2/instruction_data.rs
+++ b/program-libs/ctoken-interface/src/instructions/transfer2/instruction_data.rs
@@ -4,10 +4,13 @@ use light_compressed_account::{
 use light_zero_copy::{ZeroCopy, ZeroCopyMut};
 
 use super::compression::Compression;
-use crate::{instructions::transfer2::CompressedCpiContext, AnchorDeserialize, AnchorSerialize};
+use crate::{
+    instructions::{extensions::ExtensionInstructionData, transfer2::CompressedCpiContext},
+    AnchorDeserialize, AnchorSerialize,
+};
 
 #[repr(C)]
-#[derive(Debug, Clone, AnchorSerialize, AnchorDeserialize, ZeroCopy, ZeroCopyMut)]
+#[derive(Debug, Clone, AnchorSerialize, AnchorDeserialize, ZeroCopy)]
 pub struct CompressedTokenInstructionDataTransfer2 {
     pub with_transaction_hash: bool,
     /// Placeholder currently unimplemented.
@@ -28,10 +31,10 @@ pub struct CompressedTokenInstructionDataTransfer2 {
     pub in_lamports: Option<Vec<u64>>,
     /// Placeholder currently unimplemented.
     pub out_lamports: Option<Vec<u64>>,
-    /// Placeholder currently unimplemented.
-    pub in_tlv: Option<Vec<Vec<u8>>>,
-    /// Placeholder currently unimplemented.
-    pub out_tlv: Option<Vec<Vec<u8>>>,
+    /// Extensions for input compressed token accounts (one Vec per input account)
+    pub in_tlv: Option<Vec<Vec<ExtensionInstructionData>>>,
+    /// Extensions for output compressed token accounts (one Vec per output account)
+    pub out_tlv: Option<Vec<Vec<ExtensionInstructionData>>>,
 }
 
 #[repr(C)]
diff --git a/program-libs/ctoken-interface/src/lib.rs b/program-libs/ctoken-interface/src/lib.rs
index abc961725a..92f65d29bc 100644
--- a/program-libs/ctoken-interface/src/lib.rs
+++ b/program-libs/ctoken-interface/src/lib.rs
@@ -1,9 +1,14 @@
+pub mod discriminator;
 pub mod instructions;
 
 pub mod error;
 pub mod hash_cache;
+pub mod pool_derivation;
+pub mod token_2022_extensions;
 
 pub use error::*;
+pub use pool_derivation::*;
+pub use token_2022_extensions::*;
 mod constants;
 pub mod state;
 #[cfg(feature = "anchor")]
diff --git a/program-libs/ctoken-interface/src/pool_derivation.rs b/program-libs/ctoken-interface/src/pool_derivation.rs
new file mode 100644
index 0000000000..8eb77bde05
--- /dev/null
+++ b/program-libs/ctoken-interface/src/pool_derivation.rs
@@ -0,0 +1,176 @@
+//! SPL interface PDA derivation utilities for Light Protocol.
+//!
+//! This module provides functions to derive SPL interface PDAs (token pools) for both regular
+//! and restricted mints. Restricted mints (those with Pausable, PermanentDelegate,
+//! TransferFeeConfig, TransferHook, or DefaultAccountState extensions) use a different derivation path
+//! to prevent accidental compression via legacy anchor instructions.
+
+use solana_pubkey::Pubkey;
+use spl_token_2022::{
+    extension::{BaseStateWithExtensions, PodStateWithExtensions},
+    pod::PodMint,
+};
+
+use crate::{
+    constants::{CTOKEN_PROGRAM_ID, POOL_SEED, RESTRICTED_POOL_SEED},
+    is_restricted_extension,
+};
+
+/// Maximum number of pool accounts per mint.
+pub const NUM_MAX_POOL_ACCOUNTS: u8 = 5;
+
+// ============================================================================
+// SPL interface PDA derivation (uses CTOKEN_PROGRAM_ID)
+// ============================================================================
+
+/// Find the SPL interface PDA for a given mint (index 0).
+///
+/// # Arguments
+/// * `mint` - The mint public key
+/// * `restricted` - Whether to use restricted derivation (for mints with restricted extensions)
+///
+/// # Seed format
+/// - Regular: `["pool", mint]`
+/// - Restricted: `["pool", mint, "restricted"]`
+pub fn find_spl_interface_pda(mint: &Pubkey, restricted: bool) -> (Pubkey, u8) {
+    find_spl_interface_pda_with_index(mint, 0, restricted)
+}
+
+/// Find the SPL interface PDA for a given mint and index.
+///
+/// # Arguments
+/// * `mint` - The mint public key
+/// * `index` - The pool index (0-4)
+/// * `restricted` - Whether to use restricted derivation (for mints with restricted extensions)
+///
+/// # Seed format
+/// - Regular index 0: `["pool", mint]`
+/// - Regular index 1-4: `["pool", mint, index]`
+/// - Restricted index 0: `["pool", mint, "restricted"]`
+/// - Restricted index 1-4: `["pool", mint, "restricted", index]`
+pub fn find_spl_interface_pda_with_index(
+    mint: &Pubkey,
+    index: u8,
+    restricted: bool,
+) -> (Pubkey, u8) {
+    let program_id = Pubkey::from(CTOKEN_PROGRAM_ID);
+    let index_bytes = [index];
+
+    let seeds: &[&[u8]] = if restricted {
+        if index == 0 {
+            &[POOL_SEED, mint.as_ref(), RESTRICTED_POOL_SEED]
+        } else {
+            &[POOL_SEED, mint.as_ref(), RESTRICTED_POOL_SEED, &index_bytes]
+        }
+    } else if index == 0 {
+        &[POOL_SEED, mint.as_ref()]
+    } else {
+        &[POOL_SEED, mint.as_ref(), &index_bytes]
+    };
+
+    Pubkey::find_program_address(seeds, &program_id)
+}
+
+/// Get the SPL interface PDA address for a given mint (index 0).
+pub fn get_spl_interface_pda(mint: &Pubkey, restricted: bool) -> Pubkey {
+    find_spl_interface_pda(mint, restricted).0
+}
+
+// ============================================================================
+// Validation
+// ============================================================================
+
+/// Validate that an SPL interface PDA is correctly derived.
+///
+/// # Arguments
+/// * `mint_bytes` - The mint public key as bytes
+/// * `spl_interface_pubkey` - The SPL interface PDA to validate
+/// * `pool_index` - The pool index (0-4)
+/// * `bump` - Optional bump seed for faster validation
+/// * `restricted` - Whether to validate against restricted derivation
+///
+/// # Returns
+/// `true` if the PDA is valid, `false` otherwise
+#[inline(always)]
+pub fn is_valid_spl_interface_pda(
+    mint_bytes: &[u8],
+    spl_interface_pubkey: &Pubkey,
+    pool_index: u8,
+    bump: Option<u8>,
+    restricted: bool,
+) -> bool {
+    let program_id = Pubkey::from(CTOKEN_PROGRAM_ID);
+    let index_bytes = [pool_index];
+
+    let pda = if let Some(bump) = bump {
+        // Fast path: use provided bump to derive address directly
+        let bump_bytes = [bump];
+        let seeds: &[&[u8]] = if restricted {
+            if pool_index == 0 {
+                &[POOL_SEED, mint_bytes, RESTRICTED_POOL_SEED, &bump_bytes]
+            } else {
+                &[
+                    POOL_SEED,
+                    mint_bytes,
+                    RESTRICTED_POOL_SEED,
+                    &index_bytes,
+                    &bump_bytes,
+                ]
+            }
+        } else if pool_index == 0 {
+            &[POOL_SEED, mint_bytes, &bump_bytes]
+        } else {
+            &[POOL_SEED, mint_bytes, &index_bytes, &bump_bytes]
+        };
+
+        match Pubkey::create_program_address(seeds, &program_id) {
+            Ok(pda) => pda,
+            Err(_) => return false,
+        }
+    } else {
+        // Slow path: find program address
+        let seeds: &[&[u8]] = if restricted {
+            if pool_index == 0 {
+                &[POOL_SEED, mint_bytes, RESTRICTED_POOL_SEED]
+            } else {
+                &[POOL_SEED, mint_bytes, RESTRICTED_POOL_SEED, &index_bytes]
+            }
+        } else if pool_index == 0 {
+            &[POOL_SEED, mint_bytes]
+        } else {
+            &[POOL_SEED, mint_bytes, &index_bytes]
+        };
+
+        Pubkey::find_program_address(seeds, &program_id).0
+    };
+
+    pda == *spl_interface_pubkey
+}
+
+// ============================================================================
+// Mint extension helpers
+// ============================================================================
+
+/// Check if a mint has any restricted extensions.
+///
+/// Restricted extensions (Pausable, PermanentDelegate, TransferFeeConfig, TransferHook, DefaultAccountState)
+/// require using the restricted pool derivation path.
+///
+/// # Arguments
+/// * `mint_data` - The raw mint account data
+///
+/// # Returns
+/// `true` if the mint has any restricted extensions, `false` otherwise
+pub fn has_restricted_extensions(mint_data: &[u8]) -> bool {
+    let mint = match PodStateWithExtensions::<PodMint>::unpack(mint_data) {
+        Ok(mint) => mint,
+        Err(_) => return false,
+    };
+
+    let extensions = match mint.get_extension_types() {
+        Ok(exts) => exts,
+        Err(_) => return false,
+    };
+
+    extensions.iter().any(is_restricted_extension)
+}
diff --git a/program-libs/ctoken-interface/src/state/compressed_token/token_data.rs b/program-libs/ctoken-interface/src/state/compressed_token/token_data.rs
index 05d365b35f..aefcdc1074 100644
--- a/program-libs/ctoken-interface/src/state/compressed_token/token_data.rs
+++ b/program-libs/ctoken-interface/src/state/compressed_token/token_data.rs
@@ -2,7 +2,11 @@ use light_compressed_account::Pubkey;
 use light_program_profiler::profile;
 use light_zero_copy::{num_trait::ZeroCopyNumTrait, ZeroCopy, ZeroCopyMut};
 
-use crate::{AnchorDeserialize, AnchorSerialize, CTokenError};
+use crate::{
+    instructions::extensions::ZExtensionInstructionData,
+    state::extensions::{ExtensionStruct, ZExtensionStructMut},
+    AnchorDeserialize, AnchorSerialize, CTokenError,
+};
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, AnchorSerialize, AnchorDeserialize)]
 #[repr(u8)]
@@ -41,8 +45,8 @@ pub struct TokenData {
     pub delegate: Option<Pubkey>,
     /// The account's state
     pub state: u8,
-    /// Placeholder for TokenExtension tlv data (unimplemented)
-    pub tlv: Option<Vec<u8>>,
+    /// Extensions for the compressed token account
+    pub tlv: Option<Vec<ExtensionStruct>>,
 }
 
 impl TokenData {
@@ -52,8 +56,9 @@ impl TokenData {
 }
 
 // Implementation for zero-copy mutable TokenData
-impl ZTokenDataMut<'_> {
-    /// Set all fields of the TokenData struct at once
+impl<'a> ZTokenDataMut<'a> {
+    /// Set all fields of the TokenData struct at once.
+    /// All data must be allocated before calling this function.
     #[inline]
     #[profile]
     pub fn set(
@@ -63,6 +68,7 @@ impl ZTokenDataMut<'_> {
         amount: impl ZeroCopyNumTrait,
         delegate: Option<Pubkey>,
         state: CompressedTokenAccountState,
+        tlv_data: Option<&[ZExtensionInstructionData<'_>]>,
     ) -> Result<(), CTokenError> {
         self.mint = mint;
         self.owner = owner;
@@ -76,9 +82,31 @@ impl ZTokenDataMut<'_> {
 
         *self.state = state as u8;
 
-        if self.tlv.is_some() {
-            return Err(CTokenError::TokenDataTlvUnimplemented);
+        // Set TLV extension values (space was pre-allocated via new_zero_copy)
+        match (self.tlv.as_mut(), tlv_data) {
+            (Some(tlv_vec), Some(exts)) => {
+                if tlv_vec.len() != 1 || exts.len() != 1 {
+                    return Err(CTokenError::TlvExtensionLengthMismatch);
+                }
+                for (tlv_ext, instruction_ext) in tlv_vec.iter_mut().zip(exts.iter()) {
+                    match (tlv_ext, instruction_ext) {
+                        (
+                            ZExtensionStructMut::CompressedOnly(compressed_only),
+                            ZExtensionInstructionData::CompressedOnly(data),
+                        ) => {
+                            compressed_only.delegated_amount = data.delegated_amount;
+                            compressed_only.withheld_transfer_fee = data.withheld_transfer_fee;
+                        }
+                        _ => return Err(CTokenError::UnsupportedTlvExtensionType),
+                    }
+                }
+            }
+            (Some(_), None) | (None, Some(_)) => {
+                return Err(CTokenError::TlvExtensionLengthMismatch);
+            }
+            (None, None) => {}
         }
+
         Ok(())
     }
 }
diff --git a/program-libs/ctoken-interface/src/state/ctoken/borsh.rs b/program-libs/ctoken-interface/src/state/ctoken/borsh.rs
index bc69ed60e7..570ae380de 100644
--- a/program-libs/ctoken-interface/src/state/ctoken/borsh.rs
+++ b/program-libs/ctoken-interface/src/state/ctoken/borsh.rs
@@ -1,7 +1,8 @@
 use borsh::{BorshDeserialize, BorshSerialize};
 use light_compressed_account::Pubkey;
+use light_compressible::compression_info::CompressionInfo;
 
-use crate::state::{AccountState, CToken, ExtensionStruct};
+use crate::state::{AccountState, CToken, ExtensionStruct, ACCOUNT_TYPE_TOKEN_ACCOUNT};
 
 // Manual implementation of BorshSerialize for SPL compatibility
 impl BorshSerialize for CToken {
@@ -45,15 +46,25 @@ impl BorshSerialize for CToken {
             writer.write_all(&[0; 36])?; // COption None (4 bytes) + empty pubkey (32 bytes)
         }
 
-        // Write extensions if present
-        if let Some(ref extensions) = self.extensions {
-            // Write AccountType::Account byte for SPL Token 2022 compatibility
-            writer.write_all(&[2])?; // AccountType::Account = 2
+        // Always write account_type at byte 165
+        writer.write_all(&[self.account_type])?;
 
-            // Serialize extensions using borsh
-            extensions.serialize(writer)?;
+        // Write decimals as option prefix (1 byte) + value (1 byte)
+        if let Some(decimals) = self.decimals {
+            writer.write_all(&[1, decimals])?;
+        } else {
+            writer.write_all(&[0, 0])?;
         }
 
+        // Write compression_only (1 byte as bool)
+        writer.write_all(&[self.compression_only as u8])?;
+
+        // Write compression (CompressionInfo)
+        self.compression.serialize(writer)?;
+
+        // Write extensions as Option<Vec<ExtensionStruct>>
+        self.extensions.serialize(writer)?;
+
         Ok(())
     }
 }
@@ -119,23 +130,33 @@ impl BorshDeserialize for CToken {
             None
         };
 
-        // Try to read extensions if data remains
-        let extensions = {
-            // Try to read AccountType byte
-            let mut account_type = [0u8; 1];
-            match buf.read_exact(&mut account_type) {
-                Ok(_) => {
-                    if account_type[0] == 2 {
-                        // AccountType::Account, extensions follow
-                        Option::<Vec<ExtensionStruct>>::deserialize_reader(buf).unwrap_or_default()
-                    } else {
-                        None
-                    }
-                }
-                Err(_) => None, // No more data, no extensions
-            }
+        // Read account_type byte at position 165
+        let mut account_type_byte = [ACCOUNT_TYPE_TOKEN_ACCOUNT; 1];
+        // Ignore result and use default value.
+        let _ = buf.read_exact(&mut account_type_byte);
+        let account_type = account_type_byte[0];
+
+        // Read decimals option prefix (1 byte) + value (1 byte)
+        let mut decimals_bytes = [0u8; 2];
+        let _ = buf.read_exact(&mut decimals_bytes);
+        let decimals = if decimals_bytes[0] == 1 {
+            Some(decimals_bytes[1])
+        } else {
+            None
         };
 
+        // Read compression_only (1 byte as bool)
+        let mut compression_only_byte = [0u8; 1];
+        let _ = buf.read_exact(&mut compression_only_byte);
+        let compression_only = compression_only_byte[0] != 0;
+
+        // Read compression (CompressionInfo)
+        let compression = CompressionInfo::deserialize_reader(buf).unwrap_or_default();
+
+        // Read extensions if account_type indicates token account
+        let extensions =
+            Option::<Vec<ExtensionStruct>>::deserialize_reader(buf).unwrap_or_default();
+
         Ok(Self {
             mint,
             owner,
@@ -146,6 +167,10 @@ impl BorshDeserialize for CToken {
             is_native,
             delegated_amount,
             close_authority,
+            account_type,
+            decimals,
+            compression_only,
+            compression,
             extensions,
         })
     }
diff --git a/program-libs/ctoken-interface/src/state/ctoken/ctoken_struct.rs b/program-libs/ctoken-interface/src/state/ctoken/ctoken_struct.rs
index 3fec4957d1..6a308b8aea 100644
--- a/program-libs/ctoken-interface/src/state/ctoken/ctoken_struct.rs
+++ b/program-libs/ctoken-interface/src/state/ctoken/ctoken_struct.rs
@@ -1,8 +1,12 @@
 use light_compressed_account::Pubkey;
+use light_compressible::compression_info::CompressionInfo;
 use light_zero_copy::errors::ZeroCopyError;
 
 use crate::{state::ExtensionStruct, AnchorDeserialize, AnchorSerialize, CTokenError};
 
+/// AccountType discriminator value for token accounts (at byte 165)
+pub const ACCOUNT_TYPE_TOKEN_ACCOUNT: u8 = 2;
+
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, AnchorSerialize, AnchorDeserialize)]
 #[repr(u8)]
 pub enum AccountState {
@@ -49,6 +53,12 @@ pub struct CToken {
     pub delegated_amount: u64,
     /// Optional authority to close the account.
     pub close_authority: Option<Pubkey>,
+    // End of spl-token compatible layout
+    /// Account type discriminator at byte 165 (always 2 for CToken accounts)
+    pub account_type: u8, // t22 compatible account type - end of t22 compatible layout
+    pub decimals: Option<u8>,
+    pub compression_only: bool,
+    pub compression: CompressionInfo,
     /// Extensions for the token account (including compressible config)
     pub extensions: Option<Vec<ExtensionStruct>>,
 }
@@ -94,4 +104,10 @@ impl CToken {
     pub fn is_initialized(&self) -> bool {
         self.state == AccountState::Initialized
     }
+
+    /// Checks if account_type matches CToken discriminator value
+    #[inline(always)]
+    pub fn is_ctoken_account(&self) -> bool {
+        self.account_type == ACCOUNT_TYPE_TOKEN_ACCOUNT
+    }
 }
diff --git a/program-libs/ctoken-interface/src/state/ctoken/mod.rs b/program-libs/ctoken-interface/src/state/ctoken/mod.rs
index 9f1cd1caec..0cc5b7edf4 100644
--- a/program-libs/ctoken-interface/src/state/ctoken/mod.rs
+++ b/program-libs/ctoken-interface/src/state/ctoken/mod.rs
@@ -1,6 +1,8 @@
 mod borsh;
 mod ctoken_struct;
+mod size;
 mod zero_copy;
 
 pub use ctoken_struct::*;
+pub use size::*;
 pub use zero_copy::*;
diff --git a/program-libs/ctoken-interface/src/state/ctoken/size.rs b/program-libs/ctoken-interface/src/state/ctoken/size.rs
new file mode 100644
index 0000000000..6351e27180
--- /dev/null
+++ b/program-libs/ctoken-interface/src/state/ctoken/size.rs
@@ -0,0 +1,34 @@
+use light_zero_copy::{errors::ZeroCopyError, ZeroCopyNew};
+
+use crate::{
+    state::{ExtensionStruct, ExtensionStructConfig},
+    BASE_TOKEN_ACCOUNT_SIZE,
+};
+
+/// Calculates the size of a ctoken account based on which extensions are present.
+///
+/// Note: Compression info is now embedded in the base struct (CTokenZeroCopyMeta),
+/// so there's no separate compressible extension parameter.
+///
+/// # Arguments
+/// * `extensions` - Optional slice of extension configs
+///
+/// # Returns
+/// * `Ok(usize)` - The total account size in bytes
+/// * `Err(ZeroCopyError)` - If extension size calculation fails
+pub fn calculate_ctoken_account_size(
+    extensions: Option<&[ExtensionStructConfig]>,
+) -> Result<usize, ZeroCopyError> {
+    let mut size = BASE_TOKEN_ACCOUNT_SIZE as usize;
+
+    if let Some(exts) = extensions {
+        if !exts.is_empty() {
+            size += 4; // Vec length prefix
+            for ext in exts {
+                size += ExtensionStruct::byte_len(ext)?;
+            }
+        }
+    }
+
+    Ok(size)
+}
diff --git a/program-libs/ctoken-interface/src/state/ctoken/zero_copy.rs b/program-libs/ctoken-interface/src/state/ctoken/zero_copy.rs
index a8f4d50016..0cf919faa3 100644
--- a/program-libs/ctoken-interface/src/state/ctoken/zero_copy.rs
+++ b/program-libs/ctoken-interface/src/state/ctoken/zero_copy.rs
@@ -1,233 +1,445 @@
-use std::ops::{Deref, DerefMut};
+use core::ops::{Deref, DerefMut};
 
+use aligned_sized::aligned_sized;
 use light_compressed_account::Pubkey;
+use light_compressible::compression_info::CompressionInfo;
 use light_program_profiler::profile;
 use light_zero_copy::{
-    errors::ZeroCopyError,
-    traits::{ZeroCopyAt, ZeroCopyAtMut, ZeroCopyNew},
+    traits::{ZeroCopyAt, ZeroCopyAtMut},
+    ZeroCopy, ZeroCopyMut, ZeroCopyNew,
 };
-use spl_pod::solana_msg::msg;
 
 use crate::{
     state::{
-        CToken, CompressibleExtensionConfig, CompressionInfoConfig, ExtensionStruct,
-        ExtensionStructConfig, ZExtensionStruct, ZExtensionStructMut,
+        CToken, ExtensionStruct, ExtensionStructConfig, ZExtensionStruct, ZExtensionStructMut,
+        ACCOUNT_TYPE_TOKEN_ACCOUNT,
     },
     AnchorDeserialize, AnchorSerialize,
 };
-
-#[derive(Debug, PartialEq, Eq, Clone, AnchorSerialize, AnchorDeserialize)]
-pub struct CTokenMeta {
+pub const BASE_TOKEN_ACCOUNT_SIZE: u64 = CTokenZeroCopyMeta::LEN as u64;
+
+/// Optimized CToken zero copy struct.
+/// Uses derive macros to generate ZCToken<'a> and ZCTokenMut<'a>.
+#[derive(
+    Debug, PartialEq, Eq, Clone, AnchorSerialize, AnchorDeserialize, ZeroCopy, ZeroCopyMut,
+)]
+#[repr(C)]
+#[aligned_sized]
+struct CTokenZeroCopyMeta {
     /// The mint associated with this account
     pub mint: Pubkey,
     /// The owner of this account.
     pub owner: Pubkey,
     /// The amount of tokens this account holds.
     pub amount: u64,
+    delegate_option_prefix: u32,
     /// If `delegate` is `Some` then `delegated_amount` represents
     /// the amount authorized by the delegate
-    pub delegate: Option<Pubkey>,
+    delegate: Pubkey,
     /// The account's state
     pub state: u8,
     /// If `is_some`, this is a native token, and the value logs the rent-exempt
     /// reserve. An Account is required to be rent-exempt, so the value is
     /// used by the Processor to ensure that wrapped SOL accounts do not
     /// drop below this threshold.
-    pub is_native: Option<u64>,
+    is_native_option_prefix: u32,
+    is_native: u64,
     /// The amount delegated
     pub delegated_amount: u64,
     /// Optional authority to close the account.
-    pub close_authority: Option<Pubkey>,
+    close_authority_option_prefix: u32,
+    close_authority: Pubkey,
+    // End of spl-token compatible layout
+    /// Account type discriminator at byte 165 (always 2 for CToken accounts)
+    pub account_type: u8, // t22 compatible account type - end of t22 compatible layout
+    decimal_option_prefix: u8,
+    decimals: u8,
+    pub compression_only: bool,
+    pub compression: CompressionInfo,
+    has_extensions: bool,
 }
 
-// Note: spl zero-copy compatibility is implemented in fn zero_copy_at
-#[derive(Debug, PartialEq, Clone)]
-pub struct ZCTokenMeta<'a> {
-    pub mint: <Pubkey as ZeroCopyAt<'a>>::ZeroCopyAt,
-    pub owner: <Pubkey as ZeroCopyAt<'a>>::ZeroCopyAt,
-    pub amount: zerocopy::Ref<&'a [u8], zerocopy::little_endian::U64>,
-    pub delegate: Option<<Pubkey as ZeroCopyAt<'a>>::ZeroCopyAt>,
-    pub state: u8,
-    pub is_native: Option<zerocopy::Ref<&'a [u8], zerocopy::little_endian::U64>>,
-    pub delegated_amount: zerocopy::Ref<&'a [u8], zerocopy::little_endian::U64>,
-    pub close_authority: Option<<Pubkey as ZeroCopyAt<'a>>::ZeroCopyAt>,
+/// Zero-copy view of CToken with base and optional extensions
+#[derive(Debug)]
+pub struct ZCToken<'a> {
+    pub base: ZCTokenZeroCopyMeta<'a>,
+    pub extensions: Option<Vec<ZExtensionStruct<'a>>>,
 }
 
-#[derive(Debug, PartialEq)]
-pub struct ZCompressedTokenMetaMut<'a> {
-    pub mint: <Pubkey as ZeroCopyAtMut<'a>>::ZeroCopyAtMut,
-    pub owner: <Pubkey as ZeroCopyAtMut<'a>>::ZeroCopyAtMut,
-    pub amount: zerocopy::Ref<&'a mut [u8], zerocopy::little_endian::U64>,
-    // 4 option bytes (spl compat) + 32 pubkey bytes
-    delegate_option: zerocopy::Ref<&'a mut [u8], [u8; 36]>,
-    pub delegate: Option<<Pubkey as ZeroCopyAtMut<'a>>::ZeroCopyAtMut>,
-    pub state: zerocopy::Ref<&'a mut [u8], u8>,
-    // 4 option bytes (spl compat) + 8 u64 bytes
-    is_native_option: zerocopy::Ref<&'a mut [u8], [u8; 12]>,
-    pub is_native: Option<zerocopy::Ref<&'a mut [u8], zerocopy::little_endian::U64>>,
-    pub delegated_amount: zerocopy::Ref<&'a mut [u8], zerocopy::little_endian::U64>,
-    // 4 option bytes (spl compat) + 32 pubkey bytes
-    close_authority_option: zerocopy::Ref<&'a mut [u8], [u8; 36]>,
-    pub close_authority: Option<<Pubkey as ZeroCopyAtMut<'a>>::ZeroCopyAtMut>,
+/// Mutable zero-copy view of CToken with base and optional extensions
+#[derive(Debug)]
+pub struct ZCTokenMut<'a> {
+    pub base: ZCTokenZeroCopyMetaMut<'a>,
+    pub extensions: Option<Vec<ZExtensionStructMut<'a>>>,
 }
 
-impl<'a> ZeroCopyAt<'a> for CTokenMeta {
-    type ZeroCopyAt = ZCTokenMeta<'a>;
-
-    fn zero_copy_at(bytes: &'a [u8]) -> Result<(Self::ZeroCopyAt, &'a [u8]), ZeroCopyError> {
-        use zerocopy::{
-            little_endian::{U32 as ZU32, U64 as ZU64},
-            Ref,
-        };
+/// Configuration for creating a new CToken via ZeroCopyNew
+#[derive(Debug, Clone, PartialEq)]
+pub struct CompressedTokenConfig {
+    /// The mint pubkey
+    pub mint: Pubkey,
+    /// The owner pubkey
+    pub owner: Pubkey,
+    /// Account state: 1=Initialized, 2=Frozen
+    pub state: u8,
+    /// Whether account is compression-only (cannot decompress)
+    pub compression_only: bool,
+    /// Extensions to include in the account
+    pub extensions: Option<Vec<ExtensionStructConfig>>,
+}
 
-        if bytes.len() < 165 {
-            // SPL Token Account size
-            return Err(ZeroCopyError::Size);
+impl<'a> ZeroCopyNew<'a> for CToken {
+    type ZeroCopyConfig = CompressedTokenConfig;
+    type Output = ZCTokenMut<'a>;
+
+    fn byte_len(
+        config: &Self::ZeroCopyConfig,
+    ) -> Result<usize, light_zero_copy::errors::ZeroCopyError> {
+        let mut size = BASE_TOKEN_ACCOUNT_SIZE as usize;
+        if let Some(extensions) = &config.extensions {
+            if !extensions.is_empty() {
+                size += 4; // Vec length prefix
+                for ext in extensions {
+                    size += ExtensionStruct::byte_len(ext)?;
+                }
+            }
         }
+        Ok(size)
+    }
 
-        let (mint, bytes) = Pubkey::zero_copy_at(bytes)?;
+    fn new_zero_copy(
+        bytes: &'a mut [u8],
+        config: Self::ZeroCopyConfig,
+    ) -> Result<(Self::Output, &'a mut [u8]), light_zero_copy::errors::ZeroCopyError> {
+        // Use derived new_zero_copy for base struct
+        let base_config = CTokenZeroCopyMetaConfig {
+            compression: light_compressible::compression_info::CompressionInfoConfig {
+                rent_config: (),
+            },
+        };
+        let (mut base, mut remaining) =
+            <CTokenZeroCopyMeta as ZeroCopyNew<'a>>::new_zero_copy(bytes, base_config)?;
+
+        // Set base token account fields from config
+        base.mint = config.mint;
+        base.owner = config.owner;
+        base.state = config.state;
+        base.account_type = ACCOUNT_TYPE_TOKEN_ACCOUNT;
+        base.compression_only = config.compression_only as u8;
+
+        // Write extensions using ExtensionStruct::new_zero_copy
+        if let Some(extensions) = config.extensions {
+            if !extensions.is_empty() {
+                *base.has_extensions = 1u8;
+
+                // Write Vec length prefix (4 bytes, little-endian u32)
+                remaining[..4].copy_from_slice(&(extensions.len() as u32).to_le_bytes());
+                remaining = &mut remaining[4..];
+
+                // Write each extension
+                for ext_config in extensions {
+                    let (_, rest) = ExtensionStruct::new_zero_copy(remaining, ext_config)?;
+                    remaining = rest;
+                }
+            }
+        }
 
-        // owner: 32 bytes
-        let (owner, bytes) = Pubkey::zero_copy_at(bytes)?;
+        Ok((
+            ZCTokenMut {
+                base,
+                extensions: None, // Extensions are written directly, not tracked as Vec
+            },
+            remaining,
+        ))
+    }
+}
 
-        // amount: 8 bytes
-        let (amount, bytes) = Ref::<&[u8], ZU64>::from_prefix(bytes)?;
+impl<'a> ZeroCopyAt<'a> for CToken {
+    type ZeroCopyAt = ZCToken<'a>;
 
-        // delegate: 36 bytes (4 byte COption + 32 byte pubkey)
-        let (delegate_option, bytes) = Ref::<&[u8], ZU32>::from_prefix(bytes)?;
-        let (delegate_pubkey, bytes) = Pubkey::zero_copy_at(bytes)?;
-        let delegate = if u32::from(*delegate_option) == 1 {
-            Some(delegate_pubkey)
+    #[inline(always)]
+    fn zero_copy_at(
+        bytes: &'a [u8],
+    ) -> Result<(Self::ZeroCopyAt, &'a [u8]), light_zero_copy::errors::ZeroCopyError> {
+        let (base, bytes) = <CTokenZeroCopyMeta as ZeroCopyAt<'a>>::zero_copy_at(bytes)?;
+        // has_extensions already consumed the Option discriminator byte
+        if base.has_extensions() {
+            let (extensions, bytes) =
+                <Vec<ExtensionStruct> as ZeroCopyAt<'a>>::zero_copy_at(bytes)?;
+            Ok((
+                ZCToken {
+                    base,
+                    extensions: Some(extensions),
+                },
+                bytes,
+            ))
         } else {
-            None
-        };
+            Ok((
+                ZCToken {
+                    base,
+                    extensions: None,
+                },
+                bytes,
+            ))
+        }
+    }
+}
 
-        // state: 1 byte
-        let (state, bytes) = u8::zero_copy_at(bytes)?;
+impl<'a> ZeroCopyAtMut<'a> for CToken {
+    type ZeroCopyAtMut = ZCTokenMut<'a>;
 
-        // is_native: 12 bytes (4 byte COption + 8 byte u64)
-        let (native_option, bytes) = Ref::<&[u8], ZU32>::from_prefix(bytes)?;
-        let (native_value, bytes) = Ref::<&[u8], ZU64>::from_prefix(bytes)?;
-        let is_native = if u32::from(*native_option) == 1 {
-            Some(native_value)
+    #[inline(always)]
+    fn zero_copy_at_mut(
+        bytes: &'a mut [u8],
+    ) -> Result<(Self::ZeroCopyAtMut, &'a mut [u8]), light_zero_copy::errors::ZeroCopyError> {
+        let (base, bytes) = <CTokenZeroCopyMeta as ZeroCopyAtMut<'a>>::zero_copy_at_mut(bytes)?;
+        // has_extensions already consumed the Option discriminator byte
+        if base.has_extensions() {
+            let (extensions, bytes) =
+                <Vec<ExtensionStruct> as ZeroCopyAtMut<'a>>::zero_copy_at_mut(bytes)?;
+            Ok((
+                ZCTokenMut {
+                    base,
+                    extensions: Some(extensions),
+                },
+                bytes,
+            ))
         } else {
-            None
-        };
+            Ok((
+                ZCTokenMut {
+                    base,
+                    extensions: None,
+                },
+                bytes,
+            ))
+        }
+    }
+}
 
-        // delegated_amount: 8 bytes
-        let (delegated_amount, bytes) = Ref::<&[u8], ZU64>::from_prefix(bytes)?;
+// Deref implementations for field access
+impl<'a> Deref for ZCToken<'a> {
+    type Target = ZCTokenZeroCopyMeta<'a>;
 
-        // close_authority: 36 bytes (4 byte COption + 32 byte pubkey)
-        let (close_option, bytes) = Ref::<&[u8], ZU32>::from_prefix(bytes)?;
-        let (close_pubkey, bytes) = Pubkey::zero_copy_at(bytes)?;
-        let close_authority = if u32::from(*close_option) == 1 {
-            Some(close_pubkey)
-        } else {
-            None
-        };
+    fn deref(&self) -> &Self::Target {
+        &self.base
+    }
+}
 
-        let meta = ZCTokenMeta {
-            mint,
-            owner,
-            amount,
-            delegate,
-            state,
-            is_native,
-            delegated_amount,
-            close_authority,
-        };
+impl<'a> Deref for ZCTokenMut<'a> {
+    type Target = ZCTokenZeroCopyMetaMut<'a>;
 
-        Ok((meta, bytes))
+    fn deref(&self) -> &Self::Target {
+        &self.base
     }
 }
 
-impl<'a> ZeroCopyAtMut<'a> for CTokenMeta {
-    type ZeroCopyAtMut = ZCompressedTokenMetaMut<'a>;
+impl<'a> DerefMut for ZCTokenMut<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.base
+    }
+}
 
-    #[profile]
+// Getters on ZCTokenZeroCopyMeta (immutable)
+impl ZCTokenZeroCopyMeta<'_> {
+    /// Checks if account_type matches CToken discriminator value
     #[inline(always)]
-    fn zero_copy_at_mut(
-        bytes: &'a mut [u8],
-    ) -> Result<(Self::ZeroCopyAtMut, &'a mut [u8]), ZeroCopyError> {
-        use zerocopy::{little_endian::U64 as ZU64, Ref};
+    pub fn is_ctoken_account(&self) -> bool {
+        self.account_type == ACCOUNT_TYPE_TOKEN_ACCOUNT
+    }
+
+    /// Checks if account is initialized (state == 1)
+    #[inline(always)]
+    pub fn is_initialized(&self) -> bool {
+        self.state == 1
+    }
+
+    /// Checks if account is frozen (state == 2)
+    #[inline(always)]
+    pub fn is_frozen(&self) -> bool {
+        self.state == 2
+    }
 
-        if bytes.len() < 165 {
-            return Err(ZeroCopyError::Size);
+    /// Get delegate if set (COption discriminator == 1)
+    #[inline(always)]
+    pub fn delegate(&self) -> Option<&Pubkey> {
+        if u32::from(self.delegate_option_prefix) == 1 {
+            Some(&self.delegate)
+        } else {
+            None
         }
+    }
 
-        let (mint, bytes) = Pubkey::zero_copy_at_mut(bytes)?;
-        let (owner, bytes) = Pubkey::zero_copy_at_mut(bytes)?;
-        let (amount, bytes) = Ref::<&mut [u8], ZU64>::from_prefix(bytes)?;
+    /// Get is_native value if set (COption discriminator == 1)
+    #[inline(always)]
+    pub fn is_native_value(&self) -> Option<u64> {
+        if u32::from(self.is_native_option_prefix) == 1 {
+            Some(u64::from(self.is_native))
+        } else {
+            None
+        }
+    }
 
-        let (mut delegate_option, bytes) = Ref::<&mut [u8], [u8; 36]>::from_prefix(bytes)?;
-        let pubkey_bytes =
-            unsafe { std::slice::from_raw_parts_mut(delegate_option.as_mut_ptr().add(4), 32) };
-        let (delegate_pubkey, _) = Pubkey::zero_copy_at_mut(pubkey_bytes)?;
-        let delegate = if delegate_option[0] == 1 {
-            Some(delegate_pubkey)
+    /// Get close_authority if set (COption discriminator == 1)
+    #[inline(always)]
+    pub fn close_authority(&self) -> Option<&Pubkey> {
+        if u32::from(self.close_authority_option_prefix) == 1 {
+            Some(&self.close_authority)
         } else {
             None
-        };
+        }
+    }
 
-        // state: 1 byte
-        let (state, bytes) = Ref::<&mut [u8], u8>::from_prefix(bytes)?;
+    /// Get decimals if set (option prefix == 1)
+    #[inline(always)]
+    pub fn decimals(&self) -> Option<u8> {
+        if self.decimal_option_prefix == 1 {
+            Some(self.decimals)
+        } else {
+            None
+        }
+    }
+}
 
-        // is_native: 12 bytes (4 byte COption + 8 byte u64)
-        let (mut is_native_option, bytes) = Ref::<&mut [u8], [u8; 12]>::from_prefix(bytes)?;
-        let value_bytes =
-            unsafe { std::slice::from_raw_parts_mut(is_native_option.as_mut_ptr().add(4), 8) };
-        let (native_value, _) = Ref::<&mut [u8], ZU64>::from_prefix(value_bytes)?;
-        let is_native = if is_native_option[0] == 1 {
-            Some(native_value)
+// Getters on ZCTokenZeroCopyMetaMut (mutable)
+impl ZCTokenZeroCopyMetaMut<'_> {
+    /// Checks if account_type matches CToken discriminator value
+    #[inline(always)]
+    pub fn is_ctoken_account(&self) -> bool {
+        self.account_type == ACCOUNT_TYPE_TOKEN_ACCOUNT
+    }
+
+    /// Checks if account is initialized (state == 1)
+    #[inline(always)]
+    pub fn is_initialized(&self) -> bool {
+        self.state == 1
+    }
+
+    /// Checks if account is frozen (state == 2)
+    #[inline(always)]
+    pub fn is_frozen(&self) -> bool {
+        self.state == 2
+    }
+
+    /// Get delegate if set (COption discriminator == 1)
+    #[inline(always)]
+    pub fn delegate(&self) -> Option<&Pubkey> {
+        if u32::from(self.delegate_option_prefix) == 1 {
+            Some(&self.delegate)
         } else {
             None
-        };
+        }
+    }
 
-        // delegated_amount: 8 bytes
-        let (delegated_amount, bytes) = Ref::<&mut [u8], ZU64>::from_prefix(bytes)?;
+    /// Get is_native value if set (COption discriminator == 1)
+    #[inline(always)]
+    pub fn is_native_value(&self) -> Option<u64> {
+        if u32::from(self.is_native_option_prefix) == 1 {
+            Some(u64::from(self.is_native))
+        } else {
+            None
+        }
+    }
 
-        // close_authority: 36 bytes (4 byte COption + 32 byte pubkey)
-        let (mut close_authority_option, bytes) = Ref::<&mut [u8], [u8; 36]>::from_prefix(bytes)?;
-        let pubkey_bytes = unsafe {
-            std::slice::from_raw_parts_mut(close_authority_option.as_mut_ptr().add(4), 32)
-        };
-        let (close_pubkey, _) = Pubkey::zero_copy_at_mut(pubkey_bytes)?;
-        let close_authority = if close_authority_option[0] == 1 {
-            Some(close_pubkey)
+    /// Get close_authority if set (COption discriminator == 1)
+    #[inline(always)]
+    pub fn close_authority(&self) -> Option<&Pubkey> {
+        if u32::from(self.close_authority_option_prefix) == 1 {
+            Some(&self.close_authority)
         } else {
             None
-        };
+        }
+    }
 
-        let meta = ZCompressedTokenMetaMut {
-            mint,
-            owner,
-            amount,
-            delegate_option,
-            delegate,
-            state,
-            is_native_option,
-            is_native,
-            delegated_amount,
-            close_authority_option,
-            close_authority,
-        };
+    /// Get decimals if set (option prefix == 1)
+    #[inline(always)]
+    pub fn decimals(&self) -> Option<u8> {
+        if self.decimal_option_prefix == 1 {
+            Some(self.decimals)
+        } else {
+            None
+        }
+    }
 
-        Ok((meta, bytes))
+    /// Set decimals value
+    #[inline(always)]
+    pub fn set_decimals(&mut self, decimals: u8) {
+        self.decimal_option_prefix = 1;
+        self.decimals = decimals;
     }
-}
 
-#[derive(Debug, PartialEq, Clone)]
-pub struct ZCToken<'a> {
-    __meta: ZCTokenMeta<'a>,
-    /// Extensions for the token account (including compressible config)
-    pub extensions: Option<Vec<ZExtensionStruct<'a>>>,
+    /// Set delegate (Some to set, None to clear)
+    #[inline(always)]
+    pub fn set_delegate(&mut self, delegate: Option<Pubkey>) -> Result<(), crate::CTokenError> {
+        match delegate {
+            Some(pubkey) => {
+                self.delegate_option_prefix.set(1);
+                self.delegate = pubkey;
+            }
+            None => {
+                self.delegate_option_prefix.set(0);
+                // Clear delegate bytes
+                self.delegate = Pubkey::default();
+            }
+        }
+        Ok(())
+    }
+
+    /// Set account as frozen (state = 2)
+    #[inline(always)]
+    pub fn set_frozen(&mut self) {
+        self.state = 2;
+    }
+
+    /// Set account as initialized/unfrozen (state = 1)
+    #[inline(always)]
+    pub fn set_initialized(&mut self) {
+        self.state = 1;
+    }
 }
 
-impl<'a> Deref for ZCToken<'a> {
-    type Target = <CTokenMeta as ZeroCopyAt<'a>>::ZeroCopyAt;
+// Checked methods on CTokenZeroCopy
+impl CToken {
+    /// Zero-copy deserialization with initialization and account_type check.
+    /// Returns an error if:
+    /// - Account is uninitialized (byte 108 == 0)
+    /// - Account type is not ACCOUNT_TYPE_TOKEN_ACCOUNT (byte 165 != 2)
+    ///   Allows both Initialized (1) and Frozen (2) states.
+    #[profile]
+    #[inline(always)]
+    pub fn zero_copy_at_checked(
+        bytes: &[u8],
+    ) -> Result<(ZCToken<'_>, &[u8]), crate::error::CTokenError> {
+        let (ctoken, remaining) = CToken::zero_copy_at(bytes)?;
 
-    fn deref(&self) -> &Self::Target {
-        &self.__meta
+        if !ctoken.is_initialized() {
+            return Err(crate::error::CTokenError::InvalidAccountState);
+        }
+        if !ctoken.is_ctoken_account() {
+            return Err(crate::error::CTokenError::InvalidAccountType);
+        }
+
+        Ok((ctoken, remaining))
+    }
+
+    /// Mutable zero-copy deserialization with initialization and account_type check.
+    /// Returns an error if:
+    /// - Account is uninitialized (state == 0)
+    /// - Account type is not ACCOUNT_TYPE_TOKEN_ACCOUNT
+    #[profile]
+    #[inline(always)]
+    pub fn zero_copy_at_mut_checked(
+        bytes: &mut [u8],
+    ) -> Result<(ZCTokenMut<'_>, &mut [u8]), crate::error::CTokenError> {
+        let (ctoken, remaining) = CToken::zero_copy_at_mut(bytes)?;
+
+        if !ctoken.is_initialized() {
+            return Err(crate::error::CTokenError::InvalidAccountState);
+        }
+        if !ctoken.is_ctoken_account() {
+            return Err(crate::error::CTokenError::InvalidAccountType);
+        }
+
+        Ok((ctoken, remaining))
     }
 }
 
@@ -237,15 +449,15 @@ impl PartialEq<CToken> for ZCToken<'_> {
         // Compare basic fields
         if self.mint.to_bytes() != other.mint.to_bytes()
             || self.owner.to_bytes() != other.owner.to_bytes()
-            || u64::from(*self.amount) != other.amount
+            || u64::from(self.amount) != other.amount
             || self.state != other.state as u8
-            || u64::from(*self.delegated_amount) != other.delegated_amount
+            || u64::from(self.delegated_amount) != other.delegated_amount
         {
             return false;
         }
 
         // Compare delegate
-        match (&self.delegate, &other.delegate) {
+        match (self.delegate(), &other.delegate) {
             (Some(zc_delegate), Some(regular_delegate)) => {
                 if zc_delegate.to_bytes() != regular_delegate.to_bytes() {
                     return false;
@@ -256,9 +468,9 @@ impl PartialEq<CToken> for ZCToken<'_> {
         }
 
         // Compare is_native
-        match (&self.is_native, &other.is_native) {
+        match (self.is_native_value(), &other.is_native) {
             (Some(zc_native), Some(regular_native)) => {
-                if u64::from(**zc_native) != *regular_native {
+                if zc_native != *regular_native {
                     return false;
                 }
             }
@@ -267,7 +479,7 @@ impl PartialEq<CToken> for ZCToken<'_> {
         }
 
         // Compare close_authority
-        match (&self.close_authority, &other.close_authority) {
+        match (self.close_authority(), &other.close_authority) {
             (Some(zc_close), Some(regular_close)) => {
                 if zc_close.to_bytes() != regular_close.to_bytes() {
                     return false;
@@ -277,6 +489,73 @@ impl PartialEq<CToken> for ZCToken<'_> {
             _ => return false,
         }
 
+        // Compare decimals
+        match (self.decimals(), &other.decimals) {
+            (Some(zc_decimals), Some(regular_decimals)) => {
+                if zc_decimals != *regular_decimals {
+                    return false;
+                }
+            }
+            (None, None) => {}
+            _ => return false,
+        }
+
+        // Compare compression_only
+        if self.compression_only() != other.compression_only {
+            return false;
+        }
+
+        // Compare compression fields
+        if u16::from(self.compression.config_account_version)
+            != other.compression.config_account_version
+        {
+            return false;
+        }
+        if self.compression.compress_to_pubkey != other.compression.compress_to_pubkey {
+            return false;
+        }
+        if self.compression.account_version != other.compression.account_version {
+            return false;
+        }
+        if u64::from(self.compression.last_claimed_slot) != other.compression.last_claimed_slot {
+            return false;
+        }
+        if u32::from(self.compression.lamports_per_write) != other.compression.lamports_per_write {
+            return false;
+        }
+        if self.compression.compression_authority != other.compression.compression_authority {
+            return false;
+        }
+        if self.compression.rent_sponsor != other.compression.rent_sponsor {
+            return false;
+        }
+        // Compare rent_config fields
+        if u16::from(self.compression.rent_config.base_rent)
+            != other.compression.rent_config.base_rent
+        {
+            return false;
+        }
+        if u16::from(self.compression.rent_config.compression_cost)
+            != other.compression.rent_config.compression_cost
+        {
+            return false;
+        }
+        if self.compression.rent_config.lamports_per_byte_per_epoch
+            != other.compression.rent_config.lamports_per_byte_per_epoch
+        {
+            return false;
+        }
+        if self.compression.rent_config.max_funded_epochs
+            != other.compression.rent_config.max_funded_epochs
+        {
+            return false;
+        }
+        if u16::from(self.compression.rent_config.max_top_up)
+            != other.compression.rent_config.max_top_up
+        {
+            return false;
+        }
+
         // Compare extensions
         match (&self.extensions, &other.extensions) {
             (Some(zc_extensions), Some(regular_extensions)) => {
@@ -286,82 +565,7 @@ impl PartialEq<CToken> for ZCToken<'_> {
                 for (zc_ext, regular_ext) in zc_extensions.iter().zip(regular_extensions.iter()) {
                     match (zc_ext, regular_ext) {
                         (
-                            crate::state::extensions::ZExtensionStruct::Compressible(zc_comp),
-                            crate::state::extensions::ExtensionStruct::Compressible(regular_comp),
-                        ) => {
-                            // Compare config_account_version
-                            if zc_comp.info.config_account_version
-                                != regular_comp.info.config_account_version
-                            {
-                                return false;
-                            }
-
-                            // Compare compress_to_pubkey
-                            if zc_comp.info.compress_to_pubkey
-                                != regular_comp.info.compress_to_pubkey
-                            {
-                                return false;
-                            }
-
-                            // Compare account_version
-                            if zc_comp.info.account_version != regular_comp.info.account_version {
-                                return false;
-                            }
-
-                            // Compare last_claimed_slot
-                            if u64::from(zc_comp.info.last_claimed_slot)
-                                != regular_comp.info.last_claimed_slot
-                            {
-                                return false;
-                            }
-
-                            // Compare rent_config fields
-                            if u16::from(zc_comp.info.rent_config.base_rent)
-                                != regular_comp.info.rent_config.base_rent
-                            {
-                                return false;
-                            }
-                            if u16::from(zc_comp.info.rent_config.compression_cost)
-                                != regular_comp.info.rent_config.compression_cost
-                            {
-                                return false;
-                            }
-                            if zc_comp.info.rent_config.lamports_per_byte_per_epoch
-                                != regular_comp.info.rent_config.lamports_per_byte_per_epoch
-                            {
-                                return false;
-                            }
-                            if zc_comp.info.rent_config.max_funded_epochs
-                                != regular_comp.info.rent_config.max_funded_epochs
-                            {
-                                return false;
-                            }
-                            if u16::from(zc_comp.info.rent_config.max_top_up)
-                                != regular_comp.info.rent_config.max_top_up
-                            {
-                                return false;
-                            }
-                            // Compare compression_authority ([u8; 32])
-                            if zc_comp.info.compression_authority
-                                != regular_comp.info.compression_authority
-                            {
-                                return false;
-                            }
-
-                            // Compare rent_sponsor ([u8; 32])
-                            if zc_comp.info.rent_sponsor != regular_comp.info.rent_sponsor {
-                                return false;
-                            }
-
-                            // Compare lamports_per_write (u32)
-                            if u32::from(zc_comp.info.lamports_per_write)
-                                != regular_comp.info.lamports_per_write
-                            {
-                                return false;
-                            }
-                        }
-                        (
-                            crate::state::extensions::ZExtensionStruct::TokenMetadata(zc_tm),
+                            ZExtensionStruct::TokenMetadata(zc_tm),
                             crate::state::extensions::ExtensionStruct::TokenMetadata(regular_tm),
                         ) => {
                             if zc_tm.mint.to_bytes() != regular_tm.mint.to_bytes()
@@ -391,15 +595,49 @@ impl PartialEq<CToken> for ZCToken<'_> {
                                 }
                             }
                         }
-                        // Mismatched known extension types (e.g., Compressible vs TokenMetadata)
                         (
-                            crate::state::extensions::ZExtensionStruct::Compressible(_),
-                            crate::state::extensions::ExtensionStruct::TokenMetadata(_),
-                        )
-                        | (
-                            crate::state::extensions::ZExtensionStruct::TokenMetadata(_),
-                            crate::state::extensions::ExtensionStruct::Compressible(_),
-                        ) => return false,
+                            ZExtensionStruct::PausableAccount(_),
+                            crate::state::extensions::ExtensionStruct::PausableAccount(_),
+                        ) => {
+                            // Marker extension with no data, just matching discriminant is enough
+                        }
+                        (
+                            ZExtensionStruct::PermanentDelegateAccount(_),
+                            crate::state::extensions::ExtensionStruct::PermanentDelegateAccount(_),
+                        ) => {
+                            // Marker extension with no data
+                        }
+                        (
+                            ZExtensionStruct::TransferFeeAccount(zc_tfa),
+                            crate::state::extensions::ExtensionStruct::TransferFeeAccount(
+                                regular_tfa,
+                            ),
+                        ) => {
+                            if u64::from(zc_tfa.withheld_amount) != regular_tfa.withheld_amount {
+                                return false;
+                            }
+                        }
+                        (
+                            ZExtensionStruct::TransferHookAccount(zc_tha),
+                            crate::state::extensions::ExtensionStruct::TransferHookAccount(
+                                regular_tha,
+                            ),
+                        ) => {
+                            if zc_tha.transferring != regular_tha.transferring {
+                                return false;
+                            }
+                        }
+                        (
+                            ZExtensionStruct::CompressedOnly(zc_co),
+                            crate::state::extensions::ExtensionStruct::CompressedOnly(regular_co),
+                        ) => {
+                            if u64::from(zc_co.delegated_amount) != regular_co.delegated_amount
+                                || u64::from(zc_co.withheld_transfer_fee)
+                                    != regular_co.withheld_transfer_fee
+                            {
+                                return false;
+                            }
+                        }
                         // Unknown or unhandled extension types should panic to surface bugs early
                         (zc_ext, regular_ext) => {
                             panic!(
@@ -425,319 +663,3 @@ impl PartialEq<ZCToken<'_>> for CToken {
         other.eq(self)
     }
 }
-
-#[derive(Debug)]
-pub struct ZCompressedTokenMut<'a> {
-    __meta: <CTokenMeta as ZeroCopyAtMut<'a>>::ZeroCopyAtMut,
-    /// Extensions for the token account (including compressible config)
-    pub extensions: Option<Vec<ZExtensionStructMut<'a>>>,
-}
-impl<'a> Deref for ZCompressedTokenMut<'a> {
-    type Target = <CTokenMeta as ZeroCopyAtMut<'a>>::ZeroCopyAtMut;
-
-    fn deref(&self) -> &Self::Target {
-        &self.__meta
-    }
-}
-
-impl DerefMut for ZCompressedTokenMut<'_> {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.__meta
-    }
-}
-
-impl<'a> ZeroCopyAt<'a> for CToken {
-    type ZeroCopyAt = ZCToken<'a>;
-
-    #[profile]
-    fn zero_copy_at(bytes: &'a [u8]) -> Result<(Self::ZeroCopyAt, &'a [u8]), ZeroCopyError> {
-        let (__meta, bytes) = <CTokenMeta as ZeroCopyAt<'a>>::zero_copy_at(bytes)?;
-        let (extensions, bytes) = if !bytes.is_empty() {
-            // Check if first byte is AccountType::Account (value 2) for SPL Token 2022 compatibility
-            let extension_start = if bytes.first() == Some(&2) {
-                // Skip AccountType::Account byte at position 165
-                &bytes[1..]
-            } else {
-                return Err(ZeroCopyError::Size);
-            };
-
-            let (extensions, remaining_bytes) =
-                <Option<Vec<ExtensionStruct>> as ZeroCopyAt<'a>>::zero_copy_at(extension_start)?;
-            (extensions, remaining_bytes)
-        } else {
-            (None, bytes)
-        };
-        Ok((ZCToken { __meta, extensions }, bytes))
-    }
-}
-
-impl CToken {
-    /// Zero-copy deserialization with initialization check.
-    /// Returns an error if the account is not initialized (byte 108 must be 1).
-    #[profile]
-    pub fn zero_copy_at_checked(
-        bytes: &[u8],
-    ) -> Result<(ZCToken<'_>, &[u8]), crate::error::CTokenError> {
-        // Check minimum size for state field at byte 108
-        if bytes.len() < 109 {
-            return Err(crate::error::CTokenError::InvalidAccountData);
-        }
-
-        // Verify account is initialized (state byte at offset 108 must be 1)
-        if bytes[108] != 1 {
-            return Err(crate::error::CTokenError::InvalidAccountState);
-        }
-
-        // Proceed with normal deserialization
-        Ok(CToken::zero_copy_at(bytes)?)
-    }
-
-    /// Mutable zero-copy deserialization with initialization check.
-    /// Returns an error if the account is not initialized (byte 108 must be 1).
-    #[profile]
-    pub fn zero_copy_at_mut_checked(
-        bytes: &mut [u8],
-    ) -> Result<(ZCompressedTokenMut<'_>, &mut [u8]), crate::error::CTokenError> {
-        // Check minimum size for state field at byte 108
-        if bytes.len() < 109 {
-            return Err(crate::error::CTokenError::InvalidAccountData);
-        }
-
-        // Verify account is initialized (state byte at offset 108 must be 1)
-        if bytes[108] != 1 {
-            return Err(crate::error::CTokenError::InvalidAccountState);
-        }
-
-        Ok(CToken::zero_copy_at_mut(bytes)?)
-    }
-}
-
-impl<'a> ZeroCopyAtMut<'a> for CToken {
-    type ZeroCopyAtMut = ZCompressedTokenMut<'a>;
-
-    #[profile]
-    #[inline(always)]
-    fn zero_copy_at_mut(
-        bytes: &'a mut [u8],
-    ) -> Result<(Self::ZeroCopyAtMut, &'a mut [u8]), ZeroCopyError> {
-        let (__meta, bytes) = <CTokenMeta as ZeroCopyAtMut<'a>>::zero_copy_at_mut(bytes)?;
-        let (extensions, bytes) = if !bytes.is_empty() {
-            // Check if first byte is AccountType::Account (value 2) for SPL Token 2022 compatibility
-            let extension_start = if bytes.first() == Some(&2) {
-                // Skip AccountType::Account byte at position 165
-                &mut bytes[1..]
-            } else {
-                return Err(ZeroCopyError::Size);
-            };
-
-            let (extensions, remaining_bytes) = <Option<Vec<ExtensionStruct>> as ZeroCopyAtMut<
-                'a,
-            >>::zero_copy_at_mut(extension_start)?;
-            (extensions, remaining_bytes)
-        } else {
-            (None, bytes)
-        };
-        Ok((ZCompressedTokenMut { __meta, extensions }, bytes))
-    }
-}
-
-impl ZCompressedTokenMetaMut<'_> {
-    /// Set the delegate field by updating both the COption discriminator and value
-    pub fn set_delegate(&mut self, delegate: Option<Pubkey>) -> Result<(), ZeroCopyError> {
-        match (&mut self.delegate, delegate) {
-            (Some(delegate), Some(new)) => {
-                **delegate = new;
-            }
-            (Some(delegate), None) => {
-                // Set discriminator to 0 (None)
-                self.delegate_option[0] = 0;
-                **delegate = Pubkey::default();
-            }
-            (None, Some(new)) => {
-                self.delegate_option[0] = 1;
-                let pubkey_bytes = unsafe {
-                    std::slice::from_raw_parts_mut(self.delegate_option.as_mut_ptr().add(4), 32)
-                };
-                let (mut delegate_pubkey, _) = Pubkey::zero_copy_at_mut(pubkey_bytes)?;
-                *delegate_pubkey = new;
-                self.delegate = Some(delegate_pubkey);
-            }
-            (None, None) => {}
-        }
-        Ok(())
-    }
-
-    /// Set the is_native field by updating both the COption discriminator and value
-    pub fn set_is_native(&mut self, is_native: Option<u64>) -> Result<(), ZeroCopyError> {
-        match (&mut self.is_native, is_native) {
-            (Some(native_value), Some(new)) => {
-                **native_value = new.into();
-            }
-            (Some(native_value), None) => {
-                // Set discriminator to 0 (None)
-                self.is_native_option[0] = 0;
-                **native_value = 0u64.into();
-                self.is_native = None;
-            }
-            (None, Some(new)) => {
-                self.is_native_option[0] = 1;
-                let value_bytes = unsafe {
-                    std::slice::from_raw_parts_mut(self.is_native_option.as_mut_ptr().add(4), 8)
-                };
-                let (mut native_value, _) =
-                    zerocopy::Ref::<&mut [u8], zerocopy::little_endian::U64>::from_prefix(
-                        value_bytes,
-                    )?;
-                *native_value = new.into();
-                self.is_native = Some(native_value);
-            }
-            (None, None) => {}
-        }
-        Ok(())
-    }
-
-    /// Set the close_authority field by updating both the COption discriminator and value
-    pub fn set_close_authority(
-        &mut self,
-        close_authority: Option<Pubkey>,
-    ) -> Result<(), ZeroCopyError> {
-        match (&mut self.close_authority, close_authority) {
-            (Some(authority), Some(new)) => {
-                **authority = new;
-            }
-            (Some(authority), None) => {
-                // Set discriminator to 0 (None)
-                self.close_authority_option[0] = 0;
-                **authority = Pubkey::default();
-                self.close_authority = None;
-            }
-            (None, Some(new)) => {
-                self.close_authority_option[0] = 1;
-                let pubkey_bytes = unsafe {
-                    std::slice::from_raw_parts_mut(
-                        self.close_authority_option.as_mut_ptr().add(4),
-                        32,
-                    )
-                };
-                let (mut close_authority_pubkey, _) = Pubkey::zero_copy_at_mut(pubkey_bytes)?;
-                *close_authority_pubkey = new;
-                self.close_authority = Some(close_authority_pubkey);
-            }
-            (None, None) => {}
-        }
-        Ok(())
-    }
-}
-
-// Configuration for initializing a compressed token
-#[derive(Debug, Clone)]
-pub struct CompressedTokenConfig {
-    pub delegate: bool,
-    pub is_native: bool,
-    pub close_authority: bool,
-    pub extensions: Vec<ExtensionStructConfig>,
-}
-
-impl CompressedTokenConfig {
-    pub fn new(delegate: bool, is_native: bool, close_authority: bool) -> Self {
-        Self {
-            delegate,
-            is_native,
-            close_authority,
-            extensions: vec![],
-        }
-    }
-    pub fn new_compressible(delegate: bool, is_native: bool, close_authority: bool) -> Self {
-        Self {
-            delegate,
-            is_native,
-            close_authority,
-            extensions: vec![ExtensionStructConfig::Compressible(
-                CompressibleExtensionConfig {
-                    info: CompressionInfoConfig { rent_config: () },
-                },
-            )],
-        }
-    }
-}
-
-impl<'a> ZeroCopyNew<'a> for CToken {
-    type ZeroCopyConfig = CompressedTokenConfig;
-    type Output = ZCompressedTokenMut<'a>;
-
-    fn byte_len(config: &Self::ZeroCopyConfig) -> Result<usize, ZeroCopyError> {
-        // mint: 32 bytes
-        // owner: 32 bytes
-        // amount: 8 bytes
-        // delegate: 4 bytes discriminator + 32 bytes pubkey
-        // state: 1 byte
-        // is_native: 4 bytes discriminator + 8 bytes u64
-        // delegated_amount: 8 bytes
-        // close_authority: 4 bytes discriminator + 32 bytes pubkey
-        // Total: 165 bytes (SPL Token Account size)
-        let mut len = 165;
-        // Add AccountType byte for SPL Token 2022 compatibility (always present if we have extensions)
-        if !config.extensions.is_empty() {
-            len += 1; // AccountType::Account byte at position 165
-            len += 1; // Option discriminant for extensions (Some = 1)
-            len += <Vec<ExtensionStruct> as ZeroCopyNew<'a>>::byte_len(&config.extensions)?;
-        }
-        Ok(len)
-    }
-
-    fn new_zero_copy(
-        bytes: &'a mut [u8],
-        config: Self::ZeroCopyConfig,
-    ) -> Result<(Self::Output, &'a mut [u8]), ZeroCopyError> {
-        if bytes.len() < Self::byte_len(&config)? {
-            msg!("CToken new_zero_copy Insufficient buffer size");
-            return Err(ZeroCopyError::ArraySize(
-                bytes.len(),
-                Self::byte_len(&config)?,
-            ));
-        }
-        if bytes[108] != 0 {
-            msg!("Account already initialized");
-            return Err(ZeroCopyError::MemoryNotZeroed);
-        }
-        // Set the state to Initialized (1) at offset 108 (32 mint + 32 owner + 8 amount + 36 delegate)
-        bytes[108] = 1; // AccountState::Initialized
-
-        // Set discriminator bytes based on config
-        // delegate discriminator at offset 72 (32 mint + 32 owner + 8 amount)
-        bytes[72] = if config.delegate { 1 } else { 0 };
-
-        // is_native discriminator at offset 109 (72 + 36 delegate + 1 state)
-        bytes[109] = if config.is_native { 1 } else { 0 };
-
-        // close_authority discriminator at offset 129 (109 + 12 is_native + 8 delegated_amount)
-        bytes[129] = if config.close_authority { 1 } else { 0 };
-
-        // Initialize extensions if present
-        if !config.extensions.is_empty() {
-            // Set AccountType::Account byte at position 165 for SPL Token 2022 compatibility
-            bytes[165] = 2; // AccountType::Account = 2
-
-            // Set Option discriminant for extensions (Some = 1) at position 166
-            bytes[166] = 1;
-
-            // Extensions Vec starts after the Option discriminant (167 bytes)
-            let extension_bytes = &mut bytes[167..];
-
-            // Write Vec length (4 bytes little-endian)
-            let len = config.extensions.len() as u32;
-            extension_bytes[0..4].copy_from_slice(&len.to_le_bytes());
-
-            // Initialize each extension
-            let mut current_bytes = &mut extension_bytes[4..];
-            for extension_config in &config.extensions {
-                let (_, remaining_bytes) = <ExtensionStruct as ZeroCopyNew<'_>>::new_zero_copy(
-                    current_bytes,
-                    extension_config.clone(),
-                )?;
-                current_bytes = remaining_bytes;
-            }
-        }
-        CToken::zero_copy_at_mut(bytes)
-    }
-}
diff --git a/program-libs/ctoken-interface/src/state/extensions/compressed_only.rs b/program-libs/ctoken-interface/src/state/extensions/compressed_only.rs
new file mode 100644
index 0000000000..5e9bfffc9b
--- /dev/null
+++ b/program-libs/ctoken-interface/src/state/extensions/compressed_only.rs
@@ -0,0 +1,31 @@
+use light_zero_copy::{ZeroCopy, ZeroCopyMut};
+
+use crate::{AnchorDeserialize, AnchorSerialize};
+
+/// CompressedOnly extension for compressed token accounts.
+/// This extension marks a compressed account as decompress-only (cannot be transferred).
+/// It stores the delegated amount from the source CToken account when it was compressed-and-closed.
+#[derive(
+    Debug,
+    Clone,
+    Hash,
+    Copy,
+    PartialEq,
+    Eq,
+    AnchorSerialize,
+    AnchorDeserialize,
+    ZeroCopy,
+    ZeroCopyMut,
+)]
+#[repr(C)]
+pub struct CompressedOnlyExtension {
+    /// The delegated amount from the source CToken account's delegate field.
+    /// When decompressing, the decompression amount must match this value.
+    pub delegated_amount: u64,
+    /// Withheld transfer fee amount from the source CToken account.
+    pub withheld_transfer_fee: u64,
+}
+
+impl CompressedOnlyExtension {
+    pub const LEN: usize = std::mem::size_of::<Self>();
+}
diff --git a/program-libs/ctoken-interface/src/state/extensions/extension_struct.rs b/program-libs/ctoken-interface/src/state/extensions/extension_struct.rs
index 776874959d..1ac8402042 100644
--- a/program-libs/ctoken-interface/src/state/extensions/extension_struct.rs
+++ b/program-libs/ctoken-interface/src/state/extensions/extension_struct.rs
@@ -1,9 +1,16 @@
-use aligned_sized::aligned_sized;
-use light_zero_copy::{ZeroCopy, ZeroCopyMut};
+use light_zero_copy::ZeroCopy;
 use spl_pod::solana_msg::msg;
 
 use crate::{
-    state::extensions::{CompressionInfo, TokenMetadata, TokenMetadataConfig, ZTokenMetadataMut},
+    state::extensions::{
+        CompressedOnlyExtension, CompressedOnlyExtensionConfig, ExtensionType,
+        PausableAccountExtension, PausableAccountExtensionConfig,
+        PermanentDelegateAccountExtension, PermanentDelegateAccountExtensionConfig, TokenMetadata,
+        TokenMetadataConfig, TransferFeeAccountExtension, TransferFeeAccountExtensionConfig,
+        TransferHookAccountExtension, TransferHookAccountExtensionConfig,
+        ZPausableAccountExtensionMut, ZPermanentDelegateAccountExtensionMut, ZTokenMetadataMut,
+        ZTransferFeeAccountExtensionMut, ZTransferHookAccountExtensionMut,
+    },
     AnchorDeserialize, AnchorSerialize,
 };
 
@@ -38,34 +45,16 @@ pub enum ExtensionStruct {
     Placeholder25,
     /// Reserved for Token-2022 Pausable compatibility
     Placeholder26,
-    /// Reserved for Token-2022 PausableAccount compatibility
-    Placeholder27,
-    /// Reserved for Token-2022 extensions
-    Placeholder28,
-    Placeholder29,
-    Placeholder30,
-    Placeholder31,
-    /// Account contains compressible timing data and rent authority
-    Compressible(CompressibleExtension),
-}
-
-#[derive(
-    Debug,
-    ZeroCopy,
-    ZeroCopyMut,
-    Clone,
-    Copy,
-    PartialEq,
-    Hash,
-    Eq,
-    AnchorSerialize,
-    AnchorDeserialize,
-)]
-#[repr(C)]
-#[aligned_sized]
-pub struct CompressibleExtension {
-    pub compression_only: bool,
-    pub info: CompressionInfo,
+    /// Marker extension indicating the account belongs to a pausable mint
+    PausableAccount(PausableAccountExtension),
+    /// Marker extension indicating the account belongs to a mint with permanent delegate
+    PermanentDelegateAccount(PermanentDelegateAccountExtension),
+    /// Transfer fee extension storing withheld fees from transfers
+    TransferFeeAccount(TransferFeeAccountExtension),
+    /// Marker extension indicating the account belongs to a mint with transfer hook
+    TransferHookAccount(TransferHookAccountExtension),
+    /// CompressedOnly extension for compressed token accounts (stores delegated amount)
+    CompressedOnly(CompressedOnlyExtension),
 }
 
 #[derive(Debug)]
@@ -98,16 +87,17 @@ pub enum ZExtensionStructMut<'a> {
     Placeholder25,
     /// Reserved for Token-2022 Pausable compatibility
     Placeholder26,
-    /// Reserved for Token-2022 PausableAccount compatibility
-    Placeholder27,
-    /// Reserved for Token-2022 extensions
-    Placeholder28,
-    Placeholder29,
-    Placeholder30,
-    Placeholder31,
-    /// Account contains compressible timing data and rent authority
-    Compressible(
-        <CompressibleExtension as light_zero_copy::traits::ZeroCopyAtMut<'a>>::ZeroCopyAtMut,
+    /// Marker extension indicating the account belongs to a pausable mint
+    PausableAccount(ZPausableAccountExtensionMut<'a>),
+    /// Marker extension indicating the account belongs to a mint with permanent delegate
+    PermanentDelegateAccount(ZPermanentDelegateAccountExtensionMut<'a>),
+    /// Transfer fee extension storing withheld fees from transfers
+    TransferFeeAccount(ZTransferFeeAccountExtensionMut<'a>),
+    /// Marker extension indicating the account belongs to a mint with transfer hook
+    TransferHookAccount(ZTransferHookAccountExtensionMut<'a>),
+    /// CompressedOnly extension for compressed token accounts
+    CompressedOnly(
+        <CompressedOnlyExtension as light_zero_copy::traits::ZeroCopyAtMut<'a>>::ZeroCopyAtMut,
     ),
 }
 
@@ -127,8 +117,11 @@ impl<'a> light_zero_copy::traits::ZeroCopyAtMut<'a> for ExtensionStruct {
 
         let discriminant = data[0];
         let remaining_data = &mut data[1..];
-        match discriminant {
-            19 => {
+        let extension_type = ExtensionType::try_from(discriminant)
+            .map_err(|_| light_zero_copy::errors::ZeroCopyError::InvalidConversion)?;
+
+        match extension_type {
+            ExtensionType::TokenMetadata => {
                 let (token_metadata, remaining_bytes) =
                     TokenMetadata::zero_copy_at_mut(remaining_data)?;
                 Ok((
@@ -136,12 +129,43 @@ impl<'a> light_zero_copy::traits::ZeroCopyAtMut<'a> for ExtensionStruct {
                     remaining_bytes,
                 ))
             }
-            32 => {
-                // Compressible variant (index 32 to avoid Token-2022 overlap)
-                let (compressible_ext, remaining_bytes) =
-                    CompressibleExtension::zero_copy_at_mut(remaining_data)?;
+            ExtensionType::PausableAccount => {
+                let (pausable_ext, remaining_bytes) =
+                    PausableAccountExtension::zero_copy_at_mut(remaining_data)?;
                 Ok((
-                    ZExtensionStructMut::Compressible(compressible_ext),
+                    ZExtensionStructMut::PausableAccount(pausable_ext),
+                    remaining_bytes,
+                ))
+            }
+            ExtensionType::PermanentDelegateAccount => {
+                let (permanent_delegate_ext, remaining_bytes) =
+                    PermanentDelegateAccountExtension::zero_copy_at_mut(remaining_data)?;
+                Ok((
+                    ZExtensionStructMut::PermanentDelegateAccount(permanent_delegate_ext),
+                    remaining_bytes,
+                ))
+            }
+            ExtensionType::TransferFeeAccount => {
+                let (transfer_fee_ext, remaining_bytes) =
+                    TransferFeeAccountExtension::zero_copy_at_mut(remaining_data)?;
+                Ok((
+                    ZExtensionStructMut::TransferFeeAccount(transfer_fee_ext),
+                    remaining_bytes,
+                ))
+            }
+            ExtensionType::TransferHookAccount => {
+                let (transfer_hook_ext, remaining_bytes) =
+                    TransferHookAccountExtension::zero_copy_at_mut(remaining_data)?;
+                Ok((
+                    ZExtensionStructMut::TransferHookAccount(transfer_hook_ext),
+                    remaining_bytes,
+                ))
+            }
+            ExtensionType::CompressedOnly => {
+                let (compressed_only_ext, remaining_bytes) =
+                    CompressedOnlyExtension::zero_copy_at_mut(remaining_data)?;
+                Ok((
+                    ZExtensionStructMut::CompressedOnly(compressed_only_ext),
                     remaining_bytes,
                 ))
             }
@@ -162,9 +186,25 @@ impl<'a> light_zero_copy::ZeroCopyNew<'a> for ExtensionStruct {
                 // 1 byte for discriminant + TokenMetadata size
                 1 + TokenMetadata::byte_len(token_metadata_config)?
             }
-            ExtensionStructConfig::Compressible(config) => {
-                // 1 byte for discriminant + CompressionInfo size
-                1 + CompressibleExtension::byte_len(config)?
+            ExtensionStructConfig::PausableAccount(config) => {
+                // 1 byte for discriminant + 0 bytes for marker extension
+                1 + PausableAccountExtension::byte_len(config)?
+            }
+            ExtensionStructConfig::PermanentDelegateAccount(config) => {
+                // 1 byte for discriminant + 0 bytes for marker extension
+                1 + PermanentDelegateAccountExtension::byte_len(config)?
+            }
+            ExtensionStructConfig::TransferFeeAccount(config) => {
+                // 1 byte for discriminant + 8 bytes for withheld_amount
+                1 + TransferFeeAccountExtension::byte_len(config)?
+            }
+            ExtensionStructConfig::TransferHookAccount(config) => {
+                // 1 byte for discriminant + 1 byte for transferring flag
+                1 + TransferHookAccountExtension::byte_len(config)?
+            }
+            ExtensionStructConfig::CompressedOnly(_) => {
+                // 1 byte for discriminant + 16 bytes for CompressedOnlyExtension (2 * u64)
+                1 + CompressedOnlyExtension::LEN
             }
             _ => {
                 msg!("Invalid extension type returning");
@@ -179,14 +219,13 @@ impl<'a> light_zero_copy::ZeroCopyNew<'a> for ExtensionStruct {
     ) -> Result<(Self::Output, &'a mut [u8]), light_zero_copy::errors::ZeroCopyError> {
         match config {
             ExtensionStructConfig::TokenMetadata(config) => {
-                // Write discriminant (19 for TokenMetadata)
                 if bytes.is_empty() {
                     return Err(light_zero_copy::errors::ZeroCopyError::ArraySize(
                         1,
                         bytes.len(),
                     ));
                 }
-                bytes[0] = 19u8;
+                bytes[0] = ExtensionType::TokenMetadata as u8;
 
                 let (token_metadata, remaining_bytes) =
                     TokenMetadata::new_zero_copy(&mut bytes[1..], config)?;
@@ -195,20 +234,83 @@ impl<'a> light_zero_copy::ZeroCopyNew<'a> for ExtensionStruct {
                     remaining_bytes,
                 ))
             }
-            ExtensionStructConfig::Compressible(config) => {
-                // Write discriminant (32 for Compressible - avoids Token-2022 overlap)
+            ExtensionStructConfig::PausableAccount(config) => {
+                if bytes.is_empty() {
+                    return Err(light_zero_copy::errors::ZeroCopyError::ArraySize(
+                        1,
+                        bytes.len(),
+                    ));
+                }
+                bytes[0] = ExtensionType::PausableAccount as u8;
+
+                let (pausable_ext, remaining_bytes) =
+                    PausableAccountExtension::new_zero_copy(&mut bytes[1..], config)?;
+                Ok((
+                    ZExtensionStructMut::PausableAccount(pausable_ext),
+                    remaining_bytes,
+                ))
+            }
+            ExtensionStructConfig::PermanentDelegateAccount(config) => {
                 if bytes.is_empty() {
                     return Err(light_zero_copy::errors::ZeroCopyError::ArraySize(
                         1,
                         bytes.len(),
                     ));
                 }
-                bytes[0] = 32u8;
+                bytes[0] = ExtensionType::PermanentDelegateAccount as u8;
+
+                let (permanent_delegate_ext, remaining_bytes) =
+                    PermanentDelegateAccountExtension::new_zero_copy(&mut bytes[1..], config)?;
+                Ok((
+                    ZExtensionStructMut::PermanentDelegateAccount(permanent_delegate_ext),
+                    remaining_bytes,
+                ))
+            }
+            ExtensionStructConfig::TransferFeeAccount(config) => {
+                if bytes.is_empty() {
+                    return Err(light_zero_copy::errors::ZeroCopyError::ArraySize(
+                        1,
+                        bytes.len(),
+                    ));
+                }
+                bytes[0] = ExtensionType::TransferFeeAccount as u8;
+
+                let (transfer_fee_ext, remaining_bytes) =
+                    TransferFeeAccountExtension::new_zero_copy(&mut bytes[1..], config)?;
+                Ok((
+                    ZExtensionStructMut::TransferFeeAccount(transfer_fee_ext),
+                    remaining_bytes,
+                ))
+            }
+            ExtensionStructConfig::TransferHookAccount(config) => {
+                if bytes.is_empty() {
+                    return Err(light_zero_copy::errors::ZeroCopyError::ArraySize(
+                        1,
+                        bytes.len(),
+                    ));
+                }
+                bytes[0] = ExtensionType::TransferHookAccount as u8;
+
+                let (transfer_hook_ext, remaining_bytes) =
+                    TransferHookAccountExtension::new_zero_copy(&mut bytes[1..], config)?;
+                Ok((
+                    ZExtensionStructMut::TransferHookAccount(transfer_hook_ext),
+                    remaining_bytes,
+                ))
+            }
+            ExtensionStructConfig::CompressedOnly(config) => {
+                if bytes.len() < 1 + CompressedOnlyExtension::LEN {
+                    return Err(light_zero_copy::errors::ZeroCopyError::ArraySize(
+                        1 + CompressedOnlyExtension::LEN,
+                        bytes.len(),
+                    ));
+                }
+                bytes[0] = ExtensionType::CompressedOnly as u8;
 
-                let (compressible_ext, remaining_bytes) =
-                    CompressibleExtension::new_zero_copy(&mut bytes[1..], config)?;
+                let (compressed_only_ext, remaining_bytes) =
+                    CompressedOnlyExtension::new_zero_copy(&mut bytes[1..], config)?;
                 Ok((
-                    ZExtensionStructMut::Compressible(compressible_ext),
+                    ZExtensionStructMut::CompressedOnly(compressed_only_ext),
                     remaining_bytes,
                 ))
             }
@@ -217,8 +319,9 @@ impl<'a> light_zero_copy::ZeroCopyNew<'a> for ExtensionStruct {
     }
 }
 
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq, Default)]
 pub enum ExtensionStructConfig {
+    #[default]
     Placeholder0,
     Placeholder1,
     Placeholder2,
@@ -247,12 +350,9 @@ pub enum ExtensionStructConfig {
     Placeholder25,
     /// Reserved for Token-2022 Pausable compatibility
     Placeholder26,
-    /// Reserved for Token-2022 PausableAccount compatibility
-    Placeholder27,
-    /// Reserved for Token-2022 extensions
-    Placeholder28,
-    Placeholder29,
-    Placeholder30,
-    Placeholder31,
-    Compressible(CompressibleExtensionConfig),
+    PausableAccount(PausableAccountExtensionConfig),
+    PermanentDelegateAccount(PermanentDelegateAccountExtensionConfig),
+    TransferFeeAccount(TransferFeeAccountExtensionConfig),
+    TransferHookAccount(TransferHookAccountExtensionConfig),
+    CompressedOnly(CompressedOnlyExtensionConfig),
 }
diff --git a/program-libs/ctoken-interface/src/state/extensions/extension_type.rs b/program-libs/ctoken-interface/src/state/extensions/extension_type.rs
index 5193b44966..04e173233b 100644
--- a/program-libs/ctoken-interface/src/state/extensions/extension_type.rs
+++ b/program-libs/ctoken-interface/src/state/extensions/extension_type.rs
@@ -33,13 +33,20 @@ pub enum ExtensionType {
     Placeholder25,
     /// Reserved for Token-2022 Pausable compatibility
     Placeholder26,
-    /// Reserved for Token-2022 PausableAccount compatibility
-    Placeholder27,
-    /// Reserved for Token-2022 extensions
-    Placeholder28,
-    Placeholder29,
-    Placeholder30,
-    Placeholder31,
+    /// Marker extension indicating the account belongs to a pausable mint.
+    /// When the SPL mint has PausableConfig and is paused, token operations are blocked.
+    PausableAccount = 27,
+    /// Marker extension indicating the account belongs to a mint with permanent delegate.
+    /// When the SPL mint has PermanentDelegate extension, the delegate can transfer/burn any tokens.
+    PermanentDelegateAccount = 28,
+    /// Transfer fee extension storing withheld fees from transfers.
+    TransferFeeAccount = 29,
+    /// Marker extension indicating the account belongs to a mint with transfer hook.
+    /// We only support mints where program_id is nil (no hook invoked).
+    TransferHookAccount = 30,
+    /// CompressedOnly extension for compressed token accounts.
+    /// Marks account as decompress-only (cannot be transferred) and stores delegated amount.
+    CompressedOnly = 31,
     /// Account contains compressible timing data and rent authority
     Compressible = 32,
 }
@@ -50,6 +57,11 @@ impl TryFrom<u8> for ExtensionType {
     fn try_from(value: u8) -> Result<Self, Self::Error> {
         match value {
             19 => Ok(ExtensionType::TokenMetadata),
+            27 => Ok(ExtensionType::PausableAccount),
+            28 => Ok(ExtensionType::PermanentDelegateAccount),
+            29 => Ok(ExtensionType::TransferFeeAccount),
+            30 => Ok(ExtensionType::TransferHookAccount),
+            31 => Ok(ExtensionType::CompressedOnly),
             32 => Ok(ExtensionType::Compressible),
             _ => Err(crate::CTokenError::UnsupportedExtension),
         }
diff --git a/program-libs/ctoken-interface/src/state/extensions/mod.rs b/program-libs/ctoken-interface/src/state/extensions/mod.rs
index 3326032915..9aba70bd05 100644
--- a/program-libs/ctoken-interface/src/state/extensions/mod.rs
+++ b/program-libs/ctoken-interface/src/state/extensions/mod.rs
@@ -1,8 +1,18 @@
+mod compressed_only;
 mod extension_struct;
 mod extension_type;
+mod pausable;
+mod permanent_delegate;
+mod token_metadata;
+mod transfer_fee;
+mod transfer_hook;
 
+pub use compressed_only::*;
 pub use extension_struct::*;
 pub use extension_type::*;
-mod token_metadata;
 pub use light_compressible::compression_info::{CompressionInfo, CompressionInfoConfig};
+pub use pausable::*;
+pub use permanent_delegate::*;
 pub use token_metadata::*;
+pub use transfer_fee::*;
+pub use transfer_hook::*;
diff --git a/program-libs/ctoken-interface/src/state/extensions/pausable.rs b/program-libs/ctoken-interface/src/state/extensions/pausable.rs
new file mode 100644
index 0000000000..c20f3a804a
--- /dev/null
+++ b/program-libs/ctoken-interface/src/state/extensions/pausable.rs
@@ -0,0 +1,25 @@
+use light_zero_copy::{ZeroCopy, ZeroCopyMut};
+
+use crate::{AnchorDeserialize, AnchorSerialize};
+
+/// Marker extension indicating the account belongs to a pausable mint.
+/// This is a zero-size marker (no data) that indicates the token account's
+/// mint has the SPL Token 2022 Pausable extension.
+///
+/// When present, token operations must check the SPL mint's PausableConfig
+/// to determine if the mint is paused before allowing transfers.
+#[derive(
+    Debug,
+    Clone,
+    Copy,
+    Hash,
+    PartialEq,
+    Eq,
+    Default,
+    AnchorSerialize,
+    AnchorDeserialize,
+    ZeroCopy,
+    ZeroCopyMut,
+)]
+#[repr(C)]
+pub struct PausableAccountExtension;
diff --git a/program-libs/ctoken-interface/src/state/extensions/permanent_delegate.rs b/program-libs/ctoken-interface/src/state/extensions/permanent_delegate.rs
new file mode 100644
index 0000000000..0ff9ed67a8
--- /dev/null
+++ b/program-libs/ctoken-interface/src/state/extensions/permanent_delegate.rs
@@ -0,0 +1,25 @@
+use light_zero_copy::{ZeroCopy, ZeroCopyMut};
+
+use crate::{AnchorDeserialize, AnchorSerialize};
+
+/// Marker extension indicating the account belongs to a mint with permanent delegate.
+/// This is a zero-size marker (no data) that indicates the token account's
+/// mint has the SPL Token 2022 Permanent Delegate extension.
+///
+/// When present, token operations must check the SPL mint's PermanentDelegate
+/// to determine the delegate authority before allowing transfers/burns.
+#[derive(
+    Debug,
+    Clone,
+    Copy,
+    Hash,
+    PartialEq,
+    Eq,
+    Default,
+    AnchorSerialize,
+    AnchorDeserialize,
+    ZeroCopy,
+    ZeroCopyMut,
+)]
+#[repr(C)]
+pub struct PermanentDelegateAccountExtension;
diff --git a/program-libs/ctoken-interface/src/state/extensions/transfer_fee.rs b/program-libs/ctoken-interface/src/state/extensions/transfer_fee.rs
new file mode 100644
index 0000000000..a9a5efe1f5
--- /dev/null
+++ b/program-libs/ctoken-interface/src/state/extensions/transfer_fee.rs
@@ -0,0 +1,38 @@
+use light_zero_copy::{ZeroCopy, ZeroCopyMut};
+
+use crate::{AnchorDeserialize, AnchorSerialize, CTokenError};
+
+/// Transfer fee extension for CToken accounts.
+/// Stores withheld fees that accumulate during transfers.
+/// Mirrors SPL Token-2022's TransferFeeAmount extension.
+#[derive(
+    Debug,
+    Clone,
+    Copy,
+    Hash,
+    PartialEq,
+    Eq,
+    Default,
+    AnchorSerialize,
+    AnchorDeserialize,
+    ZeroCopy,
+    ZeroCopyMut,
+)]
+#[repr(C)]
+pub struct TransferFeeAccountExtension {
+    /// Amount withheld during transfers, to be harvested on decompress
+    pub withheld_amount: u64,
+}
+
+impl<'a> ZTransferFeeAccountExtensionMut<'a> {
+    /// Add fee to withheld amount (used during transfers).
+    /// Returns error if addition would overflow.
+    pub fn add_withheld_amount(&mut self, fee: u64) -> Result<(), CTokenError> {
+        let current: u64 = self.withheld_amount.get();
+        let new_amount = current
+            .checked_add(fee)
+            .ok_or(CTokenError::ArithmeticOverflow)?;
+        self.withheld_amount.set(new_amount);
+        Ok(())
+    }
+}
diff --git a/program-libs/ctoken-interface/src/state/extensions/transfer_hook.rs b/program-libs/ctoken-interface/src/state/extensions/transfer_hook.rs
new file mode 100644
index 0000000000..edb9be15ac
--- /dev/null
+++ b/program-libs/ctoken-interface/src/state/extensions/transfer_hook.rs
@@ -0,0 +1,27 @@
+use light_zero_copy::{ZeroCopy, ZeroCopyMut};
+
+use crate::{AnchorDeserialize, AnchorSerialize};
+
+/// Extension indicating the account belongs to a mint with transfer hook.
+/// Contains a `transferring` flag used as a reentrancy guard during hook CPI.
+/// Consistent with SPL Token-2022 TransferHookAccount layout.
+#[derive(
+    Debug,
+    Clone,
+    Copy,
+    Hash,
+    PartialEq,
+    Eq,
+    Default,
+    AnchorSerialize,
+    AnchorDeserialize,
+    ZeroCopy,
+    ZeroCopyMut,
+)]
+#[repr(C)]
+pub struct TransferHookAccountExtension {
+    /// Flag to indicate that the account is in the middle of a transfer.
+    /// Used as reentrancy guard when transfer hook program is called via CPI.
+    /// Always false at rest since we only support nil program_id (no hook invoked).
+    pub transferring: u8,
+}
diff --git a/program-libs/ctoken-interface/src/state/mint/compressed_mint.rs b/program-libs/ctoken-interface/src/state/mint/compressed_mint.rs
index 53d3e137e8..63f41d729b 100644
--- a/program-libs/ctoken-interface/src/state/mint/compressed_mint.rs
+++ b/program-libs/ctoken-interface/src/state/mint/compressed_mint.rs
@@ -1,26 +1,43 @@
 use borsh::{BorshDeserialize, BorshSerialize};
 use light_compressed_account::Pubkey;
+use light_compressible::compression_info::CompressionInfo;
 use light_hasher::{sha256::Sha256BE, Hasher};
-use light_program_profiler::profile;
 use light_zero_copy::{ZeroCopy, ZeroCopyMut};
 #[cfg(feature = "solana")]
 use solana_msg::msg;
 
-use crate::{
-    instructions::mint_action::CompressedMintInstructionData, state::ExtensionStruct,
-    AnchorDeserialize, AnchorSerialize, CTokenError,
-};
+use crate::{state::ExtensionStruct, AnchorDeserialize, AnchorSerialize, CTokenError};
+
+/// AccountType::Mint discriminator value
+pub const ACCOUNT_TYPE_MINT: u8 = 1;
 
 #[repr(C)]
-#[derive(
-    Debug, PartialEq, Default, Eq, Clone, BorshSerialize, BorshDeserialize, ZeroCopyMut, ZeroCopy,
-)]
+#[derive(Debug, PartialEq, Eq, Clone, BorshSerialize, BorshDeserialize)]
 pub struct CompressedMint {
     pub base: BaseMint,
     pub metadata: CompressedMintMetadata,
+    /// Reserved bytes for T22 layout compatibility (padding to reach byte 165)
+    pub reserved: [u8; 49],
+    /// Account type discriminator at byte 165 (1 = Mint, 2 = Account)
+    pub account_type: u8,
+    /// Compression info embedded directly in the mint
+    pub compression: CompressionInfo,
     pub extensions: Option<Vec<ExtensionStruct>>,
 }
 
+impl Default for CompressedMint {
+    fn default() -> Self {
+        Self {
+            base: BaseMint::default(),
+            metadata: CompressedMintMetadata::default(),
+            reserved: [0u8; 49],
+            account_type: ACCOUNT_TYPE_MINT,
+            compression: CompressionInfo::default(),
+            extensions: None,
+        }
+    }
+}
+
 // and subsequent deserialization for remaining data (compression metadata + extensions)
 /// SPL-compatible base mint structure with padding for COption alignment
 #[repr(C)]
@@ -104,45 +121,10 @@ impl CompressedMint {
 
         Ok(mint)
     }
-}
-
-// Implementation for zero-copy mutable CompressedMint
-impl ZCompressedMintMut<'_> {
-    /// Set all fields of the CompressedMint struct at once
-    #[inline]
-    #[profile]
-    pub fn set(
-        &mut self,
-        ix_data: &<CompressedMintInstructionData as light_zero_copy::traits::ZeroCopyAt<'_>>::ZeroCopyAt,
-        cmint_decompressed: bool,
-    ) -> Result<(), CTokenError> {
-        if ix_data.metadata.version != 3 {
-            #[cfg(feature = "solana")]
-            msg!(
-                "Only shaflat version 3 is supported got {}",
-                ix_data.metadata.version
-            );
-            return Err(CTokenError::InvalidTokenMetadataVersion);
-        }
-        // Set metadata fields from instruction data
-        self.metadata.version = ix_data.metadata.version;
-        self.metadata.mint = ix_data.metadata.mint;
-        self.metadata.cmint_decompressed = if cmint_decompressed { 1 } else { 0 };
-
-        // Set base fields
-        *self.base.supply = ix_data.supply;
-        *self.base.decimals = ix_data.decimals;
-        *self.base.is_initialized = 1; // Always initialized for compressed mints
-
-        if let Some(mint_authority) = ix_data.mint_authority.as_deref() {
-            self.base.set_mint_authority(Some(*mint_authority));
-        }
-        // Set freeze authority using COption format
-        if let Some(freeze_authority) = ix_data.freeze_authority.as_deref() {
-            self.base.set_freeze_authority(Some(*freeze_authority));
-        }
 
-        // extensions are handled separately
-        Ok(())
+    /// Checks if account_type matches CMint discriminator value
+    #[inline(always)]
+    pub fn is_cmint_account(&self) -> bool {
+        self.account_type == ACCOUNT_TYPE_MINT
     }
 }
diff --git a/program-libs/ctoken-interface/src/state/mint/zero_copy.rs b/program-libs/ctoken-interface/src/state/mint/zero_copy.rs
index 117a649a1b..e2f3ff6919 100644
--- a/program-libs/ctoken-interface/src/state/mint/zero_copy.rs
+++ b/program-libs/ctoken-interface/src/state/mint/zero_copy.rs
@@ -1,186 +1,443 @@
+use core::ops::Deref;
+
+use aligned_sized::aligned_sized;
 use light_compressed_account::Pubkey;
+use light_compressible::compression_info::CompressionInfo;
+use light_program_profiler::profile;
 use light_zero_copy::{
-    errors::ZeroCopyError,
-    traits::{ZeroCopyAt, ZeroCopyAtMut, ZeroCopyNew},
-    IntoBytes, Ref,
+    traits::{ZeroCopyAt, ZeroCopyAtMut},
+    ZeroCopy, ZeroCopyMut, ZeroCopyNew,
+};
+use spl_pod::solana_msg::msg;
+
+use super::compressed_mint::{CompressedMintMetadata, ACCOUNT_TYPE_MINT};
+use crate::{
+    instructions::mint_action::CompressedMintInstructionData,
+    state::{
+        CompressedMint, ExtensionStruct, ExtensionStructConfig, TokenDataVersion, ZExtensionStruct,
+        ZExtensionStructMut,
+    },
+    AnchorDeserialize, AnchorSerialize, CTokenError,
 };
 
-use super::compressed_mint::BaseMint;
+/// Base size for CMint accounts (without extensions)
+pub const BASE_MINT_ACCOUNT_SIZE: u64 = CompressedMintZeroCopyMeta::LEN as u64;
+
+/// Optimized CompressedMint zero copy struct.
+/// Uses derive macros to generate ZCompressedMintZeroCopyMeta<'a> and ZCompressedMintZeroCopyMetaMut<'a>.
+#[derive(
+    Debug, PartialEq, Eq, Clone, AnchorSerialize, AnchorDeserialize, ZeroCopy, ZeroCopyMut,
+)]
+#[repr(C)]
+#[aligned_sized]
+struct CompressedMintZeroCopyMeta {
+    // BaseMint fields with flattened COptions (SPL format: 4 bytes discriminator + 32 bytes pubkey)
+    mint_authority_option_prefix: u32,
+    mint_authority: Pubkey,
+    /// Total supply of tokens.
+    pub supply: u64,
+    /// Number of base 10 digits to the right of the decimal place.
+    pub decimals: u8,
+    /// Is initialized - for SPL compatibility
+    pub is_initialized: u8,
+    freeze_authority_option_prefix: u32,
+    freeze_authority: Pubkey,
+    // CompressedMintMetadata
+    pub metadata: CompressedMintMetadata,
+    /// Reserved bytes for T22 layout compatibility (padding to reach byte 165)
+    pub reserved: [u8; 49],
+    /// Account type discriminator at byte 165 (1 = Mint, 2 = Account)
+    pub account_type: u8,
+    /// Compression info embedded directly in the mint
+    pub compression: CompressionInfo,
+    /// Extensions flag
+    has_extensions: bool,
+}
+
+/// Zero-copy view of CompressedMint with base and optional extensions
+#[derive(Debug)]
+pub struct ZCompressedMint<'a> {
+    pub base: ZCompressedMintZeroCopyMeta<'a>,
+    pub extensions: Option<Vec<ZExtensionStruct<'a>>>,
+}
+
+/// Mutable zero-copy view of CompressedMint with base and optional extensions
+#[derive(Debug)]
+pub struct ZCompressedMintMut<'a> {
+    pub base: ZCompressedMintZeroCopyMetaMut<'a>,
+    pub extensions: Option<Vec<ZExtensionStructMut<'a>>>,
+}
+
+/// Configuration for creating a new CompressedMint via ZeroCopyNew
+#[derive(Debug, Clone, PartialEq)]
+pub struct CompressedMintConfig {
+    /// Extension configurations
+    pub extensions: Option<Vec<ExtensionStructConfig>>,
+}
 
-// Manual implementation of ZeroCopyAt for BaseMint with SPL COption compatibility
-impl<'a> ZeroCopyAt<'a> for BaseMint {
-    type ZeroCopyAt = ZBaseMint<'a>;
+impl<'a> ZeroCopyNew<'a> for CompressedMint {
+    type ZeroCopyConfig = CompressedMintConfig;
+    type Output = ZCompressedMintMut<'a>;
 
-    fn zero_copy_at(bytes: &'a [u8]) -> Result<(Self::ZeroCopyAt, &'a [u8]), ZeroCopyError> {
-        if bytes.len() < 82 {
-            return Err(ZeroCopyError::Size);
+    fn byte_len(
+        config: &Self::ZeroCopyConfig,
+    ) -> Result<usize, light_zero_copy::errors::ZeroCopyError> {
+        // Use derived byte_len for meta struct
+        let meta_config = CompressedMintZeroCopyMetaConfig {
+            metadata: (),
+            compression: light_compressible::compression_info::CompressionInfoConfig {
+                rent_config: (),
+            },
+        };
+        let mut size = CompressedMintZeroCopyMeta::byte_len(&meta_config)?;
+
+        // Add extension sizes if present
+        if let Some(ref extensions) = config.extensions {
+            // Vec length prefix (4 bytes) + each extension's size
+            size += 4;
+            for ext_config in extensions {
+                size += ExtensionStruct::byte_len(ext_config)?;
+            }
         }
 
-        // Parse mint_authority COption (4 bytes + 32 bytes)
-        let (mint_auth_disc, bytes) = bytes.split_at(4);
-        let (mint_auth_pubkey, bytes) = Ref::<&[u8], Pubkey>::from_prefix(bytes)?;
+        Ok(size)
+    }
 
-        let mint_auth_pubkey = if mint_auth_disc[0] == 1 {
-            Some(mint_auth_pubkey)
-        } else {
-            None
+    fn new_zero_copy(
+        bytes: &'a mut [u8],
+        config: Self::ZeroCopyConfig,
+    ) -> Result<(Self::Output, &'a mut [u8]), light_zero_copy::errors::ZeroCopyError> {
+        // Use derived new_zero_copy for meta struct
+        let meta_config = CompressedMintZeroCopyMetaConfig {
+            metadata: (),
+            compression: light_compressible::compression_info::CompressionInfoConfig {
+                rent_config: (),
+            },
         };
+        let (mut base, remaining) =
+            <CompressedMintZeroCopyMeta as ZeroCopyNew<'a>>::new_zero_copy(bytes, meta_config)?;
+        *base.account_type = ACCOUNT_TYPE_MINT;
+        base.is_initialized = 1;
 
-        // Parse supply, decimals, is_initialized
-        let (supply, bytes) =
-            Ref::<&[u8], light_zero_copy::little_endian::U64>::from_prefix(bytes)?;
-        let (decimals, bytes) = u8::zero_copy_at(bytes)?;
-        let (is_initialized, bytes) = u8::zero_copy_at(bytes)?;
-
-        // Parse freeze_authority COption (4 bytes + 32 bytes)
-        let (freeze_auth_disc, bytes) = bytes.split_at(4);
-        let (freeze_auth_pubkey, bytes) = Ref::<&[u8], Pubkey>::from_prefix(bytes)?;
-        let freeze_auth_pubkey = if freeze_auth_disc[0] == 1 {
-            Some(freeze_auth_pubkey)
+        // Initialize extensions if present
+        if let Some(extensions_config) = config.extensions {
+            *base.has_extensions = 1u8;
+            let (extensions, remaining) = <Vec<ExtensionStruct> as ZeroCopyNew<'a>>::new_zero_copy(
+                remaining,
+                extensions_config,
+            )?;
+
+            Ok((
+                ZCompressedMintMut {
+                    base,
+                    extensions: Some(extensions),
+                },
+                remaining,
+            ))
         } else {
-            None
-        };
-        Ok((
-            ZBaseMint {
-                mint_authority: mint_auth_pubkey,
-                supply,
-                decimals,
-                is_initialized,
-                freeze_authority: freeze_auth_pubkey,
-            },
-            bytes,
-        ))
+            Ok((
+                ZCompressedMintMut {
+                    base,
+                    extensions: None,
+                },
+                remaining,
+            ))
+        }
     }
 }
 
-// Zero-copy representation of BaseMint
-#[derive(Debug, Clone, PartialEq)]
-pub struct ZBaseMint<'a> {
-    pub mint_authority: <Option<Pubkey> as ZeroCopyAt<'a>>::ZeroCopyAt,
-    pub supply: Ref<&'a [u8], light_zero_copy::little_endian::U64>,
-    pub decimals: u8,
-    pub is_initialized: u8,
-    pub freeze_authority: <Option<Pubkey> as ZeroCopyAt<'a>>::ZeroCopyAt,
+impl<'a> ZeroCopyAt<'a> for CompressedMint {
+    type ZeroCopyAt = ZCompressedMint<'a>;
+
+    fn zero_copy_at(
+        bytes: &'a [u8],
+    ) -> Result<(Self::ZeroCopyAt, &'a [u8]), light_zero_copy::errors::ZeroCopyError> {
+        let (base, bytes) = <CompressedMintZeroCopyMeta as ZeroCopyAt<'a>>::zero_copy_at(bytes)?;
+        // has_extensions already consumed the Option discriminator byte
+        if base.has_extensions() {
+            let (extensions, bytes) =
+                <Vec<ExtensionStruct> as ZeroCopyAt<'a>>::zero_copy_at(bytes)?;
+            Ok((
+                ZCompressedMint {
+                    base,
+                    extensions: Some(extensions),
+                },
+                bytes,
+            ))
+        } else {
+            Ok((
+                ZCompressedMint {
+                    base,
+                    extensions: None,
+                },
+                bytes,
+            ))
+        }
+    }
 }
 
-// Manual implementation of ZeroCopyAtMut for BaseMint
-impl<'a> ZeroCopyAtMut<'a> for BaseMint {
-    type ZeroCopyAtMut = ZBaseMintMut<'a>;
+impl<'a> ZeroCopyAtMut<'a> for CompressedMint {
+    type ZeroCopyAtMut = ZCompressedMintMut<'a>;
 
     fn zero_copy_at_mut(
         bytes: &'a mut [u8],
-    ) -> Result<(Self::ZeroCopyAtMut, &'a mut [u8]), ZeroCopyError> {
-        if bytes.len() < 82 {
-            return Err(ZeroCopyError::Size);
-        }
-
-        // Parse mint_authority COption (4 bytes + 32 bytes)
-        let (mint_auth_disc, bytes) = Ref::<&mut [u8], [u8; 4]>::from_prefix(bytes)?;
-        let (mint_auth_pubkey, bytes) = Ref::<&mut [u8], Pubkey>::from_prefix(bytes)?;
-
-        // Parse supply, decimals, is_initialized
-        let (supply, bytes) =
-            Ref::<&mut [u8], light_zero_copy::little_endian::U64>::from_prefix(bytes)?;
-        let (decimals, bytes) = Ref::<&mut [u8], u8>::from_prefix(bytes)?;
-        let (is_initialized, bytes) = Ref::<&mut [u8], u8>::from_prefix(bytes)?;
-
-        // Parse freeze_authority COption (4 bytes + 32 bytes)
-        let (freeze_auth_disc, bytes) = Ref::<&mut [u8], [u8; 4]>::from_prefix(bytes)?;
-        let (freeze_auth_pubkey, bytes) = Ref::<&mut [u8], Pubkey>::from_prefix(bytes)?;
-
-        Ok((
-            ZBaseMintMut {
-                mint_authority_discriminator: mint_auth_disc,
-                mint_authority: mint_auth_pubkey,
-                supply,
-                decimals,
-                is_initialized,
-                freeze_authority_discriminator: freeze_auth_disc,
-                freeze_authority: freeze_auth_pubkey,
-            },
-            bytes,
-        ))
+    ) -> Result<(Self::ZeroCopyAtMut, &'a mut [u8]), light_zero_copy::errors::ZeroCopyError> {
+        let (base, bytes) =
+            <CompressedMintZeroCopyMeta as ZeroCopyAtMut<'a>>::zero_copy_at_mut(bytes)?;
+        // has_extensions already consumed the Option discriminator byte
+        if base.has_extensions() {
+            let (extensions, bytes) =
+                <Vec<ExtensionStruct> as ZeroCopyAtMut<'a>>::zero_copy_at_mut(bytes)?;
+            Ok((
+                ZCompressedMintMut {
+                    base,
+                    extensions: Some(extensions),
+                },
+                bytes,
+            ))
+        } else {
+            Ok((
+                ZCompressedMintMut {
+                    base,
+                    extensions: None,
+                },
+                bytes,
+            ))
+        }
     }
 }
 
-// Mutable zero-copy representation of BaseMint
-#[derive(Debug)]
-pub struct ZBaseMintMut<'a> {
-    mint_authority_discriminator: Ref<&'a mut [u8], [u8; 4]>,
-    mint_authority: Ref<&'a mut [u8], Pubkey>,
-    pub supply: Ref<&'a mut [u8], light_zero_copy::little_endian::U64>,
-    pub decimals: Ref<&'a mut [u8], u8>,
-    pub is_initialized: Ref<&'a mut [u8], u8>,
-    freeze_authority_discriminator: Ref<&'a mut [u8], [u8; 4]>,
-    freeze_authority: Ref<&'a mut [u8], Pubkey>,
+// Deref implementations for field access
+impl<'a> Deref for ZCompressedMint<'a> {
+    type Target = ZCompressedMintZeroCopyMeta<'a>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.base
+    }
 }
 
-impl ZBaseMintMut<'_> {
+impl<'a> Deref for ZCompressedMintMut<'a> {
+    type Target = ZCompressedMintZeroCopyMetaMut<'a>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.base
+    }
+}
+
+// Getters on ZCompressedMintZeroCopyMeta (immutable)
+impl ZCompressedMintZeroCopyMeta<'_> {
+    /// Checks if account_type matches CMint discriminator value
+    #[inline(always)]
+    pub fn is_cmint_account(&self) -> bool {
+        self.account_type == ACCOUNT_TYPE_MINT
+    }
+
+    /// Checks if account is initialized
+    #[inline(always)]
+    pub fn is_initialized(&self) -> bool {
+        self.is_initialized != 0
+    }
+
+    /// Get mint_authority if set (COption discriminator == 1)
     pub fn mint_authority(&self) -> Option<&Pubkey> {
-        if self.mint_authority_discriminator[0] == 1 {
-            Some(&*self.mint_authority)
+        if u32::from(self.mint_authority_option_prefix) == 1 {
+            Some(&self.mint_authority)
         } else {
             None
         }
     }
 
+    /// Get freeze_authority if set (COption discriminator == 1)
+    pub fn freeze_authority(&self) -> Option<&Pubkey> {
+        if u32::from(self.freeze_authority_option_prefix) == 1 {
+            Some(&self.freeze_authority)
+        } else {
+            None
+        }
+    }
+}
+
+// Getters on ZCompressedMintZeroCopyMetaMut (mutable)
+impl ZCompressedMintZeroCopyMetaMut<'_> {
+    /// Checks if account_type matches CMint discriminator value
+    #[inline(always)]
+    pub fn is_cmint_account(&self) -> bool {
+        *self.account_type == ACCOUNT_TYPE_MINT
+    }
+
+    /// Checks if account is initialized
+    #[inline(always)]
+    pub fn is_initialized(&self) -> bool {
+        self.is_initialized == 1
+    }
+
+    /// Get mint_authority if set (COption discriminator == 1)
+    pub fn mint_authority(&self) -> Option<&Pubkey> {
+        if u32::from(self.mint_authority_option_prefix) == 1 {
+            Some(&self.mint_authority)
+        } else {
+            None
+        }
+    }
+
+    /// Set mint_authority using COption format
     pub fn set_mint_authority(&mut self, pubkey: Option<Pubkey>) {
         if let Some(pubkey) = pubkey {
-            if self.mint_authority_discriminator[0] == 0 {
-                self.mint_authority_discriminator[0] = 1;
-            }
-            *self.mint_authority = pubkey;
+            self.mint_authority_option_prefix = 1u32.into();
+            self.mint_authority = pubkey;
         } else {
-            if self.mint_authority_discriminator[0] == 1 {
-                self.mint_authority_discriminator[0] = 0;
-            }
-            self.mint_authority.as_mut_bytes().fill(0);
+            self.mint_authority_option_prefix = 0u32.into();
+            self.mint_authority = Pubkey::default();
         }
     }
+
+    /// Get freeze_authority if set (COption discriminator == 1)
     pub fn freeze_authority(&self) -> Option<&Pubkey> {
-        if self.freeze_authority_discriminator[0] == 1 {
-            Some(&*self.freeze_authority)
+        if u32::from(self.freeze_authority_option_prefix) == 1 {
+            Some(&self.freeze_authority)
         } else {
             None
         }
     }
 
+    /// Set freeze_authority using COption format
     pub fn set_freeze_authority(&mut self, pubkey: Option<Pubkey>) {
         if let Some(pubkey) = pubkey {
-            if self.freeze_authority_discriminator[0] == 0 {
-                self.freeze_authority_discriminator[0] = 1;
-            }
-            *self.freeze_authority = pubkey;
+            self.freeze_authority_option_prefix = 1u32.into();
+            self.freeze_authority = pubkey;
         } else {
-            if self.freeze_authority_discriminator[0] == 1 {
-                self.freeze_authority_discriminator[0] = 0;
-            }
-            self.freeze_authority.as_mut_bytes().fill(0);
+            self.freeze_authority_option_prefix = 0u32.into();
+            self.freeze_authority = Pubkey::default();
         }
     }
 }
 
-// Manual implementation of ZeroCopyNew for BaseMint
-impl<'a> ZeroCopyNew<'a> for BaseMint {
-    type ZeroCopyConfig = ();
-    type Output = ZBaseMintMut<'a>;
+// Checked methods on CompressedMint
+impl CompressedMint {
+    /// Zero-copy deserialization with initialization and account_type check.
+    /// Returns an error if:
+    /// - Account is not initialized (is_initialized == false)
+    /// - Account type is not ACCOUNT_TYPE_MINT (byte 165 != 1)
+    #[profile]
+    pub fn zero_copy_at_checked(bytes: &[u8]) -> Result<(ZCompressedMint<'_>, &[u8]), CTokenError> {
+        // Check minimum size (use CMint-specific size, not CToken size)
+        if bytes.len() < BASE_MINT_ACCOUNT_SIZE as usize {
+            return Err(CTokenError::InvalidAccountData);
+        }
+
+        // Proceed with deserialization first
+        let (mint, remaining) = CompressedMint::zero_copy_at(bytes)
+            .map_err(|_| CTokenError::CMintDeserializationFailed)?;
+
+        // Verify account_type using the method
+        if !mint.is_cmint_account() {
+            return Err(CTokenError::InvalidAccountType);
+        }
 
-    fn byte_len(_config: &Self::ZeroCopyConfig) -> Result<usize, ZeroCopyError> {
-        Ok(82) // SPL Mint size
+        // Check is_initialized
+        if !mint.is_initialized() {
+            return Err(CTokenError::CMintNotInitialized);
+        }
+
+        Ok((mint, remaining))
     }
 
-    fn new_zero_copy(
-        bytes: &'a mut [u8],
-        _config: Self::ZeroCopyConfig,
-    ) -> Result<(Self::Output, &'a mut [u8]), ZeroCopyError> {
-        if bytes.len() < 82 {
-            return Err(ZeroCopyError::Size);
+    /// Mutable zero-copy deserialization with initialization and account_type check.
+    /// Returns an error if:
+    /// - Account is not initialized (is_initialized == false)
+    /// - Account type is not ACCOUNT_TYPE_MINT
+    #[profile]
+    pub fn zero_copy_at_mut_checked(
+        bytes: &mut [u8],
+    ) -> Result<(ZCompressedMintMut<'_>, &mut [u8]), CTokenError> {
+        // Check minimum size (use CMint-specific size, not CToken size)
+        if bytes.len() < BASE_MINT_ACCOUNT_SIZE as usize {
+            msg!(
+                "zero_copy_at_mut_checked bytes.len() < BASE_MINT_ACCOUNT_SIZE {}",
+                bytes.len()
+            );
+            return Err(CTokenError::InvalidAccountData);
+        }
+
+        let (mint, remaining) = CompressedMint::zero_copy_at_mut(bytes)
+            .map_err(|_| CTokenError::CMintDeserializationFailed)?;
+
+        if !mint.is_initialized() {
+            return Err(CTokenError::CMintNotInitialized);
         }
+        if !mint.is_cmint_account() {
+            return Err(CTokenError::InvalidAccountType);
+        }
+
+        Ok((mint, remaining))
+    }
+}
+
+// Helper methods on ZCompressedMint
+impl ZCompressedMint<'_> {
+    /// Checks if account_type matches CMint discriminator value
+    #[inline(always)]
+    pub fn is_cmint_account(&self) -> bool {
+        self.base.is_cmint_account()
+    }
 
-        // is_initialized
-        bytes[45] = 1;
+    /// Checks if account is initialized
+    #[inline(always)]
+    pub fn is_initialized(&self) -> bool {
+        self.base.is_initialized()
+    }
+}
+
+// Helper methods on ZCompressedMintMut
+impl ZCompressedMintMut<'_> {
+    /// Checks if account_type matches CMint discriminator value
+    #[inline(always)]
+    pub fn is_cmint_account(&self) -> bool {
+        self.base.is_cmint_account()
+    }
+
+    /// Checks if account is initialized
+    #[inline(always)]
+    pub fn is_initialized(&self) -> bool {
+        self.base.is_initialized()
+    }
+
+    /// Set all fields of the CompressedMint struct at once
+    #[inline]
+    #[profile]
+    pub fn set(
+        &mut self,
+        ix_data: &<CompressedMintInstructionData as light_zero_copy::traits::ZeroCopyAt<'_>>::ZeroCopyAt,
+        cmint_decompressed: bool,
+    ) -> Result<(), CTokenError> {
+        if ix_data.metadata.version != TokenDataVersion::ShaFlat as u8 {
+            #[cfg(feature = "solana")]
+            msg!(
+                "Only shaflat version 3 is supported got {}",
+                ix_data.metadata.version
+            );
+            return Err(CTokenError::InvalidTokenMetadataVersion);
+        }
+        // Set metadata fields from instruction data
+        self.base.metadata.version = ix_data.metadata.version;
+        self.base.metadata.mint = ix_data.metadata.mint;
+        self.base.metadata.cmint_decompressed = if cmint_decompressed { 1 } else { 0 };
+
+        // Set base fields
+        self.base.supply = ix_data.supply;
+        self.base.decimals = ix_data.decimals;
+        self.base.is_initialized = 1; // Always initialized for compressed mints
+
+        if let Some(mint_authority) = ix_data.mint_authority.as_deref() {
+            self.base.set_mint_authority(Some(*mint_authority));
+        }
+        // Set freeze authority using COption format
+        if let Some(freeze_authority) = ix_data.freeze_authority.as_deref() {
+            self.base.set_freeze_authority(Some(*freeze_authority));
+        }
 
-        // Now parse as mutable zero-copy
-        Self::zero_copy_at_mut(bytes)
+        // account_type is already set in new_zero_copy
+        // extensions are handled separately
+        Ok(())
     }
 }
diff --git a/program-libs/ctoken-interface/src/token_2022_extensions.rs b/program-libs/ctoken-interface/src/token_2022_extensions.rs
new file mode 100644
index 0000000000..f7ad2915ff
--- /dev/null
+++ b/program-libs/ctoken-interface/src/token_2022_extensions.rs
@@ -0,0 +1,148 @@
+use light_zero_copy::errors::ZeroCopyError;
+use spl_token_2022::extension::ExtensionType;
+
+use crate::state::ExtensionStructConfig;
+
+/// Restricted extension types that require compression_only mode.
+/// These extensions have special behaviors (pausable, permanent delegate, fees, hooks,
+/// default frozen state) that are incompatible with standard compressed token transfers.
+pub const RESTRICTED_EXTENSION_TYPES: [ExtensionType; 5] = [
+    ExtensionType::Pausable,
+    ExtensionType::PermanentDelegate,
+    ExtensionType::TransferFeeConfig,
+    ExtensionType::TransferHook,
+    ExtensionType::DefaultAccountState,
+];
+
+/// Allowed mint extension types for CToken accounts.
+/// Extensions not in this list will cause account creation to fail.
+///
+/// Runtime constraints enforced by check_mint_extensions():
+/// - TransferFeeConfig: fees must be zero
+/// - DefaultAccountState: any state allowed (Initialized or Frozen)
+/// - TransferHook: program_id must be nil (no hook execution)
+pub const ALLOWED_EXTENSION_TYPES: [ExtensionType; 16] = [
+    // Metadata extensions
+    ExtensionType::MetadataPointer,
+    ExtensionType::TokenMetadata,
+    // Group extensions
+    ExtensionType::InterestBearingConfig,
+    ExtensionType::GroupPointer,
+    ExtensionType::GroupMemberPointer,
+    ExtensionType::TokenGroup,
+    ExtensionType::TokenGroupMember,
+    // Token 2022 extensions with runtime constraints
+    ExtensionType::MintCloseAuthority,
+    ExtensionType::TransferFeeConfig,
+    ExtensionType::DefaultAccountState,
+    ExtensionType::PermanentDelegate,
+    ExtensionType::TransferHook,
+    ExtensionType::Pausable,
+    ExtensionType::ConfidentialTransferMint,
+    ExtensionType::ConfidentialTransferFeeConfig,
+    ExtensionType::ConfidentialMintBurn,
+];
+
+/// Check if an extension type is a restricted extension.
+#[inline(always)]
+pub const fn is_restricted_extension(ext: &ExtensionType) -> bool {
+    matches!(
+        ext,
+        ExtensionType::Pausable
+            | ExtensionType::PermanentDelegate
+            | ExtensionType::TransferFeeConfig
+            | ExtensionType::TransferHook
+            | ExtensionType::DefaultAccountState
+    )
+}
+
+/// Flags for mint extensions that affect CToken account initialization and transfers
+#[derive(Debug, Default, Clone, Copy)]
+pub struct MintExtensionFlags {
+    /// Whether the mint has the PausableAccount extension
+    pub has_pausable: bool,
+    /// Whether the mint has the PermanentDelegate extension
+    pub has_permanent_delegate: bool,
+    /// Whether the mint has the DefaultAccountState extension (restricted regardless of state)
+    pub has_default_account_state: bool,
+    /// Whether DefaultAccountState is currently set to Frozen (for CToken account creation)
+    pub default_state_frozen: bool,
+    /// Whether the mint has the TransferFeeConfig extension
+    pub has_transfer_fee: bool,
+    /// Whether the mint has the TransferHook extension (with nil program_id)
+    pub has_transfer_hook: bool,
+}
+
+impl MintExtensionFlags {
+    pub fn num_extensions(&self) -> usize {
+        let mut count = 0;
+        if self.has_pausable {
+            count += 1;
+        }
+        if self.has_permanent_delegate {
+            count += 1;
+        }
+        if self.has_transfer_fee {
+            count += 1;
+        }
+        if self.has_transfer_hook {
+            count += 1;
+        }
+        count
+    }
+
+    /// Calculate the ctoken account size based on extension flags.
+    ///
+    /// Calculate account size based on mint extensions.
+    /// All ctoken accounts now have CompressionInfo embedded in base struct.
+    ///
+    /// # Returns
+    /// * `Ok(u64)` - The account size in bytes
+    /// * `Err(ZeroCopyError)` - If extension size calculation fails
+    pub fn calculate_account_size(&self) -> Result<u64, ZeroCopyError> {
+        // Use stack-allocated array to avoid heap allocation
+        // Maximum 4 extensions: pausable, permanent_delegate, transfer_fee, transfer_hook
+        let mut extensions: [ExtensionStructConfig; 4] = [
+            ExtensionStructConfig::Placeholder0,
+            ExtensionStructConfig::Placeholder0,
+            ExtensionStructConfig::Placeholder0,
+            ExtensionStructConfig::Placeholder0,
+        ];
+        let mut count = 0;
+
+        if self.has_pausable {
+            extensions[count] = ExtensionStructConfig::PausableAccount(());
+            count += 1;
+        }
+        if self.has_permanent_delegate {
+            extensions[count] = ExtensionStructConfig::PermanentDelegateAccount(());
+            count += 1;
+        }
+        if self.has_transfer_fee {
+            extensions[count] = ExtensionStructConfig::TransferFeeAccount(());
+            count += 1;
+        }
+        if self.has_transfer_hook {
+            extensions[count] = ExtensionStructConfig::TransferHookAccount(());
+            count += 1;
+        }
+
+        let exts = if count == 0 {
+            None
+        } else {
+            Some(&extensions[..count])
+        };
+        crate::state::calculate_ctoken_account_size(exts).map(|size| size as u64)
+    }
+
+    /// Returns true if mint has any restricted extensions.
+    /// Restricted extensions (Pausable, PermanentDelegate, TransferFee, TransferHook,
+    /// DefaultAccountState) require compression_only mode when compressing tokens.
+    pub const fn has_restricted_extensions(&self) -> bool {
+        self.has_pausable
+            || self.has_permanent_delegate
+            || self.has_transfer_fee
+            || self.has_transfer_hook
+            || self.has_default_account_state
+    }
+}
diff --git a/program-libs/ctoken-interface/tests/compressed_mint.rs b/program-libs/ctoken-interface/tests/compressed_mint.rs
index 85f87c499b..9f520e1201 100644
--- a/program-libs/ctoken-interface/tests/compressed_mint.rs
+++ b/program-libs/ctoken-interface/tests/compressed_mint.rs
@@ -1,13 +1,62 @@
 use borsh::{BorshDeserialize, BorshSerialize};
 use light_compressed_account::Pubkey;
+use light_compressible::compression_info::CompressionInfo;
 use light_ctoken_interface::state::{
-    BaseMint, CompressedMint, CompressedMintConfig, CompressedMintMetadata,
+    extensions::{AdditionalMetadata, ExtensionStruct, TokenMetadata},
+    BaseMint, CompressedMint, CompressedMintConfig, CompressedMintMetadata, ACCOUNT_TYPE_MINT,
 };
 use light_zero_copy::traits::{ZeroCopyAt, ZeroCopyNew};
 use rand::{thread_rng, Rng};
 
+/// Generate random token metadata extension
+fn generate_random_token_metadata(rng: &mut impl Rng, mint: Pubkey) -> TokenMetadata {
+    let update_authority = if rng.gen_bool(0.7) {
+        Pubkey::from(rng.gen::<[u8; 32]>())
+    } else {
+        Pubkey::from([0u8; 32]) // Zero pubkey for None
+    };
+
+    let name_len = rng.gen_range(1..=32);
+    let name: Vec<u8> = (0..name_len).map(|_| rng.gen::<u8>()).collect();
+
+    let symbol_len = rng.gen_range(1..=10);
+    let symbol: Vec<u8> = (0..symbol_len).map(|_| rng.gen::<u8>()).collect();
+
+    let uri_len = rng.gen_range(0..=100);
+    let uri: Vec<u8> = (0..uri_len).map(|_| rng.gen::<u8>()).collect();
+
+    let num_metadata = rng.gen_range(0..=3);
+    let additional_metadata: Vec<AdditionalMetadata> = (0..num_metadata)
+        .map(|_| {
+            let key_len = rng.gen_range(1..=20);
+            let key: Vec<u8> = (0..key_len).map(|_| rng.gen::<u8>()).collect();
+            let value_len = rng.gen_range(0..=50);
+            let value: Vec<u8> = (0..value_len).map(|_| rng.gen::<u8>()).collect();
+            AdditionalMetadata { key, value }
+        })
+        .collect();
+
+    TokenMetadata {
+        update_authority,
+        mint,
+        name,
+        symbol,
+        uri,
+        additional_metadata,
+    }
+}
+
 /// Generate a random CompressedMint for testing
 fn generate_random_compressed_mint(rng: &mut impl Rng, with_extensions: bool) -> CompressedMint {
+    let mint = Pubkey::from(rng.gen::<[u8; 32]>());
+
+    let extensions = if with_extensions {
+        let token_metadata = generate_random_token_metadata(rng, mint);
+        Some(vec![ExtensionStruct::TokenMetadata(token_metadata)])
+    } else {
+        None
+    };
+
     CompressedMint {
         base: BaseMint {
             mint_authority: if rng.gen_bool(0.7) {
@@ -26,18 +75,16 @@ fn generate_random_compressed_mint(rng: &mut impl Rng, with_extensions: bool) ->
         },
         metadata: CompressedMintMetadata {
             version: 3,
-            mint: Pubkey::from(rng.gen::<[u8; 32]>()),
+            mint,
             cmint_decompressed: rng.gen_bool(0.5),
         },
-        extensions: if with_extensions {
-            // For simplicity, we'll test without extensions for now
-            // Extensions require more complex setup
-            None
-        } else {
-            None
-        },
+        reserved: [0u8; 49],
+        account_type: ACCOUNT_TYPE_MINT,
+        compression: CompressionInfo::default(),
+        extensions,
     }
 }
+
 #[derive(BorshDeserialize, BorshSerialize, PartialEq, Debug)]
 pub struct VecTestStruct {
     pub opt_vec: Option<Vec<u32>>,
@@ -55,7 +102,7 @@ fn test_compressed_mint_borsh_zerocopy_compatibility() {
     let mut rng = thread_rng();
 
     for i in 0..100 {
-        let original_mint = generate_random_compressed_mint(&mut rng, false); // Test Borsh serialization roundtrip
+        let original_mint = generate_random_compressed_mint(&mut rng, false);
         let borsh_bytes = original_mint.try_to_vec().unwrap();
         println!("Iteration {}: Borsh size = {} bytes", i, borsh_bytes.len());
         let borsh_deserialized = CompressedMint::deserialize_reader(&mut borsh_bytes.as_slice())
@@ -64,12 +111,10 @@ fn test_compressed_mint_borsh_zerocopy_compatibility() {
             original_mint, borsh_deserialized,
             "Borsh roundtrip failed at iteration {}",
             i
-        ); // Test zero-copy serialization
-        let config = CompressedMintConfig {
-            base: (),
-            metadata: (),
-            extensions: (false, vec![]),
-        };
+        );
+
+        // Test zero-copy serialization
+        let config = CompressedMintConfig { extensions: None };
         let byte_len = CompressedMint::byte_len(&config).unwrap();
         let mut zero_copy_bytes = vec![0u8; byte_len];
         let (mut zc_mint, _) = CompressedMint::new_zero_copy(&mut zero_copy_bytes, config)
@@ -79,13 +124,14 @@ fn test_compressed_mint_borsh_zerocopy_compatibility() {
                     i
                 )
             });
+
         // Set the zero-copy fields to match original
         zc_mint
             .base
             .set_mint_authority(original_mint.base.mint_authority);
-        *zc_mint.base.supply = original_mint.base.supply.into();
-        *zc_mint.base.decimals = original_mint.base.decimals;
-        *zc_mint.base.is_initialized = if original_mint.base.is_initialized {
+        zc_mint.base.supply = original_mint.base.supply.into();
+        zc_mint.base.decimals = original_mint.base.decimals;
+        zc_mint.base.is_initialized = if original_mint.base.is_initialized {
             1
         } else {
             0
@@ -93,13 +139,47 @@ fn test_compressed_mint_borsh_zerocopy_compatibility() {
         zc_mint
             .base
             .set_freeze_authority(original_mint.base.freeze_authority);
-        zc_mint.metadata.version = original_mint.metadata.version;
-        zc_mint.metadata.mint = original_mint.metadata.mint;
-        zc_mint.metadata.cmint_decompressed = if original_mint.metadata.cmint_decompressed {
+        zc_mint.base.metadata.version = original_mint.metadata.version;
+        zc_mint.base.metadata.mint = original_mint.metadata.mint;
+        zc_mint.base.metadata.cmint_decompressed = if original_mint.metadata.cmint_decompressed {
             1
         } else {
             0
-        }; // Now deserialize the zero-copy bytes with borsh
+        };
+        // account_type is already set in new_zero_copy
+        // Set compression fields
+        zc_mint.base.compression.config_account_version =
+            original_mint.compression.config_account_version.into();
+        zc_mint.base.compression.compress_to_pubkey = original_mint.compression.compress_to_pubkey;
+        zc_mint.base.compression.account_version = original_mint.compression.account_version;
+        zc_mint.base.compression.lamports_per_write =
+            original_mint.compression.lamports_per_write.into();
+        zc_mint.base.compression.compression_authority =
+            original_mint.compression.compression_authority;
+        zc_mint.base.compression.rent_sponsor = original_mint.compression.rent_sponsor;
+        zc_mint.base.compression.last_claimed_slot =
+            original_mint.compression.last_claimed_slot.into();
+        zc_mint.base.compression.rent_config.base_rent =
+            original_mint.compression.rent_config.base_rent.into();
+        zc_mint.base.compression.rent_config.compression_cost = original_mint
+            .compression
+            .rent_config
+            .compression_cost
+            .into();
+        zc_mint
+            .base
+            .compression
+            .rent_config
+            .lamports_per_byte_per_epoch = original_mint
+            .compression
+            .rent_config
+            .lamports_per_byte_per_epoch;
+        zc_mint.base.compression.rent_config.max_funded_epochs =
+            original_mint.compression.rent_config.max_funded_epochs;
+        zc_mint.base.compression.rent_config.max_top_up =
+            original_mint.compression.rent_config.max_top_up.into();
+
+        // Now deserialize the zero-copy bytes with borsh
         let zc_as_borsh = CompressedMint::deserialize(&mut zero_copy_bytes.as_slice())
             .unwrap_or_else(|_| {
                 panic!(
@@ -111,20 +191,23 @@ fn test_compressed_mint_borsh_zerocopy_compatibility() {
             original_mint, zc_as_borsh,
             "Zero-copy to borsh conversion failed at iteration {}",
             i
-        ); // Test zero-copy read
+        );
+
+        // Test zero-copy read
         let (zc_read, _) = CompressedMint::zero_copy_at(&zero_copy_bytes).unwrap_or_else(|_| {
             panic!("Failed to read zero-copy CompressedMint at iteration {}", i)
         });
+
         // Verify fields match
         assert_eq!(
             original_mint.base.mint_authority,
-            zc_read.base.mint_authority.map(|a| *a),
+            zc_read.base.mint_authority().copied(),
             "Mint authority mismatch at iteration {}",
             i
         );
         assert_eq!(
             original_mint.base.supply,
-            u64::from(*zc_read.base.supply),
+            u64::from(zc_read.base.supply),
             "Supply mismatch at iteration {}",
             i
         );
@@ -135,23 +218,23 @@ fn test_compressed_mint_borsh_zerocopy_compatibility() {
         );
         assert_eq!(
             original_mint.base.freeze_authority,
-            zc_read.base.freeze_authority.map(|a| *a),
+            zc_read.base.freeze_authority().copied(),
             "Freeze authority mismatch at iteration {}",
             i
         );
         assert_eq!(
-            original_mint.metadata.version, zc_read.metadata.version,
+            original_mint.metadata.version, zc_read.base.metadata.version,
             "Version mismatch at iteration {}",
             i
         );
         assert_eq!(
-            original_mint.metadata.mint, zc_read.metadata.mint,
+            original_mint.metadata.mint, zc_read.base.metadata.mint,
             "SPL mint mismatch at iteration {}",
             i
         );
         assert_eq!(
             original_mint.metadata.cmint_decompressed,
-            zc_read.metadata.cmint_decompressed != 0,
+            zc_read.base.metadata.cmint_decompressed != 0,
             "Is decompressed mismatch at iteration {}",
             i
         );
@@ -175,6 +258,9 @@ fn test_compressed_mint_edge_cases() {
             mint: Pubkey::from([0xff; 32]),
             cmint_decompressed: false,
         },
+        reserved: [0u8; 49],
+        account_type: ACCOUNT_TYPE_MINT,
+        compression: CompressionInfo::default(),
         extensions: None,
     };
 
@@ -186,11 +272,7 @@ fn test_compressed_mint_edge_cases() {
     assert_eq!(mint_no_auth, deserialized);
 
     // Zero-copy roundtrip
-    let config = CompressedMintConfig {
-        base: (),
-        metadata: (),
-        extensions: (false, vec![]),
-    };
+    let config = CompressedMintConfig { extensions: None };
 
     let byte_len = CompressedMint::byte_len(&config).unwrap();
     let mut zc_bytes = vec![0u8; byte_len];
@@ -199,15 +281,42 @@ fn test_compressed_mint_edge_cases() {
     zc_mint
         .base
         .set_mint_authority(mint_no_auth.base.mint_authority);
-    *zc_mint.base.supply = mint_no_auth.base.supply.into();
-    *zc_mint.base.decimals = mint_no_auth.base.decimals;
-    *zc_mint.base.is_initialized = 1;
+    zc_mint.base.supply = mint_no_auth.base.supply.into();
+    zc_mint.base.decimals = mint_no_auth.base.decimals;
+    zc_mint.base.is_initialized = 1;
     zc_mint
         .base
         .set_freeze_authority(mint_no_auth.base.freeze_authority);
-    zc_mint.metadata.version = mint_no_auth.metadata.version;
-    zc_mint.metadata.mint = mint_no_auth.metadata.mint;
-    zc_mint.metadata.cmint_decompressed = 0;
+    zc_mint.base.metadata.version = mint_no_auth.metadata.version;
+    zc_mint.base.metadata.mint = mint_no_auth.metadata.mint;
+    zc_mint.base.metadata.cmint_decompressed = 0;
+    // account_type is already set in new_zero_copy
+    // Set compression fields
+    zc_mint.base.compression.config_account_version =
+        mint_no_auth.compression.config_account_version.into();
+    zc_mint.base.compression.compress_to_pubkey = mint_no_auth.compression.compress_to_pubkey;
+    zc_mint.base.compression.account_version = mint_no_auth.compression.account_version;
+    zc_mint.base.compression.lamports_per_write =
+        mint_no_auth.compression.lamports_per_write.into();
+    zc_mint.base.compression.compression_authority = mint_no_auth.compression.compression_authority;
+    zc_mint.base.compression.rent_sponsor = mint_no_auth.compression.rent_sponsor;
+    zc_mint.base.compression.last_claimed_slot = mint_no_auth.compression.last_claimed_slot.into();
+    zc_mint.base.compression.rent_config.base_rent =
+        mint_no_auth.compression.rent_config.base_rent.into();
+    zc_mint.base.compression.rent_config.compression_cost =
+        mint_no_auth.compression.rent_config.compression_cost.into();
+    zc_mint
+        .base
+        .compression
+        .rent_config
+        .lamports_per_byte_per_epoch = mint_no_auth
+        .compression
+        .rent_config
+        .lamports_per_byte_per_epoch;
+    zc_mint.base.compression.rent_config.max_funded_epochs =
+        mint_no_auth.compression.rent_config.max_funded_epochs;
+    zc_mint.base.compression.rent_config.max_top_up =
+        mint_no_auth.compression.rent_config.max_top_up.into();
 
     let zc_as_borsh = CompressedMint::deserialize(&mut zc_bytes.as_slice()).unwrap();
     assert_eq!(mint_no_auth, zc_as_borsh);
@@ -226,6 +335,9 @@ fn test_compressed_mint_edge_cases() {
             mint: Pubkey::from([0xbb; 32]),
             cmint_decompressed: true,
         },
+        reserved: [0u8; 49],
+        account_type: ACCOUNT_TYPE_MINT,
+        compression: CompressionInfo::default(),
         extensions: None,
     };
 
@@ -250,6 +362,9 @@ fn test_base_mint_in_compressed_mint_spl_format() {
             mint: Pubkey::from([3; 32]),
             cmint_decompressed: false,
         },
+        reserved: [0u8; 49],
+        account_type: ACCOUNT_TYPE_MINT,
+        compression: CompressionInfo::default(),
         extensions: None,
     };
 
diff --git a/program-libs/ctoken-interface/tests/cross_deserialization.rs b/program-libs/ctoken-interface/tests/cross_deserialization.rs
new file mode 100644
index 0000000000..0dcd82b8f6
--- /dev/null
+++ b/program-libs/ctoken-interface/tests/cross_deserialization.rs
@@ -0,0 +1,171 @@
+//! Cross-deserialization security tests for CToken and CMint accounts.
+//! Verifies that account_type discriminator at byte 165 prevents confusion.
+
+use borsh::{BorshDeserialize, BorshSerialize};
+use light_compressed_account::Pubkey;
+use light_compressible::{compression_info::CompressionInfo, rent::RentConfig};
+use light_ctoken_interface::state::{
+    AccountState, BaseMint, CToken, CompressedMint, CompressedMintMetadata, ACCOUNT_TYPE_MINT,
+    ACCOUNT_TYPE_TOKEN_ACCOUNT,
+};
+
+const ACCOUNT_TYPE_OFFSET: usize = 165;
+
+fn create_test_cmint() -> CompressedMint {
+    CompressedMint {
+        base: BaseMint {
+            mint_authority: Some(Pubkey::new_from_array([1; 32])),
+            supply: 1000,
+            decimals: 6,
+            is_initialized: true,
+            freeze_authority: None,
+        },
+        metadata: CompressedMintMetadata {
+            version: 3,
+            mint: Pubkey::new_from_array([2; 32]),
+            cmint_decompressed: false,
+        },
+        reserved: [0u8; 49],
+        account_type: ACCOUNT_TYPE_MINT,
+        compression: CompressionInfo {
+            config_account_version: 1,
+            compress_to_pubkey: 0,
+            account_version: 3,
+            lamports_per_write: 100,
+            compression_authority: [3u8; 32],
+            rent_sponsor: [4u8; 32],
+            last_claimed_slot: 100,
+            rent_config: RentConfig {
+                base_rent: 0,
+                compression_cost: 0,
+                lamports_per_byte_per_epoch: 0,
+                max_funded_epochs: 0,
+                max_top_up: 0,
+            },
+        },
+        extensions: None,
+    }
+}
+
+fn create_test_ctoken() -> CToken {
+    CToken {
+        mint: Pubkey::new_from_array([1; 32]),
+        owner: Pubkey::new_from_array([2; 32]),
+        amount: 1000,
+        delegate: None,
+        state: AccountState::Initialized,
+        is_native: None,
+        delegated_amount: 0,
+        close_authority: None,
+        account_type: ACCOUNT_TYPE_TOKEN_ACCOUNT,
+        decimals: Some(6),
+        compression_only: false,
+        compression: CompressionInfo {
+            config_account_version: 1,
+            compress_to_pubkey: 0,
+            account_version: 3,
+            lamports_per_write: 100,
+            compression_authority: [3u8; 32],
+            rent_sponsor: [4u8; 32],
+            last_claimed_slot: 100,
+            rent_config: RentConfig {
+                base_rent: 0,
+                compression_cost: 0,
+                lamports_per_byte_per_epoch: 0,
+                max_funded_epochs: 0,
+                max_top_up: 0,
+            },
+        },
+        extensions: None, // CompressionInfo is now embedded directly in the struct
+    }
+}
+
+#[test]
+fn test_account_type_byte_position() {
+    let cmint = create_test_cmint();
+    let cmint_bytes = cmint.try_to_vec().unwrap();
+    assert_eq!(
+        cmint_bytes[ACCOUNT_TYPE_OFFSET], 1,
+        "CMint account_type should be 1"
+    );
+
+    let ctoken = create_test_ctoken();
+    let ctoken_bytes = ctoken.try_to_vec().unwrap();
+    assert_eq!(
+        ctoken_bytes[ACCOUNT_TYPE_OFFSET], 2,
+        "CToken account_type should be 2"
+    );
+}
+
+#[test]
+fn test_cmint_bytes_fail_zero_copy_checked_as_ctoken() {
+    let cmint = create_test_cmint();
+    let cmint_bytes = cmint.try_to_vec().unwrap();
+
+    // CToken zero_copy_at_checked verifies account_type == 2, should fail for CMint bytes
+    let result = CToken::zero_copy_at_checked(&cmint_bytes);
+    assert!(
+        result.is_err(),
+        "CMint bytes should fail to parse as CToken zero-copy checked"
+    );
+}
+
+#[test]
+fn test_ctoken_bytes_fail_zero_copy_checked_as_cmint() {
+    let ctoken = create_test_ctoken();
+    let ctoken_bytes = ctoken.try_to_vec().unwrap();
+
+    // CompressedMint zero_copy_at_checked verifies account_type == 1, should fail for CToken bytes
+    let result = CompressedMint::zero_copy_at_checked(&ctoken_bytes);
+    assert!(
+        result.is_err(),
+        "CToken bytes should fail to parse as CMint zero-copy checked"
+    );
+}
+
+#[test]
+fn test_ctoken_bytes_wrong_account_type_as_cmint() {
+    let ctoken = create_test_ctoken();
+    let ctoken_bytes = ctoken.try_to_vec().unwrap();
+
+    // Deserialize as CMint - should succeed but have wrong account_type
+    let cmint = CompressedMint::try_from_slice(&ctoken_bytes);
+    match cmint {
+        Ok(mint) => {
+            assert_ne!(
+                mint.account_type, ACCOUNT_TYPE_MINT,
+                "Cross-deserialized CMint should have wrong account_type"
+            );
+        }
+        Err(_) => {
+            // Also acceptable - deserialization failure
+        }
+    }
+}
+
+#[test]
+fn test_cmint_bytes_borsh_as_ctoken() {
+    let cmint = create_test_cmint();
+    let cmint_bytes = cmint.try_to_vec().unwrap();
+
+    // Try to deserialize CMint bytes as CToken
+    let result = CToken::try_from_slice(&cmint_bytes);
+    // Borsh deserialization is lenient, but checked deserialization should detect the wrong type
+    match result {
+        Ok(ctoken) => {
+            // Borsh is lenient and may succeed, but is_ctoken_account() check should fail
+            // because CMint has account_type = ACCOUNT_TYPE_MINT (1), not ACCOUNT_TYPE_TOKEN_ACCOUNT (2)
+            assert!(
+                !ctoken.is_ctoken_account(),
+                "CMint bytes deserialized as CToken should fail is_ctoken_account() check"
+            );
+            assert_eq!(
+                ctoken.account_type, ACCOUNT_TYPE_MINT,
+                "CMint bytes should retain ACCOUNT_TYPE_MINT discriminator"
+            );
+        }
+        Err(_) => {
+            // Also acceptable - deserialization failure
+        }
+    }
+}
diff --git a/program-libs/ctoken-interface/tests/ctoken/failing.rs b/program-libs/ctoken-interface/tests/ctoken/failing.rs
index 100e39d2e4..87aa0d595b 100644
--- a/program-libs/ctoken-interface/tests/ctoken/failing.rs
+++ b/program-libs/ctoken-interface/tests/ctoken/failing.rs
@@ -1,20 +1,26 @@
+use light_compressed_account::Pubkey;
 use light_ctoken_interface::{
     error::CTokenError,
-    state::{CToken, CompressedTokenConfig},
+    state::{CToken, CompressedTokenConfig, BASE_TOKEN_ACCOUNT_SIZE},
 };
 use light_zero_copy::ZeroCopyNew;
 
+fn default_config() -> CompressedTokenConfig {
+    CompressedTokenConfig {
+        mint: Pubkey::default(),
+        owner: Pubkey::default(),
+        state: 1,
+        compression_only: false,
+        extensions: None,
+    }
+}
+
 #[test]
 fn test_compressed_token_new_zero_copy_buffer_too_small() {
-    let config = CompressedTokenConfig {
-        delegate: false,
-        is_native: false,
-        close_authority: false,
-        extensions: vec![],
-    };
+    let config = default_config();
 
     // Create buffer that's too small
-    let mut buffer = vec![0u8; 100]; // Less than 165 bytes required
+    let mut buffer = vec![0u8; 100]; // Less than BASE_TOKEN_ACCOUNT_SIZE
     let result = CToken::new_zero_copy(&mut buffer, config);
 
     // Should fail with size error
@@ -23,10 +29,10 @@ fn test_compressed_token_new_zero_copy_buffer_too_small() {
 
 #[test]
 fn test_zero_copy_at_checked_uninitialized_account() {
-    // Create a 165-byte buffer with all zeros (byte 108 = 0, uninitialized)
-    let buffer = vec![0u8; 165];
+    // Create a buffer with all zeros (state byte = 0, uninitialized)
+    let buffer = vec![0u8; BASE_TOKEN_ACCOUNT_SIZE as usize];
 
-    // This should fail because byte 108 is 0 (not initialized)
+    // This should fail because state byte is 0 (not initialized)
     let result = CToken::zero_copy_at_checked(&buffer);
 
     // Assert it returns InvalidAccountState error
@@ -35,36 +41,10 @@ fn test_zero_copy_at_checked_uninitialized_account() {
 
 #[test]
 fn test_zero_copy_at_mut_checked_uninitialized_account() {
-    // Create a 165-byte mutable buffer with all zeros
-    let mut buffer = vec![0u8; 165];
-
-    // This should fail because byte 108 is 0 (not initialized)
-    let result = CToken::zero_copy_at_mut_checked(&mut buffer);
-
-    // Assert it returns InvalidAccountState error
-    assert!(matches!(result, Err(CTokenError::InvalidAccountState)));
-}
-
-#[test]
-fn test_zero_copy_at_checked_frozen_account() {
-    // Create a 165-byte buffer with byte 108 = 2 (AccountState::Frozen)
-    let mut buffer = vec![0u8; 165];
-    buffer[108] = 2; // AccountState::Frozen
-
-    // This should fail because byte 108 is 2 (frozen, not initialized)
-    let result = CToken::zero_copy_at_checked(&buffer);
-
-    // Assert it returns InvalidAccountState error
-    assert!(matches!(result, Err(CTokenError::InvalidAccountState)));
-}
-
-#[test]
-fn test_zero_copy_at_mut_checked_frozen_account() {
-    // Create a 165-byte mutable buffer with byte 108 = 2
-    let mut buffer = vec![0u8; 165];
-    buffer[108] = 2; // AccountState::Frozen
+    // Create a mutable buffer with all zeros
+    let mut buffer = vec![0u8; BASE_TOKEN_ACCOUNT_SIZE as usize];
 
-    // This should fail because byte 108 is 2 (frozen, not initialized)
+    // This should fail because state byte is 0 (not initialized)
     let result = CToken::zero_copy_at_mut_checked(&mut buffer);
 
     // Assert it returns InvalidAccountState error
@@ -73,14 +53,14 @@ fn test_zero_copy_at_mut_checked_frozen_account() {
 
 #[test]
 fn test_zero_copy_at_checked_buffer_too_small() {
-    // Create a 100-byte buffer (less than 109 bytes minimum)
+    // Create a 100-byte buffer (less than BASE_TOKEN_ACCOUNT_SIZE)
     let buffer = vec![0u8; 100];
 
     // This should fail because buffer is too small
     let result = CToken::zero_copy_at_checked(&buffer);
 
-    // Assert it returns InvalidAccountData error
-    assert!(matches!(result, Err(CTokenError::InvalidAccountData)));
+    // Assert it returns ZeroCopyError (buffer too small fails at zero_copy_at before checked validation)
+    assert!(matches!(result, Err(CTokenError::ZeroCopyError(_))));
 }
 
 #[test]
@@ -91,6 +71,6 @@ fn test_zero_copy_at_mut_checked_buffer_too_small() {
     // This should fail because buffer is too small
     let result = CToken::zero_copy_at_mut_checked(&mut buffer);
 
-    // Assert it returns InvalidAccountData error
-    assert!(matches!(result, Err(CTokenError::InvalidAccountData)));
+    // Assert it returns ZeroCopyError (buffer too small fails at zero_copy_at_mut before checked validation)
+    assert!(matches!(result, Err(CTokenError::ZeroCopyError(_))));
 }
diff --git a/program-libs/ctoken-interface/tests/ctoken/mod.rs b/program-libs/ctoken-interface/tests/ctoken/mod.rs
index 84143da26d..bc3c1fcb23 100644
--- a/program-libs/ctoken-interface/tests/ctoken/mod.rs
+++ b/program-libs/ctoken-interface/tests/ctoken/mod.rs
@@ -1,4 +1,5 @@
 pub mod failing;
 pub mod randomized_solana_ctoken;
+pub mod size;
 pub mod spl_compat;
 pub mod zero_copy_new;
diff --git a/program-libs/ctoken-interface/tests/ctoken/size.rs b/program-libs/ctoken-interface/tests/ctoken/size.rs
new file mode 100644
index 0000000000..458c6026f4
--- /dev/null
+++ b/program-libs/ctoken-interface/tests/ctoken/size.rs
@@ -0,0 +1,62 @@
+use light_ctoken_interface::{
+    state::{calculate_ctoken_account_size, ExtensionStructConfig},
+    BASE_TOKEN_ACCOUNT_SIZE,
+};
+
+#[test]
+fn test_ctoken_account_size_calculation() {
+    // Base only (no extensions) - includes compression info in base struct (258 bytes)
+    assert_eq!(
+        calculate_ctoken_account_size(None).unwrap(),
+        BASE_TOKEN_ACCOUNT_SIZE as usize
+    );
+
+    // With pausable only (258 + 4 metadata + 1 discriminant = 263)
+    assert_eq!(
+        calculate_ctoken_account_size(Some(&[ExtensionStructConfig::PausableAccount(())])).unwrap(),
+        263
+    );
+
+    // With permanent_delegate only (258 + 4 metadata + 1 discriminant = 263)
+    assert_eq!(
+        calculate_ctoken_account_size(Some(&[ExtensionStructConfig::PermanentDelegateAccount(())]))
+            .unwrap(),
+        263
+    );
+
+    // With pausable + permanent_delegate (258 + 4 metadata + 1 + 1 = 264)
+    assert_eq!(
+        calculate_ctoken_account_size(Some(&[
+            ExtensionStructConfig::PausableAccount(()),
+            ExtensionStructConfig::PermanentDelegateAccount(())
+        ]))
+        .unwrap(),
+        264
+    );
+
+    // With transfer_fee only (258 + 4 metadata + 9 = 271)
+    assert_eq!(
+        calculate_ctoken_account_size(Some(&[ExtensionStructConfig::TransferFeeAccount(())]))
+            .unwrap(),
+        271
+    );
+
+    // With transfer_hook only (258 + 4 metadata + 2 = 264)
+    assert_eq!(
+        calculate_ctoken_account_size(Some(&[ExtensionStructConfig::TransferHookAccount(())]))
+            .unwrap(),
+        264
+    );
+
+    // With all 4 extensions (258 + 4 + 1 + 1 + 9 + 2 = 275)
+    assert_eq!(
+        calculate_ctoken_account_size(Some(&[
+            ExtensionStructConfig::PausableAccount(()),
+            ExtensionStructConfig::PermanentDelegateAccount(()),
+            ExtensionStructConfig::TransferFeeAccount(()),
+            ExtensionStructConfig::TransferHookAccount(())
+        ]))
+        .unwrap(),
+        275
+    );
+}
diff --git a/program-libs/ctoken-interface/tests/ctoken/spl_compat.rs b/program-libs/ctoken-interface/tests/ctoken/spl_compat.rs
index 2f621ad2fb..7afae6e356 100644
--- a/program-libs/ctoken-interface/tests/ctoken/spl_compat.rs
+++ b/program-libs/ctoken-interface/tests/ctoken/spl_compat.rs
@@ -2,13 +2,17 @@
 //!
 //! Tests:
 //! 1. test_compressed_token_equivalent_to_pod_account
-//! 2. test_compressed_token_with_compressible_extension
+//! 2. test_compressed_token_with_pausable_extension
 //! 3. test_account_type_compatibility_with_spl_parsing
 
 use light_compressed_account::Pubkey;
+use light_compressible::{compression_info::CompressionInfo, rent::RentConfig};
 use light_ctoken_interface::state::{
-    ctoken::{CToken, CompressedTokenConfig, ZCToken},
-    CompressibleExtensionConfig, CompressionInfoConfig, ExtensionStructConfig,
+    ctoken::{
+        CToken, CompressedTokenConfig, ZCToken, ZCTokenMut, ACCOUNT_TYPE_TOKEN_ACCOUNT,
+        BASE_TOKEN_ACCOUNT_SIZE,
+    },
+    extensions::ExtensionStructConfig,
 };
 use light_zero_copy::traits::{ZeroCopyAt, ZeroCopyAtMut, ZeroCopyNew};
 use rand::Rng;
@@ -20,7 +24,37 @@ use spl_token_2022::{
     state::{Account, AccountState},
 };
 
+fn default_config() -> CompressedTokenConfig {
+    CompressedTokenConfig {
+        mint: Pubkey::default(),
+        owner: Pubkey::default(),
+        state: 1,
+        compression_only: false,
+        extensions: None,
+    }
+}
+
+fn zeroed_compression_info() -> CompressionInfo {
+    CompressionInfo {
+        config_account_version: 0,
+        compress_to_pubkey: 0,
+        account_version: 0,
+        lamports_per_write: 0,
+        compression_authority: [0u8; 32],
+        rent_sponsor: [0u8; 32],
+        last_claimed_slot: 0,
+        rent_config: RentConfig {
+            base_rent: 0,
+            compression_cost: 0,
+            lamports_per_byte_per_epoch: 0,
+            max_funded_epochs: 0,
+            max_top_up: 0,
+        },
+    }
+}
+
 /// Generate random token account data using SPL Token's pack method
+/// Creates a buffer large enough for the full CToken meta struct
 fn generate_random_token_account_data(rng: &mut impl Rng) -> Vec<u8> {
     let account = Account {
         mint: solana_pubkey::Pubkey::new_from_array(rng.gen::<[u8; 32]>()),
@@ -50,8 +84,11 @@ fn generate_random_token_account_data(rng: &mut impl Rng) -> Vec<u8> {
     };
     println!("Expected Account: {:?}", account);
 
-    let mut account_data = vec![0u8; Account::LEN];
-    Account::pack(account, &mut account_data).unwrap();
+    // Create buffer large enough for full CToken meta struct
+    let mut account_data = vec![0u8; BASE_TOKEN_ACCOUNT_SIZE as usize];
+    Account::pack(account, &mut account_data[..Account::LEN]).unwrap();
+    // Set account_type byte at position 165 to ACCOUNT_TYPE_TOKEN_ACCOUNT (2)
+    account_data[165] = 2;
     account_data
 }
 
@@ -81,11 +118,11 @@ fn compare_compressed_token_with_pod_account(
     }
 
     // Compare amount
-    if u64::from(*compressed_token.amount) != u64::from(pod_account.amount) {
+    if u64::from(compressed_token.amount) != u64::from(pod_account.amount) {
         return false;
     }
 
-    // Compare delegate
+    // Compare delegate using getter
     let pod_delegate_option: Option<Pubkey> = if pod_account.delegate.is_some() {
         Some(
             pod_account
@@ -97,19 +134,14 @@ fn compare_compressed_token_with_pod_account(
     } else {
         None
     };
-    match (compressed_token.delegate, pod_delegate_option) {
+    match (compressed_token.delegate(), pod_delegate_option) {
         (Some(compressed_delegate), Some(pod_delegate)) => {
             if compressed_delegate.to_bytes() != pod_delegate.to_bytes() {
                 return false;
             }
         }
-        (None, None) => {
-            // Both are None, which is correct
-        }
-        _ => {
-            // One is Some, the other is None - mismatch
-            return false;
-        }
+        (None, None) => {}
+        _ => return false,
     }
 
     // Compare state
@@ -117,7 +149,7 @@ fn compare_compressed_token_with_pod_account(
         return false;
     }
 
-    // Compare is_native
+    // Compare is_native using getter
     let pod_native_option: Option<u64> = if pod_account.is_native.is_some() {
         Some(u64::from(
             pod_account.is_native.unwrap_or(PodU64::default()),
@@ -125,27 +157,22 @@ fn compare_compressed_token_with_pod_account(
     } else {
         None
     };
-    match (compressed_token.is_native, pod_native_option) {
+    match (compressed_token.is_native_value(), pod_native_option) {
         (Some(compressed_native), Some(pod_native)) => {
-            if u64::from(*compressed_native) != pod_native {
+            if compressed_native != pod_native {
                 return false;
             }
         }
-        (None, None) => {
-            // Both are None, which is correct
-        }
-        _ => {
-            // One is Some, the other is None - mismatch
-            return false;
-        }
+        (None, None) => {}
+        _ => return false,
     }
 
     // Compare delegated_amount
-    if u64::from(*compressed_token.delegated_amount) != u64::from(pod_account.delegated_amount) {
+    if u64::from(compressed_token.delegated_amount) != u64::from(pod_account.delegated_amount) {
         return false;
     }
 
-    // Compare close_authority
+    // Compare close_authority using getter
     let pod_close_option: Option<Pubkey> = if pod_account.close_authority.is_some() {
         Some(
             pod_account
@@ -157,19 +184,14 @@ fn compare_compressed_token_with_pod_account(
     } else {
         None
     };
-    match (compressed_token.close_authority, pod_close_option) {
+    match (compressed_token.close_authority(), pod_close_option) {
         (Some(compressed_close), Some(pod_close)) => {
             if compressed_close.to_bytes() != pod_close.to_bytes() {
                 return false;
             }
         }
-        (None, None) => {
-            // Both are None, which is correct
-        }
-        _ => {
-            // One is Some, the other is None - mismatch
-            return false;
-        }
+        (None, None) => {}
+        _ => return false,
     }
 
     true
@@ -177,7 +199,7 @@ fn compare_compressed_token_with_pod_account(
 
 /// Compare all fields between our CToken mutable zero-copy implementation and Pod account
 fn compare_compressed_token_mut_with_pod_account(
-    compressed_token: &light_ctoken_interface::state::ctoken::ZCompressedTokenMut,
+    compressed_token: &ZCTokenMut,
     pod_account: &PodAccount,
 ) -> bool {
     // Extensions should be None for basic SPL Token accounts
@@ -201,11 +223,11 @@ fn compare_compressed_token_mut_with_pod_account(
     }
 
     // Compare amount
-    if u64::from(*compressed_token.amount) != u64::from(pod_account.amount) {
+    if u64::from(compressed_token.amount) != u64::from(pod_account.amount) {
         return false;
     }
 
-    // Compare delegate
+    // Compare delegate using getter
     let pod_delegate_option: Option<Pubkey> = if pod_account.delegate.is_some() {
         Some(
             pod_account
@@ -217,31 +239,26 @@ fn compare_compressed_token_mut_with_pod_account(
     } else {
         None
     };
-    match (compressed_token.delegate.as_ref(), pod_delegate_option) {
+    match (compressed_token.delegate(), pod_delegate_option) {
         (Some(compressed_delegate), Some(pod_delegate)) => {
             if compressed_delegate.to_bytes() != pod_delegate.to_bytes() {
                 return false;
             }
         }
-        (None, None) => {
-            // Both are None, which is correct
-        }
-        _ => {
-            // One is Some, the other is None - mismatch
-            return false;
-        }
+        (None, None) => {}
+        _ => return false,
     }
 
     // Compare state
-    if *compressed_token.state != pod_account.state {
+    if compressed_token.state != pod_account.state {
         println!(
             "State mismatch: compressed={}, pod={}",
-            *compressed_token.state, pod_account.state
+            compressed_token.state, pod_account.state
         );
         return false;
     }
 
-    // Compare is_native
+    // Compare is_native using getter
     let pod_native_option: Option<u64> = if pod_account.is_native.is_some() {
         Some(u64::from(
             pod_account.is_native.unwrap_or(PodU64::default()),
@@ -249,27 +266,22 @@ fn compare_compressed_token_mut_with_pod_account(
     } else {
         None
     };
-    match (compressed_token.is_native.as_ref(), pod_native_option) {
+    match (compressed_token.is_native_value(), pod_native_option) {
         (Some(compressed_native), Some(pod_native)) => {
-            if u64::from(**compressed_native) != pod_native {
+            if compressed_native != pod_native {
                 return false;
             }
         }
-        (None, None) => {
-            // Both are None, which is correct
-        }
-        _ => {
-            // One is Some, the other is None - mismatch
-            return false;
-        }
+        (None, None) => {}
+        _ => return false,
     }
 
     // Compare delegated_amount
-    if u64::from(*compressed_token.delegated_amount) != u64::from(pod_account.delegated_amount) {
+    if u64::from(compressed_token.delegated_amount) != u64::from(pod_account.delegated_amount) {
         return false;
     }
 
-    // Compare close_authority
+    // Compare close_authority using getter
     let pod_close_option: Option<Pubkey> = if pod_account.close_authority.is_some() {
         Some(
             pod_account
@@ -281,19 +293,14 @@ fn compare_compressed_token_mut_with_pod_account(
     } else {
         None
     };
-    match (compressed_token.close_authority.as_ref(), pod_close_option) {
+    match (compressed_token.close_authority(), pod_close_option) {
         (Some(compressed_close), Some(pod_close)) => {
             if compressed_close.to_bytes() != pod_close.to_bytes() {
                 return false;
             }
         }
-        (None, None) => {
-            // Both are None, which is correct
-        }
-        _ => {
-            // One is Some, the other is None - mismatch
-            return false;
-        }
+        (None, None) => {}
+        _ => return false,
     }
 
     true
@@ -306,7 +313,8 @@ fn test_compressed_token_equivalent_to_pod_account() {
     for _ in 0..10000 {
         let mut account_data = generate_random_token_account_data(&mut rng);
         let account_data_clone = account_data.clone();
-        let pod_account = pod_from_bytes::<PodAccount>(&account_data_clone).unwrap();
+        // Pod account only knows about the first 165 bytes
+        let pod_account = pod_from_bytes::<PodAccount>(&account_data_clone[..165]).unwrap();
 
         // Test immutable version
         let (compressed_token, _) = CToken::zero_copy_at(&account_data).unwrap();
@@ -318,10 +326,10 @@ fn test_compressed_token_equivalent_to_pod_account() {
         ));
         {
             let account_data_clone = account_data.clone();
-            let pod_account = pod_from_bytes::<PodAccount>(&account_data_clone).unwrap();
+            // Pod account only knows about the first 165 bytes
+            let pod_account = pod_from_bytes::<PodAccount>(&account_data_clone[..165]).unwrap();
             // Test mutable version
-            let (mut compressed_token_mut, _) =
-                CToken::zero_copy_at_mut(&mut account_data).unwrap();
+            let (compressed_token_mut, _) = CToken::zero_copy_at_mut(&mut account_data).unwrap();
             println!("Compressed Token Mut: {:?}", compressed_token_mut);
             println!("Pod Account: {:?}", pod_account);
 
@@ -329,109 +337,36 @@ fn test_compressed_token_equivalent_to_pod_account() {
                 &compressed_token_mut,
                 pod_account
             ));
-
-            // Test mutation: modify every mutable field in the zero-copy struct
-            {
-                // Modify mint (first 32 bytes)
-                *compressed_token_mut.mint = solana_pubkey::Pubkey::new_unique().to_bytes().into();
-
-                // Modify owner (next 32 bytes)
-                *compressed_token_mut.owner = solana_pubkey::Pubkey::new_unique().to_bytes().into();
-                // Modify amount
-                *compressed_token_mut.amount = rng.gen::<u64>().into();
-
-                // Modify delegate if it exists
-                if let Some(ref mut delegate) = compressed_token_mut.delegate {
-                    **delegate = solana_pubkey::Pubkey::new_unique().to_bytes().into();
-                }
-
-                // Modify state (0 = Uninitialized, 1 = Initialized, 2 = Frozen)
-                *compressed_token_mut.state = rng.gen_range(0..=2);
-
-                // Modify is_native if it exists
-                if let Some(ref mut native_value) = compressed_token_mut.is_native {
-                    **native_value = rng.gen::<u64>().into();
-                }
-
-                // Modify delegated_amount
-                *compressed_token_mut.delegated_amount = rng.gen::<u64>().into();
-
-                // Modify close_authority if it exists
-                if let Some(ref mut close_auth) = compressed_token_mut.close_authority {
-                    **close_auth = solana_pubkey::Pubkey::new_unique().to_bytes().into();
-                }
-            }
-            // Clone the modified bytes and create a new Pod account to verify changes
-            let modified_account_data = account_data.clone();
-            let modified_pod_account =
-                pod_from_bytes::<PodAccount>(&modified_account_data).unwrap();
-
-            // Create a new immutable compressed token from the modified data to compare
-            let (modified_compressed_token, _) =
-                CToken::zero_copy_at(&modified_account_data).unwrap();
-
-            println!("Modified zero copy account {:?}", modified_compressed_token);
-            println!("Modified Pod Account: {:?}", modified_pod_account);
-            // Use the comparison function to verify all modifications
-            assert!(compare_compressed_token_with_pod_account(
-                &modified_compressed_token,
-                modified_pod_account
-            ));
         }
     }
 }
 
 #[test]
-fn test_compressed_token_with_compressible_extension() {
-    use light_zero_copy::traits::ZeroCopyAtMut;
-
-    // Test configuration with compressible extension
+fn test_compressed_token_with_pausable_extension() {
     let config = CompressedTokenConfig {
-        delegate: false,
-        is_native: false,
-        close_authority: false,
-        extensions: vec![ExtensionStructConfig::Compressible(
-            CompressibleExtensionConfig {
-                info: CompressionInfoConfig { rent_config: () },
-            },
-        )],
+        extensions: Some(vec![ExtensionStructConfig::PausableAccount(())]),
+        ..default_config()
     };
 
-    // Calculate required buffer size (165 base + 1 AccountType + 1 Option + extension data)
     let required_size = CToken::byte_len(&config).unwrap();
-    println!(
-        "Required size for compressible extension: {}",
-        required_size
-    );
+    println!("Required size for pausable extension: {}", required_size);
 
     // Should be more than 165 bytes due to AccountType byte and extension
     assert!(required_size > 165);
 
-    // Create buffer and initialize
     let mut buffer = vec![0u8; required_size];
     {
-        let (compressed_token, remaining_bytes) = CToken::new_zero_copy(&mut buffer, config)
-            .expect("Failed to initialize compressed token with compressible extension");
+        let (_, remaining_bytes) = CToken::new_zero_copy(&mut buffer, config)
+            .expect("Failed to initialize compressed token with pausable extension");
 
-        // Verify the remaining bytes length
         assert_eq!(remaining_bytes.len(), 0);
+        // Note: new_zero_copy now writes extensions directly to bytes but returns extensions: None
+        // Extensions are parsed when deserializing with zero_copy_at
+    }
 
-        // Verify extensions are present
-        assert!(compressed_token.extensions.is_some());
-        let extensions = compressed_token.extensions.as_ref().unwrap();
-        assert_eq!(extensions.len(), 1);
-    } // Drop the compressed_token reference here
-
-    // Now we can access buffer directly
-    // Verify AccountType::Account byte is set at position 165
-    assert_eq!(buffer[165], 2); // AccountType::Account = 2
-
-    // Verify extension option discriminant at position 166
-    assert_eq!(buffer[166], 1); // Some = 1
-
-    // Test zero-copy deserialization round-trip
-    let (deserialized_token, _) = CToken::zero_copy_at(&buffer)
-        .expect("Failed to deserialize token with compressible extension");
+    // Test zero-copy deserialization round-trip - extensions are parsed from bytes
+    let (deserialized_token, _) =
+        CToken::zero_copy_at(&buffer).expect("Failed to deserialize token with pausable extension");
 
     assert!(deserialized_token.extensions.is_some());
     let deserialized_extensions = deserialized_token.extensions.as_ref().unwrap();
@@ -440,42 +375,37 @@ fn test_compressed_token_with_compressible_extension() {
     // Test mutable deserialization with a fresh buffer
     let mut buffer_copy = buffer.clone();
     let (mutable_token, _) = CToken::zero_copy_at_mut(&mut buffer_copy)
-        .expect("Failed to deserialize mutable token with compressible extension");
+        .expect("Failed to deserialize mutable token with pausable extension");
 
     assert!(mutable_token.extensions.is_some());
 }
 
 #[test]
 fn test_account_type_compatibility_with_spl_parsing() {
-    // This test verifies our AccountType insertion makes accounts SPL Token 2022 compatible
-
     let config = CompressedTokenConfig {
-        delegate: false,
-        is_native: false,
-        close_authority: false,
-        extensions: vec![ExtensionStructConfig::Compressible(
-            CompressibleExtensionConfig {
-                info: CompressionInfoConfig { rent_config: () },
-            },
-        )],
+        extensions: Some(vec![ExtensionStructConfig::PausableAccount(())]),
+        ..default_config()
     };
 
     let mut buffer = vec![0u8; CToken::byte_len(&config).unwrap()];
-    let (_compressed_token, _) =
-        CToken::new_zero_copy(&mut buffer, config).expect("Failed to create token with extension");
+    {
+        let (mut compressed_token, _) = CToken::new_zero_copy(&mut buffer, config)
+            .expect("Failed to create token with extension");
+        // Set state to Initialized (1) for SPL compatibility - required for SPL parsing
+        compressed_token.base.state = 1;
+    }
 
     let pod_account = pod_from_bytes::<PodAccount>(&buffer[..165])
         .expect("First 165 bytes should be valid SPL Token Account data");
-    let pod_state = PodStateWithExtensions::<PodAccount>::unpack(&buffer)
+    let pod_state = PodStateWithExtensions::<PodAccount>::unpack(&buffer[..165])
         .expect("Pod account with extensions should succeed.");
     let base_account = pod_state.base;
     assert_eq!(pod_account, base_account);
-    // Verify account structure
-    assert_eq!(pod_account.state, 1); // AccountState::Initialized
 
     // Verify AccountType byte is at position 165
-    assert_eq!(buffer[165], 2); // AccountType::Account = 2
-                                // Deserialize with extensions
+    assert_eq!(buffer[165], ACCOUNT_TYPE_TOKEN_ACCOUNT);
+
+    // Deserialize with extensions
     let token_account_data = StateWithExtensions::<Account>::unpack(&buffer)
         .unwrap()
         .base;
@@ -489,115 +419,41 @@ fn test_account_type_compatibility_with_spl_parsing() {
     println!("token_account_data {:?}", token_account_data);
 }
 
-/// Test PartialEq between ZCToken and CToken with Compressible extension.
-/// Verifies that compress_to_pubkey and account_version are compared correctly.
+/// Test PartialEq between ZCToken and CToken with Pausable extension.
 #[test]
-fn test_compressible_extension_partial_eq() {
-    use light_compressible::{compression_info::CompressionInfo, rent::RentConfig};
+fn test_pausable_extension_partial_eq() {
     use light_ctoken_interface::state::{
         ctoken::AccountState as CtokenAccountState,
-        extensions::{CompressibleExtension, ExtensionStruct},
+        extensions::{ExtensionStruct, PausableAccountExtension},
     };
 
     let config = CompressedTokenConfig {
-        delegate: false,
-        is_native: false,
-        close_authority: false,
-        extensions: vec![ExtensionStructConfig::Compressible(
-            CompressibleExtensionConfig {
-                info: CompressionInfoConfig { rent_config: () },
-            },
-        )],
+        extensions: Some(vec![ExtensionStructConfig::PausableAccount(())]),
+        ..default_config()
     };
 
     let mut buffer = vec![0u8; CToken::byte_len(&config).unwrap()];
-    {
-        let (mut zctoken_mut, _) = CToken::new_zero_copy(&mut buffer, config).unwrap();
-
-        // Set extension fields
-        if let Some(ref mut exts) = zctoken_mut.extensions {
-            for ext in exts.iter_mut() {
-                if let light_ctoken_interface::state::extensions::ZExtensionStructMut::Compressible(
-                    ref mut comp,
-                ) = ext
-                {
-                    comp.info.config_account_version = 1.into();
-                    comp.info.compress_to_pubkey = 1;
-                    comp.info.account_version = 2;
-                    comp.info.lamports_per_write = 100.into();
-                    comp.info.compression_authority = [1u8; 32];
-                    comp.info.rent_sponsor = [2u8; 32];
-                    comp.info.last_claimed_slot = 1000.into();
-                }
-            }
-        }
-    }
+    let _ = CToken::new_zero_copy(&mut buffer, config).unwrap();
 
-    // Create owned CToken with matching values (rent_config is zeroed in the buffer)
-    let compression_info = CompressionInfo {
-        config_account_version: 1,
-        compress_to_pubkey: 1,
-        account_version: 2,
-        lamports_per_write: 100,
-        compression_authority: [1u8; 32],
-        rent_sponsor: [2u8; 32],
-        last_claimed_slot: 1000,
-        rent_config: RentConfig {
-            base_rent: 0,
-            compression_cost: 0,
-            lamports_per_byte_per_epoch: 0,
-            max_funded_epochs: 0,
-            max_top_up: 0,
-        },
-    };
-
-    let ctoken = CToken {
+    // new_zero_copy now sets fields from config
+    let expected = CToken {
         mint: Pubkey::default(),
         owner: Pubkey::default(),
         amount: 0,
         delegate: None,
-        state: CtokenAccountState::Initialized,
+        state: CtokenAccountState::Initialized, // state: 1 from default_config
         is_native: None,
         delegated_amount: 0,
         close_authority: None,
-        extensions: Some(vec![ExtensionStruct::Compressible(CompressibleExtension {
-            compression_only: false,
-            info: compression_info,
-        })]),
+        account_type: ACCOUNT_TYPE_TOKEN_ACCOUNT,
+        decimals: None,
+        compression_only: false,
+        compression: zeroed_compression_info(),
+        extensions: Some(vec![ExtensionStruct::PausableAccount(
+            PausableAccountExtension,
+        )]),
     };
 
-    // Parse zero-copy view
     let (zctoken, _) = CToken::zero_copy_at(&buffer).unwrap();
-
-    // Should be equal
-    assert_eq!(zctoken, ctoken);
-    assert_eq!(ctoken, zctoken);
-
-    // Test compress_to_pubkey mismatch
-    let ctoken_diff_compress = CToken {
-        extensions: Some(vec![ExtensionStruct::Compressible(CompressibleExtension {
-            compression_only: false,
-            info: CompressionInfo {
-                compress_to_pubkey: 0,
-                ..compression_info
-            },
-        })]),
-        ..ctoken.clone()
-    };
-    assert_ne!(zctoken, ctoken_diff_compress);
-    assert_ne!(ctoken_diff_compress, zctoken);
-
-    // Test account_version mismatch
-    let ctoken_diff_version = CToken {
-        extensions: Some(vec![ExtensionStruct::Compressible(CompressibleExtension {
-            compression_only: false,
-            info: CompressionInfo {
-                account_version: 0,
-                ..compression_info
-            },
-        })]),
-        ..ctoken.clone()
-    };
-    assert_ne!(zctoken, ctoken_diff_version);
-    assert_ne!(ctoken_diff_version, zctoken);
+    assert_eq!(zctoken, expected);
 }
diff --git a/program-libs/ctoken-interface/tests/ctoken/zero_copy_new.rs b/program-libs/ctoken-interface/tests/ctoken/zero_copy_new.rs
index 580dc9df02..8148da19a7 100644
--- a/program-libs/ctoken-interface/tests/ctoken/zero_copy_new.rs
+++ b/program-libs/ctoken-interface/tests/ctoken/zero_copy_new.rs
@@ -2,110 +2,135 @@
 //! - ZeroCopyNew
 //!
 //! Tests:
-//! 1.test_compressed_token_new_zero_copy
-//! 2. test_compressed_token_new_zero_copy_with_delegate
-//! 3. test_compressed_token_new_zero_copy_all_options
+//! 1. test_compressed_token_new_zero_copy - basic creation without extensions
+//! 2. test_compressed_token_new_zero_copy_with_pausable_extension - with extension
 
-use light_ctoken_interface::state::ctoken::{CToken, CompressedTokenConfig};
-use light_zero_copy::traits::ZeroCopyNew;
+use light_compressed_account::Pubkey;
+use light_compressible::{compression_info::CompressionInfo, rent::RentConfig};
+use light_ctoken_interface::state::{
+    ctoken::{AccountState, CToken, CompressedTokenConfig, BASE_TOKEN_ACCOUNT_SIZE},
+    extensions::{ExtensionStruct, ExtensionStructConfig, PausableAccountExtension},
+};
+use light_zero_copy::traits::{ZeroCopyAt, ZeroCopyNew};
+
+fn zeroed_compression_info() -> CompressionInfo {
+    CompressionInfo {
+        config_account_version: 0,
+        compress_to_pubkey: 0,
+        account_version: 0,
+        lamports_per_write: 0,
+        compression_authority: [0u8; 32],
+        rent_sponsor: [0u8; 32],
+        last_claimed_slot: 0,
+        rent_config: RentConfig {
+            base_rent: 0,
+            compression_cost: 0,
+            lamports_per_byte_per_epoch: 0,
+            max_funded_epochs: 0,
+            max_top_up: 0,
+        },
+    }
+}
+
+fn default_config() -> CompressedTokenConfig {
+    CompressedTokenConfig {
+        mint: Pubkey::default(),
+        owner: Pubkey::default(),
+        state: 1,
+        compression_only: false,
+        extensions: None,
+    }
+}
 
 #[test]
 fn test_compressed_token_new_zero_copy() {
-    let config = CompressedTokenConfig {
-        delegate: false,
-        is_native: false,
-        close_authority: false,
-        extensions: vec![],
-    };
+    let config = default_config();
 
-    // Calculate required buffer size
     let required_size = CToken::byte_len(&config).unwrap();
-    assert_eq!(required_size, 165); // SPL Token account size
+    assert_eq!(required_size, BASE_TOKEN_ACCOUNT_SIZE as usize);
 
-    // Create buffer and initialize
     let mut buffer = vec![0u8; required_size];
-    let (compressed_token, remaining_bytes) =
-        CToken::new_zero_copy(&mut buffer, config).expect("Failed to initialize compressed token");
-
-    // Verify the remaining bytes length
-    assert_eq!(remaining_bytes.len(), 0);
-    // Verify the zero-copy structure reflects the discriminators
-    assert!(compressed_token.delegate.is_none());
-    assert!(compressed_token.is_native.is_none());
-    assert!(compressed_token.close_authority.is_none());
-    assert!(compressed_token.extensions.is_none());
-    // Verify the discriminator bytes are set correctly
-    assert_eq!(buffer[72], 0); // delegate discriminator should be 0 (None)
-    assert_eq!(buffer[109], 0); // is_native discriminator should be 0 (None)
-    assert_eq!(buffer[129], 0); // close_authority discriminator should be 0 (None)
-}
+    let _ = CToken::new_zero_copy(&mut buffer, config).expect("Failed to initialize");
 
-#[test]
-fn test_compressed_token_new_zero_copy_with_delegate() {
-    let config = CompressedTokenConfig {
-        delegate: true,
-        is_native: false,
-        close_authority: false,
-        extensions: vec![],
+    let (zctoken, remaining) = CToken::zero_copy_at(&buffer).unwrap();
+
+    // new_zero_copy now sets fields from config
+    let expected = CToken {
+        mint: Pubkey::default(),
+        owner: Pubkey::default(),
+        amount: 0,
+        delegate: None,
+        state: AccountState::Initialized, // state: 1 from default_config
+        is_native: None,
+        delegated_amount: 0,
+        close_authority: None,
+        account_type: 2, // ACCOUNT_TYPE_TOKEN_ACCOUNT
+        decimals: None,
+        compression_only: false,
+        compression: zeroed_compression_info(),
+        extensions: None,
     };
 
-    // Create buffer and initialize
-    let mut buffer = vec![0u8; CToken::byte_len(&config).unwrap()];
-    let (compressed_token, _) = CToken::new_zero_copy(&mut buffer, config)
-        .expect("Failed to initialize compressed token with delegate");
-    // The delegate field should be Some (though the pubkey will be zero)
-    assert!(compressed_token.delegate.is_some());
-    assert!(compressed_token.is_native.is_none());
-    assert!(compressed_token.close_authority.is_none());
-    // Verify delegate discriminator is set to 1 (Some)
-    assert_eq!(buffer[72], 1); // delegate discriminator should be 1 (Some)
-    assert_eq!(buffer[109], 0); // is_native discriminator should be 0 (None)
-    assert_eq!(buffer[129], 0); // close_authority discriminator should be 0 (None)
+    assert_eq!(remaining.len(), 0);
+    assert_eq!(zctoken, expected);
 }
+
 #[test]
-fn test_compressed_token_new_zero_copy_with_is_native() {
+fn test_compressed_token_new_zero_copy_with_pausable_extension() {
     let config = CompressedTokenConfig {
-        delegate: false,
-        is_native: true,
-        close_authority: false,
-        extensions: vec![],
+        extensions: Some(vec![ExtensionStructConfig::PausableAccount(())]),
+        ..default_config()
     };
 
-    // Create buffer and initialize
-    let mut buffer = vec![0u8; CToken::byte_len(&config).unwrap()];
-    let (compressed_token, _) = CToken::new_zero_copy(&mut buffer, config)
-        .expect("Failed to initialize compressed token with is_native");
+    let required_size = CToken::byte_len(&config).unwrap();
+    assert!(required_size > BASE_TOKEN_ACCOUNT_SIZE as usize);
 
-    // The is_native field should be Some (though the value will be zero)
-    assert!(compressed_token.delegate.is_none());
-    assert!(compressed_token.is_native.is_some());
-    assert!(compressed_token.close_authority.is_none());
+    let mut buffer = vec![0u8; required_size];
+    let _ = CToken::new_zero_copy(&mut buffer, config).expect("Failed to initialize");
 
-    // Verify is_native discriminator is set to 1 (Some)
-    assert_eq!(buffer[72], 0); // delegate discriminator should be 0 (None)
-    assert_eq!(buffer[109], 1); // is_native discriminator should be 1 (Some)
-    assert_eq!(buffer[129], 0); // close_authority discriminator should be 0 (None)
+    let (zctoken, remaining) = CToken::zero_copy_at(&buffer).unwrap();
+
+    // new_zero_copy now sets fields from config
+    let expected = CToken {
+        mint: Pubkey::default(),
+        owner: Pubkey::default(),
+        amount: 0,
+        delegate: None,
+        state: AccountState::Initialized, // state: 1 from default_config
+        is_native: None,
+        delegated_amount: 0,
+        close_authority: None,
+        account_type: 2, // ACCOUNT_TYPE_TOKEN_ACCOUNT
+        decimals: None,
+        compression_only: false,
+        compression: zeroed_compression_info(),
+        extensions: Some(vec![ExtensionStruct::PausableAccount(
+            PausableAccountExtension,
+        )]),
+    };
+
+    assert_eq!(remaining.len(), 0);
+    assert_eq!(zctoken, expected);
 }
+
 #[test]
-fn test_compressed_token_new_zero_copy_all_options() {
-    let config = CompressedTokenConfig {
-        delegate: true,
-        is_native: true,
-        close_authority: true,
-        extensions: vec![],
+fn test_compressed_token_byte_len_consistency() {
+    // No extensions
+    let config_no_ext = default_config();
+    let size_no_ext = CToken::byte_len(&config_no_ext).unwrap();
+    let mut buffer_no_ext = vec![0u8; size_no_ext];
+    let (_, remaining) = CToken::new_zero_copy(&mut buffer_no_ext, config_no_ext).unwrap();
+    assert_eq!(remaining.len(), 0);
+
+    // With pausable extension
+    let config_with_ext = CompressedTokenConfig {
+        extensions: Some(vec![ExtensionStructConfig::PausableAccount(())]),
+        ..default_config()
     };
+    let size_with_ext = CToken::byte_len(&config_with_ext).unwrap();
+    let mut buffer_with_ext = vec![0u8; size_with_ext];
+    let (_, remaining) = CToken::new_zero_copy(&mut buffer_with_ext, config_with_ext).unwrap();
+    assert_eq!(remaining.len(), 0);
 
-    // Create buffer and initialize
-    let mut buffer = vec![0u8; CToken::byte_len(&config).unwrap()];
-    let (compressed_token, _) = CToken::new_zero_copy(&mut buffer, config)
-        .expect("Failed to initialize compressed token with all options");
-
-    // All optional fields should be Some
-    assert!(compressed_token.delegate.is_some());
-    assert!(compressed_token.is_native.is_some());
-    assert!(compressed_token.close_authority.is_some());
-    // Verify all discriminators are set to 1 (Some)
-    assert_eq!(buffer[72], 1); // delegate discriminator should be 1 (Some)
-    assert_eq!(buffer[109], 1); // is_native discriminator should be 1 (Some)
-    assert_eq!(buffer[129], 1); // close_authority discriminator should be 1 (Some)
+    assert!(size_with_ext > size_no_ext);
 }
diff --git a/program-libs/ctoken-interface/tests/mint_borsh_zero_copy.rs b/program-libs/ctoken-interface/tests/mint_borsh_zero_copy.rs
index d492990f33..02b7a8331f 100644
--- a/program-libs/ctoken-interface/tests/mint_borsh_zero_copy.rs
+++ b/program-libs/ctoken-interface/tests/mint_borsh_zero_copy.rs
@@ -4,9 +4,10 @@
 
 use borsh::{BorshDeserialize, BorshSerialize};
 use light_compressed_account::Pubkey;
+use light_compressible::compression_info::CompressionInfo;
 use light_ctoken_interface::state::{
     extensions::{AdditionalMetadata, ExtensionStruct, TokenMetadata},
-    mint::{BaseMint, CompressedMint, CompressedMintMetadata},
+    mint::{BaseMint, CompressedMint, CompressedMintMetadata, ACCOUNT_TYPE_MINT},
 };
 use light_zero_copy::traits::{ZeroCopyAt, ZeroCopyAtMut};
 use rand::{thread_rng, Rng};
@@ -103,6 +104,9 @@ fn generate_random_mint() -> CompressedMint {
                 Pubkey::from(bytes)
             },
         },
+        reserved: [0u8; 49],
+        account_type: ACCOUNT_TYPE_MINT,
+        compression: CompressionInfo::default(),
         extensions,
     }
 }
@@ -151,17 +155,20 @@ fn compare_mint_borsh_vs_zero_copy(original: &CompressedMint, borsh_bytes: &[u8]
     // Construct a CompressedMint from zero-copy read-only data for comparison
     let zc_reconstructed = CompressedMint {
         base: BaseMint {
-            mint_authority: zc_mint.base.mint_authority.map(|p| *p),
-            freeze_authority: zc_mint.base.freeze_authority.map(|p| *p),
-            supply: (*zc_mint.base.supply).into(),
+            mint_authority: zc_mint.base.mint_authority().copied(),
+            freeze_authority: zc_mint.base.freeze_authority().copied(),
+            supply: u64::from(zc_mint.base.supply),
             decimals: zc_mint.base.decimals,
             is_initialized: zc_mint.base.is_initialized != 0,
         },
         metadata: CompressedMintMetadata {
-            version: zc_mint.metadata.version,
-            cmint_decompressed: zc_mint.metadata.cmint_decompressed != 0,
-            mint: zc_mint.metadata.mint,
+            version: zc_mint.base.metadata.version,
+            cmint_decompressed: zc_mint.base.metadata.cmint_decompressed != 0,
+            mint: zc_mint.base.metadata.mint,
         },
+        reserved: *zc_mint.base.reserved,
+        account_type: zc_mint.base.account_type,
+        compression: CompressionInfo::default(),
         extensions: zc_extensions.clone(),
     };
 
@@ -174,15 +181,18 @@ fn compare_mint_borsh_vs_zero_copy(original: &CompressedMint, borsh_bytes: &[u8]
         base: BaseMint {
             mint_authority: zc_mint_mut.base.mint_authority().copied(),
             freeze_authority: zc_mint_mut.base.freeze_authority().copied(),
-            supply: (*zc_mint_mut.base.supply).into(),
-            decimals: *zc_mint_mut.base.decimals,
-            is_initialized: *zc_mint_mut.base.is_initialized != 0,
+            supply: u64::from(zc_mint_mut.base.supply),
+            decimals: zc_mint_mut.base.decimals,
+            is_initialized: zc_mint_mut.base.is_initialized != 0,
         },
         metadata: CompressedMintMetadata {
-            version: zc_mint_mut.metadata.version,
-            cmint_decompressed: zc_mint_mut.metadata.cmint_decompressed != 0,
-            mint: zc_mint_mut.metadata.mint,
+            version: zc_mint_mut.base.metadata.version,
+            cmint_decompressed: zc_mint_mut.base.metadata.cmint_decompressed != 0,
+            mint: zc_mint_mut.base.metadata.mint,
         },
+        reserved: *zc_mint_mut.base.reserved,
+        account_type: *zc_mint_mut.base.account_type,
+        compression: CompressionInfo::default(),
         extensions: zc_extensions, // Extensions handling for mut is same as read-only
     };
 
@@ -224,3 +234,164 @@ fn test_mint_borsh_zero_copy_compatibility() {
         compare_mint_borsh_vs_zero_copy(&mint, &borsh_bytes);
     }
 }
+
+/// Generate mint with guaranteed TokenMetadata extension
+fn generate_mint_with_extensions() -> CompressedMint {
+    let mut rng = thread_rng();
+    let token_metadata = generate_random_token_metadata(&mut rng);
+
+    CompressedMint {
+        base: BaseMint {
+            mint_authority: Some(Pubkey::from(rng.gen::<[u8; 32]>())),
+            freeze_authority: Some(Pubkey::from(rng.gen::<[u8; 32]>())),
+            supply: rng.gen::<u64>(),
+            decimals: rng.gen_range(0..=18),
+            is_initialized: true,
+        },
+        metadata: CompressedMintMetadata {
+            version: 3,
+            cmint_decompressed: rng.gen_bool(0.5),
+            mint: Pubkey::from(rng.gen::<[u8; 32]>()),
+        },
+        reserved: [0u8; 49],
+        account_type: ACCOUNT_TYPE_MINT,
+        compression: CompressionInfo::default(),
+        extensions: Some(vec![ExtensionStruct::TokenMetadata(token_metadata)]),
+    }
+}
+
+/// Test with guaranteed extensions - ensures extension path is always tested
+#[test]
+fn test_mint_with_extensions_borsh_zero_copy_compatibility() {
+    for _ in 0..500 {
+        let mint = generate_mint_with_extensions();
+        let borsh_bytes = mint.try_to_vec().unwrap();
+        compare_mint_borsh_vs_zero_copy(&mint, &borsh_bytes);
+    }
+}
+
+/// Test extension edge cases
+#[test]
+fn test_mint_extension_edge_cases() {
+    // Test 1: Empty strings in TokenMetadata
+    let mint_empty_strings = CompressedMint {
+        base: BaseMint {
+            mint_authority: Some(Pubkey::from([1u8; 32])),
+            freeze_authority: None,
+            supply: 1_000_000,
+            decimals: 9,
+            is_initialized: true,
+        },
+        metadata: CompressedMintMetadata {
+            version: 3,
+            cmint_decompressed: false,
+            mint: Pubkey::from([2u8; 32]),
+        },
+        reserved: [0u8; 49],
+        account_type: ACCOUNT_TYPE_MINT,
+        compression: CompressionInfo::default(),
+        extensions: Some(vec![ExtensionStruct::TokenMetadata(TokenMetadata {
+            update_authority: Pubkey::from([3u8; 32]),
+            mint: Pubkey::from([2u8; 32]),
+            name: vec![],                // Empty name
+            symbol: vec![],              // Empty symbol
+            uri: vec![],                 // Empty URI
+            additional_metadata: vec![], // No additional metadata
+        })]),
+    };
+    let borsh_bytes = mint_empty_strings.try_to_vec().unwrap();
+    compare_mint_borsh_vs_zero_copy(&mint_empty_strings, &borsh_bytes);
+
+    // Test 2: Maximum reasonable lengths
+    let mint_max_lengths = CompressedMint {
+        base: BaseMint {
+            mint_authority: Some(Pubkey::from([0xffu8; 32])),
+            freeze_authority: Some(Pubkey::from([0xaau8; 32])),
+            supply: u64::MAX,
+            decimals: 18,
+            is_initialized: true,
+        },
+        metadata: CompressedMintMetadata {
+            version: 3,
+            cmint_decompressed: true,
+            mint: Pubkey::from([0xbbu8; 32]),
+        },
+        reserved: [0u8; 49],
+        account_type: ACCOUNT_TYPE_MINT,
+        compression: CompressionInfo::default(),
+        extensions: Some(vec![ExtensionStruct::TokenMetadata(TokenMetadata {
+            update_authority: Pubkey::from([0xccu8; 32]),
+            mint: Pubkey::from([0xbbu8; 32]),
+            name: vec![b'A'; 64],   // Long name
+            symbol: vec![b'S'; 16], // Long symbol
+            uri: vec![b'U'; 256],   // Long URI
+            additional_metadata: vec![
+                AdditionalMetadata {
+                    key: vec![b'K'; 32],
+                    value: vec![b'V'; 128],
+                },
+                AdditionalMetadata {
+                    key: vec![b'X'; 32],
+                    value: vec![b'Y'; 128],
+                },
+                AdditionalMetadata {
+                    key: vec![b'Z'; 32],
+                    value: vec![b'W'; 128],
+                },
+            ],
+        })]),
+    };
+    let borsh_bytes = mint_max_lengths.try_to_vec().unwrap();
+    compare_mint_borsh_vs_zero_copy(&mint_max_lengths, &borsh_bytes);
+
+    // Test 3: Zero update authority (represents None)
+    let mint_zero_authority = CompressedMint {
+        base: BaseMint {
+            mint_authority: None,
+            freeze_authority: None,
+            supply: 0,
+            decimals: 0,
+            is_initialized: true,
+        },
+        metadata: CompressedMintMetadata {
+            version: 3,
+            cmint_decompressed: false,
+            mint: Pubkey::from([4u8; 32]),
+        },
+        reserved: [0u8; 49],
+        account_type: ACCOUNT_TYPE_MINT,
+        compression: CompressionInfo::default(),
+        extensions: Some(vec![ExtensionStruct::TokenMetadata(TokenMetadata {
+            update_authority: Pubkey::from([0u8; 32]), // Zero = None
+            mint: Pubkey::from([4u8; 32]),
+            name: b"Test Token".to_vec(),
+            symbol: b"TEST".to_vec(),
+            uri: b"https://example.com/token.json".to_vec(),
+            additional_metadata: vec![],
+        })]),
+    };
+    let borsh_bytes = mint_zero_authority.try_to_vec().unwrap();
+    compare_mint_borsh_vs_zero_copy(&mint_zero_authority, &borsh_bytes);
+
+    // Test 4: No extensions (explicit None)
+    let mint_no_extensions = CompressedMint {
+        base: BaseMint {
+            mint_authority: Some(Pubkey::from([5u8; 32])),
+            freeze_authority: Some(Pubkey::from([6u8; 32])),
+            supply: 500_000,
+            decimals: 6,
+            is_initialized: true,
+        },
+        metadata: CompressedMintMetadata {
+            version: 3,
+            cmint_decompressed: true,
+            mint: Pubkey::from([7u8; 32]),
+        },
+        reserved: [0u8; 49],
+        account_type: ACCOUNT_TYPE_MINT,
+        compression: CompressionInfo::default(),
+        extensions: None,
+    };
+    let borsh_bytes = mint_no_extensions.try_to_vec().unwrap();
+    compare_mint_borsh_vs_zero_copy(&mint_no_extensions, &borsh_bytes);
+}
diff --git a/program-libs/ctoken-interface/tests/pool_derivation.rs b/program-libs/ctoken-interface/tests/pool_derivation.rs
new file mode 100644
index 0000000000..7a5efef6c2
--- /dev/null
+++ b/program-libs/ctoken-interface/tests/pool_derivation.rs
@@ -0,0 +1,128 @@
+use light_ctoken_interface::{
+    find_spl_interface_pda, find_spl_interface_pda_with_index, is_valid_spl_interface_pda,
+    NUM_MAX_POOL_ACCOUNTS,
+};
+use solana_pubkey::Pubkey;
+
+#[test]
+fn test_spl_interface_derivation_index_0() {
+    let mint = Pubkey::new_unique();
+
+    let (pda, bump) = find_spl_interface_pda(&mint, false);
+
+    // Verify with bump
+    assert!(is_valid_spl_interface_pda(
+        mint.as_ref(),
+        &pda,
+        0,
+        Some(bump),
+        false
+    ));
+
+    // Verify without bump
+    assert!(is_valid_spl_interface_pda(
+        mint.as_ref(),
+        &pda,
+        0,
+        None,
+        false
+    ));
+
+    // Verify restricted derivation doesn't match
+    assert!(!is_valid_spl_interface_pda(
+        mint.as_ref(),
+        &pda,
+        0,
+        None,
+        true
+    ));
+}
+
+#[test]
+fn test_restricted_spl_interface_derivation_index_0() {
+    let mint = Pubkey::new_unique();
+
+    let (pda, bump) = find_spl_interface_pda(&mint, true);
+
+    // Verify with bump
+    assert!(is_valid_spl_interface_pda(
+        mint.as_ref(),
+        &pda,
+        0,
+        Some(bump),
+        true
+    ));
+
+    // Verify without bump
+    assert!(is_valid_spl_interface_pda(
+        mint.as_ref(),
+        &pda,
+        0,
+        None,
+        true
+    ));
+
+    // Verify non-restricted derivation doesn't match
+    assert!(!is_valid_spl_interface_pda(
+        mint.as_ref(),
+        &pda,
+        0,
+        None,
+        false
+    ));
+}
+
+#[test]
+fn test_spl_interface_derivation_with_index() {
+    let mint = Pubkey::new_unique();
+
+    for index in 1..NUM_MAX_POOL_ACCOUNTS {
+        let (pda, bump) = find_spl_interface_pda_with_index(&mint, index, false);
+
+        assert!(is_valid_spl_interface_pda(
+            mint.as_ref(),
+            &pda,
+            index,
+            Some(bump),
+            false
+        ));
+    }
+}
+
+#[test]
+fn test_restricted_spl_interface_derivation_with_index() {
+    let mint = Pubkey::new_unique();
+
+    for index in 1..NUM_MAX_POOL_ACCOUNTS {
+        let (pda, bump) = find_spl_interface_pda_with_index(&mint, index, true);
+
+        assert!(is_valid_spl_interface_pda(
+            mint.as_ref(),
+            &pda,
+            index,
+            Some(bump),
+            true
+        ));
+    }
+}
+
+#[test]
+fn test_different_mints_different_pdas() {
+    let mint1 = Pubkey::new_unique();
+    let mint2 = Pubkey::new_unique();
+
+    let (pda1, _) = find_spl_interface_pda(&mint1, false);
+    let (pda2, _) = find_spl_interface_pda(&mint2, false);
+
+    assert_ne!(pda1, pda2);
+}
+
+#[test]
+fn test_restricted_vs_non_restricted_different_pdas() {
+    let mint = Pubkey::new_unique();
+
+    let (regular_pda, _) = find_spl_interface_pda(&mint, false);
+    let (restricted_pda, _) = find_spl_interface_pda(&mint, true);
+
+    assert_ne!(regular_pda, restricted_pda);
+}
diff --git a/program-tests/compressed-token-test/Cargo.toml b/program-tests/compressed-token-test/Cargo.toml
index a0ea05f3ec..c4e9a3507c 100644
--- a/program-tests/compressed-token-test/Cargo.toml
+++ b/program-tests/compressed-token-test/Cargo.toml
@@ -50,4 +50,4 @@ light-ctoken-sdk = { workspace = true }
 spl-token-2022 = { workspace = true }
 spl-pod = { workspace = true }
 light-zero-copy = { workspace = true , features = ["std", "derive", "mut"]}
-light-ctoken-types = { workspace = true }
+borsh = { workspace = true }
diff --git a/program-tests/compressed-token-test/tests/compress_only.rs b/program-tests/compressed-token-test/tests/compress_only.rs
new file mode 100644
index 0000000000..af046e6bc9
--- /dev/null
+++ b/program-tests/compressed-token-test/tests/compress_only.rs
@@ -0,0 +1,112 @@
+//! Integration tests for compress_only extension behavior.
+//!
+//! Tests for compression and decompression of CToken accounts with Token-2022 extensions.
+//! These tests verify the compress_only mode behavior for restricted extensions.
+//!
+//! ## Test Coverage (see .claude/test-coverage/transfer2-compress-and-close-tests.md)
+//!
+//! ### Compress restricted mints
+//! - #4, #5: Cannot compress to compressed token account (covered in ctoken/extensions.rs)
+//!
+//! ### CompressAndClose
+//! - #6: Frozen account can be compressed and closed (frozen.rs)
+//! - #7: Delegated account can be compressed and closed (delegated.rs)
+//! - #8: Paused mint can be compressed and closed (pausable.rs)
+//! - #9: Non-zero transfer fee mint can be compressed and closed (transfer_fee.rs)
+//! - #10: Non-nil transfer hook mint can be compressed and closed (transfer_hook.rs)
+//! - #11: CompressedOnly extension required for restricted mints (restricted_required.rs)
+//! - #12: Orphan delegate preserved (orphan_delegate.rs)
+//!
+//! ### Decompress
+//! - #13: Can only decompress to ctoken (decompress_restrictions.rs)
+//! - #14: Must decompress complete account (decompress_restrictions.rs)
+//! - #15: Restores frozen state (frozen.rs)
+//! - #16: Restores delegate and delegated_amount (delegated.rs)
+//! - #17: Restores orphan delegate (orphan_delegate.rs)
+//! - #18: Owner can decompress (all.rs)
+//! - #19: Delegate can decompress (delegated.rs)
+//! - #20: Permanent delegate can decompress (permanent_delegate.rs)
+//! - #21-23: Decompress succeeds with paused/fee/hook extensions (pausable.rs, transfer_fee.rs, transfer_hook.rs)
+//!
+//! ### Round-trip
+//! - #24: Full round-trip frozen (frozen.rs)
+//! - #25: Full round-trip delegated (delegated.rs)
+//! - #26: Full round-trip orphan delegate (orphan_delegate.rs)
+//! - #27: Full round-trip withheld_transfer_fee (withheld_fee.rs)
+//! - #28: close_authority - NOT SUPPORTED (not in CompressedOnlyExtensionInstructionData)
+//!
+//! ### Negative tests
+//! - #29-32: Mismatch validation - NOT TESTABLE (registry always builds correct out_tlv)
+//! - #33: Decompress fails to non-fresh destination (invalid_destination.rs)
+
+#[path = "compress_only/mod.rs"]
+mod shared;
+
+// 1. create mint with all restricted extensions
+//    - compress and close
+//    - decompress
+#[path = "compress_only/all.rs"]
+mod all;
+
+// 1. create mint with default state set to initialized
+//    - compress and close
+//    - decompress
+// 2. create mint with default state set to frozen
+//    - compress and close
+//    - decompress
+#[path = "compress_only/default_state.rs"]
+mod default_state;
+
+// Permanent delegate must be able to decompress
+#[path = "compress_only/permanent_delegate.rs"]
+mod permanent_delegate;
+
+//
+#[path = "compress_only/frozen.rs"]
+mod frozen;
+
+// Delegate must be able to decompress
+// Delegated value must be the same pre compress and close
+#[path = "compress_only/delegated.rs"]
+mod delegated;
+
+// Per-extension tests (single extension only)
+#[path = "compress_only/transfer_fee.rs"]
+mod transfer_fee;
+
+// Withheld transfer fee preservation through compress/decompress
+#[path = "compress_only/withheld_fee.rs"]
+mod withheld_fee;
+
+#[path = "compress_only/transfer_hook.rs"]
+mod transfer_hook;
+
+#[path = "compress_only/pausable.rs"]
+mod pausable;
+
+// Failing tests for compression_only requirement
+#[path = "compress_only/restricted_required.rs"]
+mod restricted_required;
+
+// Failing tests for invalid decompress destination
+#[path = "compress_only/invalid_destination.rs"]
+mod invalid_destination;
+
+// Failing tests for invalid extension state (non-zero fees, non-nil hook)
+#[path = "compress_only/invalid_extension_state.rs"]
+mod invalid_extension_state;
+
+// Failing tests for CompressedOnly decompress restrictions
+// - Cannot decompress to SPL Token-2022 account (must use CToken)
+// - Cannot do partial decompress (would create change output)
+#[path = "compress_only/decompress_restrictions.rs"]
+mod decompress_restrictions;
+
+// Failing tests:
+// 1. cannot decompress to invalid account (try all variants of checked values in validate_decompression_destination)
+// 2. cannot compress with restricted extension(s) (try all restricted extensions alone and all combinations)
+// 3. extensions in invalid state (transfer hook not nil, transfer fee not zero, etc.)
+//
+// Functional tests:
+// 1. can compress and close -> decompress (all extensions, restricted alone, restricted combinations, no extensions, frozen, delegated)
+// 2. randomized (any state (delegated, frozen, token balance 0, token balance > 0), any extension combinations)
diff --git a/program-tests/compressed-token-test/tests/compress_only/all.rs b/program-tests/compressed-token-test/tests/compress_only/all.rs
new file mode 100644
index 0000000000..939f3fe1e3
--- /dev/null
+++ b/program-tests/compressed-token-test/tests/compress_only/all.rs
@@ -0,0 +1,315 @@
+//! Tests for compress and close with all Token-2022 extensions.
+//!
+//! This module tests the full compress -> decompress cycle with all extensions enabled.
+
+use borsh::BorshDeserialize;
+use light_ctoken_interface::state::{
+    AccountState, CToken, ExtensionStruct, PausableAccountExtension,
+    PermanentDelegateAccountExtension, TransferFeeAccountExtension, TransferHookAccountExtension,
+    ACCOUNT_TYPE_TOKEN_ACCOUNT,
+};
+use light_program_test::program_test::TestRpc;
+use serial_test::serial;
+use solana_sdk::{signature::Keypair, signer::Signer};
+
+use super::shared::{setup_extensions_test, Rpc, ALL_EXTENSIONS};
+
+/// Test that forester can compress and close a CToken account with Token-2022 extensions
+/// after prepaid epochs expire, and then decompress it back to a CToken account.
+#[tokio::test]
+#[serial]
+async fn test_compress_and_close_ctoken_with_extensions() {
+    #[allow(unused_imports)]
+    use light_client::indexer::CompressedTokenAccount;
+    use light_client::indexer::Indexer;
+    use light_ctoken_interface::{
+        instructions::extensions::{
+            CompressedOnlyExtensionInstructionData, ExtensionInstructionData,
+        },
+        state::TokenDataVersion,
+    };
+    use light_ctoken_sdk::{
+        ctoken::{CompressibleParams, CreateCTokenAccount, TransferSplToCtoken},
+        spl_interface::find_spl_interface_pda_with_index,
+    };
+    use light_test_utils::mint_2022::{create_token_22_account, mint_spl_tokens_22};
+    use light_token_client::instructions::transfer2::{
+        create_generic_transfer2_instruction, DecompressInput, Transfer2InstructionType,
+    };
+
+    let mut context = setup_extensions_test(ALL_EXTENSIONS).await.unwrap();
+    let payer = context.payer.insecure_clone();
+    let mint_pubkey = context.mint_pubkey;
+
+    // 1. Create SPL Token-2022 account and mint tokens
+    let spl_account =
+        create_token_22_account(&mut context.rpc, &payer, &mint_pubkey, &payer.pubkey()).await;
+    let mint_amount = 1_000_000_000u64;
+    mint_spl_tokens_22(
+        &mut context.rpc,
+        &payer,
+        &mint_pubkey,
+        &spl_account,
+        mint_amount,
+    )
+    .await;
+
+    // 2. Create CToken account with 0 prepaid epochs (immediately compressible)
+    let owner = Keypair::new();
+    let account_keypair = Keypair::new();
+    let ctoken_account = account_keypair.pubkey();
+
+    let create_ix =
+        CreateCTokenAccount::new(payer.pubkey(), ctoken_account, mint_pubkey, owner.pubkey())
+            .with_compressible(CompressibleParams {
+                compressible_config: context
+                    .rpc
+                    .test_accounts
+                    .funding_pool_config
+                    .compressible_config_pda,
+                rent_sponsor: context
+                    .rpc
+                    .test_accounts
+                    .funding_pool_config
+                    .rent_sponsor_pda,
+                pre_pay_num_epochs: 0, // Immediately compressible after 1 epoch
+                lamports_per_write: Some(100),
+                compress_to_account_pubkey: None,
+                token_account_version: TokenDataVersion::ShaFlat,
+                compression_only: true,
+            })
+            .instruction()
+            .unwrap();
+
+    context
+        .rpc
+        .create_and_send_transaction(&[create_ix], &payer.pubkey(), &[&payer, &account_keypair])
+        .await
+        .unwrap();
+
+    // 3. Transfer tokens to CToken using hot path (required for mints with restricted extensions)
+    let (spl_interface_pda, spl_interface_pda_bump) =
+        find_spl_interface_pda_with_index(&mint_pubkey, 0, true);
+    let transfer_ix = TransferSplToCtoken {
+        amount: mint_amount,
+        spl_interface_pda_bump,
+        decimals: 9,
+        source_spl_token_account: spl_account,
+        destination_ctoken_account: ctoken_account,
+        authority: payer.pubkey(),
+        mint: mint_pubkey,
+        payer: payer.pubkey(),
+        spl_interface_pda,
+        spl_token_program: spl_token_2022::ID,
+    }
+    .instruction()
+    .unwrap();
+
+    context
+        .rpc
+        .create_and_send_transaction(&[transfer_ix], &payer.pubkey(), &[&payer])
+        .await
+        .unwrap();
+
+    // Verify tokens are in the CToken account
+    let account_before = context
+        .rpc
+        .get_account(ctoken_account)
+        .await
+        .unwrap()
+        .unwrap();
+    assert!(
+        account_before.lamports > 0,
+        "Account should exist before compression"
+    );
+
+    // 4. Advance 2 epochs to trigger forester compression
+    // Account created with 0 prepaid epochs needs time to become compressible
+    context.rpc.warp_epoch_forward(30).await.unwrap();
+
+    // 5. Assert the account has been compressed (closed) and compressed token account exists
+    let account_after = context.rpc.get_account(ctoken_account).await.unwrap();
+    assert!(
+        account_after.is_none() || account_after.unwrap().lamports == 0,
+        "CToken account should be closed"
+    );
+
+    let compressed_accounts = context
+        .rpc
+        .get_compressed_token_accounts_by_owner(&owner.pubkey(), None, None)
+        .await
+        .unwrap()
+        .value
+        .items;
+
+    assert_eq!(
+        compressed_accounts.len(),
+        1,
+        "Should have exactly 1 compressed token account"
+    );
+
+    // Build expected TokenData with CompressedOnly extension
+    // The CToken had marker extensions (PausableAccount, PermanentDelegateAccount),
+    // so the compressed token should have CompressedOnly TLV extension
+    use light_ctoken_interface::state::{
+        CompressedOnlyExtension, CompressedTokenAccountState, TokenData,
+    };
+
+    let expected_token_data = TokenData {
+        mint: mint_pubkey.into(),
+        owner: owner.pubkey().into(),
+        amount: mint_amount,
+        delegate: None,
+        state: CompressedTokenAccountState::Initialized as u8,
+        tlv: Some(vec![ExtensionStruct::CompressedOnly(
+            CompressedOnlyExtension {
+                delegated_amount: 0,
+                withheld_transfer_fee: 0,
+            },
+        )]),
+    };
+
+    assert_eq!(
+        compressed_accounts[0].token,
+        expected_token_data.into(),
+        "Compressed token account should match expected TokenData"
+    );
+
+    // 6. Create a new CToken account for decompress destination
+    let decompress_dest_keypair = Keypair::new();
+    let decompress_dest_account = decompress_dest_keypair.pubkey();
+
+    let create_dest_ix = CreateCTokenAccount::new(
+        payer.pubkey(),
+        decompress_dest_account,
+        mint_pubkey,
+        owner.pubkey(),
+    )
+    .with_compressible(CompressibleParams {
+        compressible_config: context
+            .rpc
+            .test_accounts
+            .funding_pool_config
+            .compressible_config_pda,
+        rent_sponsor: context
+            .rpc
+            .test_accounts
+            .funding_pool_config
+            .rent_sponsor_pda,
+        pre_pay_num_epochs: 2, // More epochs so account won't be compressed again
+        lamports_per_write: Some(100),
+        compress_to_account_pubkey: None,
+        token_account_version: TokenDataVersion::ShaFlat,
+        compression_only: true,
+    })
+    .instruction()
+    .unwrap();
+
+    context
+        .rpc
+        .create_and_send_transaction(
+            &[create_dest_ix],
+            &payer.pubkey(),
+            &[&payer, &decompress_dest_keypair],
+        )
+        .await
+        .unwrap();
+
+    println!(
+        "Created decompress destination CToken account: {}",
+        decompress_dest_account
+    );
+
+    // 7. Decompress the compressed account back to the new CToken account
+    // Need to include in_tlv for the CompressedOnly extension
+    let in_tlv = vec![vec![ExtensionInstructionData::CompressedOnly(
+        CompressedOnlyExtensionInstructionData {
+            delegated_amount: 0,
+            withheld_transfer_fee: 0,
+            is_frozen: false,
+            compression_index: 0,
+        },
+    )]];
+
+    let decompress_ix = create_generic_transfer2_instruction(
+        &mut context.rpc,
+        vec![Transfer2InstructionType::Decompress(DecompressInput {
+            compressed_token_account: vec![compressed_accounts[0].clone()],
+            decompress_amount: mint_amount,
+            solana_token_account: decompress_dest_account,
+            amount: mint_amount,
+            pool_index: None,
+            decimals: 9,
+            in_tlv: Some(in_tlv),
+        })],
+        payer.pubkey(),
+        true,
+    )
+    .await
+    .unwrap();
+
+    context
+        .rpc
+        .create_and_send_transaction(&[decompress_ix], &payer.pubkey(), &[&payer, &owner])
+        .await
+        .unwrap();
+
+    // 8. Verify the CToken account has the tokens and proper extension state
+
+    let dest_account_data = context
+        .rpc
+        .get_account(decompress_dest_account)
+        .await
+        .unwrap()
+        .unwrap();
+
+    let dest_ctoken = CToken::deserialize(&mut &dest_account_data.data[..])
+        .expect("Failed to deserialize destination CToken account");
+
+    // Build expected CToken account
+    // compression is now a direct field on CToken
+    let expected_dest_ctoken = CToken {
+        mint: mint_pubkey.to_bytes().into(),
+        owner: owner.pubkey().to_bytes().into(),
+        amount: mint_amount,
+        delegate: None,
+        state: AccountState::Initialized,
+        is_native: None,
+        delegated_amount: 0,
+        close_authority: None,
+        account_type: ACCOUNT_TYPE_TOKEN_ACCOUNT,
+        decimals: dest_ctoken.decimals,
+        compression_only: dest_ctoken.compression_only,
+        compression: dest_ctoken.compression,
+        extensions: Some(vec![
+            ExtensionStruct::PausableAccount(PausableAccountExtension),
+            ExtensionStruct::PermanentDelegateAccount(PermanentDelegateAccountExtension),
+            ExtensionStruct::TransferFeeAccount(TransferFeeAccountExtension { withheld_amount: 0 }),
+            ExtensionStruct::TransferHookAccount(TransferHookAccountExtension { transferring: 0 }),
+        ]),
+    };
+
+    assert_eq!(
+        dest_ctoken, expected_dest_ctoken,
+        "Decompressed CToken account should match expected with all extensions"
+    );
+
+    // Verify no more compressed accounts for this owner
+    let remaining_compressed = context
+        .rpc
+        .get_compressed_token_accounts_by_owner(&owner.pubkey(), None, None)
+        .await
+        .unwrap()
+        .value
+        .items;
+
+    assert_eq!(
+        remaining_compressed.len(),
+        0,
+        "Should have no more compressed token accounts after full decompress"
+    );
+
+    println!(
+        "Successfully completed compress-and-close -> decompress cycle with extension state transfer"
+    );
+}
diff --git a/program-tests/compressed-token-test/tests/compress_only/decompress_restrictions.rs b/program-tests/compressed-token-test/tests/compress_only/decompress_restrictions.rs
new file mode 100644
index 0000000000..00ff0234a5
--- /dev/null
+++ b/program-tests/compressed-token-test/tests/compress_only/decompress_restrictions.rs
@@ -0,0 +1,268 @@
+//! Tests for CompressedOnly decompress restrictions.
+//!
+//! This module tests:
+//! - Spec #13: CompressedOnly inputs can only decompress to CToken, not SPL
+//! - Spec #14: CompressedOnly inputs must decompress complete account (no change output)
+
+use light_client::indexer::Indexer;
+use light_ctoken_interface::{
+    instructions::extensions::{CompressedOnlyExtensionInstructionData, ExtensionInstructionData},
+    state::TokenDataVersion,
+};
+use light_ctoken_sdk::{
+    ctoken::{CompressibleParams, CreateCTokenAccount, TransferSplToCtoken},
+    spl_interface::find_spl_interface_pda_with_index,
+};
+use light_program_test::{
+    program_test::{LightProgramTest, TestRpc},
+    utils::assert::assert_rpc_error,
+    ProgramTestConfig, Rpc,
+};
+use light_test_utils::mint_2022::{
+    create_mint_22_with_extension_types, create_token_22_account, mint_spl_tokens_22,
+    RESTRICTED_EXTENSIONS,
+};
+use light_token_client::instructions::transfer2::{
+    create_generic_transfer2_instruction, DecompressInput, Transfer2InstructionType,
+};
+use serial_test::serial;
+use solana_sdk::{pubkey::Pubkey, signature::Keypair, signer::Signer};
+use spl_token_2022::extension::ExtensionType;
+
+/// Expected error code for CompressedOnlyRequiresCTokenDecompress
+const COMPRESSED_ONLY_REQUIRES_CTOKEN_DECOMPRESS: u32 = 6149;
+
+/// Expected error code for CompressedOnlyBlocksTransfer
+const COMPRESSED_ONLY_BLOCKS_TRANSFER: u32 = 18048;
+
+/// Helper to set up a compressed token with CompressedOnly extension for decompress testing
+async fn setup_compressed_token_for_decompress(
+    extensions: &[ExtensionType],
+) -> (
+    LightProgramTest,
+    Keypair,                                       // payer
+    Pubkey,                                        // mint
+    Keypair,                                       // owner
+    light_client::indexer::CompressedTokenAccount, // compressed account
+    u64,                                           // amount
+) {
+    let mut rpc = LightProgramTest::new(ProgramTestConfig::new_v2(false, None))
+        .await
+        .unwrap();
+    let payer = rpc.get_payer().insecure_clone();
+
+    // Create mint with extensions
+    let (mint_keypair, _) =
+        create_mint_22_with_extension_types(&mut rpc, &payer, 9, extensions).await;
+    let mint_pubkey = mint_keypair.pubkey();
+
+    // Create SPL Token-2022 account and mint tokens
+    let spl_account =
+        create_token_22_account(&mut rpc, &payer, &mint_pubkey, &payer.pubkey()).await;
+    let mint_amount = 1_000_000_000u64;
+    mint_spl_tokens_22(&mut rpc, &payer, &mint_pubkey, &spl_account, mint_amount).await;
+
+    // Create CToken account with compression_only=true
+    let owner = Keypair::new();
+    let account_keypair = Keypair::new();
+    let ctoken_account = account_keypair.pubkey();
+
+    let create_ix =
+        CreateCTokenAccount::new(payer.pubkey(), ctoken_account, mint_pubkey, owner.pubkey())
+            .with_compressible(CompressibleParams {
+                compressible_config: rpc
+                    .test_accounts
+                    .funding_pool_config
+                    .compressible_config_pda,
+                rent_sponsor: rpc.test_accounts.funding_pool_config.rent_sponsor_pda,
+                pre_pay_num_epochs: 0,
+                lamports_per_write: Some(100),
+                compress_to_account_pubkey: None,
+                token_account_version: TokenDataVersion::ShaFlat,
+                compression_only: true,
+            })
+            .instruction()
+            .unwrap();
+
+    rpc.create_and_send_transaction(&[create_ix], &payer.pubkey(), &[&payer, &account_keypair])
+        .await
+        .unwrap();
+
+    // Transfer tokens to CToken
+    let has_restricted = extensions
+        .iter()
+        .any(|ext| RESTRICTED_EXTENSIONS.contains(ext));
+    let (spl_interface_pda, spl_interface_pda_bump) =
+        find_spl_interface_pda_with_index(&mint_pubkey, 0, has_restricted);
+    let transfer_ix = TransferSplToCtoken {
+        amount: mint_amount,
+        spl_interface_pda_bump,
+        decimals: 9,
+        source_spl_token_account: spl_account,
+        destination_ctoken_account: ctoken_account,
+        authority: payer.pubkey(),
+        mint: mint_pubkey,
+        payer: payer.pubkey(),
+        spl_interface_pda,
+        spl_token_program: spl_token_2022::ID,
+    }
+    .instruction()
+    .unwrap();
+
+    rpc.create_and_send_transaction(&[transfer_ix], &payer.pubkey(), &[&payer])
+        .await
+        .unwrap();
+
+    // Warp epoch to trigger forester compression
+    rpc.warp_epoch_forward(30).await.unwrap();
+
+    // Get compressed token accounts
+    let compressed_accounts = rpc
+        .get_compressed_token_accounts_by_owner(&owner.pubkey(), None, None)
+        .await
+        .unwrap()
+        .value
+        .items;
+
+    assert_eq!(
+        compressed_accounts.len(),
+        1,
+        "Should have 1 compressed account"
+    );
+
+    (
+        rpc,
+        payer,
+        mint_pubkey,
+        owner,
+        compressed_accounts[0].clone(),
+        mint_amount,
+    )
+}
+
+/// Test that CompressedOnly accounts cannot decompress to SPL Token-2022 accounts.
+///
+/// Covers spec requirement #13: Can only decompress to CToken, not SPL account
+#[tokio::test]
+#[serial]
+async fn test_decompress_compressed_only_rejects_spl_destination() {
+    // Set up compressed token with CompressedOnly extension
+    let (mut rpc, payer, mint_pubkey, owner, compressed_account, amount) =
+        setup_compressed_token_for_decompress(&[ExtensionType::Pausable]).await;
+
+    // Create SPL Token-2022 account (NOT CToken) as destination
+    let spl_destination =
+        create_token_22_account(&mut rpc, &payer, &mint_pubkey, &owner.pubkey()).await;
+
+    // Attempt to decompress to SPL account with CompressedOnly in_tlv
+    let in_tlv = vec![vec![ExtensionInstructionData::CompressedOnly(
+        CompressedOnlyExtensionInstructionData {
+            delegated_amount: 0,
+            withheld_transfer_fee: 0,
+            is_frozen: false,
+            compression_index: 0,
+        },
+    )]];
+
+    let decompress_ix = create_generic_transfer2_instruction(
+        &mut rpc,
+        vec![Transfer2InstructionType::Decompress(DecompressInput {
+            compressed_token_account: vec![compressed_account],
+            decompress_amount: amount,
+            solana_token_account: spl_destination,
+            amount,
+            pool_index: None,
+            decimals: 9,
+            in_tlv: Some(in_tlv),
+        })],
+        payer.pubkey(),
+        true,
+    )
+    .await
+    .unwrap();
+
+    let result = rpc
+        .create_and_send_transaction(&[decompress_ix], &payer.pubkey(), &[&payer, &owner])
+        .await;
+
+    // Should fail because CompressedOnly inputs must decompress to CToken, not SPL
+    assert_rpc_error(result, 0, COMPRESSED_ONLY_REQUIRES_CTOKEN_DECOMPRESS).unwrap();
+}
+
+/// Test that CompressedOnly accounts cannot do partial decompress (would create change output).
+///
+/// Covers spec requirement #14: Must decompress complete account (no change output)
+#[tokio::test]
+#[serial]
+async fn test_decompress_compressed_only_rejects_partial_decompress() {
+    // Set up compressed token with CompressedOnly extension
+    let (mut rpc, payer, mint_pubkey, owner, compressed_account, amount) =
+        setup_compressed_token_for_decompress(&[ExtensionType::Pausable]).await;
+
+    // Create destination CToken account
+    let dest_keypair = Keypair::new();
+    let destination_pubkey = dest_keypair.pubkey();
+
+    let create_dest_ix = CreateCTokenAccount::new(
+        payer.pubkey(),
+        destination_pubkey,
+        mint_pubkey,
+        owner.pubkey(),
+    )
+    .with_compressible(CompressibleParams {
+        compressible_config: rpc
+            .test_accounts
+            .funding_pool_config
+            .compressible_config_pda,
+        rent_sponsor: rpc.test_accounts.funding_pool_config.rent_sponsor_pda,
+        pre_pay_num_epochs: 2,
+        lamports_per_write: Some(100),
+        compress_to_account_pubkey: None,
+        token_account_version: TokenDataVersion::ShaFlat,
+        compression_only: true,
+    })
+    .instruction()
+    .unwrap();
+
+    rpc.create_and_send_transaction(&[create_dest_ix], &payer.pubkey(), &[&payer, &dest_keypair])
+        .await
+        .unwrap();
+
+    // Attempt partial decompress (half the amount)
+    // This would create a change output with the remaining tokens
+    let partial_amount = amount / 2;
+
+    let in_tlv = vec![vec![ExtensionInstructionData::CompressedOnly(
+        CompressedOnlyExtensionInstructionData {
+            delegated_amount: 0,
+            withheld_transfer_fee: 0,
+            is_frozen: false,
+            compression_index: 0,
+        },
+    )]];
+
+    let decompress_ix = create_generic_transfer2_instruction(
+        &mut rpc,
+        vec![Transfer2InstructionType::Decompress(DecompressInput {
+            compressed_token_account: vec![compressed_account],
+            decompress_amount: partial_amount, // Only decompress half
+            solana_token_account: destination_pubkey,
+            amount, // Full input amount
+            pool_index: None,
+            decimals: 9,
+            in_tlv: Some(in_tlv),
+        })],
+        payer.pubkey(),
+        true,
+    )
+    .await
+    .unwrap();
+
+    let result = rpc
+        .create_and_send_transaction(&[decompress_ix], &payer.pubkey(), &[&payer, &owner])
+        .await;
+
+    // Should fail because partial decompress would create a change output (compressed output)
+    // and CompressedOnly inputs cannot have compressed outputs
+    assert_rpc_error(result, 0, COMPRESSED_ONLY_BLOCKS_TRANSFER).unwrap();
+}
diff --git a/program-tests/compressed-token-test/tests/compress_only/default_state.rs b/program-tests/compressed-token-test/tests/compress_only/default_state.rs
new file mode 100644
index 0000000000..97bf9bc349
--- /dev/null
+++ b/program-tests/compressed-token-test/tests/compress_only/default_state.rs
@@ -0,0 +1,199 @@
+//! Tests for DefaultAccountState extension behavior.
+//!
+//! This module tests the compress_only behavior with mints that have
+//! the DefaultAccountState extension set to either Initialized or Frozen.
+
+use borsh::BorshDeserialize;
+use light_ctoken_interface::state::{
+    AccountState, CToken, ExtensionStruct, PausableAccountExtension,
+    PermanentDelegateAccountExtension, ACCOUNT_TYPE_TOKEN_ACCOUNT,
+};
+use light_program_test::{LightProgramTest, ProgramTestConfig};
+use light_test_utils::{
+    mint_2022::{create_mint_22_with_extension_types, create_mint_22_with_frozen_default_state},
+    Rpc,
+};
+use serial_test::serial;
+use solana_sdk::{signature::Keypair, signer::Signer};
+use spl_token_2022::extension::ExtensionType;
+
+/// Test creating a CToken account for a mint with DefaultAccountState set to Frozen.
+/// Verifies that the account is created with state = Frozen (2) at offset 108.
+#[tokio::test]
+#[serial]
+async fn test_create_ctoken_with_frozen_default_state() {
+    use light_ctoken_interface::state::TokenDataVersion;
+    use light_ctoken_sdk::ctoken::{CompressibleParams, CreateCTokenAccount};
+
+    let mut rpc = LightProgramTest::new(ProgramTestConfig::new_v2(false, None))
+        .await
+        .unwrap();
+    let payer = rpc.get_payer().insecure_clone();
+
+    // Create mint with DefaultAccountState = Frozen
+    let (mint_keypair, extension_config) =
+        create_mint_22_with_frozen_default_state(&mut rpc, &payer, 9).await;
+    let mint_pubkey = mint_keypair.pubkey();
+
+    assert!(
+        extension_config.default_account_state_frozen,
+        "Mint should have default_account_state_frozen = true"
+    );
+
+    // Create a compressible CToken account for the frozen mint
+    let account_keypair = Keypair::new();
+    let account_pubkey = account_keypair.pubkey();
+
+    let create_ix =
+        CreateCTokenAccount::new(payer.pubkey(), account_pubkey, mint_pubkey, payer.pubkey())
+            .with_compressible(CompressibleParams {
+                compressible_config: rpc
+                    .test_accounts
+                    .funding_pool_config
+                    .compressible_config_pda,
+                rent_sponsor: rpc.test_accounts.funding_pool_config.rent_sponsor_pda,
+                pre_pay_num_epochs: 2,
+                lamports_per_write: Some(100),
+                compress_to_account_pubkey: None,
+                token_account_version: TokenDataVersion::ShaFlat,
+                compression_only: true,
+            })
+            .instruction()
+            .unwrap();
+
+    rpc.create_and_send_transaction(&[create_ix], &payer.pubkey(), &[&payer, &account_keypair])
+        .await
+        .unwrap();
+
+    // Verify account was created with correct size (264 bytes = 166 base + 7 metadata + 88 compressible + 2 markers)
+    let account = rpc.get_account(account_pubkey).await.unwrap().unwrap();
+    assert_eq!(
+        account.data.len(),
+        264,
+        "CToken account should be 264 bytes"
+    );
+
+    // Deserialize the CToken account using borsh
+    let ctoken =
+        CToken::deserialize(&mut &account.data[..]).expect("Failed to deserialize CToken account");
+
+    // Build expected CToken account for comparison
+    // compression is now a direct field on CToken
+    let expected_ctoken = CToken {
+        mint: mint_pubkey.to_bytes().into(),
+        owner: payer.pubkey().to_bytes().into(),
+        amount: 0,
+        delegate: None,
+        state: AccountState::Frozen,
+        is_native: None,
+        delegated_amount: 0,
+        close_authority: None,
+        account_type: ACCOUNT_TYPE_TOKEN_ACCOUNT,
+        decimals: ctoken.decimals,
+        compression_only: ctoken.compression_only,
+        compression: ctoken.compression,
+        extensions: Some(vec![
+            ExtensionStruct::PausableAccount(PausableAccountExtension),
+            ExtensionStruct::PermanentDelegateAccount(PermanentDelegateAccountExtension),
+        ]),
+    };
+
+    assert_eq!(
+        ctoken, expected_ctoken,
+        "CToken account should match expected"
+    );
+
+    println!(
+        "Successfully created frozen CToken account: state={:?}, extensions={}",
+        ctoken.state,
+        ctoken.extensions.as_ref().map(|e| e.len()).unwrap_or(0)
+    );
+}
+
+/// Test creating a CToken account for a mint with DefaultAccountState set to Initialized.
+/// Verifies that the account is created with state = Initialized (1).
+#[tokio::test]
+#[serial]
+async fn test_create_ctoken_with_initialized_default_state() {
+    use light_ctoken_interface::state::TokenDataVersion;
+    use light_ctoken_sdk::ctoken::{CompressibleParams, CreateCTokenAccount};
+
+    let mut rpc = LightProgramTest::new(ProgramTestConfig::new_v2(false, None))
+        .await
+        .unwrap();
+    let payer = rpc.get_payer().insecure_clone();
+
+    // Create mint with DefaultAccountState = Initialized (non-frozen)
+    let (mint_keypair, extension_config) = create_mint_22_with_extension_types(
+        &mut rpc,
+        &payer,
+        9,
+        &[ExtensionType::DefaultAccountState],
+    )
+    .await;
+    let mint_pubkey = mint_keypair.pubkey();
+
+    assert!(
+        !extension_config.default_account_state_frozen,
+        "Mint should have default_account_state_frozen = false"
+    );
+
+    // Create a compressible CToken account
+    let account_keypair = Keypair::new();
+    let account_pubkey = account_keypair.pubkey();
+
+    let create_ix =
+        CreateCTokenAccount::new(payer.pubkey(), account_pubkey, mint_pubkey, payer.pubkey())
+            .with_compressible(CompressibleParams {
+                compressible_config: rpc
+                    .test_accounts
+                    .funding_pool_config
+                    .compressible_config_pda,
+                rent_sponsor: rpc.test_accounts.funding_pool_config.rent_sponsor_pda,
+                pre_pay_num_epochs: 2,
+                lamports_per_write: Some(100),
+                compress_to_account_pubkey: None,
+                token_account_version: TokenDataVersion::ShaFlat,
+                compression_only: true, // DefaultAccountState is a restricted extension
+            })
+            .instruction()
+            .unwrap();
+
+    rpc.create_and_send_transaction(&[create_ix], &payer.pubkey(), &[&payer, &account_keypair])
+        .await
+        .unwrap();
+
+    // Verify account was created
+    let account = rpc.get_account(account_pubkey).await.unwrap().unwrap();
+
+    // Deserialize the CToken account using borsh
+    let ctoken =
+        CToken::deserialize(&mut &account.data[..]).expect("Failed to deserialize CToken account");
+
+    // Build expected CToken account for comparison
+    let expected_ctoken = CToken {
+        mint: mint_pubkey.to_bytes().into(),
+        owner: payer.pubkey().to_bytes().into(),
+        amount: 0,
+        delegate: None,
+        state: AccountState::Initialized,
+        is_native: None,
+        delegated_amount: 0,
+        close_authority: None,
+        account_type: ACCOUNT_TYPE_TOKEN_ACCOUNT,
+        decimals: ctoken.decimals,
+        compression_only: ctoken.compression_only,
+        compression: ctoken.compression,
+        extensions: None, // DefaultAccountState alone has no marker extensions
+    };
+
+    assert_eq!(
+        ctoken, expected_ctoken,
+        "CToken account should match expected"
+    );
+
+    println!(
+        "Successfully created initialized CToken account: state={:?}",
+        ctoken.state
+    );
+}
diff --git a/program-tests/compressed-token-test/tests/compress_only/delegated.rs b/program-tests/compressed-token-test/tests/compress_only/delegated.rs
new file mode 100644
index 0000000000..4042c00d49
--- /dev/null
+++ b/program-tests/compressed-token-test/tests/compress_only/delegated.rs
@@ -0,0 +1,131 @@
+//! Tests for delegate-related behavior during compress/decompress.
+//!
+//! This module tests:
+//! - Delegated amount preservation through compress -> decompress cycle
+//! - Regular delegate decompression authorization
+
+use serial_test::serial;
+use solana_sdk::signature::Keypair;
+
+use super::shared::{
+    run_compress_and_close_extension_test, CompressAndCloseTestConfig, ALL_EXTENSIONS,
+};
+
+/// Test that delegated amount is preserved through compress -> decompress cycle.
+#[tokio::test]
+#[serial]
+async fn test_compress_and_close_with_delegated_amount() {
+    let delegate = Keypair::new();
+    run_compress_and_close_extension_test(CompressAndCloseTestConfig {
+        extensions: ALL_EXTENSIONS,
+        delegate_config: Some((delegate, 500_000_000)),
+        is_frozen: false,
+        use_permanent_delegate_for_decompress: false,
+        use_delegate_for_decompress: false,
+    })
+    .await
+    .unwrap();
+}
+
+/// Test that regular delegate can decompress CompressedOnly tokens.
+#[tokio::test]
+#[serial]
+async fn test_compress_and_close_delegate_decompress() {
+    let delegate = Keypair::new();
+    run_compress_and_close_extension_test(CompressAndCloseTestConfig {
+        extensions: ALL_EXTENSIONS,
+        delegate_config: Some((delegate, 500_000_000)),
+        is_frozen: false,
+        use_permanent_delegate_for_decompress: false,
+        use_delegate_for_decompress: true,
+    })
+    .await
+    .unwrap();
+}
+
+/// Test delegated amount with no extensions.
+#[tokio::test]
+#[serial]
+async fn test_compress_and_close_with_delegated_amount_no_extensions() {
+    let delegate = Keypair::new();
+    run_compress_and_close_extension_test(CompressAndCloseTestConfig {
+        extensions: &[],
+        delegate_config: Some((delegate, 500_000_000)),
+        is_frozen: false,
+        use_permanent_delegate_for_decompress: false,
+        use_delegate_for_decompress: false,
+    })
+    .await
+    .unwrap();
+}
+
+/// Test delegate decompress with no extensions.
+#[tokio::test]
+#[serial]
+async fn test_compress_and_close_delegate_decompress_no_extensions() {
+    let delegate = Keypair::new();
+    run_compress_and_close_extension_test(CompressAndCloseTestConfig {
+        extensions: &[],
+        delegate_config: Some((delegate, 500_000_000)),
+        is_frozen: false,
+        use_permanent_delegate_for_decompress: false,
+        use_delegate_for_decompress: true,
+    })
+    .await
+    .unwrap();
+}
+
+/// Test that orphan delegate (delegate set, delegated_amount = 0) is preserved
+/// through compress -> decompress cycle.
+///
+/// Covers spec requirements:
+/// - #12: Orphan delegate (delegate set, delegated_amount = 0)
+/// - #17: Restores orphan delegate on decompress
+/// - #26: Full round-trip orphan delegate state preserved
+#[tokio::test]
+#[serial]
+async fn test_compress_and_close_preserves_orphan_delegate() {
+    let delegate = Keypair::new();
+    // delegate_config with delegated_amount = 0 creates an orphan delegate
+    run_compress_and_close_extension_test(CompressAndCloseTestConfig {
+        extensions: ALL_EXTENSIONS,
+        delegate_config: Some((delegate, 0)), // delegated_amount = 0 but delegate is set
+        is_frozen: false,
+        use_permanent_delegate_for_decompress: false,
+        use_delegate_for_decompress: false,
+    })
+    .await
+    .unwrap();
+}
+
+/// Test orphan delegate with no extensions.
+#[tokio::test]
+#[serial]
+async fn test_compress_and_close_orphan_delegate_no_extensions() {
+    let delegate = Keypair::new();
+    run_compress_and_close_extension_test(CompressAndCloseTestConfig {
+        extensions: &[],
+        delegate_config: Some((delegate, 0)),
+        is_frozen: false,
+        use_permanent_delegate_for_decompress: false,
+        use_delegate_for_decompress: false,
+    })
+    .await
+    .unwrap();
+}
+
+/// Test that orphan delegate can still decompress (delegate has authority even with 0 amount).
+#[tokio::test]
+#[serial]
+async fn test_orphan_delegate_can_decompress() {
+    let delegate = Keypair::new();
+    run_compress_and_close_extension_test(CompressAndCloseTestConfig {
+        extensions: ALL_EXTENSIONS,
+        delegate_config: Some((delegate, 0)),
+        is_frozen: false,
+        use_permanent_delegate_for_decompress: false,
+        use_delegate_for_decompress: true, // delegate signs for decompress
+    })
+    .await
+    .unwrap();
+}
diff --git a/program-tests/compressed-token-test/tests/compress_only/frozen.rs b/program-tests/compressed-token-test/tests/compress_only/frozen.rs
new file mode 100644
index 0000000000..1ecdf44d73
--- /dev/null
+++ b/program-tests/compressed-token-test/tests/compress_only/frozen.rs
@@ -0,0 +1,40 @@
+//! Tests for frozen state preservation during compress/decompress.
+//!
+//! This module tests that frozen state is preserved when compressing
+//! and decompressing CToken accounts with Token-2022 extensions.
+
+use serial_test::serial;
+
+use super::shared::{
+    run_compress_and_close_extension_test, CompressAndCloseTestConfig, ALL_EXTENSIONS,
+};
+
+/// Test that frozen state is preserved through compress -> decompress cycle.
+#[tokio::test]
+#[serial]
+async fn test_compress_and_close_frozen() {
+    run_compress_and_close_extension_test(CompressAndCloseTestConfig {
+        extensions: ALL_EXTENSIONS,
+        delegate_config: None,
+        is_frozen: true,
+        use_permanent_delegate_for_decompress: false,
+        use_delegate_for_decompress: false,
+    })
+    .await
+    .unwrap();
+}
+
+/// Test frozen state with no extensions.
+#[tokio::test]
+#[serial]
+async fn test_compress_and_close_frozen_no_extensions() {
+    run_compress_and_close_extension_test(CompressAndCloseTestConfig {
+        extensions: &[],
+        delegate_config: None,
+        is_frozen: true,
+        use_permanent_delegate_for_decompress: false,
+        use_delegate_for_decompress: false,
+    })
+    .await
+    .unwrap();
+}
diff --git a/program-tests/compressed-token-test/tests/compress_only/invalid_destination.rs b/program-tests/compressed-token-test/tests/compress_only/invalid_destination.rs
new file mode 100644
index 0000000000..4588f2be8c
--- /dev/null
+++ b/program-tests/compressed-token-test/tests/compress_only/invalid_destination.rs
@@ -0,0 +1,532 @@
+//! Tests for invalid decompress destination validation.
+//!
+//! These tests verify that decompression fails with DecompressDestinationNotFresh
+//! when the destination CToken account has invalid state (non-fresh).
+
+use light_client::indexer::Indexer;
+use light_ctoken_interface::{
+    instructions::extensions::{CompressedOnlyExtensionInstructionData, ExtensionInstructionData},
+    state::TokenDataVersion,
+};
+use light_ctoken_sdk::{
+    ctoken::{CompressibleParams, CreateCTokenAccount, TransferSplToCtoken},
+    spl_interface::find_spl_interface_pda_with_index,
+};
+use light_program_test::{
+    program_test::{LightProgramTest, TestRpc},
+    utils::assert::assert_rpc_error,
+    ProgramTestConfig, Rpc,
+};
+use light_test_utils::mint_2022::{
+    create_mint_22_with_extension_types, create_token_22_account, mint_spl_tokens_22,
+    RESTRICTED_EXTENSIONS,
+};
+use light_token_client::instructions::transfer2::{
+    create_generic_transfer2_instruction, DecompressInput, Transfer2InstructionType,
+};
+use serial_test::serial;
+use solana_sdk::{pubkey::Pubkey, signature::Keypair, signer::Signer};
+
+use super::shared::ExtensionType;
+
+/// Expected error code for DecompressDestinationNotFresh
+const DECOMPRESS_DESTINATION_NOT_FRESH: u32 = 18055;
+
+/// Helper to modify CToken account to have invalid state
+async fn set_invalid_destination_state(
+    rpc: &mut LightProgramTest,
+    account_pubkey: Pubkey,
+    amount: Option<u64>,
+    delegate: Option<Pubkey>,
+    delegated_amount: Option<u64>,
+    close_authority: Option<Pubkey>,
+) {
+    use anchor_spl::token_2022::spl_token_2022;
+    use solana_sdk::{program_option::COption, program_pack::Pack};
+
+    let mut account_info = rpc.get_account(account_pubkey).await.unwrap().unwrap();
+
+    let mut spl_account =
+        spl_token_2022::state::Account::unpack_unchecked(&account_info.data[..165]).unwrap();
+
+    if let Some(amt) = amount {
+        spl_account.amount = amt;
+    }
+    if let Some(d) = delegate {
+        spl_account.delegate = COption::Some(d);
+    }
+    if let Some(da) = delegated_amount {
+        spl_account.delegated_amount = da;
+    }
+    if let Some(ca) = close_authority {
+        spl_account.close_authority = COption::Some(ca);
+    }
+
+    spl_token_2022::state::Account::pack(spl_account, &mut account_info.data[..165]).unwrap();
+    rpc.set_account(account_pubkey, account_info);
+}
+
+/// Helper to set up a compressed token with CompressedOnly extension for decompress testing
+async fn setup_compressed_token_for_decompress(
+    extensions: &[super::shared::ExtensionType],
+) -> (
+    LightProgramTest,
+    Keypair,                                       // payer
+    Pubkey,                                        // mint
+    Keypair,                                       // owner
+    light_client::indexer::CompressedTokenAccount, // compressed account
+    u64,                                           // amount
+) {
+    let mut rpc = LightProgramTest::new(ProgramTestConfig::new_v2(false, None))
+        .await
+        .unwrap();
+    let payer = rpc.get_payer().insecure_clone();
+
+    // Create mint with extensions
+    let (mint_keypair, _) =
+        create_mint_22_with_extension_types(&mut rpc, &payer, 9, extensions).await;
+    let mint_pubkey = mint_keypair.pubkey();
+
+    // Create SPL Token-2022 account and mint tokens
+    let spl_account =
+        create_token_22_account(&mut rpc, &payer, &mint_pubkey, &payer.pubkey()).await;
+    let mint_amount = 1_000_000_000u64;
+    mint_spl_tokens_22(&mut rpc, &payer, &mint_pubkey, &spl_account, mint_amount).await;
+
+    // Create CToken account with compression_only=true
+    let owner = Keypair::new();
+    let account_keypair = Keypair::new();
+    let ctoken_account = account_keypair.pubkey();
+
+    let create_ix =
+        CreateCTokenAccount::new(payer.pubkey(), ctoken_account, mint_pubkey, owner.pubkey())
+            .with_compressible(CompressibleParams {
+                compressible_config: rpc
+                    .test_accounts
+                    .funding_pool_config
+                    .compressible_config_pda,
+                rent_sponsor: rpc.test_accounts.funding_pool_config.rent_sponsor_pda,
+                pre_pay_num_epochs: 0,
+                lamports_per_write: Some(100),
+                compress_to_account_pubkey: None,
+                token_account_version: TokenDataVersion::ShaFlat,
+                compression_only: true,
+            })
+            .instruction()
+            .unwrap();
+
+    rpc.create_and_send_transaction(&[create_ix], &payer.pubkey(), &[&payer, &account_keypair])
+        .await
+        .unwrap();
+
+    // Transfer tokens to CToken
+    use spl_token_2022::ID as SPL_TOKEN_2022_ID;
+    let has_restricted = extensions
+        .iter()
+        .any(|ext| RESTRICTED_EXTENSIONS.contains(ext));
+    let (spl_interface_pda, spl_interface_pda_bump) =
+        find_spl_interface_pda_with_index(&mint_pubkey, 0, has_restricted);
+    let transfer_ix = TransferSplToCtoken {
+        amount: mint_amount,
+        spl_interface_pda_bump,
+        decimals: 9,
+        source_spl_token_account: spl_account,
+        destination_ctoken_account: ctoken_account,
+        authority: payer.pubkey(),
+        mint: mint_pubkey,
+        payer: payer.pubkey(),
+        spl_interface_pda,
+        spl_token_program: SPL_TOKEN_2022_ID,
+    }
+    .instruction()
+    .unwrap();
+
+    rpc.create_and_send_transaction(&[transfer_ix], &payer.pubkey(), &[&payer])
+        .await
+        .unwrap();
+
+    // Warp epoch to trigger forester compression
+    rpc.warp_epoch_forward(30).await.unwrap();
+
+    // Get compressed token accounts
+    let compressed_accounts = rpc
+        .get_compressed_token_accounts_by_owner(&owner.pubkey(), None, None)
+        .await
+        .unwrap()
+        .value
+        .items;
+
+    assert_eq!(
+        compressed_accounts.len(),
+        1,
+        "Should have 1 compressed account"
+    );
+
+    (
+        rpc,
+        payer,
+        mint_pubkey,
+        owner,
+        compressed_accounts[0].clone(),
+        mint_amount,
+    )
+}
+
+/// Helper to create destination and attempt decompress
+async fn attempt_decompress(
+    rpc: &mut LightProgramTest,
+    payer: &Keypair,
+    owner: &Keypair,
+    compressed_account: light_client::indexer::CompressedTokenAccount,
+    amount: u64,
+    destination_pubkey: Pubkey,
+) -> Result<solana_sdk::signature::Signature, light_test_utils::RpcError> {
+    let in_tlv = vec![vec![ExtensionInstructionData::CompressedOnly(
+        CompressedOnlyExtensionInstructionData {
+            delegated_amount: 0,
+            withheld_transfer_fee: 0,
+            is_frozen: false,
+            compression_index: 0,
+        },
+    )]];
+
+    let decompress_ix = create_generic_transfer2_instruction(
+        rpc,
+        vec![Transfer2InstructionType::Decompress(DecompressInput {
+            compressed_token_account: vec![compressed_account],
+            decompress_amount: amount,
+            solana_token_account: destination_pubkey,
+            amount,
+            pool_index: None,
+            decimals: 9,
+            in_tlv: Some(in_tlv),
+        })],
+        payer.pubkey(),
+        true,
+    )
+    .await
+    .unwrap();
+
+    rpc.create_and_send_transaction(&[decompress_ix], &payer.pubkey(), &[payer, owner])
+        .await
+}
+
+#[tokio::test]
+#[serial]
+async fn test_decompress_owner_mismatch() {
+    // Set up compressed token - owner is the actual owner of the compressed account
+    let (mut rpc, payer, mint_pubkey, owner, compressed_account, amount) =
+        setup_compressed_token_for_decompress(&[ExtensionType::Pausable]).await;
+
+    // Create destination with DIFFERENT owner (not matching compressed account owner)
+    let different_owner = Keypair::new();
+    let dest_keypair = Keypair::new();
+    let destination_pubkey = dest_keypair.pubkey();
+
+    let create_dest_ix = CreateCTokenAccount::new(
+        payer.pubkey(),
+        destination_pubkey,
+        mint_pubkey,
+        different_owner.pubkey(), // Different owner - doesn't match compressed account owner!
+    )
+    .with_compressible(CompressibleParams {
+        compressible_config: rpc
+            .test_accounts
+            .funding_pool_config
+            .compressible_config_pda,
+        rent_sponsor: rpc.test_accounts.funding_pool_config.rent_sponsor_pda,
+        pre_pay_num_epochs: 2,
+        lamports_per_write: Some(100),
+        compress_to_account_pubkey: None,
+        token_account_version: TokenDataVersion::ShaFlat,
+        compression_only: true,
+    })
+    .instruction()
+    .unwrap();
+
+    rpc.create_and_send_transaction(&[create_dest_ix], &payer.pubkey(), &[&payer, &dest_keypair])
+        .await
+        .unwrap();
+
+    let in_tlv = vec![vec![ExtensionInstructionData::CompressedOnly(
+        CompressedOnlyExtensionInstructionData {
+            delegated_amount: 0,
+            withheld_transfer_fee: 0,
+            is_frozen: false,
+            compression_index: 0,
+        },
+    )]];
+
+    let decompress_ix = create_generic_transfer2_instruction(
+        &mut rpc,
+        vec![Transfer2InstructionType::Decompress(DecompressInput {
+            compressed_token_account: vec![compressed_account],
+            decompress_amount: amount,
+            solana_token_account: destination_pubkey,
+            amount,
+            pool_index: None,
+            decimals: 9,
+            in_tlv: Some(in_tlv),
+        })],
+        payer.pubkey(),
+        true,
+    )
+    .await
+    .unwrap();
+
+    // Sign with payer and actual owner (of the compressed account)
+    // The validation should fail because destination.owner != compressed_account.owner
+    let result = rpc
+        .create_and_send_transaction(&[decompress_ix], &payer.pubkey(), &[&payer, &owner])
+        .await;
+
+    // Should fail because destination owner doesn't match input owner
+    assert_rpc_error(result, 0, DECOMPRESS_DESTINATION_NOT_FRESH).unwrap();
+}
+
+#[tokio::test]
+#[serial]
+async fn test_decompress_non_zero_amount() {
+    // Set up compressed token
+    let (mut rpc, payer, mint_pubkey, owner, compressed_account, amount) =
+        setup_compressed_token_for_decompress(&[ExtensionType::Pausable]).await;
+
+    // Create destination with correct owner
+    let dest_keypair = Keypair::new();
+    let destination_pubkey = dest_keypair.pubkey();
+
+    let create_dest_ix = CreateCTokenAccount::new(
+        payer.pubkey(),
+        destination_pubkey,
+        mint_pubkey,
+        owner.pubkey(),
+    )
+    .with_compressible(CompressibleParams {
+        compressible_config: rpc
+            .test_accounts
+            .funding_pool_config
+            .compressible_config_pda,
+        rent_sponsor: rpc.test_accounts.funding_pool_config.rent_sponsor_pda,
+        pre_pay_num_epochs: 2,
+        lamports_per_write: Some(100),
+        compress_to_account_pubkey: None,
+        token_account_version: TokenDataVersion::ShaFlat,
+        compression_only: true,
+    })
+    .instruction()
+    .unwrap();
+
+    rpc.create_and_send_transaction(&[create_dest_ix], &payer.pubkey(), &[&payer, &dest_keypair])
+        .await
+        .unwrap();
+
+    // Set non-zero amount on destination
+    set_invalid_destination_state(
+        &mut rpc,
+        destination_pubkey,
+        Some(1000), // Non-zero amount
+        None,
+        None,
+        None,
+    )
+    .await;
+
+    // Attempt decompress
+    let result = attempt_decompress(
+        &mut rpc,
+        &payer,
+        &owner,
+        compressed_account,
+        amount,
+        destination_pubkey,
+    )
+    .await;
+
+    assert_rpc_error(result, 0, DECOMPRESS_DESTINATION_NOT_FRESH).unwrap();
+}
+
+#[tokio::test]
+#[serial]
+async fn test_decompress_has_delegate() {
+    // Set up compressed token
+    let (mut rpc, payer, mint_pubkey, owner, compressed_account, amount) =
+        setup_compressed_token_for_decompress(&[ExtensionType::Pausable]).await;
+
+    // Create destination with correct owner
+    let dest_keypair = Keypair::new();
+    let destination_pubkey = dest_keypair.pubkey();
+
+    let create_dest_ix = CreateCTokenAccount::new(
+        payer.pubkey(),
+        destination_pubkey,
+        mint_pubkey,
+        owner.pubkey(),
+    )
+    .with_compressible(CompressibleParams {
+        compressible_config: rpc
+            .test_accounts
+            .funding_pool_config
+            .compressible_config_pda,
+        rent_sponsor: rpc.test_accounts.funding_pool_config.rent_sponsor_pda,
+        pre_pay_num_epochs: 2,
+        lamports_per_write: Some(100),
+        compress_to_account_pubkey: None,
+        token_account_version: TokenDataVersion::ShaFlat,
+        compression_only: true,
+    })
+    .instruction()
+    .unwrap();
+
+    rpc.create_and_send_transaction(&[create_dest_ix], &payer.pubkey(), &[&payer, &dest_keypair])
+        .await
+        .unwrap();
+
+    // Set delegate on destination
+    let delegate = Keypair::new();
+    set_invalid_destination_state(
+        &mut rpc,
+        destination_pubkey,
+        None,
+        Some(delegate.pubkey()), // Has delegate
+        None,
+        None,
+    )
+    .await;
+
+    // Attempt decompress
+    let result = attempt_decompress(
+        &mut rpc,
+        &payer,
+        &owner,
+        compressed_account,
+        amount,
+        destination_pubkey,
+    )
+    .await;
+
+    assert_rpc_error(result, 0, DECOMPRESS_DESTINATION_NOT_FRESH).unwrap();
+}
+
+#[tokio::test]
+#[serial]
+async fn test_decompress_non_zero_delegated_amount() {
+    // Set up compressed token
+    let (mut rpc, payer, mint_pubkey, owner, compressed_account, amount) =
+        setup_compressed_token_for_decompress(&[ExtensionType::Pausable]).await;
+
+    // Create destination with correct owner
+    let dest_keypair = Keypair::new();
+    let destination_pubkey = dest_keypair.pubkey();
+
+    let create_dest_ix = CreateCTokenAccount::new(
+        payer.pubkey(),
+        destination_pubkey,
+        mint_pubkey,
+        owner.pubkey(),
+    )
+    .with_compressible(CompressibleParams {
+        compressible_config: rpc
+            .test_accounts
+            .funding_pool_config
+            .compressible_config_pda,
+        rent_sponsor: rpc.test_accounts.funding_pool_config.rent_sponsor_pda,
+        pre_pay_num_epochs: 2,
+        lamports_per_write: Some(100),
+        compress_to_account_pubkey: None,
+        token_account_version: TokenDataVersion::ShaFlat,
+        compression_only: true,
+    })
+    .instruction()
+    .unwrap();
+
+    rpc.create_and_send_transaction(&[create_dest_ix], &payer.pubkey(), &[&payer, &dest_keypair])
+        .await
+        .unwrap();
+
+    // Set non-zero delegated_amount on destination
+    let delegate = Keypair::new();
+    set_invalid_destination_state(
+        &mut rpc,
+        destination_pubkey,
+        None,
+        Some(delegate.pubkey()), // Need delegate for delegated_amount
+        Some(500),               // Non-zero delegated_amount
+        None,
+    )
+    .await;
+
+    // Attempt decompress
+    let result = attempt_decompress(
+        &mut rpc,
+        &payer,
+        &owner,
+        compressed_account,
+        amount,
+        destination_pubkey,
+    )
+    .await;
+
+    assert_rpc_error(result, 0, DECOMPRESS_DESTINATION_NOT_FRESH).unwrap();
+}
+
+#[tokio::test]
+#[serial]
+async fn test_decompress_has_close_authority() {
+    // Set up compressed token
+    let (mut rpc, payer, mint_pubkey, owner, compressed_account, amount) =
+        setup_compressed_token_for_decompress(&[ExtensionType::Pausable]).await;
+
+    // Create destination with correct owner
+    let dest_keypair = Keypair::new();
+    let destination_pubkey = dest_keypair.pubkey();
+
+    let create_dest_ix = CreateCTokenAccount::new(
+        payer.pubkey(),
+        destination_pubkey,
+        mint_pubkey,
+        owner.pubkey(),
+    )
+    .with_compressible(CompressibleParams {
+        compressible_config: rpc
+            .test_accounts
+            .funding_pool_config
+            .compressible_config_pda,
+        rent_sponsor: rpc.test_accounts.funding_pool_config.rent_sponsor_pda,
+        pre_pay_num_epochs: 2,
+        lamports_per_write: Some(100),
+        compress_to_account_pubkey: None,
+        token_account_version: TokenDataVersion::ShaFlat,
+        compression_only: true,
+    })
+    .instruction()
+    .unwrap();
+
+    rpc.create_and_send_transaction(&[create_dest_ix], &payer.pubkey(), &[&payer, &dest_keypair])
+        .await
+        .unwrap();
+
+    // Set close_authority on destination
+    let close_authority = Keypair::new();
+    set_invalid_destination_state(
+        &mut rpc,
+        destination_pubkey,
+        None,
+        None,
+        None,
+        Some(close_authority.pubkey()), // Has close_authority
+    )
+    .await;
+
+    // Attempt decompress
+    let result = attempt_decompress(
+        &mut rpc,
+        &payer,
+        &owner,
+        compressed_account,
+        amount,
+        destination_pubkey,
+    )
+    .await;
+
+    assert_rpc_error(result, 0, DECOMPRESS_DESTINATION_NOT_FRESH).unwrap();
+}
diff --git a/program-tests/compressed-token-test/tests/compress_only/invalid_extension_state.rs b/program-tests/compressed-token-test/tests/compress_only/invalid_extension_state.rs
new file mode 100644
index 0000000000..c4f41b0c6e
--- /dev/null
+++ b/program-tests/compressed-token-test/tests/compress_only/invalid_extension_state.rs
@@ -0,0 +1,207 @@
+//! Tests for invalid extension state on Token-2022 mints.
+//!
+//! These tests verify that token pool creation fails when:
+//! - TransferFeeConfig has non-zero fees
+//! - TransferHook has non-nil program_id
+
+use anchor_lang::{system_program, InstructionData, ToAccountMetas};
+use light_ctoken_interface::find_spl_interface_pda_with_index;
+use light_ctoken_sdk::constants::CPI_AUTHORITY_PDA;
+use light_program_test::{
+    program_test::LightProgramTest, utils::assert::assert_rpc_error, ProgramTestConfig, Rpc,
+};
+use serial_test::serial;
+use solana_sdk::{instruction::Instruction, pubkey::Pubkey, signature::Keypair, signer::Signer};
+use spl_token_2022::{
+    extension::{
+        transfer_fee::instruction::initialize_transfer_fee_config,
+        transfer_hook::instruction::initialize as initialize_transfer_hook, ExtensionType,
+    },
+    instruction::initialize_mint,
+    state::Mint,
+};
+
+/// Expected error code for NonZeroTransferFeeNotSupported
+const NON_ZERO_TRANSFER_FEE_NOT_SUPPORTED: u32 = 6129;
+
+/// Expected error code for TransferHookNotSupported
+const TRANSFER_HOOK_NOT_SUPPORTED: u32 = 6130;
+
+/// Create a mint with non-zero transfer fee
+async fn create_mint_with_non_zero_fee(rpc: &mut LightProgramTest, payer: &Keypair) -> Pubkey {
+    use solana_system_interface::instruction as system_instruction;
+
+    let mint_keypair = Keypair::new();
+    let mint_pubkey = mint_keypair.pubkey();
+    let authority = payer.pubkey();
+
+    let extensions = [ExtensionType::TransferFeeConfig];
+    let mint_len = ExtensionType::try_calculate_account_len::<Mint>(&extensions).unwrap();
+
+    let rent = rpc
+        .get_minimum_balance_for_rent_exemption(mint_len)
+        .await
+        .unwrap();
+
+    // Create account
+    let create_account_ix = system_instruction::create_account(
+        &authority,
+        &mint_pubkey,
+        rent,
+        mint_len as u64,
+        &spl_token_2022::ID,
+    );
+
+    // Initialize transfer fee with NON-ZERO values
+    let init_transfer_fee_ix = initialize_transfer_fee_config(
+        &spl_token_2022::ID,
+        &mint_pubkey,
+        Some(&authority),
+        Some(&authority),
+        100,  // Non-zero transfer_fee_basis_points
+        1000, // Non-zero maximum_fee
+    )
+    .unwrap();
+
+    // Initialize mint
+    let init_mint_ix = initialize_mint(
+        &spl_token_2022::ID,
+        &mint_pubkey,
+        &authority,
+        Some(&authority),
+        9,
+    )
+    .unwrap();
+
+    rpc.create_and_send_transaction(
+        &[create_account_ix, init_transfer_fee_ix, init_mint_ix],
+        &payer.pubkey(),
+        &[payer, &mint_keypair],
+    )
+    .await
+    .unwrap();
+
+    mint_pubkey
+}
+
+/// Create a mint with non-nil transfer hook program
+async fn create_mint_with_non_nil_hook(rpc: &mut LightProgramTest, payer: &Keypair) -> Pubkey {
+    use solana_system_interface::instruction as system_instruction;
+
+    let mint_keypair = Keypair::new();
+    let mint_pubkey = mint_keypair.pubkey();
+    let authority = payer.pubkey();
+
+    let extensions = [ExtensionType::TransferHook];
+    let mint_len = ExtensionType::try_calculate_account_len::<Mint>(&extensions).unwrap();
+
+    let rent = rpc
+        .get_minimum_balance_for_rent_exemption(mint_len)
+        .await
+        .unwrap();
+
+    // Create account
+    let create_account_ix = system_instruction::create_account(
+        &authority,
+        &mint_pubkey,
+        rent,
+        mint_len as u64,
+        &spl_token_2022::ID,
+    );
+
+    // Initialize transfer hook with NON-NIL program_id
+    // Use a dummy program id (not nil/zero)
+    let dummy_hook_program = Pubkey::new_unique();
+    let init_transfer_hook_ix = initialize_transfer_hook(
+        &spl_token_2022::ID,
+        &mint_pubkey,
+        Some(authority),
+        Some(dummy_hook_program), // Non-nil program_id
+    )
+    .unwrap();
+
+    // Initialize mint
+    let init_mint_ix = initialize_mint(
+        &spl_token_2022::ID,
+        &mint_pubkey,
+        &authority,
+        Some(&authority),
+        9,
+    )
+    .unwrap();
+
+    rpc.create_and_send_transaction(
+        &[create_account_ix, init_transfer_hook_ix, init_mint_ix],
+        &payer.pubkey(),
+        &[payer, &mint_keypair],
+    )
+    .await
+    .unwrap();
+
+    mint_pubkey
+}
+
+/// Helper to create a token pool instruction
+fn create_token_pool_instruction(payer: Pubkey, mint: Pubkey, restricted: bool) -> Instruction {
+    let (token_pool_pda, _) = find_spl_interface_pda_with_index(&mint, 0, restricted);
+
+    let instruction_data = light_compressed_token::instruction::CreateTokenPool {};
+    let accounts = light_compressed_token::accounts::CreateTokenPoolInstruction {
+        fee_payer: payer,
+        token_pool_pda,
+        system_program: system_program::ID,
+        mint,
+        token_program: spl_token_2022::ID,
+        cpi_authority_pda: CPI_AUTHORITY_PDA,
+    };
+
+    Instruction {
+        program_id: light_compressed_token::ID,
+        accounts: accounts.to_account_metas(Some(true)),
+        data: instruction_data.data(),
+    }
+}
+
+#[tokio::test]
+#[serial]
+async fn test_transfer_fee_not_zero() {
+    let mut rpc = LightProgramTest::new(ProgramTestConfig::new_v2(false, None))
+        .await
+        .unwrap();
+    let payer = rpc.get_payer().insecure_clone();
+
+    // Create mint with non-zero transfer fee
+    let mint_pubkey = create_mint_with_non_zero_fee(&mut rpc, &payer).await;
+
+    // Try to create token pool - should fail with NonZeroTransferFeeNotSupported
+    // TransferFeeConfig is a restricted extension, so use restricted=true for PDA derivation
+    let create_pool_ix = create_token_pool_instruction(payer.pubkey(), mint_pubkey, true);
+
+    let result = rpc
+        .create_and_send_transaction(&[create_pool_ix], &payer.pubkey(), &[&payer])
+        .await;
+
+    assert_rpc_error(result, 0, NON_ZERO_TRANSFER_FEE_NOT_SUPPORTED).unwrap();
+}
+
+#[tokio::test]
+#[serial]
+async fn test_transfer_hook_program_not_nil() {
+    let mut rpc = LightProgramTest::new(ProgramTestConfig::new_v2(false, None))
+        .await
+        .unwrap();
+    let payer = rpc.get_payer().insecure_clone();
+
+    // Create mint with non-nil hook program
+    let mint_pubkey = create_mint_with_non_nil_hook(&mut rpc, &payer).await;
+
+    // Try to create token pool - should fail with TransferHookNotSupported
+    // TransferHook is a restricted extension, so use restricted=true for PDA derivation
+    let create_pool_ix = create_token_pool_instruction(payer.pubkey(), mint_pubkey, true);
+
+    let result = rpc
+        .create_and_send_transaction(&[create_pool_ix], &payer.pubkey(), &[&payer])
+        .await;
+
+    assert_rpc_error(result, 0, TRANSFER_HOOK_NOT_SUPPORTED).unwrap();
+}
diff --git a/program-tests/compressed-token-test/tests/compress_only/mod.rs b/program-tests/compressed-token-test/tests/compress_only/mod.rs
new file mode 100644
index 0000000000..b2ef33b161
--- /dev/null
+++ b/program-tests/compressed-token-test/tests/compress_only/mod.rs
@@ -0,0 +1,494 @@
+//! Shared helpers and test context for compress_only extension tests.
+//!
+//! This module contains utilities for testing the compress_only behavior
+//! with Token-2022 mints that have restricted extensions.
+
+use borsh::BorshDeserialize;
+use light_ctoken_interface::state::{AccountState, CToken, ExtensionStruct};
+use light_program_test::{program_test::TestRpc, LightProgramTest, ProgramTestConfig};
+pub use light_test_utils::{mint_2022::ALL_EXTENSIONS, Rpc};
+use light_test_utils::{
+    mint_2022::{
+        create_mint_22_with_extension_types, create_token_22_account, mint_spl_tokens_22,
+        Token22ExtensionConfig, RESTRICTED_EXTENSIONS,
+    },
+    RpcError,
+};
+use solana_sdk::{pubkey::Pubkey, signature::Keypair, signer::Signer};
+pub use spl_token_2022::extension::ExtensionType;
+
+/// Test context for extension-related tests
+pub struct ExtensionsTestContext {
+    pub rpc: LightProgramTest,
+    pub payer: Keypair,
+    pub _mint_keypair: Keypair,
+    pub mint_pubkey: Pubkey,
+    pub extension_config: Token22ExtensionConfig,
+}
+
+/// Set up test environment with a Token 2022 mint with specified extensions
+pub async fn setup_extensions_test(
+    extensions: &[ExtensionType],
+) -> Result<ExtensionsTestContext, RpcError> {
+    let mut rpc = LightProgramTest::new(ProgramTestConfig::new_v2(false, None)).await?;
+    let payer = rpc.get_payer().insecure_clone();
+
+    // Create mint with specified extensions
+    let (mint_keypair, extension_config) =
+        create_mint_22_with_extension_types(&mut rpc, &payer, 9, extensions).await;
+
+    let mint_pubkey = mint_keypair.pubkey();
+
+    Ok(ExtensionsTestContext {
+        rpc,
+        payer,
+        _mint_keypair: mint_keypair,
+        mint_pubkey,
+        extension_config,
+    })
+}
+
+/// Configuration for parameterized compress and close extension tests
+pub struct CompressAndCloseTestConfig {
+    /// Extensions to initialize on the mint
+    pub extensions: &'static [ExtensionType],
+    /// Delegate keypair and delegated_amount (delegate can sign)
+    pub delegate_config: Option<(Keypair, u64)>,
+    /// Set account state to frozen before compress
+    pub is_frozen: bool,
+    /// Use permanent delegate as authority for decompress (instead of owner)
+    pub use_permanent_delegate_for_decompress: bool,
+    /// Use regular delegate as authority for decompress (instead of owner)
+    pub use_delegate_for_decompress: bool,
+}
+
+/// Helper to modify CToken account state for testing using set_account
+/// Only modifies the SPL token portion (first 165 bytes) - CToken::deserialize reads from there
+pub async fn set_ctoken_account_state(
+    rpc: &mut LightProgramTest,
+    account_pubkey: Pubkey,
+    delegate: Option<Pubkey>,
+    delegated_amount: u64,
+    is_frozen: bool,
+) -> Result<(), RpcError> {
+    use anchor_spl::token_2022::spl_token_2022;
+    use solana_sdk::{program_option::COption, program_pack::Pack};
+
+    let mut account_info = rpc
+        .get_account(account_pubkey)
+        .await?
+        .ok_or_else(|| RpcError::CustomError("Account not found".to_string()))?;
+
+    // Update SPL token state (first 165 bytes)
+    // CToken::deserialize reads delegate/delegated_amount/state from the SPL portion
+    let mut spl_account =
+        spl_token_2022::state::Account::unpack_unchecked(&account_info.data[..165])
+            .map_err(|e| RpcError::CustomError(format!("Failed to unpack SPL account: {:?}", e)))?;
+
+    spl_account.delegate = match delegate {
+        Some(d) => COption::Some(d),
+        None => COption::None,
+    };
+    spl_account.delegated_amount = delegated_amount;
+    if is_frozen {
+        spl_account.state = spl_token_2022::state::AccountState::Frozen;
+    }
+
+    spl_token_2022::state::Account::pack(spl_account, &mut account_info.data[..165])
+        .map_err(|e| RpcError::CustomError(format!("Failed to pack SPL account: {:?}", e)))?;
+
+    rpc.set_account(account_pubkey, account_info);
+    Ok(())
+}
+
+/// Helper to set withheld_amount in TransferFeeAccount extension for testing
+/// Finds the TransferFeeAccount extension in the CToken and modifies the withheld_amount field
+pub async fn set_ctoken_withheld_fee(
+    rpc: &mut LightProgramTest,
+    account_pubkey: Pubkey,
+    withheld_amount: u64,
+) -> Result<(), RpcError> {
+    use light_ctoken_interface::state::{ExtensionStruct, TransferFeeAccountExtension};
+
+    let mut account_info = rpc
+        .get_account(account_pubkey)
+        .await?
+        .ok_or_else(|| RpcError::CustomError("Account not found".to_string()))?;
+
+    // Deserialize CToken to find and modify TransferFeeAccount extension
+    let mut ctoken = CToken::deserialize(&mut &account_info.data[..])
+        .map_err(|e| RpcError::CustomError(format!("Failed to deserialize CToken: {:?}", e)))?;
+
+    // Find and update TransferFeeAccount extension
+    let mut found = false;
+    if let Some(extensions) = ctoken.extensions.as_mut() {
+        for ext in extensions.iter_mut() {
+            if let ExtensionStruct::TransferFeeAccount(fee_ext) = ext {
+                *fee_ext = TransferFeeAccountExtension { withheld_amount };
+                found = true;
+                break;
+            }
+        }
+    }
+
+    if !found {
+        return Err(RpcError::CustomError(
+            "TransferFeeAccount extension not found in CToken".to_string(),
+        ));
+    }
+
+    // Serialize the modified CToken back
+    use borsh::BorshSerialize;
+    let serialized = ctoken
+        .try_to_vec()
+        .map_err(|e| RpcError::CustomError(format!("Failed to serialize CToken: {:?}", e)))?;
+
+    // Update account data
+    account_info.data = serialized;
+    rpc.set_account(account_pubkey, account_info);
+    Ok(())
+}
+
+/// Core parameterized test function for compress -> decompress cycle with configurable state
+pub async fn run_compress_and_close_extension_test(
+    config: CompressAndCloseTestConfig,
+) -> Result<(), RpcError> {
+    use light_client::indexer::Indexer;
+    use light_ctoken_interface::{
+        instructions::extensions::{
+            CompressedOnlyExtensionInstructionData, ExtensionInstructionData,
+        },
+        state::{
+            CompressedOnlyExtension, CompressedTokenAccountState, TokenData, TokenDataVersion,
+        },
+    };
+    use light_ctoken_sdk::{
+        ctoken::{CompressibleParams, CreateCTokenAccount, TransferSplToCtoken},
+        spl_interface::find_spl_interface_pda_with_index,
+    };
+    use light_token_client::instructions::transfer2::{
+        create_generic_transfer2_instruction, DecompressInput, Transfer2InstructionType,
+    };
+
+    let mut context = setup_extensions_test(config.extensions).await?;
+    let payer = context.payer.insecure_clone();
+    let mint_pubkey = context.mint_pubkey;
+    let _permanent_delegate = context.extension_config.permanent_delegate;
+
+    // 1. Create SPL Token-2022 account and mint tokens
+    let spl_account =
+        create_token_22_account(&mut context.rpc, &payer, &mint_pubkey, &payer.pubkey()).await;
+    let mint_amount = 1_000_000_000u64;
+    mint_spl_tokens_22(
+        &mut context.rpc,
+        &payer,
+        &mint_pubkey,
+        &spl_account,
+        mint_amount,
+    )
+    .await;
+
+    // 2. Create CToken account with 0 prepaid epochs (immediately compressible)
+    let owner = Keypair::new();
+    let account_keypair = Keypair::new();
+    let ctoken_account = account_keypair.pubkey();
+
+    let create_ix =
+        CreateCTokenAccount::new(payer.pubkey(), ctoken_account, mint_pubkey, owner.pubkey())
+            .with_compressible(CompressibleParams {
+                compressible_config: context
+                    .rpc
+                    .test_accounts
+                    .funding_pool_config
+                    .compressible_config_pda,
+                rent_sponsor: context
+                    .rpc
+                    .test_accounts
+                    .funding_pool_config
+                    .rent_sponsor_pda,
+                pre_pay_num_epochs: 0,
+                lamports_per_write: Some(100),
+                compress_to_account_pubkey: None,
+                token_account_version: TokenDataVersion::ShaFlat,
+                compression_only: true,
+            })
+            .instruction()
+            .map_err(|e| RpcError::CustomError(format!("Failed to create instruction: {:?}", e)))?;
+
+    context
+        .rpc
+        .create_and_send_transaction(&[create_ix], &payer.pubkey(), &[&payer, &account_keypair])
+        .await?;
+
+    // 3. Transfer tokens to CToken using hot path
+    // Determine if mint has restricted extensions for pool derivation
+    let has_restricted = config
+        .extensions
+        .iter()
+        .any(|ext| RESTRICTED_EXTENSIONS.contains(ext));
+    let (spl_interface_pda, spl_interface_pda_bump) =
+        find_spl_interface_pda_with_index(&mint_pubkey, 0, has_restricted);
+    let transfer_ix = TransferSplToCtoken {
+        amount: mint_amount,
+        spl_interface_pda_bump,
+        decimals: 9,
+        source_spl_token_account: spl_account,
+        destination_ctoken_account: ctoken_account,
+        authority: payer.pubkey(),
+        mint: mint_pubkey,
+        payer: payer.pubkey(),
+        spl_interface_pda,
+        spl_token_program: spl_token_2022::ID,
+    }
+    .instruction()
+    .map_err(|e| {
+        RpcError::CustomError(format!("Failed to create transfer instruction: {:?}", e))
+    })?;
+
+    context
+        .rpc
+        .create_and_send_transaction(&[transfer_ix], &payer.pubkey(), &[&payer])
+        .await?;
+
+    // 4. Modify CToken state based on config BEFORE warp
+    let delegate_pubkey = config.delegate_config.as_ref().map(|(kp, _)| kp.pubkey());
+    let delegated_amount = config
+        .delegate_config
+        .as_ref()
+        .map(|(_, a)| *a)
+        .unwrap_or(0);
+
+    if config.delegate_config.is_some() || config.is_frozen {
+        set_ctoken_account_state(
+            &mut context.rpc,
+            ctoken_account,
+            delegate_pubkey,
+            delegated_amount,
+            config.is_frozen,
+        )
+        .await?;
+    }
+
+    // 5. Warp epoch to trigger forester compression
+    context.rpc.warp_epoch_forward(30).await?;
+
+    // 6. Assert the account has been compressed (closed)
+    let account_after = context.rpc.get_account(ctoken_account).await?;
+    assert!(
+        account_after.is_none() || account_after.unwrap().lamports == 0,
+        "CToken account should be closed after compression"
+    );
+
+    // 7. Get compressed accounts and verify state
+    let compressed_accounts = context
+        .rpc
+        .get_compressed_token_accounts_by_owner(&owner.pubkey(), None, None)
+        .await?
+        .value
+        .items;
+
+    assert_eq!(
+        compressed_accounts.len(),
+        1,
+        "Should have exactly 1 compressed token account"
+    );
+
+    // Build expected TokenData based on config
+    let expected_state = if config.is_frozen {
+        CompressedTokenAccountState::Frozen as u8
+    } else {
+        CompressedTokenAccountState::Initialized as u8
+    };
+
+    let expected_token_data = TokenData {
+        mint: mint_pubkey.into(),
+        owner: owner.pubkey().into(),
+        amount: mint_amount,
+        delegate: delegate_pubkey.map(|d| d.into()),
+        state: expected_state,
+        tlv: Some(vec![ExtensionStruct::CompressedOnly(
+            CompressedOnlyExtension {
+                delegated_amount,
+                withheld_transfer_fee: 0,
+            },
+        )]),
+    };
+
+    assert_eq!(
+        compressed_accounts[0].token,
+        expected_token_data.into(),
+        "Compressed token account should match expected TokenData"
+    );
+
+    // 8. Create destination CToken account for decompress
+    let decompress_dest_keypair = Keypair::new();
+    let decompress_dest_account = decompress_dest_keypair.pubkey();
+
+    let create_dest_ix = CreateCTokenAccount::new(
+        payer.pubkey(),
+        decompress_dest_account,
+        mint_pubkey,
+        owner.pubkey(),
+    )
+    .with_compressible(CompressibleParams {
+        compressible_config: context
+            .rpc
+            .test_accounts
+            .funding_pool_config
+            .compressible_config_pda,
+        rent_sponsor: context
+            .rpc
+            .test_accounts
+            .funding_pool_config
+            .rent_sponsor_pda,
+        pre_pay_num_epochs: 2,
+        lamports_per_write: Some(100),
+        compress_to_account_pubkey: None,
+        token_account_version: TokenDataVersion::ShaFlat,
+        compression_only: true,
+    })
+    .instruction()
+    .map_err(|e| RpcError::CustomError(format!("Failed to create dest instruction: {:?}", e)))?;
+
+    context
+        .rpc
+        .create_and_send_transaction(
+            &[create_dest_ix],
+            &payer.pubkey(),
+            &[&payer, &decompress_dest_keypair],
+        )
+        .await?;
+
+    // 9. Decompress with correct in_tlv including is_frozen
+    let in_tlv = vec![vec![ExtensionInstructionData::CompressedOnly(
+        CompressedOnlyExtensionInstructionData {
+            delegated_amount,
+            withheld_transfer_fee: 0,
+            is_frozen: config.is_frozen,
+            compression_index: 0,
+        },
+    )]];
+
+    let mut decompress_ix = create_generic_transfer2_instruction(
+        &mut context.rpc,
+        vec![Transfer2InstructionType::Decompress(DecompressInput {
+            compressed_token_account: vec![compressed_accounts[0].clone()],
+            decompress_amount: mint_amount,
+            solana_token_account: decompress_dest_account,
+            amount: mint_amount,
+            pool_index: None,
+            decimals: 9,
+            in_tlv: Some(in_tlv),
+        })],
+        payer.pubkey(),
+        true,
+    )
+    .await
+    .map_err(|e| {
+        RpcError::CustomError(format!("Failed to create decompress instruction: {:?}", e))
+    })?;
+
+    // 10. Sign with owner, permanent delegate, or regular delegate based on config
+    let signers: Vec<&Keypair> = if config.use_permanent_delegate_for_decompress {
+        // Permanent delegate is the payer in this test setup.
+        // Find owner in account metas and set is_signer = false since permanent delegate acts on behalf.
+        let owner_pubkey = owner.pubkey();
+        for account_meta in decompress_ix.accounts.iter_mut() {
+            if account_meta.pubkey == owner_pubkey {
+                account_meta.is_signer = false;
+            }
+        }
+        vec![&payer]
+    } else if config.use_delegate_for_decompress {
+        // Regular delegate signs instead of owner
+        let delegate_kp = &config
+            .delegate_config
+            .as_ref()
+            .expect("delegate_config required when use_delegate_for_decompress is true")
+            .0;
+        let delegate_pubkey = delegate_kp.pubkey();
+
+        // Add delegate as signer account (it's not in the instruction by default)
+        decompress_ix
+            .accounts
+            .push(solana_sdk::instruction::AccountMeta {
+                pubkey: delegate_pubkey,
+                is_signer: true,
+                is_writable: false,
+            });
+
+        // Remove owner as signer
+        let owner_pubkey = owner.pubkey();
+        for account_meta in decompress_ix.accounts.iter_mut() {
+            if account_meta.pubkey == owner_pubkey {
+                account_meta.is_signer = false;
+            }
+        }
+        vec![&payer, delegate_kp]
+    } else {
+        vec![&payer, &owner]
+    };
+
+    context
+        .rpc
+        .create_and_send_transaction(&[decompress_ix], &payer.pubkey(), &signers)
+        .await?;
+
+    // 11. Verify decompressed CToken state
+    let dest_account_data = context
+        .rpc
+        .get_account(decompress_dest_account)
+        .await?
+        .ok_or_else(|| RpcError::CustomError("Dest account not found".to_string()))?;
+
+    let dest_ctoken = CToken::deserialize(&mut &dest_account_data.data[..])
+        .map_err(|e| RpcError::CustomError(format!("Failed to deserialize CToken: {:?}", e)))?;
+
+    // Verify state matches config
+    let expected_ctoken_state = if config.is_frozen {
+        AccountState::Frozen
+    } else {
+        AccountState::Initialized
+    };
+
+    assert_eq!(
+        dest_ctoken.state, expected_ctoken_state,
+        "Decompressed CToken state should match config"
+    );
+
+    assert_eq!(
+        dest_ctoken.delegated_amount, delegated_amount,
+        "Decompressed CToken delegated_amount should match"
+    );
+
+    if let Some((delegate_kp, _)) = &config.delegate_config {
+        assert_eq!(
+            dest_ctoken.delegate,
+            Some(delegate_kp.pubkey().to_bytes().into()),
+            "Decompressed CToken delegate should match"
+        );
+    } else {
+        assert!(
+            dest_ctoken.delegate.is_none(),
+            "Decompressed CToken should have no delegate"
+        );
+    }
+
+    // 12. Verify no more compressed accounts
+    let remaining_compressed = context
+        .rpc
+        .get_compressed_token_accounts_by_owner(&owner.pubkey(), None, None)
+        .await?
+        .value
+        .items;
+
+    assert_eq!(
+        remaining_compressed.len(),
+        0,
+        "Should have no more compressed token accounts after decompress"
+    );
+
+    println!("Successfully completed compress-and-close -> decompress cycle");
+
+    Ok(())
+}
diff --git a/program-tests/compressed-token-test/tests/compress_only/pausable.rs b/program-tests/compressed-token-test/tests/compress_only/pausable.rs
new file mode 100644
index 0000000000..ef134ba4f2
--- /dev/null
+++ b/program-tests/compressed-token-test/tests/compress_only/pausable.rs
@@ -0,0 +1,23 @@
+//! Tests for Pausable extension behavior during compress/decompress.
+//!
+//! This module tests the compress_only behavior with only the Pausable extension.
+
+use serial_test::serial;
+use spl_token_2022::extension::ExtensionType;
+
+use super::shared::{run_compress_and_close_extension_test, CompressAndCloseTestConfig};
+
+/// Test compress -> decompress cycle with only Pausable extension.
+#[tokio::test]
+#[serial]
+async fn test_pausable_only() {
+    run_compress_and_close_extension_test(CompressAndCloseTestConfig {
+        extensions: &[ExtensionType::Pausable],
+        delegate_config: None,
+        is_frozen: false,
+        use_permanent_delegate_for_decompress: false,
+        use_delegate_for_decompress: false,
+    })
+    .await
+    .unwrap();
+}
diff --git a/program-tests/compressed-token-test/tests/compress_only/permanent_delegate.rs b/program-tests/compressed-token-test/tests/compress_only/permanent_delegate.rs
new file mode 100644
index 0000000000..3fdd2b46e9
--- /dev/null
+++ b/program-tests/compressed-token-test/tests/compress_only/permanent_delegate.rs
@@ -0,0 +1,24 @@
+//! Tests for PermanentDelegate extension behavior during compress/decompress.
+//!
+//! This module tests that the permanent delegate can decompress
+//! CompressedOnly tokens on behalf of the owner.
+
+use serial_test::serial;
+use spl_token_2022::extension::ExtensionType;
+
+use super::shared::{run_compress_and_close_extension_test, CompressAndCloseTestConfig};
+
+/// Test that permanent delegate can decompress CompressedOnly tokens.
+#[tokio::test]
+#[serial]
+async fn test_compress_and_close_with_permanent_delegate() {
+    run_compress_and_close_extension_test(CompressAndCloseTestConfig {
+        extensions: &[ExtensionType::PermanentDelegate],
+        delegate_config: None,
+        is_frozen: false,
+        use_permanent_delegate_for_decompress: true,
+        use_delegate_for_decompress: false,
+    })
+    .await
+    .unwrap();
+}
diff --git a/program-tests/compressed-token-test/tests/compress_only/restricted_required.rs b/program-tests/compressed-token-test/tests/compress_only/restricted_required.rs
new file mode 100644
index 0000000000..8493602baa
--- /dev/null
+++ b/program-tests/compressed-token-test/tests/compress_only/restricted_required.rs
@@ -0,0 +1,109 @@
+//! Tests for compression_only requirement with restricted extensions.
+//!
+//! These tests verify that CToken accounts cannot be created without compression_only
+//! when the mint has restricted extensions (Pausable, PermanentDelegate, TransferFeeConfig,
+//! TransferHook, DefaultAccountState).
+
+use light_ctoken_interface::state::TokenDataVersion;
+use light_ctoken_sdk::ctoken::{CompressibleParams, CreateCTokenAccount};
+use light_program_test::{
+    program_test::LightProgramTest, utils::assert::assert_rpc_error, ProgramTestConfig, Rpc,
+};
+use light_test_utils::mint_2022::create_mint_22_with_extension_types;
+use serial_test::serial;
+use solana_sdk::{signature::Keypair, signer::Signer};
+use spl_token_2022::extension::ExtensionType;
+
+/// Expected error code for CompressionOnlyRequired
+const COMPRESSION_ONLY_REQUIRED: u32 = 6131;
+
+/// Helper to test that creating a CToken account without compression_only fails
+/// when the mint has the specified extensions.
+async fn test_compression_only_required_for_extensions(extensions: &[ExtensionType]) {
+    let mut rpc = LightProgramTest::new(ProgramTestConfig::new_v2(false, None))
+        .await
+        .unwrap();
+    let payer = rpc.get_payer().insecure_clone();
+
+    // Create mint with specified extensions
+    let (mint_keypair, _) =
+        create_mint_22_with_extension_types(&mut rpc, &payer, 9, extensions).await;
+    let mint_pubkey = mint_keypair.pubkey();
+
+    // Try to create CToken account WITHOUT compression_only (should fail)
+    let token_account_keypair = Keypair::new();
+    let token_account_pubkey = token_account_keypair.pubkey();
+
+    let create_ix = CreateCTokenAccount::new(
+        payer.pubkey(),
+        token_account_pubkey,
+        mint_pubkey,
+        payer.pubkey(),
+    )
+    .with_compressible(CompressibleParams {
+        compressible_config: rpc
+            .test_accounts
+            .funding_pool_config
+            .compressible_config_pda,
+        rent_sponsor: rpc.test_accounts.funding_pool_config.rent_sponsor_pda,
+        pre_pay_num_epochs: 2,
+        lamports_per_write: Some(100),
+        compress_to_account_pubkey: None,
+        token_account_version: TokenDataVersion::ShaFlat,
+        compression_only: false, // This should cause the error
+    })
+    .instruction()
+    .unwrap();
+
+    let result = rpc
+        .create_and_send_transaction(
+            &[create_ix],
+            &payer.pubkey(),
+            &[&payer, &token_account_keypair],
+        )
+        .await;
+
+    assert_rpc_error(result, 0, COMPRESSION_ONLY_REQUIRED).unwrap();
+}
+
+#[tokio::test]
+#[serial]
+async fn test_pausable_requires_compression_only() {
+    test_compression_only_required_for_extensions(&[ExtensionType::Pausable]).await;
+}
+
+#[tokio::test]
+#[serial]
+async fn test_permanent_delegate_requires_compression_only() {
+    test_compression_only_required_for_extensions(&[ExtensionType::PermanentDelegate]).await;
+}
+
+#[tokio::test]
+#[serial]
+async fn test_transfer_fee_requires_compression_only() {
+    test_compression_only_required_for_extensions(&[ExtensionType::TransferFeeConfig]).await;
+}
+
+#[tokio::test]
+#[serial]
+async fn test_transfer_hook_requires_compression_only() {
+    test_compression_only_required_for_extensions(&[ExtensionType::TransferHook]).await;
+}
+
+#[tokio::test]
+#[serial]
+async fn test_default_account_state_requires_compression_only() {
+    test_compression_only_required_for_extensions(&[ExtensionType::DefaultAccountState]).await;
+}
+
+#[tokio::test]
+#[serial]
+async fn test_multiple_restricted_requires_compression_only() {
+    test_compression_only_required_for_extensions(&[
+        ExtensionType::Pausable,
+        ExtensionType::PermanentDelegate,
+        ExtensionType::TransferFeeConfig,
+        ExtensionType::TransferHook,
+    ])
+    .await;
+}
diff --git a/program-tests/compressed-token-test/tests/compress_only/transfer_fee.rs b/program-tests/compressed-token-test/tests/compress_only/transfer_fee.rs
new file mode 100644
index 0000000000..ce2d8f1632
--- /dev/null
+++ b/program-tests/compressed-token-test/tests/compress_only/transfer_fee.rs
@@ -0,0 +1,23 @@
+//! Tests for TransferFeeConfig extension behavior during compress/decompress.
+//!
+//! This module tests the compress_only behavior with only the TransferFeeConfig extension.
+
+use serial_test::serial;
+use spl_token_2022::extension::ExtensionType;
+
+use super::shared::{run_compress_and_close_extension_test, CompressAndCloseTestConfig};
+
+/// Test compress -> decompress cycle with only TransferFeeConfig extension.
+#[tokio::test]
+#[serial]
+async fn test_transfer_fee_only() {
+    run_compress_and_close_extension_test(CompressAndCloseTestConfig {
+        extensions: &[ExtensionType::TransferFeeConfig],
+        delegate_config: None,
+        is_frozen: false,
+        use_permanent_delegate_for_decompress: false,
+        use_delegate_for_decompress: false,
+    })
+    .await
+    .unwrap();
+}
diff --git a/program-tests/compressed-token-test/tests/compress_only/transfer_hook.rs b/program-tests/compressed-token-test/tests/compress_only/transfer_hook.rs
new file mode 100644
index 0000000000..f94af45681
--- /dev/null
+++ b/program-tests/compressed-token-test/tests/compress_only/transfer_hook.rs
@@ -0,0 +1,23 @@
+//! Tests for TransferHook extension behavior during compress/decompress.
+//!
+//! This module tests the compress_only behavior with only the TransferHook extension.
+
+use serial_test::serial;
+use spl_token_2022::extension::ExtensionType;
+
+use super::shared::{run_compress_and_close_extension_test, CompressAndCloseTestConfig};
+
+/// Test compress -> decompress cycle with only TransferHook extension.
+#[tokio::test]
+#[serial]
+async fn test_transfer_hook_only() {
+    run_compress_and_close_extension_test(CompressAndCloseTestConfig {
+        extensions: &[ExtensionType::TransferHook],
+        delegate_config: None,
+        is_frozen: false,
+        use_permanent_delegate_for_decompress: false,
+        use_delegate_for_decompress: false,
+    })
+    .await
+    .unwrap();
+}
diff --git a/program-tests/compressed-token-test/tests/compress_only/withheld_fee.rs b/program-tests/compressed-token-test/tests/compress_only/withheld_fee.rs
new file mode 100644
index 0000000000..0e882927e2
--- /dev/null
+++ b/program-tests/compressed-token-test/tests/compress_only/withheld_fee.rs
@@ -0,0 +1,268 @@
+//! Tests for withheld_transfer_fee preservation through compress/decompress cycle.
+//!
+//! This module tests:
+//! - Withheld transfer fee preservation (spec #27)
+
+use borsh::BorshDeserialize;
+use light_client::indexer::Indexer;
+use light_ctoken_interface::{
+    instructions::extensions::{CompressedOnlyExtensionInstructionData, ExtensionInstructionData},
+    state::{
+        CToken, CompressedOnlyExtension, CompressedTokenAccountState, ExtensionStruct, TokenData,
+        TokenDataVersion,
+    },
+};
+use light_ctoken_sdk::{
+    ctoken::{CompressibleParams, CreateCTokenAccount, TransferSplToCtoken},
+    spl_interface::find_spl_interface_pda_with_index,
+};
+use light_program_test::{program_test::TestRpc, LightProgramTest, ProgramTestConfig};
+use light_test_utils::{
+    mint_2022::{create_mint_22_with_extension_types, create_token_22_account, mint_spl_tokens_22},
+    Rpc, RpcError,
+};
+use light_token_client::instructions::transfer2::{
+    create_generic_transfer2_instruction, DecompressInput, Transfer2InstructionType,
+};
+use serial_test::serial;
+use solana_sdk::{signature::Keypair, signer::Signer};
+use spl_token_2022::extension::ExtensionType;
+
+use super::shared::set_ctoken_withheld_fee;
+
+/// Test that withheld_transfer_fee is preserved through compress -> decompress cycle.
+///
+/// Covers spec requirement #27: Full round-trip withheld_transfer_fee preserved
+#[tokio::test]
+#[serial]
+async fn test_roundtrip_withheld_transfer_fee_preserved() -> Result<(), RpcError> {
+    let mut rpc = LightProgramTest::new(ProgramTestConfig::new_v2(false, None)).await?;
+    let payer = rpc.get_payer().insecure_clone();
+
+    // 1. Create mint with TransferFeeConfig extension
+    let extensions = &[ExtensionType::TransferFeeConfig];
+    let (mint_keypair, _extension_config) =
+        create_mint_22_with_extension_types(&mut rpc, &payer, 9, extensions).await;
+    let mint_pubkey = mint_keypair.pubkey();
+
+    // 2. Create SPL Token-2022 account and mint tokens
+    let spl_account =
+        create_token_22_account(&mut rpc, &payer, &mint_pubkey, &payer.pubkey()).await;
+    let mint_amount = 1_000_000_000u64;
+    mint_spl_tokens_22(&mut rpc, &payer, &mint_pubkey, &spl_account, mint_amount).await;
+
+    // 3. Create CToken account with compression_only
+    let owner = Keypair::new();
+    let account_keypair = Keypair::new();
+    let ctoken_account = account_keypair.pubkey();
+
+    let create_ix =
+        CreateCTokenAccount::new(payer.pubkey(), ctoken_account, mint_pubkey, owner.pubkey())
+            .with_compressible(CompressibleParams {
+                compressible_config: rpc
+                    .test_accounts
+                    .funding_pool_config
+                    .compressible_config_pda,
+                rent_sponsor: rpc.test_accounts.funding_pool_config.rent_sponsor_pda,
+                pre_pay_num_epochs: 0,
+                lamports_per_write: Some(100),
+                compress_to_account_pubkey: None,
+                token_account_version: TokenDataVersion::ShaFlat,
+                compression_only: true,
+            })
+            .instruction()
+            .map_err(|e| RpcError::CustomError(format!("Failed to create instruction: {:?}", e)))?;
+
+    rpc.create_and_send_transaction(&[create_ix], &payer.pubkey(), &[&payer, &account_keypair])
+        .await?;
+
+    // 4. Transfer tokens to CToken
+    let (spl_interface_pda, spl_interface_pda_bump) =
+        find_spl_interface_pda_with_index(&mint_pubkey, 0, true); // true = restricted
+    let transfer_ix = TransferSplToCtoken {
+        amount: mint_amount,
+        spl_interface_pda_bump,
+        decimals: 9,
+        source_spl_token_account: spl_account,
+        destination_ctoken_account: ctoken_account,
+        authority: payer.pubkey(),
+        mint: mint_pubkey,
+        payer: payer.pubkey(),
+        spl_interface_pda,
+        spl_token_program: spl_token_2022::ID,
+    }
+    .instruction()
+    .map_err(|e| {
+        RpcError::CustomError(format!("Failed to create transfer instruction: {:?}", e))
+    })?;
+
+    rpc.create_and_send_transaction(&[transfer_ix], &payer.pubkey(), &[&payer])
+        .await?;
+
+    // 5. Set withheld_amount to a non-zero value BEFORE compression
+    let withheld_amount = 12345u64;
+    set_ctoken_withheld_fee(&mut rpc, ctoken_account, withheld_amount).await?;
+
+    // Verify the withheld_amount was set correctly
+    let account_before = rpc.get_account(ctoken_account).await?.unwrap();
+    let ctoken_before = CToken::deserialize(&mut &account_before.data[..])
+        .map_err(|e| RpcError::CustomError(format!("Failed to deserialize CToken: {:?}", e)))?;
+
+    let withheld_before = ctoken_before
+        .extensions
+        .as_ref()
+        .and_then(|exts| {
+            exts.iter().find_map(|e| match e {
+                ExtensionStruct::TransferFeeAccount(fee) => Some(fee.withheld_amount),
+                _ => None,
+            })
+        })
+        .unwrap_or(0);
+
+    assert_eq!(
+        withheld_before, withheld_amount,
+        "Withheld amount should be set before compression"
+    );
+
+    // 6. Warp to trigger forester compression
+    rpc.warp_epoch_forward(30).await?;
+
+    // 7. Verify account was compressed
+    let account_after = rpc.get_account(ctoken_account).await?;
+    assert!(
+        account_after.is_none() || account_after.unwrap().lamports == 0,
+        "CToken account should be closed after compression"
+    );
+
+    // 8. Get compressed account and verify withheld_transfer_fee in CompressedOnly extension
+    let compressed_accounts = rpc
+        .get_compressed_token_accounts_by_owner(&owner.pubkey(), None, None)
+        .await?
+        .value
+        .items;
+
+    assert_eq!(
+        compressed_accounts.len(),
+        1,
+        "Should have exactly 1 compressed token account"
+    );
+
+    // Build expected TokenData with withheld_transfer_fee
+    let expected_token_data = TokenData {
+        mint: mint_pubkey.into(),
+        owner: owner.pubkey().into(),
+        amount: mint_amount,
+        delegate: None,
+        state: CompressedTokenAccountState::Initialized as u8,
+        tlv: Some(vec![ExtensionStruct::CompressedOnly(
+            CompressedOnlyExtension {
+                delegated_amount: 0,
+                withheld_transfer_fee: withheld_amount,
+            },
+        )]),
+    };
+
+    assert_eq!(
+        compressed_accounts[0].token,
+        expected_token_data.into(),
+        "Compressed token should have withheld_transfer_fee preserved"
+    );
+
+    // 9. Create destination CToken for decompress
+    let decompress_dest_keypair = Keypair::new();
+    let decompress_dest_account = decompress_dest_keypair.pubkey();
+
+    let create_dest_ix = CreateCTokenAccount::new(
+        payer.pubkey(),
+        decompress_dest_account,
+        mint_pubkey,
+        owner.pubkey(),
+    )
+    .with_compressible(CompressibleParams {
+        compressible_config: rpc
+            .test_accounts
+            .funding_pool_config
+            .compressible_config_pda,
+        rent_sponsor: rpc.test_accounts.funding_pool_config.rent_sponsor_pda,
+        pre_pay_num_epochs: 2,
+        lamports_per_write: Some(100),
+        compress_to_account_pubkey: None,
+        token_account_version: TokenDataVersion::ShaFlat,
+        compression_only: true,
+    })
+    .instruction()
+    .map_err(|e| RpcError::CustomError(format!("Failed to create dest instruction: {:?}", e)))?;
+
+    rpc.create_and_send_transaction(
+        &[create_dest_ix],
+        &payer.pubkey(),
+        &[&payer, &decompress_dest_keypair],
+    )
+    .await?;
+
+    // 10. Decompress with withheld_transfer_fee in in_tlv
+    let in_tlv = vec![vec![ExtensionInstructionData::CompressedOnly(
+        CompressedOnlyExtensionInstructionData {
+            delegated_amount: 0,
+            withheld_transfer_fee: withheld_amount,
+            is_frozen: false,
+            compression_index: 0,
+        },
+    )]];
+
+    let decompress_ix = create_generic_transfer2_instruction(
+        &mut rpc,
+        vec![Transfer2InstructionType::Decompress(DecompressInput {
+            compressed_token_account: vec![compressed_accounts[0].clone()],
+            decompress_amount: mint_amount,
+            solana_token_account: decompress_dest_account,
+            amount: mint_amount,
+            pool_index: None,
+            decimals: 9,
+            in_tlv: Some(in_tlv),
+        })],
+        payer.pubkey(),
+        true,
+    )
+    .await
+    .map_err(|e| {
+        RpcError::CustomError(format!("Failed to create decompress instruction: {:?}", e))
+    })?;
+
+    rpc.create_and_send_transaction(&[decompress_ix], &payer.pubkey(), &[&payer, &owner])
+        .await?;
+
+    // 11. Verify decompressed CToken has withheld_amount restored
+    let dest_account_data = rpc
+        .get_account(decompress_dest_account)
+        .await?
+        .ok_or_else(|| RpcError::CustomError("Dest account not found".to_string()))?;
+
+    let dest_ctoken = CToken::deserialize(&mut &dest_account_data.data[..])
+        .map_err(|e| RpcError::CustomError(format!("Failed to deserialize CToken: {:?}", e)))?;
+
+    let withheld_after = dest_ctoken
+        .extensions
+        .as_ref()
+        .and_then(|exts| {
+            exts.iter().find_map(|e| match e {
+                ExtensionStruct::TransferFeeAccount(fee) => Some(fee.withheld_amount),
+                _ => None,
+            })
+        })
+        .ok_or_else(|| {
+            RpcError::CustomError("TransferFeeAccount extension not found".to_string())
+        })?;
+
+    assert_eq!(
+        withheld_after, withheld_amount,
+        "Withheld amount should be restored after decompress"
+    );
+
+    println!(
+        "Successfully verified withheld_transfer_fee {} preserved through compress/decompress",
+        withheld_amount
+    );
+
+    Ok(())
+}
diff --git a/program-tests/compressed-token-test/tests/ctoken.rs b/program-tests/compressed-token-test/tests/ctoken.rs
index b5b1841b26..22eef0d54f 100644
--- a/program-tests/compressed-token-test/tests/ctoken.rs
+++ b/program-tests/compressed-token-test/tests/ctoken.rs
@@ -31,3 +31,18 @@ mod create_ata2;
 
 #[path = "ctoken/spl_instruction_compat.rs"]
 mod spl_instruction_compat;
+
+#[path = "ctoken/extensions.rs"]
+mod extensions;
+
+#[path = "ctoken/freeze_thaw.rs"]
+mod freeze_thaw;
+
+#[path = "ctoken/approve_revoke.rs"]
+mod approve_revoke;
+
+#[path = "ctoken/burn.rs"]
+mod burn;
+
+#[path = "ctoken/extensions_failing.rs"]
+mod extensions_failing;
diff --git a/program-tests/compressed-token-test/tests/ctoken/approve_revoke.rs b/program-tests/compressed-token-test/tests/ctoken/approve_revoke.rs
new file mode 100644
index 0000000000..778e151218
--- /dev/null
+++ b/program-tests/compressed-token-test/tests/ctoken/approve_revoke.rs
@@ -0,0 +1,644 @@
+//! Approve and Revoke instruction tests for CToken accounts.
+//!
+//! ## Test Matrix
+//!
+//! | Test Category | Approve | Revoke |
+//! |--------------|---------|--------|
+//! | SPL compat | test_approve_success_cases | test_revoke_success_cases |
+//! | With SPL mint | test_approve_success_cases | test_revoke_success_cases |
+//! | With CMint | test_approve_revoke_compressible | test_approve_revoke_compressible |
+//! | Invalid ctoken (non-existent) | test_approve_fails | test_revoke_fails |
+//! | Invalid ctoken (wrong owner) | test_approve_fails | test_revoke_fails |
+//! | Invalid ctoken (spl account) | test_approve_fails | test_revoke_fails |
+//! | Max top-up exceeded | test_approve_fails | test_revoke_fails |
+//!
+//! **Note**: "Invalid mint" tests not applicable - approve/revoke don't take mint as account.
+
+use super::shared::*;
+
+// ============================================================================
+// Approve Success Cases
+// ============================================================================
+
+#[tokio::test]
+#[serial]
+async fn test_approve_success_cases() {
+    // Test 1: SPL compat (uses SPL instruction format with modifications for CToken)
+    {
+        let mut context = setup_account_test_with_created_account(Some((0, false)))
+            .await
+            .unwrap();
+        // Fund owner for compressible top-up
+        context
+            .rpc
+            .airdrop_lamports(&context.owner_keypair.pubkey(), 1_000_000_000)
+            .await
+            .unwrap();
+        let delegate = Keypair::new();
+        approve_spl_compat_and_assert(&mut context, delegate.pubkey(), 100, "spl_compat").await;
+    }
+
+    // Test 2: With SPL mint + compressible extension with prepaid_epochs=2 (uses SDK instruction format)
+    {
+        let mut context = setup_account_test_with_created_account(Some((2, false)))
+            .await
+            .unwrap();
+        // Fund owner for potential top-up
+        context
+            .rpc
+            .airdrop_lamports(&context.owner_keypair.pubkey(), 1_000_000_000)
+            .await
+            .unwrap();
+        let delegate = Keypair::new();
+        approve_and_assert(
+            &mut context,
+            delegate.pubkey(),
+            100,
+            "with_spl_mint_compressible",
+        )
+        .await;
+    }
+}
+
+// ============================================================================
+// Approve Failure Cases
+// ============================================================================
+
+#[tokio::test]
+#[serial]
+async fn test_approve_fails() {
+    // Test 1: Invalid account - non-existent
+    {
+        let mut context = setup_account_test_with_created_account(Some((0, false)))
+            .await
+            .unwrap();
+        let delegate = Keypair::new();
+        let non_existent = Pubkey::new_unique();
+        let owner = context.owner_keypair.insecure_clone();
+        approve_and_assert_fails(
+            &mut context,
+            non_existent,
+            delegate.pubkey(),
+            &owner,
+            100,
+            None,
+            "non_existent_account",
+            15010, // ZeroCopyError::Size - account doesn't exist
+        )
+        .await;
+    }
+
+    // Test 2: Invalid account - wrong program owner (valid CToken data but wrong owner)
+    {
+        use anchor_spl::token::spl_token;
+        use light_program_test::program_test::TestRpc;
+
+        let mut context = setup_account_test_with_created_account(Some((0, false)))
+            .await
+            .unwrap();
+
+        // Fund owner so the test doesn't fail due to insufficient lamports
+        context
+            .rpc
+            .airdrop_lamports(&context.owner_keypair.pubkey(), 1_000_000_000)
+            .await
+            .unwrap();
+
+        // Get the valid CToken account data
+        let valid_account = context
+            .rpc
+            .get_account(context.token_account_keypair.pubkey())
+            .await
+            .unwrap()
+            .unwrap();
+
+        // Create a new account with the same data but owned by spl_token program
+        let wrong_owner_account = Keypair::new();
+        let mut account_with_wrong_owner = valid_account.clone();
+        account_with_wrong_owner.owner = spl_token::ID;
+
+        context
+            .rpc
+            .set_account(wrong_owner_account.pubkey(), account_with_wrong_owner);
+
+        let delegate = Keypair::new();
+        let owner = context.owner_keypair.insecure_clone();
+        approve_and_assert_fails(
+            &mut context,
+            wrong_owner_account.pubkey(),
+            delegate.pubkey(),
+            &owner,
+            100,
+            None,
+            "wrong_program_owner",
+            13, // InstructionError::ExternalAccountDataModified - program tried to modify account it doesn't own
+        )
+        .await;
+    }
+
+    // Test 3: Max top-up exceeded
+    {
+        let mut context = setup_account_test_with_created_account(Some((10, false)))
+            .await
+            .unwrap();
+
+        // Fund owner so the test doesn't fail due to insufficient lamports
+        context
+            .rpc
+            .airdrop_lamports(&context.owner_keypair.pubkey(), 1_000_000_000)
+            .await
+            .unwrap();
+
+        // Warp time to trigger top-up requirement (past funded epochs)
+        context.rpc.warp_to_slot(SLOTS_PER_EPOCH * 12 + 1).unwrap();
+
+        let delegate = Keypair::new();
+        let token_account = context.token_account_keypair.pubkey();
+        let owner = context.owner_keypair.insecure_clone();
+        approve_and_assert_fails(
+            &mut context,
+            token_account,
+            delegate.pubkey(),
+            &owner,
+            100,
+            Some(1), // max_top_up too low
+            "max_topup_exceeded",
+            18043, // CTokenError::MaxTopUpExceeded
+        )
+        .await;
+    }
+}
+
+// ============================================================================
+// Revoke Success Cases
+// ============================================================================
+
+#[tokio::test]
+#[serial]
+async fn test_revoke_success_cases() {
+    // Test 1: SPL compat (uses SPL instruction format with modifications for CToken)
+    {
+        let mut context = setup_account_test_with_created_account(Some((0, false)))
+            .await
+            .unwrap();
+        // Fund owner for compressible top-up
+        context
+            .rpc
+            .airdrop_lamports(&context.owner_keypair.pubkey(), 1_000_000_000)
+            .await
+            .unwrap();
+
+        // First approve a delegate using SPL compat
+        let delegate = Keypair::new();
+        approve_spl_compat_and_assert(
+            &mut context,
+            delegate.pubkey(),
+            100,
+            "spl_compat_approve_for_revoke",
+        )
+        .await;
+
+        // Then revoke using SPL compat
+        revoke_spl_compat_and_assert(&mut context, "spl_compat").await;
+    }
+
+    // Test 2: With SPL mint + compressible extension with prepaid_epochs=2 (uses SDK instruction format)
+    {
+        let mut context = setup_account_test_with_created_account(Some((2, false)))
+            .await
+            .unwrap();
+
+        // Fund owner for potential top-up
+        context
+            .rpc
+            .airdrop_lamports(&context.owner_keypair.pubkey(), 1_000_000_000)
+            .await
+            .unwrap();
+
+        // First approve
+        let delegate = Keypair::new();
+        approve_and_assert(
+            &mut context,
+            delegate.pubkey(),
+            100,
+            "sdk_approve_for_revoke",
+        )
+        .await;
+
+        // Then revoke
+        revoke_and_assert(&mut context, "with_spl_mint_compressible").await;
+    }
+
+    // Note: Delegate self-revoke (Token-2022 feature) is NOT supported by pinocchio-token-program.
+    // The pinocchio implementation only validates against the owner, not the delegate.
+}
+
+// ============================================================================
+// Revoke Failure Cases
+// ============================================================================
+
+#[tokio::test]
+#[serial]
+async fn test_revoke_fails() {
+    // Test 1: Invalid account - non-existent
+    {
+        let mut context = setup_account_test_with_created_account(Some((0, false)))
+            .await
+            .unwrap();
+        let non_existent = Pubkey::new_unique();
+        let owner = context.owner_keypair.insecure_clone();
+        revoke_and_assert_fails(
+            &mut context,
+            non_existent,
+            &owner,
+            None,
+            "non_existent_account",
+            15010, // ZeroCopyError::Size - account doesn't exist
+        )
+        .await;
+    }
+
+    // Test 2: Invalid account - wrong program owner (valid CToken data but wrong owner)
+    {
+        use anchor_spl::token::spl_token;
+        use light_program_test::program_test::TestRpc;
+
+        let mut context = setup_account_test_with_created_account(Some((0, false)))
+            .await
+            .unwrap();
+
+        // Fund owner so the test doesn't fail due to insufficient lamports
+        context
+            .rpc
+            .airdrop_lamports(&context.owner_keypair.pubkey(), 1_000_000_000)
+            .await
+            .unwrap();
+
+        // Get the valid CToken account data
+        let valid_account = context
+            .rpc
+            .get_account(context.token_account_keypair.pubkey())
+            .await
+            .unwrap()
+            .unwrap();
+
+        // Create a new account with the same data but owned by spl_token program
+        let wrong_owner_account = Keypair::new();
+        let mut account_with_wrong_owner = valid_account.clone();
+        account_with_wrong_owner.owner = spl_token::ID;
+
+        context
+            .rpc
+            .set_account(wrong_owner_account.pubkey(), account_with_wrong_owner);
+
+        let owner = context.owner_keypair.insecure_clone();
+        revoke_and_assert_fails(
+            &mut context,
+            wrong_owner_account.pubkey(),
+            &owner,
+            None,
+            "wrong_program_owner",
+            13, // InstructionError::ExternalAccountDataModified - program tried to modify account it doesn't own
+        )
+        .await;
+    }
+
+    // Test 3: Max top-up exceeded
+    {
+        let mut context = setup_account_test_with_created_account(Some((10, false)))
+            .await
+            .unwrap();
+
+        // First approve to set delegate (need to do before warping)
+        context
+            .rpc
+            .airdrop_lamports(&context.owner_keypair.pubkey(), 1_000_000_000)
+            .await
+            .unwrap();
+        let delegate = Keypair::new();
+        approve_and_assert(&mut context, delegate.pubkey(), 100, "approve_before_warp").await;
+
+        // Warp time to trigger top-up requirement (past funded epochs)
+        context.rpc.warp_to_slot(SLOTS_PER_EPOCH * 12 + 1).unwrap();
+
+        let token_account = context.token_account_keypair.pubkey();
+        let owner = context.owner_keypair.insecure_clone();
+        revoke_and_assert_fails(
+            &mut context,
+            token_account,
+            &owner,
+            Some(1), // max_top_up too low
+            "max_topup_exceeded",
+            18043, // CTokenError::MaxTopUpExceeded
+        )
+        .await;
+    }
+}
+
+// ============================================================================
+// Original Compressible Test (CMint scenario with extensions)
+// ============================================================================
+
+use anchor_lang::AnchorDeserialize;
+use light_ctoken_interface::state::{CToken, TokenDataVersion};
+use light_ctoken_sdk::ctoken::{ApproveCToken, CreateCTokenAccount, RevokeCToken};
+use light_program_test::program_test::TestRpc;
+use light_test_utils::RpcError;
+use solana_sdk::program_pack::Pack;
+
+use super::extensions::setup_extensions_test;
+
+/// Test approve and revoke with a compressible CToken account with extensions.
+/// 1. Create compressible CToken account with all extensions
+/// 2. Set token balance to 100 using set_account
+/// 3. Approve 10 tokens to delegate
+/// 4. Assert delegate and delegated_amount fields
+/// 5. Revoke delegation
+/// 6. Assert delegate cleared and delegated_amount is 0
+#[tokio::test]
+#[serial]
+async fn test_approve_revoke_compressible() -> Result<(), RpcError> {
+    use anchor_spl::token_2022::spl_token_2022;
+
+    let mut context = setup_extensions_test().await?;
+    let payer = context.payer.insecure_clone();
+    let mint_pubkey = context.mint_pubkey;
+    let owner = Keypair::new();
+    let delegate = Keypair::new();
+
+    // 1. Create compressible CToken account with all extensions
+    let account_keypair = Keypair::new();
+    let account_pubkey = account_keypair.pubkey();
+
+    let create_ix =
+        CreateCTokenAccount::new(payer.pubkey(), account_pubkey, mint_pubkey, owner.pubkey())
+            .with_compressible(CompressibleParams {
+                compressible_config: context
+                    .rpc
+                    .test_accounts
+                    .funding_pool_config
+                    .compressible_config_pda,
+                rent_sponsor: context
+                    .rpc
+                    .test_accounts
+                    .funding_pool_config
+                    .rent_sponsor_pda,
+                pre_pay_num_epochs: 2,
+                lamports_per_write: Some(100),
+                compress_to_account_pubkey: None,
+                token_account_version: TokenDataVersion::ShaFlat,
+                compression_only: true,
+            })
+            .instruction()
+            .map_err(|e| {
+                RpcError::AssertRpcError(format!("Failed to create instruction: {}", e))
+            })?;
+
+    context
+        .rpc
+        .create_and_send_transaction(&[create_ix], &payer.pubkey(), &[&payer, &account_keypair])
+        .await?;
+
+    // 2. Set token balance to 100 using set_account
+    let token_balance = 100u64;
+    let mut token_account_info = context
+        .rpc
+        .get_account(account_pubkey)
+        .await?
+        .ok_or_else(|| RpcError::AssertRpcError("Token account not found".to_string()))?;
+
+    let mut spl_token_account =
+        spl_token_2022::state::Account::unpack_unchecked(&token_account_info.data[..165])
+            .map_err(|e| RpcError::AssertRpcError(format!("Failed to unpack: {:?}", e)))?;
+    spl_token_account.amount = token_balance;
+    spl_token_2022::state::Account::pack(spl_token_account, &mut token_account_info.data[..165])
+        .map_err(|e| RpcError::AssertRpcError(format!("Failed to pack: {:?}", e)))?;
+    context.rpc.set_account(account_pubkey, token_account_info);
+
+    // Verify initial state
+    let account_data_initial = context.rpc.get_account(account_pubkey).await?.unwrap();
+    let ctoken_initial = CToken::deserialize(&mut &account_data_initial.data[..])
+        .expect("Failed to deserialize CToken");
+    assert_eq!(ctoken_initial.amount, token_balance);
+    assert!(ctoken_initial.delegate.is_none());
+    assert_eq!(ctoken_initial.delegated_amount, 0);
+
+    // Fund the owner for compressible top-up
+    context
+        .rpc
+        .airdrop_lamports(&owner.pubkey(), 1_000_000_000)
+        .await?;
+
+    // 3. Approve 10 tokens to delegate
+    let approve_amount = 10u64;
+    let approve_ix = ApproveCToken {
+        token_account: account_pubkey,
+        delegate: delegate.pubkey(),
+        owner: owner.pubkey(),
+        amount: approve_amount,
+    }
+    .instruction()
+    .map_err(|e| {
+        RpcError::AssertRpcError(format!("Failed to create approve instruction: {}", e))
+    })?;
+
+    context
+        .rpc
+        .create_and_send_transaction(&[approve_ix], &payer.pubkey(), &[&payer, &owner])
+        .await?;
+
+    // 4. Assert delegate and delegated_amount fields after approve
+    assert_ctoken_approve(
+        &mut context.rpc,
+        account_pubkey,
+        delegate.pubkey(),
+        approve_amount,
+    )
+    .await;
+
+    // 5. Revoke delegation
+    let revoke_ix = RevokeCToken {
+        token_account: account_pubkey,
+        owner: owner.pubkey(),
+    }
+    .instruction()
+    .map_err(|e| RpcError::AssertRpcError(format!("Failed to create revoke instruction: {}", e)))?;
+
+    context
+        .rpc
+        .create_and_send_transaction(&[revoke_ix], &payer.pubkey(), &[&payer, &owner])
+        .await?;
+
+    // 6. Assert delegate cleared and delegated_amount is 0 after revoke
+    assert_ctoken_revoke(&mut context.rpc, account_pubkey).await;
+
+    println!("Successfully tested approve and revoke with compressible CToken");
+    Ok(())
+}
+
+// ============================================================================
+// Approve Checked Tests
+// ============================================================================
+
+use light_ctoken_sdk::ctoken::ApproveCTokenChecked;
+use light_program_test::utils::assert::assert_rpc_error;
+
+use super::shared::setup_account_test_with_spl_mint;
+
+/// Test approve checked with correct decimals succeeds
+#[tokio::test]
+#[serial]
+async fn test_approve_checked_success() {
+    let mut context = setup_account_test_with_spl_mint(9).await.unwrap();
+    let payer_pubkey = context.payer.pubkey();
+    let mint = context.mint_pubkey;
+    let delegate = Keypair::new();
+    let token_account_keypair = Keypair::new();
+
+    // Create a token account directly (without assertion that expects specific structure)
+    let compressible_params = CompressibleParams {
+        compressible_config: context.compressible_config,
+        rent_sponsor: context.rent_sponsor,
+        pre_pay_num_epochs: 2,
+        lamports_per_write: Some(100),
+        compress_to_account_pubkey: None,
+        token_account_version: TokenDataVersion::ShaFlat,
+        compression_only: false,
+    };
+
+    let create_ix = CreateCTokenAccount::new(
+        payer_pubkey,
+        token_account_keypair.pubkey(),
+        mint,
+        context.owner_keypair.pubkey(),
+    )
+    .with_compressible(compressible_params)
+    .instruction()
+    .unwrap();
+
+    context
+        .rpc
+        .create_and_send_transaction(
+            &[create_ix],
+            &payer_pubkey,
+            &[&context.payer, &token_account_keypair],
+        )
+        .await
+        .unwrap();
+
+    // Fund owner for compressible top-up
+    context
+        .rpc
+        .airdrop_lamports(&context.owner_keypair.pubkey(), 1_000_000_000)
+        .await
+        .unwrap();
+
+    let approve_ix = ApproveCTokenChecked {
+        token_account: token_account_keypair.pubkey(),
+        mint,
+        delegate: delegate.pubkey(),
+        owner: context.owner_keypair.pubkey(),
+        amount: 100,
+        decimals: 9, // Correct decimals
+        max_top_up: None,
+    }
+    .instruction()
+    .unwrap();
+
+    context
+        .rpc
+        .create_and_send_transaction(
+            &[approve_ix],
+            &payer_pubkey,
+            &[&context.payer, &context.owner_keypair],
+        )
+        .await
+        .unwrap();
+
+    // Verify delegation was set
+    assert_ctoken_approve(
+        &mut context.rpc,
+        token_account_keypair.pubkey(),
+        delegate.pubkey(),
+        100,
+    )
+    .await;
+
+    println!("test_approve_checked_success: passed");
+}
+
+/// Test approve checked with wrong decimals fails
+#[tokio::test]
+#[serial]
+async fn test_approve_checked_wrong_decimals() {
+    let mut context = setup_account_test_with_spl_mint(9).await.unwrap();
+    let payer_pubkey = context.payer.pubkey();
+    let mint = context.mint_pubkey;
+    let delegate = Keypair::new();
+    let token_account_keypair = Keypair::new();
+
+    // Create a token account directly (without assertion that expects specific structure)
+    let compressible_params = CompressibleParams {
+        compressible_config: context.compressible_config,
+        rent_sponsor: context.rent_sponsor,
+        pre_pay_num_epochs: 2,
+        lamports_per_write: Some(100),
+        compress_to_account_pubkey: None,
+        token_account_version: TokenDataVersion::ShaFlat,
+        compression_only: false,
+    };
+
+    let create_ix = CreateCTokenAccount::new(
+        payer_pubkey,
+        token_account_keypair.pubkey(),
+        mint,
+        context.owner_keypair.pubkey(),
+    )
+    .with_compressible(compressible_params)
+    .instruction()
+    .unwrap();
+
+    context
+        .rpc
+        .create_and_send_transaction(
+            &[create_ix],
+            &payer_pubkey,
+            &[&context.payer, &token_account_keypair],
+        )
+        .await
+        .unwrap();
+
+    // Fund owner for compressible top-up
+    context
+        .rpc
+        .airdrop_lamports(&context.owner_keypair.pubkey(), 1_000_000_000)
+        .await
+        .unwrap();
+
+    // Try to approve with wrong decimals (8 instead of 9)
+    let approve_ix = ApproveCTokenChecked {
+        token_account: token_account_keypair.pubkey(),
+        mint,
+        delegate: delegate.pubkey(),
+        owner: context.owner_keypair.pubkey(),
+        amount: 100,
+        decimals: 8, // Wrong decimals
+        max_top_up: None,
+    }
+    .instruction()
+    .unwrap();
+
+    let result = context
+        .rpc
+        .create_and_send_transaction(
+            &[approve_ix],
+            &payer_pubkey,
+            &[&context.payer, &context.owner_keypair],
+        )
+        .await;
+
+    // Should fail because cached decimals (9) mismatch instruction decimals (8)
+    // When CToken has cached decimals, we return InvalidInstructionData (code 2)
+    assert_rpc_error(result, 0, 2).unwrap();
+    println!("test_approve_checked_wrong_decimals: passed");
+}
diff --git a/program-tests/compressed-token-test/tests/ctoken/burn.rs b/program-tests/compressed-token-test/tests/ctoken/burn.rs
new file mode 100644
index 0000000000..d27e1fe0e6
--- /dev/null
+++ b/program-tests/compressed-token-test/tests/ctoken/burn.rs
@@ -0,0 +1,467 @@
+//! Burn instruction tests for CToken accounts.
+//!
+//! ## Test Matrix
+//!
+//! | Test Category | Test Name |
+//! |--------------|-----------|
+//! | With CMint (partial burn) | test_burn_success_cases |
+//! | With CMint (full balance) | test_burn_success_cases |
+//! | Invalid mint (wrong mint) | test_burn_fails |
+//! | Invalid ctoken (non-existent) | test_burn_fails |
+//! | Invalid ctoken (wrong owner) | test_burn_fails |
+//! | Insufficient balance | test_burn_fails |
+//! | Wrong authority | test_burn_fails |
+//!
+//! **Note**: Burn requires a real CMint account (owned by ctoken program) for supply tracking.
+//! This is different from approve/revoke which only modify the CToken account.
+//!
+//! **Note**: Max top-up exceeded test requires compressible accounts with time warp.
+//! For comprehensive max_top_up testing, see sdk-tests/sdk-ctoken-test/tests/test_burn.rs
+use light_ctoken_sdk::{
+    compressed_token::create_compressed_mint::find_cmint_address,
+    ctoken::{derive_ctoken_ata, BurnCToken, CTokenMintTo, CreateAssociatedCTokenAccount},
+};
+use light_program_test::{
+    program_test::TestRpc, utils::assert::assert_rpc_error, LightProgramTest, ProgramTestConfig,
+};
+use light_test_utils::assert_ctoken_burn::assert_ctoken_burn;
+use light_token_client::instructions::mint_action::DecompressMintParams;
+
+use super::shared::*;
+
+// ============================================================================
+// Burn Success Cases
+// ============================================================================
+
+#[tokio::test]
+#[serial]
+async fn test_burn_success_cases() {
+    // Test 1: Basic burn with CMint (no top-up needed)
+    {
+        let mut ctx = setup_burn_test().await;
+        let burn_amount = 50u64;
+
+        // Burn 50 tokens
+        let burn_ix = BurnCToken {
+            source: ctx.ctoken_account,
+            cmint: ctx.cmint_pda,
+            amount: burn_amount,
+            authority: ctx.owner_keypair.pubkey(),
+            max_top_up: None,
+        }
+        .instruction()
+        .unwrap();
+
+        ctx.rpc
+            .create_and_send_transaction(
+                &[burn_ix],
+                &ctx.payer.pubkey(),
+                &[&ctx.payer, &ctx.owner_keypair],
+            )
+            .await
+            .unwrap();
+
+        // Assert burn was successful using assert_ctoken_burn
+        assert_ctoken_burn(&mut ctx.rpc, ctx.ctoken_account, ctx.cmint_pda, burn_amount).await;
+
+        println!("test_burn_success_cases: basic burn passed");
+    }
+
+    // Test 2: Burn full balance
+    {
+        let mut ctx = setup_burn_test().await;
+        let burn_amount = 100u64;
+
+        // Burn all 100 tokens
+        let burn_ix = BurnCToken {
+            source: ctx.ctoken_account,
+            cmint: ctx.cmint_pda,
+            amount: burn_amount,
+            authority: ctx.owner_keypair.pubkey(),
+            max_top_up: None,
+        }
+        .instruction()
+        .unwrap();
+
+        ctx.rpc
+            .create_and_send_transaction(
+                &[burn_ix],
+                &ctx.payer.pubkey(),
+                &[&ctx.payer, &ctx.owner_keypair],
+            )
+            .await
+            .unwrap();
+
+        // Assert burn was successful using assert_ctoken_burn
+        assert_ctoken_burn(&mut ctx.rpc, ctx.ctoken_account, ctx.cmint_pda, burn_amount).await;
+
+        println!("test_burn_success_cases: burn full balance passed");
+    }
+}
+
+// ============================================================================
+// Burn Failure Cases
+// ============================================================================
+
+/// Error codes used in burn validation
+mod error_codes {
+    /// Insufficient funds to complete the operation (SPL Token code 1)
+    pub const INSUFFICIENT_FUNDS: u32 = 1;
+    /// Authority doesn't match token account owner (SPL Token code 4)
+    pub const OWNER_MISMATCH: u32 = 4;
+}
+
+#[tokio::test]
+#[serial]
+async fn test_burn_fails() {
+    // Test 1: Invalid mint - wrong mint (different CMint)
+    {
+        let mut ctx = setup_burn_test().await;
+
+        // Create a different CMint
+        let other_mint_seed = Keypair::new();
+        let (other_cmint_pda, _) = find_cmint_address(&other_mint_seed.pubkey());
+
+        // Try to burn with wrong mint
+        let burn_ix = BurnCToken {
+            source: ctx.ctoken_account,
+            cmint: other_cmint_pda, // Wrong mint
+            amount: 50,
+            authority: ctx.owner_keypair.pubkey(),
+            max_top_up: None,
+        }
+        .instruction()
+        .unwrap();
+
+        let result = ctx
+            .rpc
+            .create_and_send_transaction(
+                &[burn_ix],
+                &ctx.payer.pubkey(),
+                &[&ctx.payer, &ctx.owner_keypair],
+            )
+            .await;
+
+        // Non-existent CMint returns GenericError (code 0)
+        assert_rpc_error(result, 0, 0).unwrap();
+        println!("test_burn_fails: wrong mint passed");
+    }
+
+    // Test 2: Invalid ctoken - non-existent account
+    {
+        let mut ctx = setup_burn_test().await;
+
+        let non_existent = Pubkey::new_unique();
+
+        let burn_ix = BurnCToken {
+            source: non_existent,
+            cmint: ctx.cmint_pda,
+            amount: 50,
+            authority: ctx.owner_keypair.pubkey(),
+            max_top_up: None,
+        }
+        .instruction()
+        .unwrap();
+
+        let result = ctx
+            .rpc
+            .create_and_send_transaction(
+                &[burn_ix],
+                &ctx.payer.pubkey(),
+                &[&ctx.payer, &ctx.owner_keypair],
+            )
+            .await;
+
+        // Non-existent CToken account returns GenericError (code 0)
+        assert_rpc_error(result, 0, 0).unwrap();
+        println!("test_burn_fails: non-existent account passed");
+    }
+
+    // Test 3: Invalid ctoken - wrong program owner
+    {
+        use anchor_spl::token::spl_token;
+
+        let mut ctx = setup_burn_test().await;
+
+        // Get the valid CToken account data
+        let valid_account = ctx
+            .rpc
+            .get_account(ctx.ctoken_account)
+            .await
+            .unwrap()
+            .unwrap();
+
+        // Create a new account with same data but owned by spl_token program
+        let wrong_owner_account = Keypair::new();
+        let mut account_with_wrong_owner = valid_account.clone();
+        account_with_wrong_owner.owner = spl_token::ID;
+
+        ctx.rpc
+            .set_account(wrong_owner_account.pubkey(), account_with_wrong_owner);
+
+        let burn_ix = BurnCToken {
+            source: wrong_owner_account.pubkey(),
+            cmint: ctx.cmint_pda,
+            amount: 50,
+            authority: ctx.owner_keypair.pubkey(),
+            max_top_up: None,
+        }
+        .instruction()
+        .unwrap();
+
+        let result = ctx
+            .rpc
+            .create_and_send_transaction(
+                &[burn_ix],
+                &ctx.payer.pubkey(),
+                &[&ctx.payer, &ctx.owner_keypair],
+            )
+            .await;
+
+        // Expect ExternalAccountDataModified error (Solana code 13)
+        // This happens when trying to modify an account not owned by the program
+        assert_rpc_error(result, 0, 13).unwrap();
+        println!("test_burn_fails: wrong program owner passed");
+    }
+
+    // Test 4: Insufficient balance
+    {
+        let mut ctx = setup_burn_test().await;
+
+        // Try to burn more than balance (100 tokens)
+        let burn_ix = BurnCToken {
+            source: ctx.ctoken_account,
+            cmint: ctx.cmint_pda,
+            amount: 200, // More than 100 balance
+            authority: ctx.owner_keypair.pubkey(),
+            max_top_up: None,
+        }
+        .instruction()
+        .unwrap();
+
+        let result = ctx
+            .rpc
+            .create_and_send_transaction(
+                &[burn_ix],
+                &ctx.payer.pubkey(),
+                &[&ctx.payer, &ctx.owner_keypair],
+            )
+            .await;
+
+        // Expect InsufficientFunds error (SPL Token code 1)
+        assert_rpc_error(result, 0, error_codes::INSUFFICIENT_FUNDS).unwrap();
+        println!("test_burn_fails: insufficient balance passed");
+    }
+
+    // Test 5: Wrong authority
+    {
+        let mut ctx = setup_burn_test().await;
+
+        // Use a different authority (not the owner)
+        let wrong_authority = Keypair::new();
+        ctx.rpc
+            .airdrop_lamports(&wrong_authority.pubkey(), 1_000_000_000)
+            .await
+            .unwrap();
+
+        let burn_ix = BurnCToken {
+            source: ctx.ctoken_account,
+            cmint: ctx.cmint_pda,
+            amount: 50,
+            authority: wrong_authority.pubkey(),
+            max_top_up: None,
+        }
+        .instruction()
+        .unwrap();
+
+        let result = ctx
+            .rpc
+            .create_and_send_transaction(
+                &[burn_ix],
+                &ctx.payer.pubkey(),
+                &[&ctx.payer, &wrong_authority],
+            )
+            .await;
+
+        // Expect OwnerMismatch error (SPL Token code 4)
+        assert_rpc_error(result, 0, error_codes::OWNER_MISMATCH).unwrap();
+        println!("test_burn_fails: wrong authority passed");
+    }
+
+    // Test 6: Max top-up exceeded
+    // Note: This requires compressible accounts that need top-up after time warp.
+    // The current setup creates non-compressible accounts, so max_top_up test
+    // would need additional setup. For comprehensive max_top_up testing, see
+    // sdk-tests/sdk-ctoken-test/tests/test_burn.rs
+}
+
+// ============================================================================
+// Helper Functions
+// ============================================================================
+
+/// Test context for burn operations
+struct BurnTestContext {
+    rpc: LightProgramTest,
+    payer: Keypair,
+    cmint_pda: Pubkey,
+    ctoken_account: Pubkey,
+    owner_keypair: Keypair,
+}
+
+/// Setup: Create CMint + CToken with 100 tokens
+///
+/// Steps:
+/// 1. Init LightProgramTest
+/// 2. Create compressed mint + CMint via mint_action_comprehensive
+/// 3. Create CToken ATA
+/// 4. Mint 100 tokens
+async fn setup_burn_test() -> BurnTestContext {
+    let mut rpc = LightProgramTest::new(ProgramTestConfig::new_v2(false, None))
+        .await
+        .unwrap();
+
+    let payer = rpc.get_payer().insecure_clone();
+    let mint_seed = Keypair::new();
+    let mint_authority = payer.insecure_clone();
+    let owner_keypair = Keypair::new();
+
+    // Derive CMint PDA
+    let (cmint_pda, _) = find_cmint_address(&mint_seed.pubkey());
+
+    // Step 1: Create CToken ATA for owner
+    let (ctoken_ata, _) = derive_ctoken_ata(&owner_keypair.pubkey(), &cmint_pda);
+
+    let create_ata_ix =
+        CreateAssociatedCTokenAccount::new(payer.pubkey(), owner_keypair.pubkey(), cmint_pda)
+            .instruction()
+            .unwrap();
+
+    rpc.create_and_send_transaction(&[create_ata_ix], &payer.pubkey(), &[&payer])
+        .await
+        .unwrap();
+
+    // Step 2: Create compressed mint + CMint (no recipients)
+    light_token_client::actions::mint_action_comprehensive(
+        &mut rpc,
+        &mint_seed,
+        &mint_authority,
+        &payer,
+        Some(DecompressMintParams::default()), // Creates CMint
+        false,                                 // Don't compress and close
+        vec![],                                // No compressed recipients
+        vec![],                                // No ctoken recipients
+        None,                                  // No mint authority update
+        None,                                  // No freeze authority update
+        Some(light_token_client::instructions::mint_action::NewMint {
+            decimals: 8,
+            supply: 0,
+            mint_authority: mint_authority.pubkey(),
+            freeze_authority: None,
+            metadata: None,
+            version: 3,
+        }),
+    )
+    .await
+    .unwrap();
+
+    // Step 3: Mint 100 tokens to the CToken account
+    let mint_ix = CTokenMintTo {
+        cmint: cmint_pda,
+        destination: ctoken_ata,
+        amount: 100,
+        authority: mint_authority.pubkey(),
+        max_top_up: None,
+    }
+    .instruction()
+    .unwrap();
+
+    rpc.create_and_send_transaction(&[mint_ix], &payer.pubkey(), &[&payer])
+        .await
+        .unwrap();
+
+    // Fund owner for transaction fees
+    rpc.airdrop_lamports(&owner_keypair.pubkey(), 1_000_000_000)
+        .await
+        .unwrap();
+
+    BurnTestContext {
+        rpc,
+        payer,
+        cmint_pda,
+        ctoken_account: ctoken_ata,
+        owner_keypair,
+    }
+}
+
+// ============================================================================
+// Burn Checked Tests
+// ============================================================================
+
+use light_ctoken_sdk::ctoken::BurnCTokenChecked;
+
+/// MintDecimalsMismatch error code (SPL Token code 18)
+const MINT_DECIMALS_MISMATCH: u32 = 18;
+
+#[tokio::test]
+#[serial]
+async fn test_burn_checked_success() {
+    let mut ctx = setup_burn_test().await;
+    let burn_amount = 50u64;
+
+    // Burn 50 tokens with correct decimals (8)
+    let burn_ix = BurnCTokenChecked {
+        source: ctx.ctoken_account,
+        cmint: ctx.cmint_pda,
+        amount: burn_amount,
+        decimals: 8, // Correct decimals
+        authority: ctx.owner_keypair.pubkey(),
+        max_top_up: None,
+    }
+    .instruction()
+    .unwrap();
+
+    ctx.rpc
+        .create_and_send_transaction(
+            &[burn_ix],
+            &ctx.payer.pubkey(),
+            &[&ctx.payer, &ctx.owner_keypair],
+        )
+        .await
+        .unwrap();
+
+    // Assert burn was successful using assert_ctoken_burn
+    assert_ctoken_burn(&mut ctx.rpc, ctx.ctoken_account, ctx.cmint_pda, burn_amount).await;
+
+    println!("test_burn_checked_success: passed");
+}
+
+#[tokio::test]
+#[serial]
+async fn test_burn_checked_wrong_decimals() {
+    let mut ctx = setup_burn_test().await;
+
+    // Try to burn with wrong decimals (7 instead of 8)
+    let burn_ix = BurnCTokenChecked {
+        source: ctx.ctoken_account,
+        cmint: ctx.cmint_pda,
+        amount: 50,
+        decimals: 7, // Wrong decimals
+        authority: ctx.owner_keypair.pubkey(),
+        max_top_up: None,
+    }
+    .instruction()
+    .unwrap();
+
+    let result = ctx
+        .rpc
+        .create_and_send_transaction(
+            &[burn_ix],
+            &ctx.payer.pubkey(),
+            &[&ctx.payer, &ctx.owner_keypair],
+        )
+        .await;
+
+    // Expect MintDecimalsMismatch error (SPL Token code 18)
+    assert_rpc_error(result, 0, MINT_DECIMALS_MISMATCH).unwrap();
+    println!("test_burn_checked_wrong_decimals: passed");
+}
diff --git a/program-tests/compressed-token-test/tests/ctoken/close.rs b/program-tests/compressed-token-test/tests/ctoken/close.rs
index 90b76392ce..5849c18eae 100644
--- a/program-tests/compressed-token-test/tests/ctoken/close.rs
+++ b/program-tests/compressed-token-test/tests/ctoken/close.rs
@@ -100,9 +100,9 @@ async fn test_close_token_account_fails() {
             &mut context,
             destination,
             &wrong_owner,
-            Some(rent_sponsor),
+            rent_sponsor,
             "wrong_owner",
-            75, // ErrorCode::OwnerMismatch
+            6075, // ErrorCode::OwnerMismatch
         )
         .await;
     }
@@ -113,7 +113,7 @@ async fn test_close_token_account_fails() {
             &mut context,
             token_account_pubkey, // destination same as token_account
             &owner_keypair,
-            Some(rent_sponsor),
+            rent_sponsor,
             "destination_same_as_token_account",
             3, // ProgramError::InvalidAccountData
         )
@@ -133,7 +133,7 @@ async fn test_close_token_account_fails() {
             &mut context,
             destination,
             &owner_keypair,
-            None, // Missing rent_sponsor
+            Pubkey::default(), // Missing rent_sponsor
             "missing_rent_sponsor",
             11, // ProgramError::NotEnoughAccountKeys
         )
@@ -155,7 +155,7 @@ async fn test_close_token_account_fails() {
             &mut context,
             destination,
             &owner_keypair,
-            Some(wrong_rent_sponsor), // Wrong rent_sponsor
+            wrong_rent_sponsor, // Wrong rent_sponsor
             "wrong_rent_sponsor",
             3, // ProgramError::InvalidAccountData
         )
@@ -191,7 +191,7 @@ async fn test_close_token_account_fails() {
         use light_ctoken_interface::state::ctoken::CToken;
         use light_zero_copy::traits::ZeroCopyAtMut;
         let (mut ctoken, _) = CToken::zero_copy_at_mut(&mut account.data).unwrap();
-        *ctoken.amount = 1u64.into();
+        ctoken.amount.set(1u64);
         drop(ctoken);
 
         // Set the modified account back
@@ -208,9 +208,9 @@ async fn test_close_token_account_fails() {
             &mut context,
             destination,
             &owner_keypair,
-            Some(rent_sponsor),
+            rent_sponsor,
             "non_zero_balance",
-            74, // ErrorCode::NonNativeHasBalance
+            6074, // ErrorCode::NonNativeHasBalance
         )
         .await;
     }
@@ -245,7 +245,7 @@ async fn test_close_token_account_fails() {
         use light_zero_copy::traits::ZeroCopyAtMut;
         use spl_token_2022::state::AccountState;
         let (mut ctoken, _) = CToken::zero_copy_at_mut(&mut account.data).unwrap();
-        *ctoken.state = AccountState::Uninitialized as u8;
+        ctoken.state = AccountState::Uninitialized as u8;
         drop(ctoken);
 
         // Set the modified account back
@@ -262,14 +262,14 @@ async fn test_close_token_account_fails() {
             &mut context,
             destination,
             &owner_keypair,
-            Some(rent_sponsor),
+            rent_sponsor,
             "uninitialized_account",
             18036, // CTokenError::InvalidAccountState
         )
         .await;
     }
 
-    // Test 11: Frozen account → Error 6076 (AccountFrozen)
+    // Test 11: Frozen account → Error 18036 (CTokenError::InvalidAccountState)
     {
         // Create a fresh account for this test
         context.token_account_keypair = Keypair::new();
@@ -298,7 +298,7 @@ async fn test_close_token_account_fails() {
         use light_zero_copy::traits::ZeroCopyAtMut;
         use spl_token_2022::state::AccountState;
         let (mut ctoken, _) = CToken::zero_copy_at_mut(&mut account.data).unwrap();
-        *ctoken.state = AccountState::Frozen as u8;
+        ctoken.state = AccountState::Frozen as u8;
         drop(ctoken);
 
         // Set the modified account back
@@ -315,9 +315,9 @@ async fn test_close_token_account_fails() {
             &mut context,
             destination,
             &owner_keypair,
-            Some(rent_sponsor),
+            rent_sponsor,
             "frozen_account",
-            18036, // CTokenError::InvalidAccountState
+            18036, // CTokenError::InvalidAccountState (frozen accounts rejected by zero_copy_at_mut_checked)
         )
         .await;
     }
diff --git a/program-tests/compressed-token-test/tests/ctoken/compress_and_close.rs b/program-tests/compressed-token-test/tests/ctoken/compress_and_close.rs
index a5cdf3a2ed..9143bdf0fa 100644
--- a/program-tests/compressed-token-test/tests/ctoken/compress_and_close.rs
+++ b/program-tests/compressed-token-test/tests/ctoken/compress_and_close.rs
@@ -1,5 +1,4 @@
 use light_client::rpc::Rpc;
-use light_ctoken_interface::state::ZExtensionStructMut;
 use light_zero_copy::traits::ZeroCopyAtMut;
 use solana_sdk::signer::Signer;
 
@@ -249,7 +248,7 @@ async fn test_compress_and_close_rent_authority_scenarios() {
             .rpc
             .airdrop_lamports(
                 &token_account_pubkey,
-                RentConfig::default().get_rent(COMPRESSIBLE_TOKEN_ACCOUNT_SIZE, 1),
+                RentConfig::default().get_rent(BASE_TOKEN_ACCOUNT_SIZE, 1),
             )
             .await
             .unwrap();
@@ -437,15 +436,8 @@ async fn test_compress_and_close_compress_to_pubkey() {
         let (mut ctoken, _) = CToken::zero_copy_at_mut(&mut token_account.data)
             .expect("Failed to deserialize ctoken account");
 
-        // Modify compress_to_pubkey in the compressible extension
-        if let Some(extensions) = ctoken.extensions.as_mut() {
-            for ext in extensions.iter_mut() {
-                if let ZExtensionStructMut::Compressible(ref mut comp) = ext {
-                    comp.info.compress_to_pubkey = 1;
-                    break;
-                }
-            }
-        }
+        // Modify compress_to_pubkey in the compression field (now on meta, not extension)
+        ctoken.compression.compress_to_pubkey = 1;
 
         // Write the modified account back
         context.rpc.set_account(token_account_pubkey, token_account);
@@ -507,7 +499,7 @@ async fn test_compressible_account_with_custom_rent_payer_close_with_compression
     // Create system account with compressible size
     let rent_exemption = context
         .rpc
-        .get_minimum_balance_for_rent_exemption(COMPRESSIBLE_TOKEN_ACCOUNT_SIZE as usize)
+        .get_minimum_balance_for_rent_exemption(BASE_TOKEN_ACCOUNT_SIZE as usize)
         .await
         .unwrap();
 
@@ -522,6 +514,7 @@ async fn test_compressible_account_with_custom_rent_payer_close_with_compression
         lamports_per_write,
         compress_to_account_pubkey: None,
         token_account_version: light_ctoken_interface::state::TokenDataVersion::ShaFlat,
+        compression_only: false,
     };
 
     let create_token_account_ix = CreateCTokenAccount::new(
@@ -567,6 +560,7 @@ async fn test_compressible_account_with_custom_rent_payer_close_with_compression
             account_version: light_ctoken_interface::state::TokenDataVersion::ShaFlat,
             payer: payer_pubkey,
         }),
+        None,
     )
     .await;
 
@@ -581,7 +575,7 @@ async fn test_compressible_account_with_custom_rent_payer_close_with_compression
         .expect("Payer should exist")
         .lamports;
     let rent = RentConfig::default()
-        .get_rent_with_compression_cost(COMPRESSIBLE_TOKEN_ACCOUNT_SIZE, num_prepaid_epochs as u64);
+        .get_rent_with_compression_cost(BASE_TOKEN_ACCOUNT_SIZE, num_prepaid_epochs as u64);
     let tx_fee = 10_000; // Standard transaction fee
     assert_eq!(
         pool_balance_before - payer_balance_after,
@@ -606,8 +600,8 @@ async fn test_compressible_account_with_custom_rent_payer_close_with_compression
             .unwrap()
             .expect("Payer should exist")
             .lamports;
-        let rent = RentConfig::default()
-            .get_rent(COMPRESSIBLE_TOKEN_ACCOUNT_SIZE, num_prepaid_epochs as u64);
+        let rent =
+            RentConfig::default().get_rent(BASE_TOKEN_ACCOUNT_SIZE, num_prepaid_epochs as u64);
         assert_eq!(
             payer_balance_after,
             payer_balance_before + rent_exemption + rent,
@@ -739,7 +733,7 @@ async fn test_compress_and_close_output_validation_errors() {
             &mut context,
             CompressAndCloseValidationError::OwnerMismatch(wrong_owner.pubkey()),
             None, // Default destination
-            89,   // CompressAndCloseInvalidOwner
+            6089, // CompressAndCloseInvalidOwner
         )
         .await;
     }
@@ -774,15 +768,8 @@ async fn test_compress_and_close_output_validation_errors() {
         let (mut ctoken, _) = CToken::zero_copy_at_mut(&mut token_account.data)
             .expect("Failed to deserialize ctoken account");
 
-        // Set compress_to_pubkey=true in the compressible extension
-        if let Some(extensions) = ctoken.extensions.as_mut() {
-            for ext in extensions.iter_mut() {
-                if let ZExtensionStructMut::Compressible(ref mut comp) = ext {
-                    comp.info.compress_to_pubkey = 1;
-                    break;
-                }
-            }
-        }
+        // Set compress_to_pubkey=true in the compression field (now on meta, not extension)
+        ctoken.compression.compress_to_pubkey = 1;
 
         // Write the modified account back
         context.rpc.set_account(token_account_pubkey, token_account);
@@ -793,14 +780,14 @@ async fn test_compress_and_close_output_validation_errors() {
             &mut context,
             CompressAndCloseValidationError::OwnerNotAccountPubkey(owner_pubkey),
             None, // Default destination
-            89,   // CompressAndCloseInvalidOwner
+            6089, // CompressAndCloseInvalidOwner
         )
         .await;
     }
 
-    // Test 8: Token account has delegate - should fail when forester tries to close
-    // The validation checks that delegate must be None in compressed output
-    // Since compressed token doesn't support delegation, any account with a delegate should fail
+    // Test 8: Forester CAN compress and close accounts with delegates
+    // When a delegate is present, the registry automatically adds CompressedOnly extension
+    // to preserve the delegate in the compressed output. This allows recovery of delegated accounts.
     {
         let mut context = setup_compress_and_close_test(
             2,       // 2 prepaid epochs
@@ -847,23 +834,37 @@ async fn test_compress_and_close_output_validation_errors() {
             .await
             .unwrap();
 
-        // Try to compress and close via forester (should fail because delegate is present)
-        // Error: CompressAndCloseDelegateNotAllowed (92 = 0x5c)
-        let result = compress_and_close_forester(
+        // Compress and close via forester (should succeed - delegate preserved via CompressedOnly)
+        compress_and_close_forester(
             &mut context.rpc,
             &[token_account_pubkey],
             &forester_keypair,
             &context.payer,
             Some(destination.pubkey()),
         )
-        .await;
+        .await
+        .unwrap();
 
-        // Assert that the transaction failed with delegate not allowed error
-        light_program_test::utils::assert::assert_rpc_error(result, 0, 92).unwrap();
+        // Assert compress and close succeeded
+        use light_test_utils::assert_transfer2::assert_transfer2_compress_and_close;
+        use light_token_client::instructions::transfer2::CompressAndCloseInput;
+
+        let output_queue = context.rpc.get_random_state_tree_info().unwrap().queue;
+        assert_transfer2_compress_and_close(
+            &mut context.rpc,
+            CompressAndCloseInput {
+                solana_ctoken_account: token_account_pubkey,
+                authority: context.compression_authority,
+                output_queue,
+                destination: Some(destination.pubkey()),
+                is_compressible: true,
+            },
+        )
+        .await;
     }
 
-    // Test 9: Frozen account cannot be closed
-    // The validation checks that account state must be Initialized, not Frozen
+    // Test 9: Forester CAN compress and close frozen accounts
+    // Note: Owner compress_and_close is already tested in test_compress_and_close_owner_scenarios
     {
         let mut context = setup_compress_and_close_test(
             2,       // 2 prepaid epochs
@@ -897,7 +898,9 @@ async fn test_compress_and_close_output_validation_errors() {
             .unwrap();
         context.rpc.set_account(token_account_pubkey, token_account);
 
-        // Get forester keypair and setup for compress_and_close
+        // Test 9: Forester CAN close frozen accounts
+        // Note: Owners can't compress_and_close at all (they fail compression_authority check
+        // in test_compress_and_close_owner_scenarios), so frozen account test for owners is redundant
         let forester_keypair = context.rpc.test_accounts.protocol.forester.insecure_clone();
 
         // Create destination for compression incentive
@@ -908,19 +911,32 @@ async fn test_compress_and_close_output_validation_errors() {
             .await
             .unwrap();
 
-        // Try to compress and close via forester (should fail because account is frozen)
-        // Error: AccountFrozen
-        let result = compress_and_close_forester(
+        // Compress and close via forester (should succeed)
+        compress_and_close_forester(
             &mut context.rpc,
             &[token_account_pubkey],
             &forester_keypair,
             &context.payer,
             Some(destination.pubkey()),
         )
-        .await;
+        .await
+        .unwrap();
 
-        // Assert that the transaction failed with account frozen error
-        // Error: InvalidAccountState (18036)
-        light_program_test::utils::assert::assert_rpc_error(result, 0, 18036).unwrap();
+        // Assert compress and close succeeded
+        use light_test_utils::assert_transfer2::assert_transfer2_compress_and_close;
+        use light_token_client::instructions::transfer2::CompressAndCloseInput;
+
+        let output_queue = context.rpc.get_random_state_tree_info().unwrap().queue;
+        assert_transfer2_compress_and_close(
+            &mut context.rpc,
+            CompressAndCloseInput {
+                solana_ctoken_account: token_account_pubkey,
+                authority: context.compression_authority,
+                output_queue,
+                destination: Some(destination.pubkey()),
+                is_compressible: true,
+            },
+        )
+        .await;
     }
 }
diff --git a/program-tests/compressed-token-test/tests/ctoken/create.rs b/program-tests/compressed-token-test/tests/ctoken/create.rs
index 4432b80bcf..663f93b001 100644
--- a/program-tests/compressed-token-test/tests/ctoken/create.rs
+++ b/program-tests/compressed-token-test/tests/ctoken/create.rs
@@ -1,10 +1,7 @@
-use anchor_lang::prelude::AccountMeta;
-use light_ctoken_interface::instructions::create_ctoken_account::CreateTokenAccountInstructionData;
 use rand::{
     rngs::{StdRng, ThreadRng},
     Rng, RngCore, SeedableRng,
 };
-use solana_sdk::instruction::Instruction;
 
 use super::shared::*;
 
@@ -177,41 +174,16 @@ async fn test_create_compressible_token_account_failing() {
             &mut context,
             compressible_data,
             "one_epoch_prefunding_forbidden",
-            101, // OneEpochPrefundingNotAllowed (0x65 hex = 101 decimal)
+            6101, // OneEpochPrefundingNotAllowed
         )
         .await;
     }
 
-    // Test 2: Account already initialized
-    // Creating the same account twice should fail.
-    // Error: 6078 (AlreadyInitialized)
-    {
-        context.token_account_keypair = Keypair::new();
-        let compressible_data = CompressibleData {
-            compression_authority: context.compression_authority,
-            rent_sponsor: context.rent_sponsor,
-            num_prepaid_epochs: 2,
-            lamports_per_write: Some(100),
-            account_version: light_ctoken_interface::state::TokenDataVersion::ShaFlat,
-            compress_to_pubkey: false,
-            payer: payer_pubkey,
-        };
+    // Note: Test 2 (AlreadyInitialized) removed because create_pda_account now uses
+    // DoS prevention logic that allows re-initialization via Assign + realloc path.
+    // When an account already has lamports, it doesn't call CreateAccount.
 
-        // First creation succeeds
-        create_and_assert_token_account(&mut context, compressible_data.clone(), "first_creation")
-            .await;
-
-        // Second creation fails
-        create_and_assert_token_account_fails(
-            &mut context,
-            compressible_data,
-            "account_already_initialized",
-            78, // AlreadyInitialized (our program checks this after Assign+realloc pattern)
-        )
-        .await;
-    }
-
-    // Test 3: Insufficient payer balance
+    // Test 2: Insufficient payer balance
     // Payer doesn't have enough lamports for rent payment.
     // This will fail during the transfer_lamports_via_cpi call.
     // Error: 1 (InsufficientFunds from system program)
@@ -234,6 +206,7 @@ async fn test_create_compressible_token_account_failing() {
             lamports_per_write: Some(1000),
             compress_to_account_pubkey: None,
             token_account_version: light_ctoken_interface::state::TokenDataVersion::ShaFlat,
+            compression_only: false,
         };
 
         let create_token_account_ix = CreateCTokenAccount::new(
@@ -259,102 +232,17 @@ async fn test_create_compressible_token_account_failing() {
         light_program_test::utils::assert::assert_rpc_error(result, 0, 1).unwrap();
     }
 
-    // Test 4: Non-compressible account already initialized
-    // For non-compressible accounts, the account already exists and is owned by the program.
-    // Trying to initialize it again should fail with AlreadyInitialized from our program.
-    // Error: 58 (AlreadyInitialized from our program, not system program)
-    {
-        println!("starting test 4");
-        context.token_account_keypair = Keypair::new();
-        // Create the account via system program
-        let rent = context
-            .rpc
-            .get_minimum_balance_for_rent_exemption(165)
-            .await
-            .unwrap();
-
-        let create_account_ix = solana_sdk::system_instruction::create_account(
-            &payer_pubkey,
-            &context.token_account_keypair.pubkey(),
-            rent,
-            165,
-            &light_compressed_token::ID,
-        );
-
-        // Send create account transaction
-        context
-            .rpc
-            .create_and_send_transaction(
-                &[create_account_ix],
-                &payer_pubkey,
-                &[&context.payer, &context.token_account_keypair],
-            )
-            .await
-            .unwrap();
-        // Build initialize instruction data (non-compressible)
-        let init_data = CreateTokenAccountInstructionData {
-            owner: context.owner_keypair.pubkey().into(),
-            compressible_config: None, // Non-compressible
-        };
-        use anchor_lang::prelude::borsh::BorshSerialize;
-        let mut data = vec![18]; // CreateTokenAccount discriminator
-        init_data.serialize(&mut data).unwrap();
-
-        // Build instruction
-        let init_ix = Instruction {
-            program_id: light_compressed_token::ID,
-            accounts: vec![
-                AccountMeta::new(context.token_account_keypair.pubkey(), true),
-                AccountMeta::new_readonly(context.mint_pubkey, false),
-            ],
-            data: data.clone(),
-        };
-
-        // First initialization should succeed
-        context
-            .rpc
-            .create_and_send_transaction(
-                std::slice::from_ref(&init_ix),
-                &payer_pubkey,
-                &[&context.payer, &context.token_account_keypair],
-            )
-            .await
-            .unwrap();
-        let other_payer = Keypair::new();
-        context
-            .rpc
-            .airdrop_lamports(&other_payer.pubkey(), 10000000000)
-            .await
-            .unwrap();
-        // Build instruction
-        let init_ix = Instruction {
-            program_id: light_compressed_token::ID,
-            accounts: vec![
-                AccountMeta::new(context.token_account_keypair.pubkey(), true),
-                AccountMeta::new_readonly(context.mint_pubkey, false),
-            ],
-            data,
-        };
-        // Second initialization should fail with AlreadyInitialized
-        let result = context
-            .rpc
-            .create_and_send_transaction(
-                &[init_ix],
-                &other_payer.pubkey(),
-                &[&other_payer, &context.token_account_keypair],
-            )
-            .await;
-
-        // Should fail with AlreadyInitialized (78) from our program
-        light_program_test::utils::assert::assert_rpc_error(result, 0, 78).unwrap();
-    }
+    // Note: Test 4 (Non-compressible account already initialized) removed because:
+    // 1. All accounts now have compression infrastructure (no pure non-compressible accounts)
+    // 2. The manual instruction approach with only 2 accounts is no longer valid
+    // 3. DoS prevention allows re-initialization via Assign + realloc path
 
-    // Test 5: Invalid PDA seeds for compress_to_account_pubkey
+    // Test 3: Invalid PDA seeds for compress_to_account_pubkey
     // When compress_to_account_pubkey is provided, the seeds must derive to the token account.
     // Providing invalid seeds should fail the PDA validation.
     // Error: 18002 (InvalidAccountData from CTokenError)
     {
-        use light_ctoken_interface::instructions::extensions::compressible::CompressToPubkey;
+        use light_ctoken_interface::instructions::create_ctoken_account::CompressToPubkey;
 
         context.token_account_keypair = Keypair::new();
         let token_account_pubkey = context.token_account_keypair.pubkey();
@@ -373,6 +261,7 @@ async fn test_create_compressible_token_account_failing() {
             lamports_per_write: Some(100),
             compress_to_account_pubkey: Some(invalid_compress_to_pubkey),
             token_account_version: light_ctoken_interface::state::TokenDataVersion::ShaFlat,
+            compression_only: false,
         };
 
         let create_token_account_ix = CreateCTokenAccount::new(
@@ -423,6 +312,7 @@ async fn test_create_compressible_token_account_failing() {
             lamports_per_write: Some(100),
             compress_to_account_pubkey: None,
             token_account_version: light_ctoken_interface::state::TokenDataVersion::ShaFlat,
+            compression_only: false,
         };
 
         let create_token_account_ix = CreateCTokenAccount::new(
@@ -494,6 +384,7 @@ async fn test_create_compressible_token_account_failing() {
             lamports_per_write: Some(100),
             compress_to_account_pubkey: None,
             token_account_version: light_ctoken_interface::state::TokenDataVersion::ShaFlat,
+            compression_only: false,
         };
 
         let create_token_account_ix = CreateCTokenAccount::new(
@@ -537,6 +428,7 @@ async fn test_create_compressible_token_account_failing() {
             lamports_per_write: Some(100),
             compress_to_account_pubkey: None,
             token_account_version: light_ctoken_interface::state::TokenDataVersion::ShaFlat,
+            compression_only: false,
         };
 
         let create_token_account_ix = CreateCTokenAccount::new(
diff --git a/program-tests/compressed-token-test/tests/ctoken/create_ata.rs b/program-tests/compressed-token-test/tests/ctoken/create_ata.rs
index 9d232c7841..6cf82e0380 100644
--- a/program-tests/compressed-token-test/tests/ctoken/create_ata.rs
+++ b/program-tests/compressed-token-test/tests/ctoken/create_ata.rs
@@ -168,24 +168,40 @@ async fn test_create_ata_idempotent() {
         // Verify the account still has the same properties (unchanged by second creation)
         let account = context.rpc.get_account(ata_pubkey).await.unwrap().unwrap();
 
-        // Should still be compressible size (COMPRESSIBLE_TOKEN_ACCOUNT_SIZE bytes)
+        // Should still be compressible size (BASE_TOKEN_ACCOUNT_SIZE bytes)
         assert_eq!(
             account.data.len(),
-            light_ctoken_interface::COMPRESSIBLE_TOKEN_ACCOUNT_SIZE as usize,
+            light_ctoken_interface::BASE_TOKEN_ACCOUNT_SIZE as usize,
             "Account should still be compressible size after idempotent recreation"
         );
     }
 }
 
+/// Tests creation of an ATA with 0 prepaid epochs (immediately compressible).
+/// All CToken accounts now have compression infrastructure, so we pass
+/// CompressibleData with num_prepaid_epochs: 0.
 #[tokio::test]
 async fn test_create_non_compressible_ata() {
     let mut context = setup_account_test().await.unwrap();
+    let payer_pubkey = context.payer.pubkey();
+
+    // All accounts now have compression infrastructure, so pass CompressibleData
+    // with 0 prepaid epochs (immediately compressible)
+    let compressible_data = CompressibleData {
+        compression_authority: context.compression_authority,
+        rent_sponsor: context.rent_sponsor,
+        num_prepaid_epochs: 0,
+        lamports_per_write: None,
+        account_version: light_ctoken_interface::state::TokenDataVersion::ShaFlat,
+        compress_to_pubkey: false,
+        payer: payer_pubkey,
+    };
 
     create_and_assert_ata(
         &mut context,
-        None,  // Non-compressible
+        Some(compressible_data),
         false, // Non-idempotent
-        "non_compressible_ata",
+        "ata_zero_epochs",
     )
     .await;
 }
@@ -217,7 +233,7 @@ async fn test_create_ata_failing() {
             Some(compressible_data),
             false, // Non-idempotent
             "one_epoch_prefunding_forbidden",
-            101, // OneEpochPrefundingNotAllowed (0x65 hex = 101 decimal)
+            6101, // OneEpochPrefundingNotAllowed
         )
         .await;
     }
@@ -284,6 +300,7 @@ async fn test_create_ata_failing() {
             lamports_per_write: Some(1000),
             compress_to_account_pubkey: None,
             token_account_version: light_ctoken_interface::state::TokenDataVersion::ShaFlat,
+            compression_only: false,
         };
 
         let create_ata_ix = CreateAssociatedCTokenAccount::new(
@@ -311,7 +328,7 @@ async fn test_create_ata_failing() {
         use anchor_lang::prelude::borsh::BorshSerialize;
         use light_ctoken_interface::instructions::{
             create_associated_token_account::CreateAssociatedTokenAccountInstructionData,
-            extensions::compressible::{CompressToPubkey, CompressibleExtensionInstructionData},
+            create_ctoken_account::CompressToPubkey,
         };
         use solana_sdk::instruction::Instruction;
 
@@ -320,7 +337,7 @@ async fn test_create_ata_failing() {
         let (ata_pubkey, bump) =
             derive_ctoken_ata(&context.owner_keypair.pubkey(), &context.mint_pubkey);
 
-        // Manually build instruction data with compress_to_account_pubkey (forbidden)
+        // Manually build instruction data with compress_to_account_pubkey (forbidden for ATAs)
         let compress_to_pubkey = CompressToPubkey {
             bump: 255,
             program_id: light_compressed_token::ID.to_bytes(),
@@ -329,14 +346,11 @@ async fn test_create_ata_failing() {
 
         let instruction_data = CreateAssociatedTokenAccountInstructionData {
             bump,
-            compressible_config: Some(CompressibleExtensionInstructionData {
-                compression_only: 0,
-                token_account_version: light_ctoken_interface::state::TokenDataVersion::ShaFlat
-                    as u8,
-                rent_payment: 2,
-                write_top_up: 100,
-                compress_to_account_pubkey: Some(compress_to_pubkey), // Forbidden for ATAs!
-            }),
+            token_account_version: light_ctoken_interface::state::TokenDataVersion::ShaFlat as u8,
+            rent_payment: 2,
+            compression_only: 0,
+            write_top_up: 100,
+            compressible_config: Some(compress_to_pubkey), // Forbidden for ATAs!
         };
 
         let mut data = vec![100]; // CreateAssociatedCTokenAccount discriminator
@@ -380,10 +394,7 @@ async fn test_create_ata_failing() {
     // Error: 21 (ProgramFailedToComplete - provided seeds do not result in valid address)
     {
         use anchor_lang::prelude::borsh::BorshSerialize;
-        use light_ctoken_interface::instructions::{
-            create_associated_token_account::CreateAssociatedTokenAccountInstructionData,
-            extensions::compressible::CompressibleExtensionInstructionData,
-        };
+        use light_ctoken_interface::instructions::create_associated_token_account::CreateAssociatedTokenAccountInstructionData;
         use solana_sdk::instruction::Instruction;
 
         // Use different mint for this test
@@ -401,14 +412,11 @@ async fn test_create_ata_failing() {
         // Owner and mint are now passed as accounts, not in instruction data
         let instruction_data = CreateAssociatedTokenAccountInstructionData {
             bump: wrong_bump, // Wrong bump!
-            compressible_config: Some(CompressibleExtensionInstructionData {
-                compression_only: 0,
-                token_account_version: light_ctoken_interface::state::TokenDataVersion::ShaFlat
-                    as u8,
-                rent_payment: 2,
-                write_top_up: 100,
-                compress_to_account_pubkey: None,
-            }),
+            token_account_version: light_ctoken_interface::state::TokenDataVersion::ShaFlat as u8,
+            rent_payment: 2,
+            compression_only: 0,
+            write_top_up: 100,
+            compressible_config: None,
         };
 
         let mut data = vec![100]; // CreateAssociatedCTokenAccount discriminator
@@ -472,6 +480,7 @@ async fn test_create_ata_failing() {
             lamports_per_write: Some(100),
             compress_to_account_pubkey: None,
             token_account_version: light_ctoken_interface::state::TokenDataVersion::ShaFlat,
+            compression_only: false,
         };
 
         let create_ata_ix = CreateAssociatedCTokenAccount::new(
@@ -541,6 +550,7 @@ async fn test_create_ata_failing() {
             lamports_per_write: Some(100),
             compress_to_account_pubkey: None,
             token_account_version: light_ctoken_interface::state::TokenDataVersion::ShaFlat,
+            compression_only: false,
         };
 
         let create_ata_ix = CreateAssociatedCTokenAccount::new(
@@ -579,6 +589,7 @@ async fn test_create_ata_failing() {
             lamports_per_write: Some(100),
             compress_to_account_pubkey: None,
             token_account_version: light_ctoken_interface::state::TokenDataVersion::ShaFlat,
+            compression_only: false,
         };
 
         let create_ata_ix = CreateAssociatedCTokenAccount::new(
@@ -625,13 +636,17 @@ async fn test_create_ata_failing() {
         // Build instruction with correct bump but WRONG address (arbitrary keypair)
         let instruction_data = CreateAssociatedTokenAccountInstructionData {
             bump: correct_bump, // Correct bump for the real PDA
+            token_account_version: 0,
+            rent_payment: 0,
+            compression_only: 0,
+            write_top_up: 0,
             compressible_config: None,
         };
 
         let mut data = vec![100]; // CreateAssociatedCTokenAccount discriminator
         instruction_data.serialize(&mut data).unwrap();
 
-        // Account order: owner, mint, payer, ata (fake!), system_program
+        // Account order: owner, mint, payer, ata (fake!), system_program, compressible_config, rent_sponsor
         let ix = Instruction {
             program_id: light_compressed_token::ID,
             accounts: vec![
@@ -646,6 +661,11 @@ async fn test_create_ata_failing() {
                     solana_sdk::pubkey::Pubkey::default(),
                     false,
                 ),
+                solana_sdk::instruction::AccountMeta::new_readonly(
+                    context.compressible_config,
+                    false,
+                ),
+                solana_sdk::instruction::AccountMeta::new(context.rent_sponsor, false),
             ],
             data,
         };
@@ -760,6 +780,7 @@ async fn test_ata_multiple_owners_same_mint() {
         lamports_per_write: Some(100),
         compress_to_account_pubkey: None,
         token_account_version: light_ctoken_interface::state::TokenDataVersion::ShaFlat,
+        compression_only: false,
     };
 
     let create_ata_ix1 = CreateAssociatedCTokenAccount::new(payer_pubkey, owner1, mint)
@@ -781,6 +802,7 @@ async fn test_ata_multiple_owners_same_mint() {
         owner1,
         mint,
         Some(compressible_data.clone()),
+        None,
     )
     .await;
 
@@ -803,6 +825,7 @@ async fn test_ata_multiple_owners_same_mint() {
         owner2,
         mint,
         Some(compressible_data.clone()),
+        None,
     )
     .await;
 
@@ -825,6 +848,7 @@ async fn test_ata_multiple_owners_same_mint() {
         owner3,
         mint,
         Some(compressible_data.clone()),
+        None,
     )
     .await;
 
diff --git a/program-tests/compressed-token-test/tests/ctoken/create_ata2.rs b/program-tests/compressed-token-test/tests/ctoken/create_ata2.rs
index c3d87283ec..8d1c13f999 100644
--- a/program-tests/compressed-token-test/tests/ctoken/create_ata2.rs
+++ b/program-tests/compressed-token-test/tests/ctoken/create_ata2.rs
@@ -21,6 +21,7 @@ async fn create_and_assert_ata2(
             lamports_per_write: compressible.lamports_per_write,
             compress_to_account_pubkey: None,
             token_account_version: compressible.account_version,
+            compression_only: false,
         };
 
         let mut builder =
@@ -41,7 +42,7 @@ async fn create_and_assert_ata2(
             owner: owner_pubkey,
             mint: context.mint_pubkey,
             associated_token_account: ata_pubkey,
-            compressible: None,
+            compressible: CompressibleParams::default(),
         };
 
         if idempotent {
@@ -62,6 +63,7 @@ async fn create_and_assert_ata2(
         owner_pubkey,
         context.mint_pubkey,
         compressible_data,
+        None,
     )
     .await;
 
@@ -95,8 +97,24 @@ async fn test_create_ata2_basic() {
 
     {
         context.mint_pubkey = solana_sdk::pubkey::Pubkey::new_unique();
-
-        create_and_assert_ata2(&mut context, None, false, "non_compressible_ata2").await;
+        // All accounts now have compression infrastructure, so pass CompressibleData
+        // with 0 prepaid epochs (immediately compressible)
+        let compressible_data = CompressibleData {
+            compression_authority: context.compression_authority,
+            rent_sponsor: context.rent_sponsor,
+            num_prepaid_epochs: 0,
+            lamports_per_write: None,
+            account_version: light_ctoken_interface::state::TokenDataVersion::ShaFlat,
+            compress_to_pubkey: false,
+            payer: payer_pubkey,
+        };
+        create_and_assert_ata2(
+            &mut context,
+            Some(compressible_data),
+            false,
+            "ata2_zero_epochs",
+        )
+        .await;
     }
 }
 
@@ -140,7 +158,7 @@ async fn test_create_ata2_idempotent() {
 
     assert_eq!(
         account.data.len(),
-        light_ctoken_interface::COMPRESSIBLE_TOKEN_ACCOUNT_SIZE as usize,
+        light_ctoken_interface::BASE_TOKEN_ACCOUNT_SIZE as usize,
         "Account should still be compressible size after idempotent recreation"
     );
 }
diff --git a/program-tests/compressed-token-test/tests/ctoken/extensions.rs b/program-tests/compressed-token-test/tests/ctoken/extensions.rs
new file mode 100644
index 0000000000..8133b10841
--- /dev/null
+++ b/program-tests/compressed-token-test/tests/ctoken/extensions.rs
@@ -0,0 +1,823 @@
+//! Tests for Token 2022 mint with multiple extensions
+//!
+//! This module tests the creation and verification of Token 2022 mints
+//! with all supported extensions.
+
+use light_ctoken_interface::state::{
+    ExtensionStruct, PausableAccountExtension, PermanentDelegateAccountExtension,
+    TransferFeeAccountExtension, TransferHookAccountExtension, ACCOUNT_TYPE_TOKEN_ACCOUNT,
+};
+use light_program_test::{utils::assert::assert_rpc_error, LightProgramTest, ProgramTestConfig};
+use light_test_utils::{
+    mint_2022::{
+        create_mint_22_with_extensions, create_token_22_account, mint_spl_tokens_22,
+        Token22ExtensionConfig,
+    },
+    Rpc, RpcError,
+};
+use light_token_client::instructions::transfer2::{
+    create_generic_transfer2_instruction, CompressInput, Transfer2InstructionType,
+};
+use serial_test::serial;
+use solana_sdk::{
+    native_token::LAMPORTS_PER_SOL, pubkey::Pubkey, signature::Keypair, signer::Signer,
+};
+
+/// Test context for extension-related tests
+pub struct ExtensionsTestContext {
+    pub rpc: LightProgramTest,
+    pub payer: Keypair,
+    pub _mint_keypair: Keypair,
+    pub mint_pubkey: Pubkey,
+    pub extension_config: Token22ExtensionConfig,
+}
+
+/// Set up test environment with a Token 2022 mint with all extensions
+pub async fn setup_extensions_test() -> Result<ExtensionsTestContext, RpcError> {
+    let mut rpc = LightProgramTest::new(ProgramTestConfig::new_v2(false, None)).await?;
+    let payer = rpc.get_payer().insecure_clone();
+
+    // Create mint with all extensions
+    let (mint_keypair, extension_config) =
+        create_mint_22_with_extensions(&mut rpc, &payer, 9).await;
+
+    let mint_pubkey = mint_keypair.pubkey();
+
+    Ok(ExtensionsTestContext {
+        rpc,
+        payer,
+        _mint_keypair: mint_keypair,
+        mint_pubkey,
+        extension_config,
+    })
+}
+
+#[tokio::test]
+#[serial]
+async fn test_setup_mint_22_with_all_extensions() {
+    use light_test_utils::mint_2022::assert_mint_22_with_all_extensions;
+
+    let mut context = setup_extensions_test().await.unwrap();
+
+    // Use the assert helper to verify all extensions are correctly configured
+    assert_mint_22_with_all_extensions(
+        &mut context.rpc,
+        &context.mint_pubkey,
+        &context.extension_config,
+        &context.payer.pubkey(),
+    )
+    .await;
+
+    println!(
+        "Mint with all extensions created successfully: {}",
+        context.mint_pubkey
+    );
+}
+
+/// Test minting SPL tokens and transferring to CToken using hot path with a Token 2022 mint with all extensions.
+/// Mints with restricted extensions (Pausable, PermanentDelegate, TransferFee, TransferHook) require hot path.
+#[tokio::test]
+#[serial]
+async fn test_mint_and_compress_with_extensions() {
+    use light_ctoken_interface::state::TokenDataVersion;
+    use light_ctoken_sdk::{
+        ctoken::{CompressibleParams, CreateCTokenAccount, TransferSplToCtoken},
+        spl_interface::find_spl_interface_pda_with_index,
+    };
+
+    let mut context = setup_extensions_test().await.unwrap();
+    let payer = context.payer.insecure_clone();
+    let mint_pubkey = context.mint_pubkey;
+
+    // 1. Create a Token 2022 token account for the payer (SPL source)
+    let spl_account =
+        create_token_22_account(&mut context.rpc, &payer, &mint_pubkey, &payer.pubkey()).await;
+
+    println!("Created SPL token account: {}", spl_account);
+
+    // 2. Mint SPL tokens to the token account
+    let mint_amount = 1_000_000_000u64; // 1 token with 9 decimals
+    mint_spl_tokens_22(
+        &mut context.rpc,
+        &payer,
+        &mint_pubkey,
+        &spl_account,
+        mint_amount,
+    )
+    .await;
+
+    println!("Minted {} tokens to {}", mint_amount, spl_account);
+
+    // 3. Create CToken account with extensions (destination for hot path transfer)
+    let owner = Keypair::new();
+    let account_keypair = Keypair::new();
+    let create_ix = CreateCTokenAccount::new(
+        payer.pubkey(),
+        account_keypair.pubkey(),
+        mint_pubkey,
+        owner.pubkey(),
+    )
+    .with_compressible(CompressibleParams {
+        compressible_config: context
+            .rpc
+            .test_accounts
+            .funding_pool_config
+            .compressible_config_pda,
+        rent_sponsor: context
+            .rpc
+            .test_accounts
+            .funding_pool_config
+            .rent_sponsor_pda,
+        pre_pay_num_epochs: 2,
+        lamports_per_write: Some(100),
+        compress_to_account_pubkey: None,
+        token_account_version: TokenDataVersion::ShaFlat,
+        compression_only: true,
+    })
+    .instruction()
+    .unwrap();
+    context
+        .rpc
+        .create_and_send_transaction(&[create_ix], &payer.pubkey(), &[&payer, &account_keypair])
+        .await
+        .unwrap();
+
+    println!("Created CToken account: {}", account_keypair.pubkey());
+
+    // 4. Transfer SPL to CToken using hot path (compress + decompress in same tx)
+    let transfer_amount = 500_000_000u64; // Transfer half
+                                          // Use restricted=true because this mint has restricted extensions (PermanentDelegate, etc.)
+    let (spl_interface_pda, spl_interface_pda_bump) =
+        find_spl_interface_pda_with_index(&mint_pubkey, 0, true);
+    let transfer_ix = TransferSplToCtoken {
+        amount: transfer_amount,
+        spl_interface_pda_bump,
+        source_spl_token_account: spl_account,
+        destination_ctoken_account: account_keypair.pubkey(),
+        authority: payer.pubkey(),
+        mint: mint_pubkey,
+        payer: payer.pubkey(),
+        spl_interface_pda,
+        spl_token_program: spl_token_2022::ID,
+        decimals: 9,
+    }
+    .instruction()
+    .unwrap();
+
+    context
+        .rpc
+        .create_and_send_transaction(&[transfer_ix], &payer.pubkey(), &[&payer])
+        .await
+        .unwrap();
+
+    // Verify CToken account has the tokens
+    let ctoken_account_data = context
+        .rpc
+        .get_account(account_keypair.pubkey())
+        .await
+        .unwrap()
+        .unwrap();
+    let ctoken_account = spl_pod::bytemuck::pod_from_bytes::<spl_token_2022::pod::PodAccount>(
+        &ctoken_account_data.data[..165],
+    )
+    .unwrap();
+    assert_eq!(
+        u64::from(ctoken_account.amount),
+        transfer_amount,
+        "CToken account should have {} tokens",
+        transfer_amount
+    );
+
+    println!(
+        "Successfully transferred {} tokens from SPL to CToken using hot path",
+        transfer_amount
+    );
+}
+
+/// Test creating a CToken account for a Token-2022 mint with permanent delegate extension
+/// Verifies that the account gets all extensions: compressible, pausable, permanent_delegate, transfer_fee, transfer_hook
+#[tokio::test]
+#[serial]
+async fn test_create_ctoken_with_extensions() {
+    use light_ctoken_interface::state::TokenDataVersion;
+    use light_ctoken_sdk::ctoken::{CompressibleParams, CreateCTokenAccount};
+    use light_test_utils::assert_create_token_account::{
+        assert_create_token_account, CompressibleData,
+    };
+
+    let mut context = setup_extensions_test().await.unwrap();
+    let payer = context.payer.insecure_clone();
+    let mint_pubkey = context.mint_pubkey;
+
+    // Create a compressible CToken account for the Token-2022 mint
+    let account_keypair = Keypair::new();
+    let account_pubkey = account_keypair.pubkey();
+
+    let compressible_config = context
+        .rpc
+        .test_accounts
+        .funding_pool_config
+        .compressible_config_pda;
+    let rent_sponsor = context
+        .rpc
+        .test_accounts
+        .funding_pool_config
+        .rent_sponsor_pda;
+    let compression_authority = context
+        .rpc
+        .test_accounts
+        .funding_pool_config
+        .compression_authority_pda;
+
+    let create_ix =
+        CreateCTokenAccount::new(payer.pubkey(), account_pubkey, mint_pubkey, payer.pubkey())
+            .with_compressible(CompressibleParams {
+                compressible_config,
+                rent_sponsor,
+                pre_pay_num_epochs: 2,
+                lamports_per_write: Some(100),
+                compress_to_account_pubkey: None,
+                token_account_version: TokenDataVersion::ShaFlat,
+                compression_only: true,
+            })
+            .instruction()
+            .unwrap();
+
+    context
+        .rpc
+        .create_and_send_transaction(&[create_ix], &payer.pubkey(), &[&payer, &account_keypair])
+        .await
+        .unwrap();
+
+    // Use assertion function to verify account creation with T22 extensions
+    let expected_extensions = vec![
+        ExtensionStruct::PausableAccount(PausableAccountExtension),
+        ExtensionStruct::PermanentDelegateAccount(PermanentDelegateAccountExtension),
+        ExtensionStruct::TransferFeeAccount(TransferFeeAccountExtension { withheld_amount: 0 }),
+        ExtensionStruct::TransferHookAccount(TransferHookAccountExtension { transferring: 0 }),
+    ];
+
+    assert_create_token_account(
+        &mut context.rpc,
+        account_pubkey,
+        mint_pubkey,
+        payer.pubkey(),
+        Some(CompressibleData {
+            compression_authority,
+            rent_sponsor,
+            num_prepaid_epochs: 2,
+            lamports_per_write: Some(100),
+            compress_to_pubkey: false,
+            account_version: TokenDataVersion::ShaFlat,
+            payer: payer.pubkey(),
+        }),
+        Some(expected_extensions),
+    )
+    .await;
+
+    println!("Successfully created CToken account with all extensions from Token-2022 mint");
+}
+
+/// Test complete flow: Create Token-2022 mint -> SPL account -> Mint -> Create CToken accounts -> Transfer SPL to CToken (hot path) -> Transfer with permanent delegate
+#[tokio::test]
+#[serial]
+async fn test_transfer_with_permanent_delegate() {
+    use anchor_lang::prelude::AccountMeta;
+    use anchor_spl::token_2022::spl_token_2022;
+    use light_ctoken_interface::state::TokenDataVersion;
+    use light_ctoken_sdk::{
+        ctoken::{CompressibleParams, CreateCTokenAccount, TransferSplToCtoken},
+        spl_interface::find_spl_interface_pda_with_index,
+    };
+    use solana_sdk::{instruction::Instruction, program_pack::Pack};
+
+    let mut context = setup_extensions_test().await.unwrap();
+    let payer = context.payer.insecure_clone();
+    let mint_pubkey = context.mint_pubkey;
+    let permanent_delegate = context.extension_config.permanent_delegate;
+
+    // Step 1: Create SPL Token-2022 account and mint tokens
+    let spl_account =
+        create_token_22_account(&mut context.rpc, &payer, &mint_pubkey, &payer.pubkey()).await;
+
+    let mint_amount = 1_000_000_000u64;
+    mint_spl_tokens_22(
+        &mut context.rpc,
+        &payer,
+        &mint_pubkey,
+        &spl_account,
+        mint_amount,
+    )
+    .await;
+
+    // Step 2: Create two compressible CToken accounts (A and B) - must be created before transfer
+    let owner = Keypair::new();
+    let account_a_keypair = Keypair::new();
+    let account_a_pubkey = account_a_keypair.pubkey();
+
+    let create_a_ix = CreateCTokenAccount::new(
+        payer.pubkey(),
+        account_a_pubkey,
+        mint_pubkey,
+        owner.pubkey(),
+    )
+    .with_compressible(CompressibleParams {
+        compressible_config: context
+            .rpc
+            .test_accounts
+            .funding_pool_config
+            .compressible_config_pda,
+        rent_sponsor: context
+            .rpc
+            .test_accounts
+            .funding_pool_config
+            .rent_sponsor_pda,
+        pre_pay_num_epochs: 2,
+        lamports_per_write: Some(100),
+        compress_to_account_pubkey: None,
+        token_account_version: TokenDataVersion::ShaFlat,
+        compression_only: true,
+    })
+    .instruction()
+    .unwrap();
+
+    context
+        .rpc
+        .create_and_send_transaction(
+            &[create_a_ix],
+            &payer.pubkey(),
+            &[&payer, &account_a_keypair],
+        )
+        .await
+        .unwrap();
+
+    let account_b_keypair = Keypair::new();
+    let account_b_pubkey = account_b_keypair.pubkey();
+
+    let create_b_ix = CreateCTokenAccount::new(
+        payer.pubkey(),
+        account_b_pubkey,
+        mint_pubkey,
+        owner.pubkey(),
+    )
+    .with_compressible(CompressibleParams {
+        compressible_config: context
+            .rpc
+            .test_accounts
+            .funding_pool_config
+            .compressible_config_pda,
+        rent_sponsor: context
+            .rpc
+            .test_accounts
+            .funding_pool_config
+            .rent_sponsor_pda,
+        pre_pay_num_epochs: 2,
+        lamports_per_write: Some(100),
+        compress_to_account_pubkey: None,
+        token_account_version: TokenDataVersion::ShaFlat,
+        compression_only: true,
+    })
+    .instruction()
+    .unwrap();
+
+    context
+        .rpc
+        .create_and_send_transaction(
+            &[create_b_ix],
+            &payer.pubkey(),
+            &[&payer, &account_b_keypair],
+        )
+        .await
+        .unwrap();
+
+    // Step 3: Transfer SPL to CToken account A using hot path (compress + decompress in same tx)
+    let (spl_interface_pda, spl_interface_pda_bump) =
+        find_spl_interface_pda_with_index(&mint_pubkey, 0, true);
+
+    let transfer_spl_to_ctoken_ix = TransferSplToCtoken {
+        amount: mint_amount,
+        spl_interface_pda_bump,
+        source_spl_token_account: spl_account,
+        destination_ctoken_account: account_a_pubkey,
+        authority: payer.pubkey(),
+        mint: mint_pubkey,
+        payer: payer.pubkey(),
+        spl_interface_pda,
+        spl_token_program: spl_token_2022::ID,
+        decimals: 9,
+    }
+    .instruction()
+    .unwrap();
+
+    context
+        .rpc
+        .create_and_send_transaction(&[transfer_spl_to_ctoken_ix], &payer.pubkey(), &[&payer])
+        .await
+        .unwrap();
+
+    // Step 5: Transfer from A to B using permanent delegate as authority
+    // Use CTokenTransferChecked (discriminator 6) because accounts have PausableAccount extension
+    let transfer_amount = 500_000_000u64;
+    let decimals: u8 = 9;
+    let mut data = vec![6]; // CTokenTransferChecked discriminator
+    data.extend_from_slice(&transfer_amount.to_le_bytes());
+    data.push(decimals);
+
+    let transfer_ix = Instruction {
+        program_id: light_compressed_token::ID,
+        accounts: vec![
+            AccountMeta::new(account_a_pubkey, false),     // source
+            AccountMeta::new_readonly(mint_pubkey, false), // mint (required for extension check)
+            AccountMeta::new(account_b_pubkey, false),     // destination
+            AccountMeta::new(permanent_delegate, true), // authority (permanent delegate must sign)
+            AccountMeta::new_readonly(solana_sdk::system_program::ID, false), // System program for compressible top-up
+        ],
+        data,
+    };
+
+    context
+        .rpc
+        .create_and_send_transaction(&[transfer_ix], &payer.pubkey(), &[&payer])
+        .await
+        .unwrap();
+
+    // Step 6: Verify balances
+    let account_a = context
+        .rpc
+        .get_account(account_a_pubkey)
+        .await
+        .unwrap()
+        .unwrap();
+    let account_b = context
+        .rpc
+        .get_account(account_b_pubkey)
+        .await
+        .unwrap()
+        .unwrap();
+
+    let token_a = spl_token_2022::state::Account::unpack_unchecked(&account_a.data[..165]).unwrap();
+    let token_b = spl_token_2022::state::Account::unpack_unchecked(&account_b.data[..165]).unwrap();
+
+    assert_eq!(
+        token_a.amount,
+        mint_amount - transfer_amount,
+        "Account A should have 500M tokens"
+    );
+    assert_eq!(
+        token_b.amount, transfer_amount,
+        "Account B should have 500M tokens"
+    );
+
+    println!(
+        "Successfully completed full flow: compressed {} tokens, decompressed to account A, transferred {} using permanent delegate to account B",
+        mint_amount, transfer_amount
+    );
+}
+
+// test_create_ctoken_with_frozen_default_state moved to compress_only/default_state.rs
+
+/// Test complete flow with owner as transfer authority:
+/// Create mint -> Create CToken accounts -> Transfer SPL to CToken (hot path) -> Transfer using owner
+/// Verifies that transfer works with owner authority and all extensions are preserved
+#[tokio::test]
+#[serial]
+async fn test_transfer_with_owner_authority() {
+    use anchor_lang::prelude::AccountMeta;
+    use anchor_spl::token_2022::spl_token_2022;
+    use borsh::BorshDeserialize;
+    use light_ctoken_interface::state::{
+        AccountState, CToken, ExtensionStruct, PausableAccountExtension,
+        PermanentDelegateAccountExtension, TokenDataVersion, TransferFeeAccountExtension,
+        TransferHookAccountExtension,
+    };
+    use light_ctoken_sdk::{
+        ctoken::{CompressibleParams, CreateCTokenAccount, TransferSplToCtoken},
+        spl_interface::find_spl_interface_pda_with_index,
+    };
+    use solana_sdk::{instruction::Instruction, program_pack::Pack};
+
+    let mut context = setup_extensions_test().await.unwrap();
+    let payer = context.payer.insecure_clone();
+    let mint_pubkey = context.mint_pubkey;
+
+    // Step 1: Create SPL Token-2022 account and mint tokens
+    let spl_account =
+        create_token_22_account(&mut context.rpc, &payer, &mint_pubkey, &payer.pubkey()).await;
+
+    let mint_amount = 1_000_000_000u64;
+    mint_spl_tokens_22(
+        &mut context.rpc,
+        &payer,
+        &mint_pubkey,
+        &spl_account,
+        mint_amount,
+    )
+    .await;
+
+    // Step 2: Create two compressible CToken accounts (A and B) with all extensions
+    let owner = Keypair::new();
+    context
+        .rpc
+        .airdrop_lamports(&owner.pubkey(), LAMPORTS_PER_SOL)
+        .await
+        .unwrap();
+    let account_a_keypair = Keypair::new();
+    let account_a_pubkey = account_a_keypair.pubkey();
+
+    let create_a_ix = CreateCTokenAccount::new(
+        payer.pubkey(),
+        account_a_pubkey,
+        mint_pubkey,
+        owner.pubkey(),
+    )
+    .with_compressible(CompressibleParams {
+        compressible_config: context
+            .rpc
+            .test_accounts
+            .funding_pool_config
+            .compressible_config_pda,
+        rent_sponsor: context
+            .rpc
+            .test_accounts
+            .funding_pool_config
+            .rent_sponsor_pda,
+        pre_pay_num_epochs: 2,
+        lamports_per_write: Some(100),
+        compress_to_account_pubkey: None,
+        token_account_version: TokenDataVersion::ShaFlat,
+        compression_only: true,
+    })
+    .instruction()
+    .unwrap();
+
+    context
+        .rpc
+        .create_and_send_transaction(
+            &[create_a_ix],
+            &payer.pubkey(),
+            &[&payer, &account_a_keypair],
+        )
+        .await
+        .unwrap();
+
+    let account_b_keypair = Keypair::new();
+    let account_b_pubkey = account_b_keypair.pubkey();
+
+    let create_b_ix = CreateCTokenAccount::new(
+        payer.pubkey(),
+        account_b_pubkey,
+        mint_pubkey,
+        owner.pubkey(),
+    )
+    .with_compressible(CompressibleParams {
+        compressible_config: context
+            .rpc
+            .test_accounts
+            .funding_pool_config
+            .compressible_config_pda,
+        rent_sponsor: context
+            .rpc
+            .test_accounts
+            .funding_pool_config
+            .rent_sponsor_pda,
+        pre_pay_num_epochs: 2,
+        lamports_per_write: Some(100),
+        compress_to_account_pubkey: None,
+        token_account_version: TokenDataVersion::ShaFlat,
+        compression_only: true,
+    })
+    .instruction()
+    .unwrap();
+
+    context
+        .rpc
+        .create_and_send_transaction(
+            &[create_b_ix],
+            &payer.pubkey(),
+            &[&payer, &account_b_keypair],
+        )
+        .await
+        .unwrap();
+
+    // Verify both accounts have correct size (274 bytes with all extensions)
+    let account_a_data = context
+        .rpc
+        .get_account(account_a_pubkey)
+        .await
+        .unwrap()
+        .unwrap();
+    let account_b_data = context
+        .rpc
+        .get_account(account_b_pubkey)
+        .await
+        .unwrap()
+        .unwrap();
+    assert_eq!(account_a_data.data.len(), 275);
+    assert_eq!(account_b_data.data.len(), 275);
+
+    // Step 3: Transfer SPL to CToken account A using hot path (compress + decompress in same tx)
+    let (spl_interface_pda, spl_interface_pda_bump) =
+        find_spl_interface_pda_with_index(&mint_pubkey, 0, true);
+
+    let transfer_spl_to_ctoken_ix = TransferSplToCtoken {
+        amount: mint_amount,
+        spl_interface_pda_bump,
+        source_spl_token_account: spl_account,
+        destination_ctoken_account: account_a_pubkey,
+        authority: payer.pubkey(),
+        mint: mint_pubkey,
+        payer: payer.pubkey(),
+        spl_interface_pda,
+        spl_token_program: spl_token_2022::ID,
+        decimals: 9,
+    }
+    .instruction()
+    .unwrap();
+
+    context
+        .rpc
+        .create_and_send_transaction(&[transfer_spl_to_ctoken_ix], &payer.pubkey(), &[&payer])
+        .await
+        .unwrap();
+
+    // Step 4: Transfer from A to B using owner as authority
+    // Use CTokenTransferChecked (discriminator 6) because accounts have PausableAccount extension
+    let transfer_amount = 500_000_000u64;
+    let decimals: u8 = 9;
+    let mut data = vec![6]; // CTokenTransferChecked discriminator
+    data.extend_from_slice(&transfer_amount.to_le_bytes());
+    data.push(decimals);
+
+    let transfer_ix = Instruction {
+        program_id: light_compressed_token::ID,
+        accounts: vec![
+            AccountMeta::new(account_a_pubkey, false),     // source
+            AccountMeta::new_readonly(mint_pubkey, false), // mint (required for extension check)
+            AccountMeta::new(account_b_pubkey, false),     // destination
+            AccountMeta::new(owner.pubkey(), true),        // authority (owner must sign)
+            AccountMeta::new_readonly(solana_sdk::system_program::ID, false), // System program for compressible top-up
+        ],
+        data,
+    };
+
+    context
+        .rpc
+        .create_and_send_transaction(&[transfer_ix], &payer.pubkey(), &[&payer, &owner])
+        .await
+        .unwrap();
+
+    // Step 6: Verify balances and TransferFeeAccount extension
+    let account_a = context
+        .rpc
+        .get_account(account_a_pubkey)
+        .await
+        .unwrap()
+        .unwrap();
+    let account_b = context
+        .rpc
+        .get_account(account_b_pubkey)
+        .await
+        .unwrap()
+        .unwrap();
+
+    // Verify token balances using SPL unpacking
+    let token_a = spl_token_2022::state::Account::unpack_unchecked(&account_a.data[..165]).unwrap();
+    let token_b = spl_token_2022::state::Account::unpack_unchecked(&account_b.data[..165]).unwrap();
+
+    assert_eq!(
+        token_a.amount,
+        mint_amount - transfer_amount,
+        "Account A should have 500M tokens"
+    );
+    assert_eq!(
+        token_b.amount, transfer_amount,
+        "Account B should have 500M tokens"
+    );
+
+    // Deserialize and verify TransferFeeAccount extension on both accounts
+    let ctoken_a = CToken::deserialize(&mut &account_a.data[..]).unwrap();
+    let ctoken_b = CToken::deserialize(&mut &account_b.data[..]).unwrap();
+
+    // Build expected CToken accounts
+    // compression is now a direct field on CToken
+    let expected_ctoken_a = CToken {
+        mint: mint_pubkey.to_bytes().into(),
+        owner: owner.pubkey().to_bytes().into(),
+        amount: mint_amount - transfer_amount,
+        delegate: None,
+        state: AccountState::Initialized,
+        is_native: None,
+        delegated_amount: 0,
+        close_authority: None,
+        account_type: ACCOUNT_TYPE_TOKEN_ACCOUNT,
+        decimals: ctoken_a.decimals,
+        compression_only: ctoken_a.compression_only,
+        compression: ctoken_a.compression,
+        extensions: Some(vec![
+            ExtensionStruct::PausableAccount(PausableAccountExtension),
+            ExtensionStruct::PermanentDelegateAccount(PermanentDelegateAccountExtension),
+            ExtensionStruct::TransferFeeAccount(TransferFeeAccountExtension { withheld_amount: 0 }),
+            ExtensionStruct::TransferHookAccount(TransferHookAccountExtension { transferring: 0 }),
+        ]),
+    };
+
+    let expected_ctoken_b = CToken {
+        mint: mint_pubkey.to_bytes().into(),
+        owner: owner.pubkey().to_bytes().into(),
+        amount: transfer_amount,
+        delegate: None,
+        state: AccountState::Initialized,
+        is_native: None,
+        delegated_amount: 0,
+        close_authority: None,
+        account_type: ACCOUNT_TYPE_TOKEN_ACCOUNT,
+        decimals: ctoken_b.decimals,
+        compression_only: ctoken_b.compression_only,
+        compression: ctoken_b.compression,
+        extensions: Some(vec![
+            ExtensionStruct::PausableAccount(PausableAccountExtension),
+            ExtensionStruct::PermanentDelegateAccount(PermanentDelegateAccountExtension),
+            ExtensionStruct::TransferFeeAccount(TransferFeeAccountExtension { withheld_amount: 0 }),
+            ExtensionStruct::TransferHookAccount(TransferHookAccountExtension { transferring: 0 }),
+        ]),
+    };
+
+    assert_eq!(
+        ctoken_a, expected_ctoken_a,
+        "Account A should match expected with withheld_amount=0"
+    );
+    assert_eq!(
+        ctoken_b, expected_ctoken_b,
+        "Account B should match expected with withheld_amount=0"
+    );
+
+    println!(
+        "Successfully completed transfer with owner authority: A={} tokens, B={} tokens",
+        token_a.amount, token_b.amount
+    );
+}
+
+/// Test that compressing SPL tokens with restricted extensions outside the hot path fails.
+/// Mints with restricted extensions (Pausable, PermanentDelegate, TransferFee, TransferHook) require hot path.
+#[tokio::test]
+#[serial]
+async fn test_compress_with_restricted_extensions_fails() {
+    let mut context = setup_extensions_test().await.unwrap();
+    let payer = context.payer.insecure_clone();
+    let mint_pubkey = context.mint_pubkey;
+
+    // Create SPL account and mint tokens
+    let spl_account =
+        create_token_22_account(&mut context.rpc, &payer, &mint_pubkey, &payer.pubkey()).await;
+    let mint_amount = 1_000_000_000u64;
+    mint_spl_tokens_22(
+        &mut context.rpc,
+        &payer,
+        &mint_pubkey,
+        &spl_account,
+        mint_amount,
+    )
+    .await;
+
+    // Try to compress to compressed accounts (NOT hot path) - should fail
+    let owner = Keypair::new();
+    let output_queue = context.rpc.get_random_state_tree_info().unwrap().queue;
+    let compress_ix = create_generic_transfer2_instruction(
+        &mut context.rpc,
+        vec![Transfer2InstructionType::Compress(CompressInput {
+            compressed_token_account: None,
+            solana_token_account: spl_account,
+            to: owner.pubkey(),
+            mint: mint_pubkey,
+            amount: mint_amount,
+            authority: payer.pubkey(),
+            output_queue,
+            pool_index: None,
+            decimals: 9,
+        })],
+        payer.pubkey(),
+        true,
+    )
+    .await
+    .unwrap();
+    let result = context
+        .rpc
+        .create_and_send_transaction(&[compress_ix], &payer.pubkey(), &[&payer])
+        .await;
+    // MintHasRestrictedExtensions: mints with Pausable, PermanentDelegate, TransferFee,
+    // or TransferHook cannot create compressed token outputs (error code 6142)
+    assert_rpc_error(result, 0, 6142).unwrap();
+
+    println!("Correctly rejected compress operation for mint with restricted extensions");
+}
+
+// test_compress_and_close_ctoken_with_extensions moved to compress_only/all.rs
+
+// CompressAndCloseTestConfig, set_ctoken_account_state, and run_compress_and_close_extension_test
+// moved to compress_only/mod.rs
+
+// Compress and close tests moved to compress_only/ directory:
+// - test_compress_and_close_with_delegated_amount -> delegated.rs
+// - test_compress_and_close_frozen -> frozen.rs
+// - test_compress_and_close_with_permanent_delegate -> permanent_delegate.rs
+// - test_compress_and_close_delegate_decompress -> delegated.rs
diff --git a/program-tests/compressed-token-test/tests/ctoken/extensions_failing.rs b/program-tests/compressed-token-test/tests/ctoken/extensions_failing.rs
new file mode 100644
index 0000000000..be3a93e03d
--- /dev/null
+++ b/program-tests/compressed-token-test/tests/ctoken/extensions_failing.rs
@@ -0,0 +1,726 @@
+//! Tests for extension validation failures in CToken operations.
+//!
+//! This module tests extension validation for:
+//! 1. CTokenTransfer(Checked) - transfers between CToken accounts
+//! 2. SPL → CToken (TransferSplToCtoken) - entering via Compress mode
+//! 3. CToken → SPL (TransferCTokenToSpl) - exiting via Compress+Decompress mode
+//!
+//! All three operations enforce extension state checks because they involve
+//! Compress mode operations. The bypass only applies to pure Decompress operations
+//! (e.g., decompressing from compressed accounts to SPL/CToken without any Compress).
+
+use light_ctoken_interface::state::TokenDataVersion;
+use light_ctoken_sdk::{
+    ctoken::{
+        CompressibleParams, CreateCTokenAccount, TransferCTokenChecked, TransferCTokenToSpl,
+        TransferSplToCtoken,
+    },
+    spl_interface::find_spl_interface_pda_with_index,
+};
+use light_program_test::utils::assert::assert_rpc_error;
+use light_test_utils::{
+    mint_2022::{
+        create_token_22_account, mint_spl_tokens_22, pause_mint, set_mint_transfer_fee,
+        set_mint_transfer_hook,
+    },
+    Rpc,
+};
+use serial_test::serial;
+use solana_sdk::{pubkey::Pubkey, signature::Keypair, signer::Signer};
+
+use super::extensions::{setup_extensions_test, ExtensionsTestContext};
+
+/// Expected error code for MintPaused
+const MINT_PAUSED: u32 = 6127;
+
+/// Expected error code for NonZeroTransferFeeNotSupported
+const NON_ZERO_TRANSFER_FEE_NOT_SUPPORTED: u32 = 6129;
+
+/// Expected error code for TransferHookNotSupported
+const TRANSFER_HOOK_NOT_SUPPORTED: u32 = 6130;
+
+/// Set up two CToken accounts with tokens for transfer testing.
+/// Returns (source_account, destination_account, owner)
+async fn setup_ctoken_accounts_for_transfer(
+    context: &mut ExtensionsTestContext,
+) -> (Pubkey, Pubkey, Keypair) {
+    let payer = context.payer.insecure_clone();
+    let mint_pubkey = context.mint_pubkey;
+
+    // Create SPL source account and mint tokens
+    let spl_account =
+        create_token_22_account(&mut context.rpc, &payer, &mint_pubkey, &payer.pubkey()).await;
+
+    let mint_amount = 1_000_000_000u64;
+    mint_spl_tokens_22(
+        &mut context.rpc,
+        &payer,
+        &mint_pubkey,
+        &spl_account,
+        mint_amount,
+    )
+    .await;
+
+    // Create owner and CToken accounts
+    let owner = Keypair::new();
+
+    // Create source CToken account
+    let account_a_keypair = Keypair::new();
+    let account_a_pubkey = account_a_keypair.pubkey();
+    let create_a_ix = CreateCTokenAccount::new(
+        payer.pubkey(),
+        account_a_pubkey,
+        mint_pubkey,
+        owner.pubkey(),
+    )
+    .with_compressible(CompressibleParams {
+        compressible_config: context
+            .rpc
+            .test_accounts
+            .funding_pool_config
+            .compressible_config_pda,
+        rent_sponsor: context
+            .rpc
+            .test_accounts
+            .funding_pool_config
+            .rent_sponsor_pda,
+        pre_pay_num_epochs: 2,
+        lamports_per_write: Some(100),
+        compress_to_account_pubkey: None,
+        token_account_version: TokenDataVersion::ShaFlat,
+        compression_only: true,
+    })
+    .instruction()
+    .unwrap();
+
+    context
+        .rpc
+        .create_and_send_transaction(
+            &[create_a_ix],
+            &payer.pubkey(),
+            &[&payer, &account_a_keypair],
+        )
+        .await
+        .unwrap();
+
+    // Create destination CToken account
+    let account_b_keypair = Keypair::new();
+    let account_b_pubkey = account_b_keypair.pubkey();
+    let create_b_ix = CreateCTokenAccount::new(
+        payer.pubkey(),
+        account_b_pubkey,
+        mint_pubkey,
+        owner.pubkey(),
+    )
+    .with_compressible(CompressibleParams {
+        compressible_config: context
+            .rpc
+            .test_accounts
+            .funding_pool_config
+            .compressible_config_pda,
+        rent_sponsor: context
+            .rpc
+            .test_accounts
+            .funding_pool_config
+            .rent_sponsor_pda,
+        pre_pay_num_epochs: 2,
+        lamports_per_write: Some(100),
+        compress_to_account_pubkey: None,
+        token_account_version: TokenDataVersion::ShaFlat,
+        compression_only: true,
+    })
+    .instruction()
+    .unwrap();
+
+    context
+        .rpc
+        .create_and_send_transaction(
+            &[create_b_ix],
+            &payer.pubkey(),
+            &[&payer, &account_b_keypair],
+        )
+        .await
+        .unwrap();
+
+    // Transfer SPL to source CToken account using hot path
+    let (spl_interface_pda, spl_interface_pda_bump) =
+        find_spl_interface_pda_with_index(&mint_pubkey, 0, true);
+
+    let transfer_spl_to_ctoken_ix = TransferSplToCtoken {
+        amount: mint_amount,
+        spl_interface_pda_bump,
+        source_spl_token_account: spl_account,
+        destination_ctoken_account: account_a_pubkey,
+        authority: payer.pubkey(),
+        mint: mint_pubkey,
+        payer: payer.pubkey(),
+        spl_interface_pda,
+        spl_token_program: spl_token_2022::ID,
+        decimals: 9,
+    }
+    .instruction()
+    .unwrap();
+
+    context
+        .rpc
+        .create_and_send_transaction(&[transfer_spl_to_ctoken_ix], &payer.pubkey(), &[&payer])
+        .await
+        .unwrap();
+
+    (account_a_pubkey, account_b_pubkey, owner)
+}
+
+/// Test that CTokenTransferChecked fails when the mint is paused.
+///
+/// Setup:
+/// 1. Create mint with Pausable extension (not paused initially)
+/// 2. Create token pool, two CToken accounts with tokens
+/// 3. Pause the mint via set_account
+/// 4. Attempt CTokenTransferChecked
+///
+/// Expected: MintPaused (6496)
+#[tokio::test]
+#[serial]
+async fn test_ctoken_transfer_fails_when_mint_paused() {
+    let mut context = setup_extensions_test().await.unwrap();
+    let mint_pubkey = context.mint_pubkey;
+
+    // Set up accounts with tokens
+    let (source, destination, owner) = setup_ctoken_accounts_for_transfer(&mut context).await;
+
+    // Pause the mint
+    pause_mint(&mut context.rpc, &mint_pubkey).await;
+
+    // Attempt transfer - should fail with MintPaused
+    let transfer_ix = TransferCTokenChecked {
+        source,
+        mint: mint_pubkey,
+        destination,
+        amount: 100_000_000,
+        decimals: 9,
+        authority: owner.pubkey(),
+        max_top_up: None,
+    }
+    .instruction()
+    .unwrap();
+
+    let result = context
+        .rpc
+        .create_and_send_transaction(
+            &[transfer_ix],
+            &context.payer.pubkey(),
+            &[&context.payer, &owner],
+        )
+        .await;
+
+    assert_rpc_error(result, 0, MINT_PAUSED).unwrap();
+    println!("Correctly rejected CTokenTransferChecked when mint is paused");
+}
+
+/// Test that CTokenTransferChecked fails when the mint has non-zero transfer fees.
+///
+/// Setup:
+/// 1. Create mint with TransferFeeConfig (zero fees initially)
+/// 2. Create token pool, two CToken accounts with tokens
+/// 3. Modify mint TransferFeeConfig to have non-zero fees
+/// 4. Attempt CTokenTransferChecked
+///
+/// Expected: NonZeroTransferFeeNotSupported (6500)
+#[tokio::test]
+#[serial]
+async fn test_ctoken_transfer_fails_with_non_zero_transfer_fee() {
+    let mut context = setup_extensions_test().await.unwrap();
+    let mint_pubkey = context.mint_pubkey;
+
+    // Set up accounts with tokens
+    let (source, destination, owner) = setup_ctoken_accounts_for_transfer(&mut context).await;
+
+    // Set non-zero transfer fees on the mint
+    set_mint_transfer_fee(&mut context.rpc, &mint_pubkey, 100, 1000).await;
+
+    // Attempt transfer - should fail with NonZeroTransferFeeNotSupported
+    let transfer_ix = TransferCTokenChecked {
+        source,
+        mint: mint_pubkey,
+        destination,
+        amount: 100_000_000,
+        decimals: 9,
+        authority: owner.pubkey(),
+        max_top_up: None,
+    }
+    .instruction()
+    .unwrap();
+
+    let result = context
+        .rpc
+        .create_and_send_transaction(
+            &[transfer_ix],
+            &context.payer.pubkey(),
+            &[&context.payer, &owner],
+        )
+        .await;
+
+    assert_rpc_error(result, 0, NON_ZERO_TRANSFER_FEE_NOT_SUPPORTED).unwrap();
+    println!("Correctly rejected CTokenTransferChecked with non-zero transfer fees");
+}
+
+/// Test that CTokenTransferChecked fails when the mint has a non-nil transfer hook.
+///
+/// Setup:
+/// 1. Create mint with TransferHook (nil program initially)
+/// 2. Create token pool, two CToken accounts with tokens
+/// 3. Modify mint TransferHook to have non-nil program_id
+/// 4. Attempt CTokenTransferChecked
+///
+/// Expected: TransferHookNotSupported (6501)
+#[tokio::test]
+#[serial]
+async fn test_ctoken_transfer_fails_with_non_nil_transfer_hook() {
+    let mut context = setup_extensions_test().await.unwrap();
+    let mint_pubkey = context.mint_pubkey;
+
+    // Set up accounts with tokens
+    let (source, destination, owner) = setup_ctoken_accounts_for_transfer(&mut context).await;
+
+    // Set non-nil transfer hook program on the mint
+    let dummy_hook_program = Pubkey::new_unique();
+    set_mint_transfer_hook(&mut context.rpc, &mint_pubkey, dummy_hook_program).await;
+
+    // Attempt transfer - should fail with TransferHookNotSupported
+    let transfer_ix = TransferCTokenChecked {
+        source,
+        mint: mint_pubkey,
+        destination,
+        amount: 100_000_000,
+        decimals: 9,
+        authority: owner.pubkey(),
+        max_top_up: None,
+    }
+    .instruction()
+    .unwrap();
+
+    let result = context
+        .rpc
+        .create_and_send_transaction(
+            &[transfer_ix],
+            &context.payer.pubkey(),
+            &[&context.payer, &owner],
+        )
+        .await;
+
+    assert_rpc_error(result, 0, TRANSFER_HOOK_NOT_SUPPORTED).unwrap();
+    println!("Correctly rejected CTokenTransferChecked with non-nil transfer hook");
+}
+
+// ============================================================================
+// SPL → CToken Transfer Tests (TransferSplToCtoken)
+// These should FAIL when extension state is invalid (entering compressed state)
+// ============================================================================
+
+/// Set up SPL account with tokens and empty CToken account for SPL→CToken testing.
+/// Returns (spl_account, ctoken_account, owner)
+async fn setup_spl_to_ctoken_accounts(
+    context: &mut ExtensionsTestContext,
+) -> (Pubkey, Pubkey, Keypair) {
+    let payer = context.payer.insecure_clone();
+    let mint_pubkey = context.mint_pubkey;
+
+    // Create SPL source account and mint tokens
+    let spl_account =
+        create_token_22_account(&mut context.rpc, &payer, &mint_pubkey, &payer.pubkey()).await;
+
+    let mint_amount = 1_000_000_000u64;
+    mint_spl_tokens_22(
+        &mut context.rpc,
+        &payer,
+        &mint_pubkey,
+        &spl_account,
+        mint_amount,
+    )
+    .await;
+
+    // Create CToken account (destination)
+    let owner = Keypair::new();
+    let ctoken_keypair = Keypair::new();
+    let ctoken_pubkey = ctoken_keypair.pubkey();
+    let create_ix =
+        CreateCTokenAccount::new(payer.pubkey(), ctoken_pubkey, mint_pubkey, owner.pubkey())
+            .with_compressible(CompressibleParams {
+                compressible_config: context
+                    .rpc
+                    .test_accounts
+                    .funding_pool_config
+                    .compressible_config_pda,
+                rent_sponsor: context
+                    .rpc
+                    .test_accounts
+                    .funding_pool_config
+                    .rent_sponsor_pda,
+                pre_pay_num_epochs: 2,
+                lamports_per_write: Some(100),
+                compress_to_account_pubkey: None,
+                token_account_version: TokenDataVersion::ShaFlat,
+                compression_only: true,
+            })
+            .instruction()
+            .unwrap();
+
+    context
+        .rpc
+        .create_and_send_transaction(&[create_ix], &payer.pubkey(), &[&payer, &ctoken_keypair])
+        .await
+        .unwrap();
+
+    (spl_account, ctoken_pubkey, owner)
+}
+
+/// Test that SPL→CToken transfer fails when the mint is paused.
+///
+/// SPL→CToken uses Compress mode which enforces extension state checks.
+#[tokio::test]
+#[serial]
+async fn test_spl_to_ctoken_fails_when_mint_paused() {
+    let mut context = setup_extensions_test().await.unwrap();
+    let mint_pubkey = context.mint_pubkey;
+    let payer = context.payer.insecure_clone();
+
+    // Set up accounts
+    let (spl_account, ctoken_account, _owner) = setup_spl_to_ctoken_accounts(&mut context).await;
+
+    // Pause the mint
+    pause_mint(&mut context.rpc, &mint_pubkey).await;
+
+    // Attempt SPL→CToken transfer - should fail with MintPaused
+    let (spl_interface_pda, spl_interface_pda_bump) =
+        find_spl_interface_pda_with_index(&mint_pubkey, 0, true);
+
+    let transfer_ix = TransferSplToCtoken {
+        amount: 100_000_000,
+        spl_interface_pda_bump,
+        source_spl_token_account: spl_account,
+        destination_ctoken_account: ctoken_account,
+        authority: payer.pubkey(),
+        mint: mint_pubkey,
+        payer: payer.pubkey(),
+        spl_interface_pda,
+        spl_token_program: spl_token_2022::ID,
+        decimals: 9,
+    }
+    .instruction()
+    .unwrap();
+
+    let result = context
+        .rpc
+        .create_and_send_transaction(&[transfer_ix], &payer.pubkey(), &[&payer])
+        .await;
+
+    assert_rpc_error(result, 0, MINT_PAUSED).unwrap();
+    println!("Correctly rejected SPL→CToken when mint is paused");
+}
+
+/// Test that SPL→CToken transfer fails when the mint has non-zero transfer fees.
+#[tokio::test]
+#[serial]
+async fn test_spl_to_ctoken_fails_with_non_zero_transfer_fee() {
+    let mut context = setup_extensions_test().await.unwrap();
+    let mint_pubkey = context.mint_pubkey;
+    let payer = context.payer.insecure_clone();
+
+    // Set up accounts
+    let (spl_account, ctoken_account, _owner) = setup_spl_to_ctoken_accounts(&mut context).await;
+
+    // Set non-zero transfer fees
+    set_mint_transfer_fee(&mut context.rpc, &mint_pubkey, 100, 1000).await;
+
+    // Attempt SPL→CToken transfer - should fail
+    let (spl_interface_pda, spl_interface_pda_bump) =
+        find_spl_interface_pda_with_index(&mint_pubkey, 0, true);
+
+    let transfer_ix = TransferSplToCtoken {
+        amount: 100_000_000,
+        spl_interface_pda_bump,
+        source_spl_token_account: spl_account,
+        destination_ctoken_account: ctoken_account,
+        authority: payer.pubkey(),
+        mint: mint_pubkey,
+        payer: payer.pubkey(),
+        spl_interface_pda,
+        spl_token_program: spl_token_2022::ID,
+        decimals: 9,
+    }
+    .instruction()
+    .unwrap();
+
+    let result = context
+        .rpc
+        .create_and_send_transaction(&[transfer_ix], &payer.pubkey(), &[&payer])
+        .await;
+
+    assert_rpc_error(result, 0, NON_ZERO_TRANSFER_FEE_NOT_SUPPORTED).unwrap();
+    println!("Correctly rejected SPL→CToken with non-zero transfer fees");
+}
+
+/// Test that SPL→CToken transfer fails when the mint has a non-nil transfer hook.
+#[tokio::test]
+#[serial]
+async fn test_spl_to_ctoken_fails_with_non_nil_transfer_hook() {
+    let mut context = setup_extensions_test().await.unwrap();
+    let mint_pubkey = context.mint_pubkey;
+    let payer = context.payer.insecure_clone();
+
+    // Set up accounts
+    let (spl_account, ctoken_account, _owner) = setup_spl_to_ctoken_accounts(&mut context).await;
+
+    // Set non-nil transfer hook
+    let dummy_hook_program = Pubkey::new_unique();
+    set_mint_transfer_hook(&mut context.rpc, &mint_pubkey, dummy_hook_program).await;
+
+    // Attempt SPL→CToken transfer - should fail
+    let (spl_interface_pda, spl_interface_pda_bump) =
+        find_spl_interface_pda_with_index(&mint_pubkey, 0, true);
+
+    let transfer_ix = TransferSplToCtoken {
+        amount: 100_000_000,
+        spl_interface_pda_bump,
+        source_spl_token_account: spl_account,
+        destination_ctoken_account: ctoken_account,
+        authority: payer.pubkey(),
+        mint: mint_pubkey,
+        payer: payer.pubkey(),
+        spl_interface_pda,
+        spl_token_program: spl_token_2022::ID,
+        decimals: 9,
+    }
+    .instruction()
+    .unwrap();
+
+    let result = context
+        .rpc
+        .create_and_send_transaction(&[transfer_ix], &payer.pubkey(), &[&payer])
+        .await;
+
+    assert_rpc_error(result, 0, TRANSFER_HOOK_NOT_SUPPORTED).unwrap();
+    println!("Correctly rejected SPL→CToken with non-nil transfer hook");
+}
+
+// ============================================================================
+// CToken → SPL Transfer Tests (TransferCTokenToSpl)
+// These FAIL because CToken→SPL uses compress_ctoken (Compress mode) which
+// enforces extension state checks. The bypass only applies to pure Decompress
+// operations (from compressed accounts, not CToken accounts).
+// ============================================================================
+
+/// Set up CToken account with tokens and empty SPL account for CToken→SPL testing.
+/// Returns (ctoken_account, spl_account, owner)
+async fn setup_ctoken_to_spl_accounts(
+    context: &mut ExtensionsTestContext,
+) -> (Pubkey, Pubkey, Keypair) {
+    let payer = context.payer.insecure_clone();
+    let mint_pubkey = context.mint_pubkey;
+
+    // Create SPL source account and mint tokens
+    let spl_source =
+        create_token_22_account(&mut context.rpc, &payer, &mint_pubkey, &payer.pubkey()).await;
+
+    let mint_amount = 1_000_000_000u64;
+    mint_spl_tokens_22(
+        &mut context.rpc,
+        &payer,
+        &mint_pubkey,
+        &spl_source,
+        mint_amount,
+    )
+    .await;
+
+    // Create CToken account and fund it
+    let owner = Keypair::new();
+    let ctoken_keypair = Keypair::new();
+    let ctoken_pubkey = ctoken_keypair.pubkey();
+    let create_ix =
+        CreateCTokenAccount::new(payer.pubkey(), ctoken_pubkey, mint_pubkey, owner.pubkey())
+            .with_compressible(CompressibleParams {
+                compressible_config: context
+                    .rpc
+                    .test_accounts
+                    .funding_pool_config
+                    .compressible_config_pda,
+                rent_sponsor: context
+                    .rpc
+                    .test_accounts
+                    .funding_pool_config
+                    .rent_sponsor_pda,
+                pre_pay_num_epochs: 2,
+                lamports_per_write: Some(100),
+                compress_to_account_pubkey: None,
+                token_account_version: TokenDataVersion::ShaFlat,
+                compression_only: true,
+            })
+            .instruction()
+            .unwrap();
+
+    context
+        .rpc
+        .create_and_send_transaction(&[create_ix], &payer.pubkey(), &[&payer, &ctoken_keypair])
+        .await
+        .unwrap();
+
+    // Transfer SPL tokens to CToken account (before modifying extension state)
+    let (spl_interface_pda, spl_interface_pda_bump) =
+        find_spl_interface_pda_with_index(&mint_pubkey, 0, true);
+
+    let transfer_ix = TransferSplToCtoken {
+        amount: mint_amount,
+        spl_interface_pda_bump,
+        source_spl_token_account: spl_source,
+        destination_ctoken_account: ctoken_pubkey,
+        authority: payer.pubkey(),
+        mint: mint_pubkey,
+        payer: payer.pubkey(),
+        spl_interface_pda,
+        spl_token_program: spl_token_2022::ID,
+        decimals: 9,
+    }
+    .instruction()
+    .unwrap();
+
+    context
+        .rpc
+        .create_and_send_transaction(&[transfer_ix], &payer.pubkey(), &[&payer])
+        .await
+        .unwrap();
+
+    // Create destination SPL account for withdrawal
+    let spl_dest =
+        create_token_22_account(&mut context.rpc, &payer, &mint_pubkey, &payer.pubkey()).await;
+
+    (ctoken_pubkey, spl_dest, owner)
+}
+
+/// Test that CToken→SPL transfer FAILS when the mint is paused.
+///
+/// CToken→SPL uses compress_ctoken (Compress mode) which enforces extension checks.
+#[tokio::test]
+#[serial]
+async fn test_ctoken_to_spl_fails_when_mint_paused() {
+    let mut context = setup_extensions_test().await.unwrap();
+    let mint_pubkey = context.mint_pubkey;
+    let payer = context.payer.insecure_clone();
+
+    // Set up accounts with tokens in CToken
+    let (ctoken_account, spl_account, owner) = setup_ctoken_to_spl_accounts(&mut context).await;
+
+    // Pause the mint AFTER funding CToken account
+    pause_mint(&mut context.rpc, &mint_pubkey).await;
+
+    // Attempt CToken→SPL transfer - should FAIL
+    let (spl_interface_pda, spl_interface_pda_bump) =
+        find_spl_interface_pda_with_index(&mint_pubkey, 0, true);
+
+    let transfer_ix = TransferCTokenToSpl {
+        source_ctoken_account: ctoken_account,
+        destination_spl_token_account: spl_account,
+        amount: 100_000_000,
+        authority: owner.pubkey(),
+        mint: mint_pubkey,
+        payer: payer.pubkey(),
+        spl_interface_pda,
+        spl_interface_pda_bump,
+        decimals: 9,
+        spl_token_program: spl_token_2022::ID,
+    }
+    .instruction()
+    .unwrap();
+
+    let result = context
+        .rpc
+        .create_and_send_transaction(&[transfer_ix], &payer.pubkey(), &[&payer, &owner])
+        .await;
+
+    assert_rpc_error(result, 0, MINT_PAUSED).unwrap();
+    println!("Correctly rejected CToken→SPL when mint is paused");
+}
+
+/// Test that CToken→SPL transfer FAILS with non-zero transfer fees.
+#[tokio::test]
+#[serial]
+async fn test_ctoken_to_spl_fails_with_non_zero_transfer_fee() {
+    let mut context = setup_extensions_test().await.unwrap();
+    let mint_pubkey = context.mint_pubkey;
+    let payer = context.payer.insecure_clone();
+
+    // Set up accounts with tokens in CToken
+    let (ctoken_account, spl_account, owner) = setup_ctoken_to_spl_accounts(&mut context).await;
+
+    // Set non-zero transfer fees AFTER funding CToken account
+    set_mint_transfer_fee(&mut context.rpc, &mint_pubkey, 100, 1000).await;
+
+    // Attempt CToken→SPL transfer - should FAIL
+    let (spl_interface_pda, spl_interface_pda_bump) =
+        find_spl_interface_pda_with_index(&mint_pubkey, 0, true);
+
+    let transfer_ix = TransferCTokenToSpl {
+        source_ctoken_account: ctoken_account,
+        destination_spl_token_account: spl_account,
+        amount: 100_000_000,
+        authority: owner.pubkey(),
+        mint: mint_pubkey,
+        payer: payer.pubkey(),
+        spl_interface_pda,
+        spl_interface_pda_bump,
+        decimals: 9,
+        spl_token_program: spl_token_2022::ID,
+    }
+    .instruction()
+    .unwrap();
+
+    let result = context
+        .rpc
+        .create_and_send_transaction(&[transfer_ix], &payer.pubkey(), &[&payer, &owner])
+        .await;
+
+    assert_rpc_error(result, 0, NON_ZERO_TRANSFER_FEE_NOT_SUPPORTED).unwrap();
+    println!("Correctly rejected CToken→SPL with non-zero transfer fees");
+}
+
+/// Test that CToken→SPL transfer FAILS with non-nil transfer hook.
+#[tokio::test]
+#[serial]
+async fn test_ctoken_to_spl_fails_with_non_nil_transfer_hook() {
+    let mut context = setup_extensions_test().await.unwrap();
+    let mint_pubkey = context.mint_pubkey;
+    let payer = context.payer.insecure_clone();
+
+    // Set up accounts with tokens in CToken
+    let (ctoken_account, spl_account, owner) = setup_ctoken_to_spl_accounts(&mut context).await;
+
+    // Set non-nil transfer hook AFTER funding CToken account
+    let dummy_hook_program = Pubkey::new_unique();
+    set_mint_transfer_hook(&mut context.rpc, &mint_pubkey, dummy_hook_program).await;
+
+    // Attempt CToken→SPL transfer - should FAIL
+    let (spl_interface_pda, spl_interface_pda_bump) =
+        find_spl_interface_pda_with_index(&mint_pubkey, 0, true);
+
+    let transfer_ix = TransferCTokenToSpl {
+        source_ctoken_account: ctoken_account,
+        destination_spl_token_account: spl_account,
+        amount: 100_000_000,
+        authority: owner.pubkey(),
+        mint: mint_pubkey,
+        payer: payer.pubkey(),
+        spl_interface_pda,
+        spl_interface_pda_bump,
+        decimals: 9,
+        spl_token_program: spl_token_2022::ID,
+    }
+    .instruction()
+    .unwrap();
+
+    let result = context
+        .rpc
+        .create_and_send_transaction(&[transfer_ix], &payer.pubkey(), &[&payer, &owner])
+        .await;
+
+    assert_rpc_error(result, 0, TRANSFER_HOOK_NOT_SUPPORTED).unwrap();
+    println!("Correctly rejected CToken→SPL with non-nil transfer hook");
+}
diff --git a/program-tests/compressed-token-test/tests/ctoken/freeze_thaw.rs b/program-tests/compressed-token-test/tests/ctoken/freeze_thaw.rs
new file mode 100644
index 0000000000..4e464ac39f
--- /dev/null
+++ b/program-tests/compressed-token-test/tests/ctoken/freeze_thaw.rs
@@ -0,0 +1,206 @@
+//! Tests for CToken freeze and thaw instructions
+//!
+//! These tests verify that freeze and thaw instructions work correctly
+//! for both basic mints and Token-2022 mints with extensions.
+
+use anchor_lang::AnchorDeserialize;
+use light_ctoken_interface::state::{AccountState, CToken, TokenDataVersion};
+use light_ctoken_sdk::ctoken::{CompressibleParams, CreateCTokenAccount, FreezeCToken, ThawCToken};
+use light_program_test::{LightProgramTest, ProgramTestConfig};
+use light_test_utils::{
+    assert_ctoken_freeze_thaw::{assert_ctoken_freeze, assert_ctoken_thaw},
+    spl::create_mint_helper,
+    Rpc, RpcError,
+};
+use serial_test::serial;
+use solana_sdk::{signature::Keypair, signer::Signer};
+
+use super::extensions::setup_extensions_test;
+
+/// Test freeze and thaw with a basic SPL Token mint (not Token-2022)
+/// Uses create_mint_helper which creates a mint with freeze_authority = payer
+#[tokio::test]
+#[serial]
+async fn test_freeze_thaw_with_basic_mint() -> Result<(), RpcError> {
+    let mut rpc = LightProgramTest::new(ProgramTestConfig::new_v2(false, None)).await?;
+    let payer = rpc.get_payer().insecure_clone();
+    let owner = Keypair::new();
+
+    // 1. Create SPL Token mint with freeze_authority = payer
+    let mint_pubkey = create_mint_helper(&mut rpc, &payer).await;
+
+    // 2. Create CToken account with 0 prepaid epochs (immediately compressible)
+    let token_account_keypair = Keypair::new();
+    let token_account_pubkey = token_account_keypair.pubkey();
+
+    let compressible_params = CompressibleParams {
+        compressible_config: rpc
+            .test_accounts
+            .funding_pool_config
+            .compressible_config_pda,
+        rent_sponsor: rpc.test_accounts.funding_pool_config.rent_sponsor_pda,
+        pre_pay_num_epochs: 0,
+        lamports_per_write: None,
+        compress_to_account_pubkey: None,
+        token_account_version: TokenDataVersion::ShaFlat,
+        compression_only: false,
+    };
+
+    let create_ix = CreateCTokenAccount::new(
+        payer.pubkey(),
+        token_account_pubkey,
+        mint_pubkey,
+        owner.pubkey(),
+    )
+    .with_compressible(compressible_params)
+    .instruction()
+    .map_err(|e| RpcError::AssertRpcError(format!("Failed to create instruction: {}", e)))?;
+
+    rpc.create_and_send_transaction(
+        &[create_ix],
+        &payer.pubkey(),
+        &[&payer, &token_account_keypair],
+    )
+    .await?;
+
+    // Verify initial state is Initialized
+    let account_data = rpc.get_account(token_account_pubkey).await?.unwrap();
+    let ctoken_before =
+        CToken::deserialize(&mut &account_data.data[..]).expect("Failed to deserialize CToken");
+    assert_eq!(
+        ctoken_before.state,
+        AccountState::Initialized,
+        "Initial state should be Initialized"
+    );
+
+    // 3. Freeze the account
+    let freeze_ix = FreezeCToken {
+        token_account: token_account_pubkey,
+        mint: mint_pubkey,
+        freeze_authority: payer.pubkey(),
+    }
+    .instruction()
+    .map_err(|e| RpcError::AssertRpcError(format!("Failed to create freeze instruction: {}", e)))?;
+
+    rpc.create_and_send_transaction(&[freeze_ix], &payer.pubkey(), &[&payer])
+        .await?;
+
+    // 4. Assert state is Frozen
+    assert_ctoken_freeze(&mut rpc, token_account_pubkey).await;
+
+    // 5. Thaw the account
+    let thaw_ix = ThawCToken {
+        token_account: token_account_pubkey,
+        mint: mint_pubkey,
+        freeze_authority: payer.pubkey(),
+    }
+    .instruction()
+    .map_err(|e| RpcError::AssertRpcError(format!("Failed to create thaw instruction: {}", e)))?;
+
+    rpc.create_and_send_transaction(&[thaw_ix], &payer.pubkey(), &[&payer])
+        .await?;
+
+    // 6. Assert state is Initialized again
+    assert_ctoken_thaw(&mut rpc, token_account_pubkey).await;
+
+    println!("Successfully tested freeze and thaw with basic mint");
+    Ok(())
+}
+
+/// Test freeze and thaw with a Token-2022 mint that has all extensions
+/// Verifies that extensions are preserved through freeze/thaw cycle
+#[tokio::test]
+#[serial]
+async fn test_freeze_thaw_with_extensions() -> Result<(), RpcError> {
+    let mut context = setup_extensions_test().await?;
+    let payer = context.payer.insecure_clone();
+    let mint_pubkey = context.mint_pubkey;
+    let owner = Keypair::new();
+
+    // 1. Create compressible CToken account with all extensions
+    let account_keypair = Keypair::new();
+    let account_pubkey = account_keypair.pubkey();
+
+    let create_ix =
+        CreateCTokenAccount::new(payer.pubkey(), account_pubkey, mint_pubkey, owner.pubkey())
+            .with_compressible(CompressibleParams {
+                compressible_config: context
+                    .rpc
+                    .test_accounts
+                    .funding_pool_config
+                    .compressible_config_pda,
+                rent_sponsor: context
+                    .rpc
+                    .test_accounts
+                    .funding_pool_config
+                    .rent_sponsor_pda,
+                pre_pay_num_epochs: 2,
+                lamports_per_write: Some(100),
+                compress_to_account_pubkey: None,
+                token_account_version: TokenDataVersion::ShaFlat,
+                compression_only: true,
+            })
+            .instruction()
+            .map_err(|e| {
+                RpcError::AssertRpcError(format!("Failed to create instruction: {}", e))
+            })?;
+
+    context
+        .rpc
+        .create_and_send_transaction(&[create_ix], &payer.pubkey(), &[&payer, &account_keypair])
+        .await?;
+
+    // Verify account was created with correct size (275 bytes with all extensions)
+    let account_data_initial = context.rpc.get_account(account_pubkey).await?.unwrap();
+    assert_eq!(
+        account_data_initial.data.len(),
+        275,
+        "CToken account should be 275 bytes with all extensions"
+    );
+
+    // Deserialize and verify initial state
+    let ctoken_initial = CToken::deserialize(&mut &account_data_initial.data[..])
+        .expect("Failed to deserialize CToken");
+    assert_eq!(
+        ctoken_initial.state,
+        AccountState::Initialized,
+        "Initial state should be Initialized"
+    );
+
+    // 2. Freeze the account
+    let freeze_ix = FreezeCToken {
+        token_account: account_pubkey,
+        mint: mint_pubkey,
+        freeze_authority: payer.pubkey(),
+    }
+    .instruction()
+    .map_err(|e| RpcError::AssertRpcError(format!("Failed to create freeze instruction: {}", e)))?;
+
+    context
+        .rpc
+        .create_and_send_transaction(&[freeze_ix], &payer.pubkey(), &[&payer])
+        .await?;
+
+    // 3. Assert state is Frozen with all extensions preserved
+    assert_ctoken_freeze(&mut context.rpc, account_pubkey).await;
+
+    // 4. Thaw the account
+    let thaw_ix = ThawCToken {
+        token_account: account_pubkey,
+        mint: mint_pubkey,
+        freeze_authority: payer.pubkey(),
+    }
+    .instruction()
+    .map_err(|e| RpcError::AssertRpcError(format!("Failed to create thaw instruction: {}", e)))?;
+
+    context
+        .rpc
+        .create_and_send_transaction(&[thaw_ix], &payer.pubkey(), &[&payer])
+        .await?;
+
+    // 5. Assert state is Initialized again with all extensions preserved
+    assert_ctoken_thaw(&mut context.rpc, account_pubkey).await;
+
+    println!("Successfully tested freeze and thaw with Token-2022 extensions");
+    Ok(())
+}
diff --git a/program-tests/compressed-token-test/tests/ctoken/functional.rs b/program-tests/compressed-token-test/tests/ctoken/functional.rs
index 40c6d5bb8f..02eaebade3 100644
--- a/program-tests/compressed-token-test/tests/ctoken/functional.rs
+++ b/program-tests/compressed-token-test/tests/ctoken/functional.rs
@@ -1,10 +1,9 @@
 use super::shared::*;
 /// Test:
-/// 1. SUCCESS: Create system account with SPL token size
-/// 2. SUCCESS: Initialize basic token account using SPL SDK compatible instruction
-/// 3. SUCCESS: Verify account structure and ownership using existing assertion helpers
-/// 4. SUCCESS: Close account transferring lamports to destination
-/// 5. SUCCESS: Verify account closure and lamport transfer using existing assertion helpers
+/// 1. SUCCESS: Create CToken account with 0 prepaid epochs (immediately compressible)
+/// 2. SUCCESS: Verify account structure and ownership using existing assertion helpers
+/// 3. SUCCESS: Close account transferring lamports to destination
+/// 4. SUCCESS: Verify account closure and lamport transfer using existing assertion helpers
 #[tokio::test]
 #[serial]
 async fn test_spl_sdk_compatible_account_lifecycle() -> Result<(), RpcError> {
@@ -12,51 +11,58 @@ async fn test_spl_sdk_compatible_account_lifecycle() -> Result<(), RpcError> {
     let payer_pubkey = context.payer.pubkey();
     let token_account_pubkey = context.token_account_keypair.pubkey();
 
-    // Create system account with proper rent exemption
-    let rent_exemption = context
-        .rpc
-        .get_minimum_balance_for_rent_exemption(165)
-        .await?;
-
-    let create_account_ix = create_account(
-        &payer_pubkey,
-        &token_account_pubkey,
-        rent_exemption,
-        165,
-        &light_compressed_token::ID,
-    );
+    // Create CToken account with 0 prepaid epochs (immediately compressible)
+    let compressible_params = CompressibleParams {
+        compressible_config: context.compressible_config,
+        rent_sponsor: context.rent_sponsor,
+        pre_pay_num_epochs: 0,
+        lamports_per_write: None,
+        compress_to_account_pubkey: None,
+        token_account_version: light_ctoken_interface::state::TokenDataVersion::ShaFlat,
+        compression_only: false,
+    };
 
-    // Initialize token account using SPL SDK compatible instruction (non-compressible)
-    let mut initialize_account_ix = CreateCTokenAccount {
-        payer: payer_pubkey,
-        account: token_account_pubkey,
-        mint: context.mint_pubkey,
-        owner: context.owner_keypair.pubkey(),
-        compressible: None,
-    }
+    let create_ix = CreateCTokenAccount::new(
+        payer_pubkey,
+        token_account_pubkey,
+        context.mint_pubkey,
+        context.owner_keypair.pubkey(),
+    )
+    .with_compressible(compressible_params)
     .instruction()
     .map_err(|e| {
         RpcError::AssertRpcError(format!("Failed to create token account instruction: {}", e))
     })?;
-    initialize_account_ix.data.push(0);
 
     // Execute account creation
     context
         .rpc
         .create_and_send_transaction(
-            &[create_account_ix, initialize_account_ix],
+            &[create_ix],
             &payer_pubkey,
             &[&context.payer, &context.token_account_keypair],
         )
         .await?;
 
     // Verify account creation using existing assertion helper
+    // Pass CompressibleData with 0 prepaid epochs since all accounts now have compression infrastructure
+    let compressible_data = CompressibleData {
+        compression_authority: context.compression_authority,
+        rent_sponsor: context.rent_sponsor,
+        num_prepaid_epochs: 0,
+        lamports_per_write: None,
+        account_version: light_ctoken_interface::state::TokenDataVersion::ShaFlat,
+        compress_to_pubkey: false,
+        payer: payer_pubkey,
+    };
+
     assert_create_token_account(
         &mut context.rpc,
         token_account_pubkey,
         context.mint_pubkey,
         context.owner_keypair.pubkey(),
-        None, // Basic token account
+        Some(compressible_data),
+        None,
     )
     .await;
 
@@ -119,7 +125,7 @@ async fn test_compressible_account_with_compression_authority_lifecycle() {
     // Create system account with compressible size
     let rent_exemption = context
         .rpc
-        .get_minimum_balance_for_rent_exemption(COMPRESSIBLE_TOKEN_ACCOUNT_SIZE as usize)
+        .get_minimum_balance_for_rent_exemption(BASE_TOKEN_ACCOUNT_SIZE as usize)
         .await
         .unwrap();
 
@@ -134,6 +140,7 @@ async fn test_compressible_account_with_compression_authority_lifecycle() {
         lamports_per_write,
         compress_to_account_pubkey: None,
         token_account_version: light_ctoken_interface::state::TokenDataVersion::ShaFlat,
+        compression_only: false,
     };
 
     let create_token_account_ix = CreateCTokenAccount::new(
@@ -185,6 +192,7 @@ async fn test_compressible_account_with_compression_authority_lifecycle() {
             account_version: light_ctoken_interface::state::TokenDataVersion::ShaFlat,
             payer: payer_pubkey,
         }),
+        None,
     )
     .await;
 
@@ -215,12 +223,12 @@ async fn test_compressible_account_with_compression_authority_lifecycle() {
 
     // Calculate transaction fee from the transaction result
     let tx_fee = 10_000; // Standard transaction fee
-                         // With 3 prepaid epochs: compression_cost (11000) + 3 * rent_per_epoch (389) = 12167
-                         // rent_per_epoch = 261 bytes * 1 lamport/byte/epoch + base_rent (128) = 389
+                         // With 3 prepaid epochs: compression_cost (11000) + 3 * rent_per_epoch (386) = 12158
+                         // rent_per_epoch = 262 bytes * 1 lamport/byte/epoch + base_rent (124) = 386
     assert_eq!(
         payer_balance_before - payer_balance_after,
-        12_167 + tx_fee,
-        "Payer should have paid 12,167 lamports for additional rent (3 epochs) plus {} tx fee",
+        12_158 + tx_fee,
+        "Payer should have paid 12,158 lamports for additional rent (3 epochs) plus {} tx fee",
         tx_fee
     );
 
@@ -246,6 +254,7 @@ async fn test_compressible_account_with_compression_authority_lifecycle() {
             context.owner_keypair.pubkey(),
             &context.owner_keypair,
             &context.payer,
+            9,
         )
         .await
         .unwrap();
@@ -260,6 +269,7 @@ async fn test_compressible_account_with_compression_authority_lifecycle() {
             authority: context.owner_keypair.pubkey(),
             output_queue,
             pool_index: None,
+            decimals: 9,
         };
         assert_transfer2_compress(&mut context.rpc, compress_input).await;
     }
diff --git a/program-tests/compressed-token-test/tests/ctoken/functional_ata.rs b/program-tests/compressed-token-test/tests/ctoken/functional_ata.rs
index dc86f21fbd..53081dd978 100644
--- a/program-tests/compressed-token-test/tests/ctoken/functional_ata.rs
+++ b/program-tests/compressed-token-test/tests/ctoken/functional_ata.rs
@@ -19,19 +19,22 @@ async fn test_associated_token_account_operations() {
     let payer_pubkey = context.payer.pubkey();
     let owner_pubkey = context.owner_keypair.pubkey();
 
-    // Create basic (non-compressible) ATA using SDK function
-    let (ata, bump) = derive_ctoken_ata(&owner_pubkey, &context.mint_pubkey);
-    let instruction = CreateAssociatedCTokenAccount {
-        idempotent: false,
-        bump,
-        payer: payer_pubkey,
-        owner: owner_pubkey,
-        mint: context.mint_pubkey,
-        associated_token_account: ata,
-        compressible: None,
-    }
-    .instruction()
-    .unwrap();
+    // Create ATA with 0 prepaid epochs (immediately compressible)
+    let compressible_params = CompressibleParams {
+        compressible_config: context.compressible_config,
+        rent_sponsor: context.rent_sponsor,
+        pre_pay_num_epochs: 0,
+        lamports_per_write: None,
+        compress_to_account_pubkey: None,
+        token_account_version: light_ctoken_interface::state::TokenDataVersion::ShaFlat,
+        compression_only: false,
+    };
+
+    let instruction =
+        CreateAssociatedCTokenAccount::new(payer_pubkey, owner_pubkey, context.mint_pubkey)
+            .with_compressible(compressible_params)
+            .instruction()
+            .unwrap();
 
     context
         .rpc
@@ -39,11 +42,23 @@ async fn test_associated_token_account_operations() {
         .await
         .unwrap();
 
-    // Verify basic ATA creation using existing assertion helper
+    // Verify ATA creation using existing assertion helper
+    // Pass CompressibleData with 0 prepaid epochs since all accounts now have compression infrastructure
+    let compressible_data = CompressibleData {
+        compression_authority: context.compression_authority,
+        rent_sponsor: context.rent_sponsor,
+        num_prepaid_epochs: 0,
+        lamports_per_write: None,
+        account_version: light_ctoken_interface::state::TokenDataVersion::ShaFlat,
+        compress_to_pubkey: false,
+        payer: payer_pubkey,
+    };
+
     assert_create_associated_token_account(
         &mut context.rpc,
         owner_pubkey,
         context.mint_pubkey,
+        Some(compressible_data),
         None,
     )
     .await;
@@ -62,6 +77,7 @@ async fn test_associated_token_account_operations() {
         lamports_per_write,
         compress_to_account_pubkey: None,
         token_account_version: light_ctoken_interface::state::TokenDataVersion::ShaFlat,
+        compression_only: false,
     };
 
     let compressible_instruction = CreateAssociatedCTokenAccount::new(
@@ -97,6 +113,7 @@ async fn test_associated_token_account_operations() {
             account_version: light_ctoken_interface::state::TokenDataVersion::ShaFlat,
             payer: payer_pubkey,
         }),
+        None,
     )
     .await;
 
@@ -152,19 +169,23 @@ async fn test_create_ata_idempotent() {
     let mut context = setup_account_test().await.unwrap();
     let payer_pubkey = context.payer.pubkey();
     let owner_pubkey = context.owner_keypair.pubkey();
-    let (ata, bump) = derive_ctoken_ata(&owner_pubkey, &context.mint_pubkey);
-    // Create ATA using non-idempotent instruction (first creation)
-    let instruction = CreateAssociatedCTokenAccount {
-        idempotent: false,
-        bump,
-        payer: payer_pubkey,
-        owner: owner_pubkey,
-        mint: context.mint_pubkey,
-        associated_token_account: ata,
-        compressible: None,
-    }
-    .instruction()
-    .unwrap();
+
+    // Create ATA with 0 prepaid epochs using non-idempotent instruction (first creation)
+    let compressible_params = CompressibleParams {
+        compressible_config: context.compressible_config,
+        rent_sponsor: context.rent_sponsor,
+        pre_pay_num_epochs: 0,
+        lamports_per_write: None,
+        compress_to_account_pubkey: None,
+        token_account_version: light_ctoken_interface::state::TokenDataVersion::ShaFlat,
+        compression_only: false,
+    };
+
+    let instruction =
+        CreateAssociatedCTokenAccount::new(payer_pubkey, owner_pubkey, context.mint_pubkey)
+            .with_compressible(compressible_params)
+            .instruction()
+            .unwrap();
 
     context
         .rpc
@@ -173,10 +194,21 @@ async fn test_create_ata_idempotent() {
         .unwrap();
 
     // Verify ATA creation
+    let compressible_data = CompressibleData {
+        compression_authority: context.compression_authority,
+        rent_sponsor: context.rent_sponsor,
+        num_prepaid_epochs: 0,
+        lamports_per_write: None,
+        account_version: light_ctoken_interface::state::TokenDataVersion::ShaFlat,
+        compress_to_pubkey: false,
+        payer: payer_pubkey,
+    };
+
     assert_create_associated_token_account(
         &mut context.rpc,
         owner_pubkey,
         context.mint_pubkey,
+        Some(compressible_data),
         None,
     )
     .await;
@@ -211,11 +243,20 @@ async fn test_create_ata_idempotent() {
         .await
         .unwrap();
 
-    // Verify ATA is still correct
+    // Verify ATA is still correct - account was created with compressible params so still has compression
     assert_create_associated_token_account(
         &mut context.rpc,
         owner_pubkey,
         context.mint_pubkey,
+        Some(CompressibleData {
+            compression_authority: context.compression_authority,
+            rent_sponsor: context.rent_sponsor,
+            num_prepaid_epochs: 0,
+            lamports_per_write: None,
+            account_version: light_ctoken_interface::state::TokenDataVersion::ShaFlat,
+            compress_to_pubkey: false,
+            payer: payer_pubkey,
+        }),
         None,
     )
     .await;
@@ -258,6 +299,16 @@ async fn test_create_ata_with_prefunded_lamports() {
     );
 
     // Now create the ATA - this should succeed despite pre-funded lamports
+    let compressible_params = CompressibleParams {
+        compressible_config: context.compressible_config,
+        rent_sponsor: context.rent_sponsor,
+        pre_pay_num_epochs: 0,
+        lamports_per_write: None,
+        compress_to_account_pubkey: None,
+        token_account_version: light_ctoken_interface::state::TokenDataVersion::ShaFlat,
+        compression_only: false,
+    };
+
     let instruction = CreateAssociatedCTokenAccount {
         idempotent: false,
         bump,
@@ -265,7 +316,7 @@ async fn test_create_ata_with_prefunded_lamports() {
         owner: owner_pubkey,
         mint: context.mint_pubkey,
         associated_token_account: ata,
-        compressible: None,
+        compressible: compressible_params,
     }
     .instruction()
     .unwrap();
@@ -281,6 +332,15 @@ async fn test_create_ata_with_prefunded_lamports() {
         &mut context.rpc,
         owner_pubkey,
         context.mint_pubkey,
+        Some(CompressibleData {
+            compression_authority: context.compression_authority,
+            rent_sponsor: context.rent_sponsor,
+            num_prepaid_epochs: 0,
+            lamports_per_write: None,
+            account_version: light_ctoken_interface::state::TokenDataVersion::ShaFlat,
+            compress_to_pubkey: false,
+            payer: payer_pubkey,
+        }),
         None,
     )
     .await;
@@ -338,6 +398,7 @@ async fn test_create_token_account_with_prefunded_lamports() {
         lamports_per_write: Some(100),
         compress_to_account_pubkey: None,
         token_account_version: light_ctoken_interface::state::TokenDataVersion::ShaFlat,
+        compression_only: false,
     };
 
     let create_token_account_ix = CreateCTokenAccount::new(
@@ -375,6 +436,7 @@ async fn test_create_token_account_with_prefunded_lamports() {
             account_version: light_ctoken_interface::state::TokenDataVersion::ShaFlat,
             payer: payer_pubkey,
         }),
+        None,
     )
     .await;
 
diff --git a/program-tests/compressed-token-test/tests/ctoken/shared.rs b/program-tests/compressed-token-test/tests/ctoken/shared.rs
index 67af58b715..b7cb3847ea 100644
--- a/program-tests/compressed-token-test/tests/ctoken/shared.rs
+++ b/program-tests/compressed-token-test/tests/ctoken/shared.rs
@@ -1,9 +1,9 @@
 // Re-export all necessary imports for test modules
 pub use light_compressible::rent::{RentConfig, SLOTS_PER_EPOCH};
-pub use light_ctoken_interface::COMPRESSIBLE_TOKEN_ACCOUNT_SIZE;
+pub use light_ctoken_interface::BASE_TOKEN_ACCOUNT_SIZE;
 pub use light_ctoken_sdk::ctoken::{
-    derive_ctoken_ata, CloseCTokenAccount, CompressibleParams, CreateAssociatedCTokenAccount,
-    CreateCTokenAccount,
+    derive_ctoken_ata, ApproveCToken, CloseCTokenAccount, CompressibleParams,
+    CreateAssociatedCTokenAccount, CreateCTokenAccount, RevokeCToken,
 };
 pub use light_program_test::{
     forester::compress_and_close_forester, program_test::TestRpc, LightProgramTest,
@@ -15,6 +15,7 @@ pub use light_test_utils::{
     assert_create_token_account::{
         assert_create_associated_token_account, assert_create_token_account, CompressibleData,
     },
+    assert_ctoken_approve_revoke::{assert_ctoken_approve, assert_ctoken_revoke},
     assert_transfer2::assert_transfer2_compress,
     Rpc, RpcError,
 };
@@ -23,7 +24,6 @@ pub use light_token_client::{
 };
 pub use serial_test::serial;
 pub use solana_sdk::{pubkey::Pubkey, signature::Keypair, signer::Signer};
-pub use solana_system_interface::instruction::create_account;
 /// Shared test context for account operations
 pub struct AccountTestContext {
     pub rpc: LightProgramTest,
@@ -96,6 +96,7 @@ pub async fn create_and_assert_token_account(
         lamports_per_write: compressible_data.lamports_per_write,
         compress_to_account_pubkey: None,
         token_account_version: compressible_data.account_version,
+        compression_only: false,
     };
 
     let create_token_account_ix = CreateCTokenAccount::new(
@@ -124,6 +125,7 @@ pub async fn create_and_assert_token_account(
         context.mint_pubkey,
         context.owner_keypair.pubkey(),
         Some(compressible_data),
+        None,
     )
     .await;
 }
@@ -150,6 +152,7 @@ pub async fn create_and_assert_token_account_fails(
         lamports_per_write: compressible_data.lamports_per_write,
         compress_to_account_pubkey: None,
         token_account_version: compressible_data.account_version,
+        compression_only: false,
     };
 
     let create_token_account_ix = CreateCTokenAccount::new(
@@ -210,73 +213,63 @@ pub async fn setup_account_test_with_created_account(
     Ok(context)
 }
 
-/// Create a non-compressible token account (165 bytes, no compressible extension)
+/// Create a token account with 0 prepaid epochs (immediately compressible by compression authority)
 pub async fn create_non_compressible_token_account(
     context: &mut AccountTestContext,
     token_keypair: Option<&Keypair>,
 ) {
-    use anchor_lang::prelude::{borsh::BorshSerialize, AccountMeta};
-    use light_ctoken_interface::instructions::create_ctoken_account::CreateTokenAccountInstructionData;
-    use solana_sdk::instruction::Instruction;
     let token_keypair = token_keypair.unwrap_or(&context.token_account_keypair);
     let payer_pubkey = context.payer.pubkey();
     let token_account_pubkey = token_keypair.pubkey();
 
-    // Create account via system program (165 bytes for non-compressible)
-    let rent = context
-        .rpc
-        .get_minimum_balance_for_rent_exemption(165)
-        .await
-        .unwrap();
+    // Use the SDK builder with 0 prepaid epochs
+    let compressible_params = CompressibleParams {
+        compressible_config: context.compressible_config,
+        rent_sponsor: context.rent_sponsor,
+        pre_pay_num_epochs: 0,
+        lamports_per_write: None,
+        compress_to_account_pubkey: None,
+        token_account_version: light_ctoken_interface::state::TokenDataVersion::ShaFlat,
+        compression_only: false,
+    };
 
-    let create_account_ix = solana_sdk::system_instruction::create_account(
-        &payer_pubkey,
-        &token_account_pubkey,
-        rent,
-        165,
-        &light_compressed_token::ID,
-    );
+    let create_ix = CreateCTokenAccount::new(
+        payer_pubkey,
+        token_account_pubkey,
+        context.mint_pubkey,
+        context.owner_keypair.pubkey(),
+    )
+    .with_compressible(compressible_params)
+    .instruction()
+    .unwrap();
 
     context
         .rpc
         .create_and_send_transaction(
-            &[create_account_ix],
+            &[create_ix],
             &payer_pubkey,
             &[&context.payer, token_keypair],
         )
         .await
         .unwrap();
 
-    // Initialize the token account (non-compressible)
-    let init_data = CreateTokenAccountInstructionData {
-        owner: context.owner_keypair.pubkey().into(),
-        compressible_config: None, // Non-compressible
+    // Assert account was created correctly with 0 prepaid epochs
+    let compressible_data = CompressibleData {
+        compression_authority: context.compression_authority,
+        rent_sponsor: context.rent_sponsor,
+        num_prepaid_epochs: 0,
+        lamports_per_write: None,
+        compress_to_pubkey: false,
+        account_version: light_ctoken_interface::state::TokenDataVersion::ShaFlat,
+        payer: payer_pubkey,
     };
-    let mut data = vec![18]; // CreateTokenAccount discriminator
-    init_data.serialize(&mut data).unwrap();
-
-    let init_ix = Instruction {
-        program_id: light_compressed_token::ID,
-        accounts: vec![
-            AccountMeta::new(token_account_pubkey, true),
-            AccountMeta::new_readonly(context.mint_pubkey, false),
-        ],
-        data,
-    };
-
-    context
-        .rpc
-        .create_and_send_transaction(&[init_ix], &payer_pubkey, &[&context.payer, token_keypair])
-        .await
-        .unwrap();
-
-    // Assert account was created correctly
     assert_create_token_account(
         &mut context.rpc,
         token_account_pubkey,
         context.mint_pubkey,
         context.owner_keypair.pubkey(),
-        None, // Non-compressible
+        Some(compressible_data),
+        None,
     )
     .await;
 }
@@ -300,48 +293,23 @@ pub async fn close_and_assert_token_account(
         .unwrap()
         .unwrap();
 
-    let is_compressible = account_info.data.len() == COMPRESSIBLE_TOKEN_ACCOUNT_SIZE as usize;
-
-    let close_ix = if is_compressible {
-        // Read rent_sponsor from the account's compressible extension
-        use light_ctoken_interface::state::{CToken, ZExtensionStruct};
-        use light_zero_copy::traits::ZeroCopyAt;
-
-        let (ctoken, _) = CToken::zero_copy_at(&account_info.data).unwrap();
-        let rent_sponsor = if let Some(extensions) = ctoken.extensions.as_ref() {
-            extensions
-                .iter()
-                .find_map(|ext| match ext {
-                    ZExtensionStruct::Compressible(comp) => {
-                        Some(Pubkey::from(comp.info.rent_sponsor))
-                    }
-                    _ => None,
-                })
-                .unwrap()
-        } else {
-            panic!("Compressible account must have compressible extension");
-        };
+    // Read rent_sponsor from the account's embedded compression info
+    use light_ctoken_interface::state::CToken;
+    use light_zero_copy::traits::ZeroCopyAt;
 
-        CloseCTokenAccount {
-            token_program: light_compressed_token::ID,
-            account: token_account_pubkey,
-            destination,
-            owner: context.owner_keypair.pubkey(),
-            rent_sponsor: Some(rent_sponsor),
-        }
-        .instruction()
-        .unwrap()
-    } else {
-        CloseCTokenAccount {
-            token_program: light_compressed_token::ID,
-            account: token_account_pubkey,
-            destination,
-            owner: context.owner_keypair.pubkey(),
-            rent_sponsor: None,
-        }
-        .instruction()
-        .unwrap()
-    };
+    let (ctoken, _) = CToken::zero_copy_at(&account_info.data).unwrap();
+    let compression = &ctoken.compression;
+    let rent_sponsor = Pubkey::from(compression.rent_sponsor);
+
+    let close_ix = CloseCTokenAccount {
+        token_program: light_compressed_token::ID,
+        account: token_account_pubkey,
+        destination,
+        owner: context.owner_keypair.pubkey(),
+        rent_sponsor,
+    }
+    .instruction()
+    .unwrap();
 
     context
         .rpc
@@ -368,7 +336,7 @@ pub async fn close_and_assert_token_account_fails(
     context: &mut AccountTestContext,
     destination: Pubkey,
     authority: &Keypair,
-    rent_sponsor: Option<Pubkey>,
+    rent_sponsor: Pubkey,
     name: &str,
     expected_error_code: u32,
 ) {
@@ -380,7 +348,7 @@ pub async fn close_and_assert_token_account_fails(
     let payer_pubkey = context.payer.pubkey();
     let token_account_pubkey = context.token_account_keypair.pubkey();
 
-    let close_ix = CloseCTokenAccount {
+    let mut close_ix = CloseCTokenAccount {
         token_program: light_compressed_token::ID,
         account: token_account_pubkey,
         destination,
@@ -389,6 +357,10 @@ pub async fn close_and_assert_token_account_fails(
     }
     .instruction()
     .unwrap();
+    // Remove rent_sponsor account if it's default to test missing rent sponsor
+    if rent_sponsor == Pubkey::default() {
+        close_ix.accounts.pop();
+    }
 
     let result = context
         .rpc
@@ -424,6 +396,7 @@ pub async fn create_and_assert_ata(
             lamports_per_write: compressible.lamports_per_write,
             compress_to_account_pubkey: None,
             token_account_version: compressible.account_version,
+            compression_only: false,
         };
 
         let mut builder =
@@ -436,7 +409,7 @@ pub async fn create_and_assert_ata(
 
         builder.instruction().unwrap()
     } else {
-        // Create non-compressible account
+        // Create account with default compressible params
         let mut builder = CreateAssociatedCTokenAccount {
             idempotent: false,
             bump,
@@ -444,7 +417,7 @@ pub async fn create_and_assert_ata(
             owner: owner_pubkey,
             mint: context.mint_pubkey,
             associated_token_account: ata_pubkey,
-            compressible: None,
+            compressible: CompressibleParams::default(),
         };
 
         if idempotent {
@@ -466,6 +439,7 @@ pub async fn create_and_assert_ata(
         owner_pubkey,
         context.mint_pubkey,
         compressible_data,
+        None,
     )
     .await;
 
@@ -494,6 +468,7 @@ pub async fn create_and_assert_ata_fails(
             lamports_per_write: compressible.lamports_per_write,
             compress_to_account_pubkey: None,
             token_account_version: compressible.account_version,
+            compression_only: false,
         }
     } else {
         CompressibleParams::default()
@@ -679,7 +654,7 @@ pub async fn compress_and_close_forester_with_invalid_output(
 
     use anchor_lang::{InstructionData, ToAccountMetas};
     use light_compressible::config::CompressibleConfig;
-    use light_ctoken_interface::state::{CToken, ZExtensionStruct};
+    use light_ctoken_interface::state::CToken;
     use light_registry::{
         accounts::CompressAndCloseContext as CompressAndCloseAccounts,
         instruction::CompressAndClose, utils::get_forester_epoch_pda_from_authority,
@@ -720,17 +695,9 @@ pub async fn compress_and_close_forester_with_invalid_output(
     let (ctoken, _) = CToken::zero_copy_at(&token_account_info.data).unwrap();
     let mint_pubkey = Pubkey::from(ctoken.mint.to_bytes());
 
-    // Extract compressible extension data
-    let extensions = ctoken.extensions.as_ref().unwrap();
-    let compressible_ext = extensions
-        .iter()
-        .find_map(|ext| match ext {
-            ZExtensionStruct::Compressible(comp) => Some(comp),
-            _ => None,
-        })
-        .unwrap();
-
-    let rent_sponsor = Pubkey::from(compressible_ext.info.rent_sponsor);
+    // Extract compression info from embedded field
+    let compression = &ctoken.compression;
+    let rent_sponsor = Pubkey::from(compression.rent_sponsor);
 
     // Get output queue for compression
     let output_queue = context
@@ -764,6 +731,7 @@ pub async fn compress_and_close_forester_with_invalid_output(
         mint_index,
         owner_index,
         rent_sponsor_index,
+        delegate_index: 0, // No delegate in validation tests
     };
 
     // Add system accounts
@@ -819,3 +787,314 @@ pub async fn compress_and_close_forester_with_invalid_output(
     // Assert that the transaction failed with the expected error code
     light_program_test::utils::assert::assert_rpc_error(result, 0, expected_error_code).unwrap();
 }
+
+// ============================================================================
+// Approve and Revoke Helper Functions
+// ============================================================================
+
+/// Execute SPL-format approve and assert success (uses spl_token_2022 instruction format)
+/// This tests SPL compatibility - building instruction with spl_token_2022 and changing program_id.
+/// Note: CToken requires system_program account for compressible top-up, so we add it here.
+pub async fn approve_spl_compat_and_assert(
+    context: &mut AccountTestContext,
+    delegate: Pubkey,
+    amount: u64,
+    name: &str,
+) {
+    use anchor_spl::token_2022::spl_token_2022;
+    use solana_sdk::instruction::AccountMeta;
+    println!("SPL compat approve initiated for: {}", name);
+
+    // Build SPL approve instruction and change program_id
+    let mut approve_ix = spl_token_2022::instruction::approve(
+        &spl_token_2022::ID,
+        &context.token_account_keypair.pubkey(),
+        &delegate,
+        &context.owner_keypair.pubkey(),
+        &[],
+        amount,
+    )
+    .unwrap();
+    approve_ix.program_id = light_compressed_token::ID;
+    // Mark owner as writable for compressible top-up (ctoken extension)
+    approve_ix.accounts[2].is_writable = true;
+    // Add system program for CPI (required for lamport transfers)
+    approve_ix
+        .accounts
+        .push(AccountMeta::new_readonly(Pubkey::default(), false));
+
+    context
+        .rpc
+        .create_and_send_transaction(
+            &[approve_ix],
+            &context.payer.pubkey(),
+            &[&context.payer, &context.owner_keypair],
+        )
+        .await
+        .unwrap();
+
+    // Use existing assert function from light-test-utils
+    assert_ctoken_approve(
+        &mut context.rpc,
+        context.token_account_keypair.pubkey(),
+        delegate,
+        amount,
+    )
+    .await;
+}
+
+/// Execute SPL-format revoke and assert success (uses spl_token_2022 instruction format)
+/// This tests SPL compatibility - building instruction with spl_token_2022 and changing program_id.
+/// Note: CToken requires system_program account for compressible top-up, so we add it here.
+pub async fn revoke_spl_compat_and_assert(context: &mut AccountTestContext, name: &str) {
+    use anchor_spl::token_2022::spl_token_2022;
+    use solana_sdk::instruction::AccountMeta;
+    println!("SPL compat revoke initiated for: {}", name);
+
+    // Build SPL revoke instruction and change program_id
+    let mut revoke_ix = spl_token_2022::instruction::revoke(
+        &spl_token_2022::ID,
+        &context.token_account_keypair.pubkey(),
+        &context.owner_keypair.pubkey(),
+        &[],
+    )
+    .unwrap();
+    revoke_ix.program_id = light_compressed_token::ID;
+    // Mark owner as writable for compressible top-up (ctoken extension)
+    revoke_ix.accounts[1].is_writable = true;
+    // Add system program for CPI (required for lamport transfers)
+    revoke_ix
+        .accounts
+        .push(AccountMeta::new_readonly(Pubkey::default(), false));
+
+    context
+        .rpc
+        .create_and_send_transaction(
+            &[revoke_ix],
+            &context.payer.pubkey(),
+            &[&context.payer, &context.owner_keypair],
+        )
+        .await
+        .unwrap();
+
+    // Use existing assert function from light-test-utils
+    assert_ctoken_revoke(&mut context.rpc, context.token_account_keypair.pubkey()).await;
+}
+
+/// Execute approve and assert success using SDK
+pub async fn approve_and_assert(
+    context: &mut AccountTestContext,
+    delegate: Pubkey,
+    amount: u64,
+    name: &str,
+) {
+    println!("Approve initiated for: {}", name);
+
+    // Use light-ctoken-sdk
+    let approve_ix = ApproveCToken {
+        token_account: context.token_account_keypair.pubkey(),
+        delegate,
+        owner: context.owner_keypair.pubkey(),
+        amount,
+    }
+    .instruction()
+    .unwrap();
+
+    context
+        .rpc
+        .create_and_send_transaction(
+            &[approve_ix],
+            &context.payer.pubkey(),
+            &[&context.payer, &context.owner_keypair],
+        )
+        .await
+        .unwrap();
+
+    // Use existing assert function from light-test-utils
+    assert_ctoken_approve(
+        &mut context.rpc,
+        context.token_account_keypair.pubkey(),
+        delegate,
+        amount,
+    )
+    .await;
+}
+
+/// Execute approve expecting failure - modify SDK instruction if needed
+#[allow(clippy::too_many_arguments)]
+pub async fn approve_and_assert_fails(
+    context: &mut AccountTestContext,
+    token_account: Pubkey,
+    delegate: Pubkey,
+    authority: &Keypair,
+    amount: u64,
+    max_top_up: Option<u16>,
+    name: &str,
+    expected_error_code: u32,
+) {
+    println!("Approve (expecting failure) initiated for: {}", name);
+
+    // Build using SDK, then modify if needed for max_top_up
+    let mut instruction = ApproveCToken {
+        token_account,
+        delegate,
+        owner: authority.pubkey(),
+        amount,
+    }
+    .instruction()
+    .unwrap();
+
+    // Add max_top_up to instruction data if specified
+    if let Some(max) = max_top_up {
+        instruction.data.extend_from_slice(&max.to_le_bytes());
+    }
+
+    let result = context
+        .rpc
+        .create_and_send_transaction(
+            &[instruction],
+            &context.payer.pubkey(),
+            &[&context.payer, authority],
+        )
+        .await;
+
+    light_program_test::utils::assert::assert_rpc_error(result, 0, expected_error_code).unwrap();
+}
+
+/// Execute revoke and assert success using SDK
+pub async fn revoke_and_assert(context: &mut AccountTestContext, name: &str) {
+    println!("Revoke initiated for: {}", name);
+
+    // Use light-ctoken-sdk
+    let revoke_ix = RevokeCToken {
+        token_account: context.token_account_keypair.pubkey(),
+        owner: context.owner_keypair.pubkey(),
+    }
+    .instruction()
+    .unwrap();
+
+    context
+        .rpc
+        .create_and_send_transaction(
+            &[revoke_ix],
+            &context.payer.pubkey(),
+            &[&context.payer, &context.owner_keypair],
+        )
+        .await
+        .unwrap();
+
+    // Use existing assert function from light-test-utils
+    assert_ctoken_revoke(&mut context.rpc, context.token_account_keypair.pubkey()).await;
+}
+
+/// Execute revoke expecting failure - modify SDK instruction if needed
+pub async fn revoke_and_assert_fails(
+    context: &mut AccountTestContext,
+    token_account: Pubkey,
+    authority: &Keypair,
+    max_top_up: Option<u16>,
+    name: &str,
+    expected_error_code: u32,
+) {
+    println!("Revoke (expecting failure) initiated for: {}", name);
+
+    // Build using SDK, then modify if needed for max_top_up
+    let mut instruction = RevokeCToken {
+        token_account,
+        owner: authority.pubkey(),
+    }
+    .instruction()
+    .unwrap();
+
+    // Add max_top_up to instruction data if specified
+    if let Some(max) = max_top_up {
+        instruction.data.extend_from_slice(&max.to_le_bytes());
+    }
+
+    let result = context
+        .rpc
+        .create_and_send_transaction(
+            &[instruction],
+            &context.payer.pubkey(),
+            &[&context.payer, authority],
+        )
+        .await;
+
+    light_program_test::utils::assert::assert_rpc_error(result, 0, expected_error_code).unwrap();
+}
+
+// Note: Delegate self-revoke (Token-2022 feature) is NOT supported by pinocchio-token-program.
+// The pinocchio implementation only validates against the owner, not the delegate.
+
+// ============================================================================
+// Transfer Checked Helper Functions
+// ============================================================================
+
+use anchor_spl::token::Mint;
+
+/// Set up test environment with an SPL Token mint (not Token-2022)
+/// Creates a real SPL Token mint for transfer_checked tests
+pub async fn setup_account_test_with_spl_mint(
+    decimals: u8,
+) -> Result<AccountTestContext, RpcError> {
+    use anchor_spl::token::spl_token;
+
+    let rpc = LightProgramTest::new(ProgramTestConfig::new_v2(false, None)).await?;
+    let payer = rpc.get_payer().insecure_clone();
+    let owner_keypair = Keypair::new();
+    let token_account_keypair = Keypair::new();
+
+    // Create SPL Token mint
+    let mint_keypair = Keypair::new();
+    let mint_pubkey = mint_keypair.pubkey();
+
+    let mint_rent = rpc
+        .get_minimum_balance_for_rent_exemption(Mint::LEN)
+        .await?;
+
+    let create_mint_account_ix = solana_sdk::system_instruction::create_account(
+        &payer.pubkey(),
+        &mint_pubkey,
+        mint_rent,
+        Mint::LEN as u64,
+        &spl_token::ID,
+    );
+
+    let initialize_mint_ix = spl_token::instruction::initialize_mint(
+        &spl_token::ID,
+        &mint_pubkey,
+        &payer.pubkey(),
+        Some(&payer.pubkey()),
+        decimals,
+    )
+    .unwrap();
+
+    let mut rpc_mut = rpc;
+    rpc_mut
+        .create_and_send_transaction(
+            &[create_mint_account_ix, initialize_mint_ix],
+            &payer.pubkey(),
+            &[&payer, &mint_keypair],
+        )
+        .await?;
+
+    Ok(AccountTestContext {
+        compressible_config: rpc_mut
+            .test_accounts
+            .funding_pool_config
+            .compressible_config_pda,
+        rent_sponsor: rpc_mut.test_accounts.funding_pool_config.rent_sponsor_pda,
+        compression_authority: rpc_mut
+            .test_accounts
+            .funding_pool_config
+            .compression_authority_pda,
+        rpc: rpc_mut,
+        payer,
+        mint_pubkey,
+        owner_keypair,
+        token_account_keypair,
+    })
+}
+
+// Note: Token-2022 mint setup is more complex and requires additional handling.
+// Tests for Token-2022 mints are covered in sdk-tests/sdk-ctoken-test/tests/test_transfer_checked.rs
diff --git a/program-tests/compressed-token-test/tests/ctoken/spl_instruction_compat.rs b/program-tests/compressed-token-test/tests/ctoken/spl_instruction_compat.rs
index 5a38dbda9f..b55a704cc9 100644
--- a/program-tests/compressed-token-test/tests/ctoken/spl_instruction_compat.rs
+++ b/program-tests/compressed-token-test/tests/ctoken/spl_instruction_compat.rs
@@ -7,7 +7,12 @@ use super::shared::*;
 ///
 /// This test creates SPL token instructions using the official spl_token library,
 /// then changes the program_id to the ctoken program to verify instruction format compatibility.
+///
+/// NOTE: This test is currently ignored because the ctoken program now requires additional accounts
+/// (compressible_config, rent_sponsor) that SPL token instructions don't provide. The CToken
+/// instruction format has diverged from raw SPL Token compatibility.
 #[tokio::test]
+#[ignore = "CToken instruction format has changed - requires compressible_config and rent_sponsor accounts"]
 #[allow(deprecated)] // We're testing SPL compatibility with the basic transfer instruction
 async fn test_spl_instruction_compatibility() {
     let mut context = setup_account_test().await.unwrap();
diff --git a/program-tests/compressed-token-test/tests/ctoken/transfer.rs b/program-tests/compressed-token-test/tests/ctoken/transfer.rs
index 53b5061a3d..998c825d93 100644
--- a/program-tests/compressed-token-test/tests/ctoken/transfer.rs
+++ b/program-tests/compressed-token-test/tests/ctoken/transfer.rs
@@ -28,30 +28,30 @@ async fn setup_transfer_test(
     let rent_sponsor = context.rent_sponsor;
 
     // Create source token account
+    // When num_prepaid_epochs is None, use 3 epochs (sufficient for no top-up: epochs_funded_ahead = 3 - 1 = 2 >= 2)
+    let source_epochs = num_prepaid_epochs.unwrap_or(3);
     context.token_account_keypair = source_keypair.insecure_clone();
-    if let Some(epochs) = num_prepaid_epochs {
+    {
         let compressible_data = CompressibleData {
             compression_authority: context.compression_authority,
             rent_sponsor,
-            num_prepaid_epochs: epochs,
+            num_prepaid_epochs: source_epochs,
             lamports_per_write: Some(100),
             account_version: light_ctoken_interface::state::TokenDataVersion::ShaFlat,
             compress_to_pubkey: false,
             payer: payer_pubkey,
         };
         create_and_assert_token_account(&mut context, compressible_data, "source_account").await;
-    } else {
-        // Create non-compressible source account (165 bytes, no extension)
-        create_non_compressible_token_account(&mut context, Some(&source_keypair)).await;
     }
 
     // Create destination token account
+    let dest_epochs = num_prepaid_epochs.unwrap_or(3);
     context.token_account_keypair = destination_keypair.insecure_clone();
-    if let Some(epochs) = num_prepaid_epochs {
+    {
         let compressible_data = CompressibleData {
             compression_authority: context.compression_authority,
             rent_sponsor,
-            num_prepaid_epochs: epochs,
+            num_prepaid_epochs: dest_epochs,
             lamports_per_write: Some(100),
             account_version: light_ctoken_interface::state::TokenDataVersion::ShaFlat,
             compress_to_pubkey: false,
@@ -59,9 +59,6 @@ async fn setup_transfer_test(
         };
         create_and_assert_token_account(&mut context, compressible_data, "destination_account")
             .await;
-    } else {
-        // Create non-compressible destination account (165 bytes, no extension)
-        create_non_compressible_token_account(&mut context, Some(&destination_keypair)).await;
     }
 
     // Mint tokens to source account using set_account
@@ -98,6 +95,9 @@ async fn setup_transfer_test(
 }
 
 /// Build a ctoken transfer instruction
+///
+/// For basic transfers (no T22 extensions), only 3 accounts are needed.
+/// Authority is writable because compressible accounts may require top-up.
 fn build_transfer_instruction(
     source: Pubkey,
     destination: Pubkey,
@@ -107,18 +107,18 @@ fn build_transfer_instruction(
     use anchor_lang::prelude::AccountMeta;
     use solana_sdk::instruction::Instruction;
 
-    // Build instruction data: discriminator (3) + SPL Transfer data
-    let mut data = vec![3]; // CTokenTransfer discriminator (first byte: 3)
-    data.extend_from_slice(&amount.to_le_bytes()); // Amount as u64 little-endian
+    // Build instruction data: discriminator (3) + amount (8 bytes)
+    let mut data = vec![3u8];
+    data.extend_from_slice(&amount.to_le_bytes());
 
-    // Build instruction
+    // Note: Index 3 would be interpreted as mint (for T22 extension validation).
+    // For basic transfers, we only pass 3 accounts.
     Instruction {
         program_id: light_compressed_token::ID,
         accounts: vec![
             AccountMeta::new(source, false),
             AccountMeta::new(destination, false),
-            AccountMeta::new(authority, true), // Authority must sign (also acts as payer for top-ups)
-            AccountMeta::new_readonly(Pubkey::default(), false), // System program for lamport transfers during top-up
+            AccountMeta::new(authority, true), // Authority must sign and be writable for top-ups
         ],
         data,
     }
@@ -136,18 +136,16 @@ fn build_transfer_instruction_with_max_top_up(
     use solana_sdk::instruction::Instruction;
 
     // Build instruction data: discriminator (3) + amount (8 bytes) + max_top_up (2 bytes)
-    let mut data = vec![3]; // CTokenTransfer discriminator
-    data.extend_from_slice(&amount.to_le_bytes()); // Amount as u64 little-endian
-    data.extend_from_slice(&max_top_up.to_le_bytes()); // max_top_up as u16 little-endian
+    let mut data = vec![3u8];
+    data.extend_from_slice(&amount.to_le_bytes());
+    data.extend_from_slice(&max_top_up.to_le_bytes());
 
-    // Build instruction
     Instruction {
         program_id: light_compressed_token::ID,
         accounts: vec![
             AccountMeta::new(source, false),
             AccountMeta::new(destination, false),
-            AccountMeta::new(authority, true), // Authority must sign (also acts as payer for top-ups)
-            AccountMeta::new_readonly(Pubkey::default(), false), // System program for lamport transfers during top-up
+            AccountMeta::new(authority, true), // Authority must sign and be writable for top-ups
         ],
         data,
     }
@@ -345,7 +343,7 @@ async fn test_ctoken_transfer_frozen_source() {
     let owner_keypair = context.owner_keypair.insecure_clone();
 
     // Try to transfer from frozen account
-    // Expected error: AccountFrozen (error code 17)
+    // Expected error: CTokenError::InvalidAccountState (frozen accounts rejected by zero_copy_at_mut_checked)
     transfer_and_assert_fails(
         &mut context,
         source,
@@ -353,7 +351,7 @@ async fn test_ctoken_transfer_frozen_source() {
         500,
         &owner_keypair,
         "frozen_source_transfer",
-        17, // AccountFrozen
+        18036, // CTokenError::InvalidAccountState
     )
     .await;
 }
@@ -373,7 +371,7 @@ async fn test_ctoken_transfer_frozen_destination() {
     let owner_keypair = context.owner_keypair.insecure_clone();
 
     // Try to transfer to frozen account
-    // Expected error: AccountFrozen (error code 17)
+    // Expected error: CTokenError::InvalidAccountState (frozen accounts rejected by zero_copy_at_mut_checked)
     transfer_and_assert_fails(
         &mut context,
         source,
@@ -381,7 +379,7 @@ async fn test_ctoken_transfer_frozen_destination() {
         500,
         &owner_keypair,
         "frozen_destination_transfer",
-        17, // AccountFrozen
+        18036, // CTokenError::InvalidAccountState
     )
     .await;
 }
@@ -410,32 +408,28 @@ async fn test_ctoken_transfer_wrong_authority() {
 
 #[tokio::test]
 async fn test_ctoken_transfer_mint_mismatch() {
-    // Create source account with default mint
-    let (mut context, source, _destination, _mint_amount, _source_keypair, _dest_keypair) =
+    // Create two accounts with the same mint first
+    let (mut context, source, destination, _mint_amount, _source_keypair, _dest_keypair) =
         setup_transfer_test(None, 1000).await.unwrap();
 
-    // Create destination account with a different mint
+    // Modify the destination account's mint field to create a mint mismatch
     let different_mint = Pubkey::new_unique();
-    let original_mint = context.mint_pubkey;
-    context.mint_pubkey = different_mint;
-
-    let dest_keypair = Keypair::new();
-    context.token_account_keypair = dest_keypair.insecure_clone();
-    create_non_compressible_token_account(&mut context, Some(&dest_keypair)).await;
-    let destination_with_different_mint = dest_keypair.pubkey();
+    let mut dest_account = context.rpc.get_account(destination).await.unwrap().unwrap();
 
-    // Restore original mint for context
-    context.mint_pubkey = original_mint;
+    // CToken mint is the first 32 bytes after the account type discriminator
+    // The mint field is at bytes 0-32 in the CToken account data
+    dest_account.data[0..32].copy_from_slice(&different_mint.to_bytes());
+    context.rpc.set_account(destination, dest_account);
 
     // Use the owner keypair as authority
     let owner_keypair = context.owner_keypair.insecure_clone();
 
     // Try to transfer between accounts with different mints
-    // Expected error: MintMismatch (error code 3)
+    // The SPL Token program returns error code 3 (MintMismatch)
     transfer_and_assert_fails(
         &mut context,
         source,
-        destination_with_different_mint,
+        destination,
         500,
         &owner_keypair,
         "mint_mismatch_transfer",
@@ -470,31 +464,41 @@ async fn test_ctoken_transfer_zero_amount() {
 
 #[tokio::test]
 async fn test_ctoken_transfer_mixed_compressible_non_compressible() {
-    // Create source as compressible
+    // Create source with more prepaid epochs
     let mut context = setup_account_test().await.unwrap();
     let payer_pubkey = context.payer.pubkey();
 
-    // Create compressible source account
+    // Create source account with more prepaid epochs (lamports_per_write = Some(100))
     let source_keypair = Keypair::new();
     let source_pubkey = source_keypair.pubkey();
     context.token_account_keypair = source_keypair.insecure_clone();
 
-    let compressible_data = CompressibleData {
+    let source_data = CompressibleData {
         compression_authority: context.compression_authority,
         rent_sponsor: context.rent_sponsor,
-        num_prepaid_epochs: 3, // 3 epochs for no top-up: epochs_funded_ahead = 3 - 1 = 2 >= 2
+        num_prepaid_epochs: 5, // More epochs with higher lamports_per_write
         lamports_per_write: Some(100),
         account_version: light_ctoken_interface::state::TokenDataVersion::ShaFlat,
         compress_to_pubkey: false,
         payer: payer_pubkey,
     };
-    create_and_assert_token_account(&mut context, compressible_data, "source_account").await;
+    create_and_assert_token_account(&mut context, source_data, "source_account").await;
 
-    // Create non-compressible destination account
+    // Create destination account with fewer prepaid epochs (no lamports_per_write)
     let destination_keypair = Keypair::new();
     let destination_pubkey = destination_keypair.pubkey();
     context.token_account_keypair = destination_keypair.insecure_clone();
-    create_non_compressible_token_account(&mut context, Some(&destination_keypair)).await;
+
+    let dest_data = CompressibleData {
+        compression_authority: context.compression_authority,
+        rent_sponsor: context.rent_sponsor,
+        num_prepaid_epochs: 3, // Standard 3 epochs sufficient for no top-up
+        lamports_per_write: None,
+        account_version: light_ctoken_interface::state::TokenDataVersion::ShaFlat,
+        compress_to_pubkey: false,
+        payer: payer_pubkey,
+    };
+    create_and_assert_token_account(&mut context, dest_data, "destination_account").await;
 
     // Mint tokens to source
     let mut source_account = context
@@ -509,7 +513,7 @@ async fn test_ctoken_transfer_mixed_compressible_non_compressible() {
     spl_token_2022::state::Account::pack(token_account, &mut source_account.data[..165]).unwrap();
     context.rpc.set_account(source_pubkey, source_account);
 
-    // Fund owner to pay for top-up
+    // Fund owner to pay for potential top-up
     context
         .rpc
         .airdrop_lamports(&context.owner_keypair.pubkey(), 100_000_000)
@@ -518,7 +522,7 @@ async fn test_ctoken_transfer_mixed_compressible_non_compressible() {
 
     let owner_keypair = context.owner_keypair.insecure_clone();
 
-    // Transfer from compressible to non-compressible (only source needs top-up)
+    // Transfer from source with more prepaid to destination with fewer prepaid
     transfer_and_assert(
         &mut context,
         source_pubkey,
@@ -576,3 +580,379 @@ async fn test_ctoken_transfer_max_top_up_exceeded() {
     // Assert MaxTopUpExceeded (error code 18043)
     light_program_test::utils::assert::assert_rpc_error(result, 0, 18043).unwrap();
 }
+
+// ============================================================================
+// Transfer Checked Helper Functions
+// ============================================================================
+
+use light_ctoken_sdk::ctoken::TransferCTokenChecked;
+
+/// Setup context with two token accounts for transfer_checked tests using a real SPL Token mint
+async fn setup_transfer_checked_test_with_spl_mint(
+    num_prepaid_epochs: Option<u8>,
+    mint_amount: u64,
+    decimals: u8,
+) -> Result<(AccountTestContext, Pubkey, Pubkey, u64, Keypair, Keypair), RpcError> {
+    let mut context = setup_account_test_with_spl_mint(decimals).await?;
+    let payer_pubkey = context.payer.pubkey();
+
+    let source_keypair = Keypair::new();
+    let source_pubkey = source_keypair.pubkey();
+
+    let destination_keypair = Keypair::new();
+    let destination_pubkey = destination_keypair.pubkey();
+
+    let rent_sponsor = context.rent_sponsor;
+    let source_epochs = num_prepaid_epochs.unwrap_or(3);
+
+    context.token_account_keypair = source_keypair.insecure_clone();
+    {
+        let compressible_params = CompressibleParams {
+            compressible_config: context.compressible_config,
+            rent_sponsor,
+            pre_pay_num_epochs: source_epochs,
+            lamports_per_write: Some(100),
+            compress_to_account_pubkey: None,
+            token_account_version: light_ctoken_interface::state::TokenDataVersion::ShaFlat,
+            compression_only: false,
+        };
+
+        let create_token_account_ix = CreateCTokenAccount::new(
+            payer_pubkey,
+            source_pubkey,
+            context.mint_pubkey,
+            context.owner_keypair.pubkey(),
+        )
+        .with_compressible(compressible_params)
+        .instruction()
+        .unwrap();
+
+        context
+            .rpc
+            .create_and_send_transaction(
+                &[create_token_account_ix],
+                &payer_pubkey,
+                &[&context.payer, &source_keypair],
+            )
+            .await
+            .unwrap();
+    }
+
+    let dest_epochs = num_prepaid_epochs.unwrap_or(3);
+    context.token_account_keypair = destination_keypair.insecure_clone();
+    {
+        let compressible_params = CompressibleParams {
+            compressible_config: context.compressible_config,
+            rent_sponsor,
+            pre_pay_num_epochs: dest_epochs,
+            lamports_per_write: Some(100),
+            compress_to_account_pubkey: None,
+            token_account_version: light_ctoken_interface::state::TokenDataVersion::ShaFlat,
+            compression_only: false,
+        };
+
+        let create_token_account_ix = CreateCTokenAccount::new(
+            payer_pubkey,
+            destination_pubkey,
+            context.mint_pubkey,
+            context.owner_keypair.pubkey(),
+        )
+        .with_compressible(compressible_params)
+        .instruction()
+        .unwrap();
+
+        context
+            .rpc
+            .create_and_send_transaction(
+                &[create_token_account_ix],
+                &payer_pubkey,
+                &[&context.payer, &destination_keypair],
+            )
+            .await
+            .unwrap();
+    }
+
+    if mint_amount > 0 {
+        let mut source_account = context
+            .rpc
+            .get_account(source_pubkey)
+            .await?
+            .ok_or_else(|| RpcError::AssertRpcError("Source account not found".to_string()))?;
+
+        let mut token_account =
+            spl_token_2022::state::Account::unpack_unchecked(&source_account.data[..165]).map_err(
+                |e| RpcError::AssertRpcError(format!("Failed to unpack token account: {:?}", e)),
+            )?;
+        token_account.amount = mint_amount;
+        spl_token_2022::state::Account::pack(token_account, &mut source_account.data[..165])
+            .map_err(|e| {
+                RpcError::AssertRpcError(format!("Failed to pack token account: {:?}", e))
+            })?;
+
+        context.rpc.set_account(source_pubkey, source_account);
+    }
+
+    Ok((
+        context,
+        source_pubkey,
+        destination_pubkey,
+        mint_amount,
+        source_keypair,
+        destination_keypair,
+    ))
+}
+
+/// Execute a ctoken transfer_checked and assert success
+#[allow(clippy::too_many_arguments)]
+async fn transfer_checked_and_assert(
+    context: &mut AccountTestContext,
+    source: Pubkey,
+    mint: Pubkey,
+    destination: Pubkey,
+    amount: u64,
+    decimals: u8,
+    authority: &Keypair,
+    name: &str,
+) {
+    use light_test_utils::assert_ctoken_transfer::assert_ctoken_transfer;
+
+    println!("Transfer checked initiated for: {}", name);
+
+    let payer_pubkey = context.payer.pubkey();
+
+    let transfer_ix = TransferCTokenChecked {
+        source,
+        mint,
+        destination,
+        amount,
+        decimals,
+        authority: authority.pubkey(),
+        max_top_up: None,
+    }
+    .instruction()
+    .unwrap();
+
+    context
+        .rpc
+        .create_and_send_transaction(&[transfer_ix], &payer_pubkey, &[&context.payer, authority])
+        .await
+        .unwrap();
+
+    assert_ctoken_transfer(&mut context.rpc, source, destination, amount).await;
+}
+
+/// Execute a ctoken transfer_checked expecting failure with specific error code
+#[allow(clippy::too_many_arguments)]
+async fn transfer_checked_and_assert_fails(
+    context: &mut AccountTestContext,
+    source: Pubkey,
+    mint: Pubkey,
+    destination: Pubkey,
+    amount: u64,
+    decimals: u8,
+    authority: &Keypair,
+    name: &str,
+    expected_error_code: u32,
+) {
+    println!(
+        "Transfer checked (expecting failure) initiated for: {}",
+        name
+    );
+
+    let payer_pubkey = context.payer.pubkey();
+
+    let transfer_ix = TransferCTokenChecked {
+        source,
+        mint,
+        destination,
+        amount,
+        decimals,
+        authority: authority.pubkey(),
+        max_top_up: None,
+    }
+    .instruction()
+    .unwrap();
+
+    let result = context
+        .rpc
+        .create_and_send_transaction(&[transfer_ix], &payer_pubkey, &[&context.payer, authority])
+        .await;
+
+    light_program_test::utils::assert::assert_rpc_error(result, 0, expected_error_code).unwrap();
+}
+
+// ============================================================================
+// Transfer Checked Success Tests
+// ============================================================================
+
+#[tokio::test]
+async fn test_ctoken_transfer_checked_with_spl_mint() {
+    let (mut context, source, destination, _mint_amount, _source_keypair, _dest_keypair) =
+        setup_transfer_checked_test_with_spl_mint(None, 1000, 9)
+            .await
+            .unwrap();
+
+    let mint = context.mint_pubkey;
+    let owner_keypair = context.owner_keypair.insecure_clone();
+
+    transfer_checked_and_assert(
+        &mut context,
+        source,
+        mint,
+        destination,
+        500,
+        9,
+        &owner_keypair,
+        "transfer_checked_spl_mint",
+    )
+    .await;
+}
+
+// Note: Token-2022 mint tests are covered in sdk-tests/sdk-ctoken-test/tests/test_transfer_checked.rs
+// The T22 mint requires additional setup (extensions, token pool, etc.) that is handled there.
+
+#[tokio::test]
+async fn test_ctoken_transfer_checked_compressible_with_topup() {
+    let (mut context, source, destination, _mint_amount, _source_keypair, _dest_keypair) =
+        setup_transfer_checked_test_with_spl_mint(Some(3), 1000, 9)
+            .await
+            .unwrap();
+
+    context
+        .rpc
+        .airdrop_lamports(&context.owner_keypair.pubkey(), 100_000_000)
+        .await
+        .unwrap();
+
+    let mint = context.mint_pubkey;
+    let owner_keypair = context.owner_keypair.insecure_clone();
+
+    transfer_checked_and_assert(
+        &mut context,
+        source,
+        mint,
+        destination,
+        500,
+        9,
+        &owner_keypair,
+        "compressible_transfer_checked_with_topup",
+    )
+    .await;
+}
+
+// ============================================================================
+// Transfer Checked Failure Tests
+// ============================================================================
+
+#[tokio::test]
+async fn test_ctoken_transfer_checked_wrong_decimals() {
+    let (mut context, source, destination, _mint_amount, _source_keypair, _dest_keypair) =
+        setup_transfer_checked_test_with_spl_mint(None, 1000, 9)
+            .await
+            .unwrap();
+
+    let mint = context.mint_pubkey;
+    let owner_keypair = context.owner_keypair.insecure_clone();
+
+    transfer_checked_and_assert_fails(
+        &mut context,
+        source,
+        mint,
+        destination,
+        500,
+        8, // Wrong decimals - mint has 9
+        &owner_keypair,
+        "wrong_decimals_transfer_checked",
+        2, // InvalidInstructionData
+    )
+    .await;
+}
+
+#[tokio::test]
+async fn test_ctoken_transfer_checked_wrong_mint() {
+    let (mut context, source, destination, _mint_amount, _source_keypair, _dest_keypair) =
+        setup_transfer_checked_test_with_spl_mint(None, 1000, 9)
+            .await
+            .unwrap();
+
+    let wrong_mint = Pubkey::new_unique();
+    let owner_keypair = context.owner_keypair.insecure_clone();
+
+    transfer_checked_and_assert_fails(
+        &mut context,
+        source,
+        wrong_mint,
+        destination,
+        500,
+        9,
+        &owner_keypair,
+        "wrong_mint_transfer_checked",
+        18002, // CTokenError::MintMismatch
+    )
+    .await;
+}
+
+#[tokio::test]
+async fn test_ctoken_transfer_checked_insufficient_balance() {
+    let (mut context, source, destination, _mint_amount, _source_keypair, _dest_keypair) =
+        setup_transfer_checked_test_with_spl_mint(None, 1000, 9)
+            .await
+            .unwrap();
+
+    let mint = context.mint_pubkey;
+    let owner_keypair = context.owner_keypair.insecure_clone();
+
+    transfer_checked_and_assert_fails(
+        &mut context,
+        source,
+        mint,
+        destination,
+        1500,
+        9,
+        &owner_keypair,
+        "insufficient_balance_transfer_checked",
+        1, // InsufficientFunds
+    )
+    .await;
+}
+
+#[tokio::test]
+async fn test_ctoken_transfer_checked_max_top_up_exceeded() {
+    let (mut context, source, destination, _mint_amount, _source_keypair, _dest_keypair) =
+        setup_transfer_checked_test_with_spl_mint(Some(0), 1000, 9)
+            .await
+            .unwrap();
+
+    context
+        .rpc
+        .airdrop_lamports(&context.owner_keypair.pubkey(), 100_000_000)
+        .await
+        .unwrap();
+
+    let mint = context.mint_pubkey;
+    let owner_keypair = context.owner_keypair.insecure_clone();
+    let payer_pubkey = context.payer.pubkey();
+
+    let transfer_ix = TransferCTokenChecked {
+        source,
+        mint,
+        destination,
+        amount: 100,
+        decimals: 9,
+        authority: owner_keypair.pubkey(),
+        max_top_up: Some(1),
+    }
+    .instruction()
+    .unwrap();
+
+    let result = context
+        .rpc
+        .create_and_send_transaction(
+            &[transfer_ix],
+            &payer_pubkey,
+            &[&context.payer, &owner_keypair],
+        )
+        .await;
+
+    light_program_test::utils::assert::assert_rpc_error(result, 0, 18043).unwrap();
+}
diff --git a/program-tests/compressed-token-test/tests/mint/cpi_context.rs b/program-tests/compressed-token-test/tests/mint/cpi_context.rs
index bf35dd0609..b3a1249206 100644
--- a/program-tests/compressed-token-test/tests/mint/cpi_context.rs
+++ b/program-tests/compressed-token-test/tests/mint/cpi_context.rs
@@ -310,8 +310,8 @@ async fn test_write_to_cpi_context_invalid_address_tree() {
         .await;
 
     // Assert that the transaction failed with MintActionInvalidCpiContextAddressTreePubkey error
-    // Error code 105 = MintActionInvalidCpiContextAddressTreePubkey
-    assert_rpc_error(result, 0, 105).unwrap();
+    // Error code 6105 = MintActionInvalidCpiContextAddressTreePubkey
+    assert_rpc_error(result, 0, 6105).unwrap();
 }
 
 #[tokio::test]
@@ -402,8 +402,8 @@ async fn test_write_to_cpi_context_invalid_compressed_address() {
         .await;
 
     // Assert that the transaction failed with MintActionInvalidCompressedMintAddress error
-    // Error code 103 = MintActionInvalidCompressedMintAddress
-    assert_rpc_error(result, 0, 103).unwrap();
+    // Error code 6103 = MintActionInvalidCompressedMintAddress
+    assert_rpc_error(result, 0, 6103).unwrap();
 }
 
 #[tokio::test]
@@ -497,6 +497,6 @@ async fn test_execute_cpi_context_invalid_tree_index() {
         .await;
 
     // Assert that the transaction failed with MintActionInvalidCpiContextForCreateMint error
-    // Error code 104 = MintActionInvalidCpiContextForCreateMint
-    assert_rpc_error(result, 0, 104).unwrap();
+    // Error code 6104 = MintActionInvalidCpiContextForCreateMint
+    assert_rpc_error(result, 0, 6104).unwrap();
 }
diff --git a/program-tests/compressed-token-test/tests/mint/ctoken_mint_to.rs b/program-tests/compressed-token-test/tests/mint/ctoken_mint_to.rs
index 613040a797..e60c4bc481 100644
--- a/program-tests/compressed-token-test/tests/mint/ctoken_mint_to.rs
+++ b/program-tests/compressed-token-test/tests/mint/ctoken_mint_to.rs
@@ -148,3 +148,83 @@ async fn test_ctoken_mint_to() {
         "Final balance should be 1000 after minting 500 + 500"
     );
 }
+
+// ============================================================================
+// MintTo Checked Tests
+// ============================================================================
+
+use light_ctoken_sdk::ctoken::CTokenMintToChecked;
+
+#[tokio::test]
+#[serial]
+async fn test_ctoken_mint_to_checked_success() {
+    let mut ctx = setup_mint_to_test().await;
+
+    // Mint 500 tokens with correct decimals (8)
+    let mint_ix = CTokenMintToChecked {
+        cmint: ctx.cmint_pda,
+        destination: ctx.ctoken_account,
+        amount: 500,
+        decimals: 8, // Correct decimals
+        authority: ctx.mint_authority.pubkey(),
+        max_top_up: None,
+    }
+    .instruction()
+    .unwrap();
+
+    ctx.rpc
+        .create_and_send_transaction(
+            &[mint_ix],
+            &ctx.payer.pubkey(),
+            &[&ctx.payer, &ctx.mint_authority],
+        )
+        .await
+        .unwrap();
+
+    // Verify balance
+    use anchor_lang::prelude::borsh::BorshDeserialize;
+    use light_ctoken_interface::state::CToken;
+    let ctoken_after = ctx
+        .rpc
+        .get_account(ctx.ctoken_account)
+        .await
+        .unwrap()
+        .unwrap();
+    let token_account: CToken =
+        BorshDeserialize::deserialize(&mut ctoken_after.data.as_slice()).unwrap();
+    assert_eq!(token_account.amount, 500, "Balance should be 500");
+
+    println!("test_ctoken_mint_to_checked_success: passed");
+}
+
+#[tokio::test]
+#[serial]
+async fn test_ctoken_mint_to_checked_wrong_decimals() {
+    let mut ctx = setup_mint_to_test().await;
+
+    // Try to mint with wrong decimals (7 instead of 8)
+    let mint_ix = CTokenMintToChecked {
+        cmint: ctx.cmint_pda,
+        destination: ctx.ctoken_account,
+        amount: 500,
+        decimals: 7, // Wrong decimals
+        authority: ctx.mint_authority.pubkey(),
+        max_top_up: None,
+    }
+    .instruction()
+    .unwrap();
+
+    let result = ctx
+        .rpc
+        .create_and_send_transaction(
+            &[mint_ix],
+            &ctx.payer.pubkey(),
+            &[&ctx.payer, &ctx.mint_authority],
+        )
+        .await;
+
+    // Should fail with MintDecimalsMismatch (error code 18 in pinocchio)
+    assert!(result.is_err(), "Mint with wrong decimals should fail");
+    light_program_test::utils::assert::assert_rpc_error(result, 0, 18).unwrap();
+    println!("test_ctoken_mint_to_checked_wrong_decimals: passed");
+}
diff --git a/program-tests/compressed-token-test/tests/mint/edge_cases.rs b/program-tests/compressed-token-test/tests/mint/edge_cases.rs
index 2c3180c07a..d555638396 100644
--- a/program-tests/compressed-token-test/tests/mint/edge_cases.rs
+++ b/program-tests/compressed-token-test/tests/mint/edge_cases.rs
@@ -159,6 +159,7 @@ async fn functional_all_in_one_instruction() {
         lamports_per_write: Some(1000),
         compress_to_account_pubkey: None,
         token_account_version: TokenDataVersion::ShaFlat,
+        compression_only: false,
     };
 
     let create_compressible_ata_ix =
diff --git a/program-tests/compressed-token-test/tests/mint/failing.rs b/program-tests/compressed-token-test/tests/mint/failing.rs
index e121ce4a5a..42040ed68b 100644
--- a/program-tests/compressed-token-test/tests/mint/failing.rs
+++ b/program-tests/compressed-token-test/tests/mint/failing.rs
@@ -204,7 +204,7 @@ async fn functional_and_failing_tests() {
         .await;
 
         assert_rpc_error(
-            result, 0, 18, // light_compressed_token::ErrorCode::InvalidAuthorityMint.into(),
+            result, 0, 6018, // light_compressed_token::ErrorCode::InvalidAuthorityMint
         )
         .unwrap();
     }
@@ -282,7 +282,7 @@ async fn functional_and_failing_tests() {
         .await;
 
         assert_rpc_error(
-            result, 0, 18, // light_compressed_token::ErrorCode::InvalidAuthorityMint.into(),
+            result, 0, 6018, // light_compressed_token::ErrorCode::InvalidAuthorityMint
         )
         .unwrap();
     }
@@ -353,8 +353,7 @@ async fn functional_and_failing_tests() {
         .await;
 
         assert_rpc_error(
-            result, 0,
-            18, // InvalidAuthorityMint error code (authority validation always returns 18)
+            result, 0, 6018, // InvalidAuthorityMint error code
         )
         .unwrap();
     }
@@ -437,8 +436,7 @@ async fn functional_and_failing_tests() {
         .await;
 
         assert_rpc_error(
-            result, 0,
-            18, //    light_compressed_token::ErrorCode::InvalidAuthorityMint.into(),
+            result, 0, 6018, // light_compressed_token::ErrorCode::InvalidAuthorityMint
         )
         .unwrap();
     }
@@ -534,7 +532,7 @@ async fn functional_and_failing_tests() {
         .await;
 
         assert_rpc_error(
-            result, 0, 18, // light_compressed_token::ErrorCode::InvalidAuthorityMint.into(),
+            result, 0, 6018, // light_compressed_token::ErrorCode::InvalidAuthorityMint
         )
         .unwrap();
     }
@@ -615,7 +613,7 @@ async fn functional_and_failing_tests() {
         .await;
 
         assert_rpc_error(
-            result, 0, 18, // light_compressed_token::ErrorCode::InvalidAuthorityMint.into(),
+            result, 0, 6018, // light_compressed_token::ErrorCode::InvalidAuthorityMint
         )
         .unwrap();
     }
@@ -695,7 +693,7 @@ async fn functional_and_failing_tests() {
         .await;
 
         assert_rpc_error(
-            result, 0, 18, // light_compressed_token::ErrorCode::InvalidAuthorityMint.into(),
+            result, 0, 6018, // light_compressed_token::ErrorCode::InvalidAuthorityMint
         )
         .unwrap();
     }
@@ -872,6 +870,7 @@ async fn test_mint_to_ctoken_max_top_up_exceeded() {
         lamports_per_write: Some(1000),
         compress_to_account_pubkey: None,
         token_account_version: TokenDataVersion::ShaFlat,
+        compression_only: false,
     };
 
     let create_ata_ix =
diff --git a/program-tests/compressed-token-test/tests/mint/functional.rs b/program-tests/compressed-token-test/tests/mint/functional.rs
index 7f0564099a..6aa8257ade 100644
--- a/program-tests/compressed-token-test/tests/mint/functional.rs
+++ b/program-tests/compressed-token-test/tests/mint/functional.rs
@@ -1,13 +1,13 @@
 use anchor_lang::{prelude::borsh::BorshDeserialize, solana_program::program_pack::Pack};
 use light_client::indexer::Indexer;
-use light_compressible::rent::SLOTS_PER_EPOCH;
+use light_compressible::{compression_info::CompressionInfo, rent::SLOTS_PER_EPOCH};
 use light_ctoken_interface::{
     instructions::{
         extensions::token_metadata::TokenMetadataInstructionData, mint_action::Recipient,
     },
     state::{
         extensions::AdditionalMetadata, BaseMint, CompressedMint, CompressedMintMetadata,
-        TokenDataVersion,
+        TokenDataVersion, ACCOUNT_TYPE_MINT,
     },
     COMPRESSED_MINT_SEED,
 };
@@ -253,7 +253,7 @@ async fn test_create_compressed_mint() {
         owner: new_recipient,
         mint: spl_mint_pda,
         associated_token_account: ctoken_ata_pubkey,
-        compressible: None,
+        compressible: CompressibleParams::default(),
     }
     .instruction()
     .unwrap();
@@ -268,6 +268,7 @@ async fn test_create_compressed_mint() {
         decompress_amount,
         ctoken_ata_pubkey,
         payer.pubkey(),
+        9, // decimals
     )
     .await
     .unwrap();
@@ -292,6 +293,8 @@ async fn test_create_compressed_mint() {
                     decompress_amount,
                     solana_token_account: ctoken_ata_pubkey,
                     amount: decompress_amount,
+                    decimals: 9,
+                    in_tlv: None,
                 },
             )
             .await;
@@ -322,6 +325,7 @@ async fn test_create_compressed_mint() {
             authority: new_recipient_keypair.pubkey(), // Authority for compression
             output_queue,
             pool_index: None,
+            decimals: 9,
         })],
         payer.pubkey(),
         true,
@@ -350,6 +354,7 @@ async fn test_create_compressed_mint() {
             authority: new_recipient_keypair.pubkey(),
             output_queue,
             pool_index: None,
+            decimals: 9,
         },
     )
     .await;
@@ -368,6 +373,7 @@ async fn test_create_compressed_mint() {
             authority: new_recipient_keypair.pubkey(), // Authority for compression
             output_queue,
             pool_index: None,
+            decimals: 9,
         })],
         payer.pubkey(),
         true,
@@ -406,6 +412,7 @@ async fn test_create_compressed_mint() {
             authority: new_recipient_keypair.pubkey(), // Authority for compression
             output_queue,
             pool_index: None,
+            decimals: 9,
         })],
         payer.pubkey(),
         true,
@@ -449,7 +456,7 @@ async fn test_create_compressed_mint() {
         owner: decompress_recipient.pubkey(),
         mint: spl_mint_pda,
         associated_token_account: decompress_dest_ata,
-        compressible: None,
+        compressible: CompressibleParams::default(),
     }
     .instruction()
     .unwrap();
@@ -489,6 +496,8 @@ async fn test_create_compressed_mint() {
                 solana_token_account: decompress_dest_ata,
                 amount: decompress_amount,
                 pool_index: None,
+                decimals: 9,
+                in_tlv: None,
             }),
             // 3. Compress SPL tokens to compressed tokens
             Transfer2InstructionType::Compress(CompressInput {
@@ -500,6 +509,7 @@ async fn test_create_compressed_mint() {
                 authority: new_recipient_keypair.pubkey(), // Authority for compression
                 output_queue: multi_output_queue,
                 pool_index: None,
+                decimals: 9,
             }),
         ];
         // Create the combined multi-transfer instruction
@@ -715,6 +725,7 @@ async fn test_ctoken_transfer() {
         lamports_per_write: Some(1000),
         compress_to_account_pubkey: None,
         token_account_version: light_ctoken_interface::state::TokenDataVersion::ShaFlat,
+        compression_only: false,
     };
 
     let create_ata_instruction = CreateAssociatedCTokenAccount::new(
@@ -791,7 +802,7 @@ async fn test_ctoken_transfer() {
         owner: second_recipient_keypair.pubkey(),
         mint: spl_mint_pda,
         associated_token_account: second_recipient_ata,
-        compressible: None,
+        compressible: CompressibleParams::default(),
     }
     .instruction()
     .unwrap();
@@ -907,6 +918,7 @@ async fn test_ctoken_transfer() {
             authority: second_recipient_keypair.pubkey(), // Authority for compression
             output_queue,
             pool_index: None,
+            decimals: 9,
         })],
         payer.pubkey(),
         true,
@@ -921,7 +933,7 @@ async fn test_ctoken_transfer() {
         .unwrap()
         .unwrap();
     let pre_compress_spl_account =
-        spl_token_2022::state::Account::unpack(&pre_compress_account_data.data).unwrap();
+        spl_token_2022::state::Account::unpack(&pre_compress_account_data.data[..165]).unwrap();
     println!(
         "Account balance before compression: {}",
         pre_compress_spl_account.amount
@@ -954,6 +966,7 @@ async fn test_ctoken_transfer() {
             amount: compress_amount,
             authority: second_recipient_keypair.pubkey(),
             output_queue,
+            decimals: 9,
         },
     )
     .await;
@@ -965,7 +978,7 @@ async fn test_ctoken_transfer() {
         .unwrap()
         .unwrap();
     let final_spl_account =
-        spl_token_2022::state::Account::unpack(&final_account_data.data).unwrap();
+        spl_token_2022::state::Account::unpack(&final_account_data.data[..165]).unwrap();
     println!(
         "Final account balance after compression: {}",
         final_spl_account.amount
@@ -1238,6 +1251,9 @@ async fn test_mint_actions() {
             mint: spl_mint_pda.into(),
             cmint_decompressed: false, // Should be true after CreateSplMint action
         },
+        reserved: [0u8; 49],
+        account_type: ACCOUNT_TYPE_MINT,
+        compression: CompressionInfo::default(),
         extensions: Some(vec![
             light_ctoken_interface::state::extensions::ExtensionStruct::TokenMetadata(
                 light_ctoken_interface::state::extensions::TokenMetadata {
@@ -1468,6 +1484,9 @@ async fn test_create_compressed_mint_with_cmint() {
             cmint_decompressed: false, // Before DecompressMint
             mint: cmint_pda.to_bytes().into(),
         },
+        reserved: [0u8; 49],
+        account_type: ACCOUNT_TYPE_MINT,
+        compression: CompressionInfo::default(),
         extensions: None,
     };
 
diff --git a/program-tests/compressed-token-test/tests/token_pool.rs b/program-tests/compressed-token-test/tests/token_pool.rs
new file mode 100644
index 0000000000..2e969ffbf7
--- /dev/null
+++ b/program-tests/compressed-token-test/tests/token_pool.rs
@@ -0,0 +1,879 @@
+#![cfg(feature = "test-sbf")]
+
+use anchor_lang::{system_program, InstructionData, ToAccountMetas};
+use anchor_spl::{
+    token::{Mint, TokenAccount},
+    token_2022::spl_token_2022::{self, extension::ExtensionType},
+};
+use forester_utils::instructions::create_account_instruction;
+use light_compressed_token::{
+    constants::NUM_MAX_POOL_ACCOUNTS, get_token_pool_pda, get_token_pool_pda_with_index,
+    mint_sdk::create_create_token_pool_instruction, process_transfer::get_cpi_authority_pda,
+    spl_compression::check_spl_token_pool_derivation_with_index, ErrorCode,
+};
+use light_ctoken_interface::{
+    find_spl_interface_pda, find_spl_interface_pda_with_index, has_restricted_extensions,
+};
+use light_ctoken_sdk::spl_interface::CreateSplInterfacePda;
+use light_program_test::{utils::assert::assert_rpc_error, LightProgramTest, ProgramTestConfig};
+use light_test_utils::{
+    spl::{create_additional_token_pools, create_mint_22_helper, create_mint_helper},
+    Rpc, RpcError,
+};
+use serial_test::serial;
+use solana_sdk::{
+    instruction::Instruction,
+    pubkey::Pubkey,
+    signature::{Keypair, Signature},
+    signer::Signer,
+};
+use solana_system_interface::instruction as system_instruction;
+use spl_token::instruction::initialize_mint;
+
+#[serial]
+#[tokio::test]
+async fn test_create_mint() {
+    let mut rpc = LightProgramTest::new(ProgramTestConfig::new(false, None))
+        .await
+        .unwrap();
+    let payer = rpc.get_payer().insecure_clone();
+    let mint = create_mint_helper(&mut rpc, &payer).await;
+    create_additional_token_pools(&mut rpc, &payer, &mint, false, NUM_MAX_POOL_ACCOUNTS)
+        .await
+        .unwrap();
+    let mint_22 = create_mint_22_helper(&mut rpc, &payer).await;
+    create_additional_token_pools(&mut rpc, &payer, &mint_22, true, NUM_MAX_POOL_ACCOUNTS)
+        .await
+        .unwrap();
+}
+
+#[serial]
+#[tokio::test]
+async fn test_failing_create_token_pool() {
+    let mut rpc = LightProgramTest::new(ProgramTestConfig::new(false, None))
+        .await
+        .unwrap();
+    let payer = rpc.get_payer().insecure_clone();
+
+    let rent = rpc
+        .get_minimum_balance_for_rent_exemption(Mint::LEN)
+        .await
+        .unwrap();
+
+    let mint_1_keypair = Keypair::new();
+    let mint_1_account_create_ix = create_account_instruction(
+        &payer.pubkey(),
+        Mint::LEN,
+        rent,
+        &spl_token::ID,
+        Some(&mint_1_keypair),
+    );
+    let create_mint_1_ix = initialize_mint(
+        &spl_token::ID,
+        &mint_1_keypair.pubkey(),
+        &payer.pubkey(),
+        Some(&payer.pubkey()),
+        2,
+    )
+    .unwrap();
+    rpc.create_and_send_transaction(
+        &[mint_1_account_create_ix, create_mint_1_ix],
+        &payer.pubkey(),
+        &[&payer, &mint_1_keypair],
+    )
+    .await
+    .unwrap();
+    let mint_1_pool_pda = get_token_pool_pda(&mint_1_keypair.pubkey());
+
+    let mint_2_keypair = Keypair::new();
+    let mint_2_account_create_ix = create_account_instruction(
+        &payer.pubkey(),
+        Mint::LEN,
+        rent,
+        &spl_token::ID,
+        Some(&mint_2_keypair),
+    );
+    let create_mint_2_ix = initialize_mint(
+        &spl_token::ID,
+        &mint_2_keypair.pubkey(),
+        &payer.pubkey(),
+        Some(&payer.pubkey()),
+        2,
+    )
+    .unwrap();
+    rpc.create_and_send_transaction(
+        &[mint_2_account_create_ix, create_mint_2_ix],
+        &payer.pubkey(),
+        &[&payer, &mint_2_keypair],
+    )
+    .await
+    .unwrap();
+    let mint_2_pool_pda = get_token_pool_pda(&mint_2_keypair.pubkey());
+
+    // Try to create pool for `mint_1` while using seeds of `mint_2` for PDAs.
+    {
+        let instruction_data = light_compressed_token::instruction::CreateTokenPool {};
+        let accounts = light_compressed_token::accounts::CreateTokenPoolInstruction {
+            fee_payer: payer.pubkey(),
+            token_pool_pda: mint_2_pool_pda,
+            system_program: system_program::ID,
+            mint: mint_1_keypair.pubkey(),
+            token_program: anchor_spl::token::ID,
+            cpi_authority_pda: get_cpi_authority_pda().0,
+        };
+        let instruction = Instruction {
+            program_id: light_compressed_token::ID,
+            accounts: accounts.to_account_metas(Some(true)),
+            data: instruction_data.data(),
+        };
+        let result = rpc
+            .create_and_send_transaction(&[instruction], &payer.pubkey(), &[&payer])
+            .await;
+        assert_rpc_error(
+            result,
+            0,
+            anchor_lang::error::ErrorCode::ConstraintSeeds.into(),
+        )
+        .unwrap();
+    }
+    // Invalid program id.
+    {
+        let instruction_data = light_compressed_token::instruction::CreateTokenPool {};
+        let accounts = light_compressed_token::accounts::CreateTokenPoolInstruction {
+            fee_payer: payer.pubkey(),
+            token_pool_pda: mint_1_pool_pda,
+            system_program: system_program::ID,
+            mint: mint_1_keypair.pubkey(),
+            token_program: light_system_program::ID, // invalid program id should be spl token program or token 2022 program
+            cpi_authority_pda: get_cpi_authority_pda().0,
+        };
+        let instruction = Instruction {
+            program_id: light_compressed_token::ID,
+            accounts: accounts.to_account_metas(Some(true)),
+            data: instruction_data.data(),
+        };
+        let result = rpc
+            .create_and_send_transaction(&[instruction], &payer.pubkey(), &[&payer])
+            .await;
+        assert_rpc_error(
+            result,
+            0,
+            anchor_lang::error::ErrorCode::InvalidProgramId.into(),
+        )
+        .unwrap();
+    }
+    // Try to create pool for `mint_2` while using seeds of `mint_1` for PDAs.
+    {
+        let instruction_data = light_compressed_token::instruction::CreateTokenPool {};
+        let accounts = light_compressed_token::accounts::CreateTokenPoolInstruction {
+            fee_payer: payer.pubkey(),
+            token_pool_pda: mint_1_pool_pda,
+            system_program: system_program::ID,
+            mint: mint_2_keypair.pubkey(),
+            token_program: anchor_spl::token::ID,
+            cpi_authority_pda: get_cpi_authority_pda().0,
+        };
+        let instruction = Instruction {
+            program_id: light_compressed_token::ID,
+            accounts: accounts.to_account_metas(Some(true)),
+            data: instruction_data.data(),
+        };
+        let result = rpc
+            .create_and_send_transaction(&[instruction], &payer.pubkey(), &[&payer])
+            .await;
+        assert_rpc_error(
+            result,
+            0,
+            anchor_lang::error::ErrorCode::ConstraintSeeds.into(),
+        )
+        .unwrap();
+    }
+    // failing test try to create a token pool with mint with non-whitelisted token extension
+    {
+        let payer = rpc.get_payer().insecure_clone();
+        let payer_pubkey = payer.pubkey();
+        let mint = Keypair::new();
+        let token_authority = payer.insecure_clone();
+        let space = ExtensionType::try_calculate_account_len::<spl_token_2022::state::Mint>(&[
+            ExtensionType::NonTransferable,
+        ])
+        .unwrap();
+
+        let mut instructions = vec![system_instruction::create_account(
+            &payer.pubkey(),
+            &mint.pubkey(),
+            rpc.get_minimum_balance_for_rent_exemption(space)
+                .await
+                .unwrap(),
+            space as u64,
+            &spl_token_2022::ID,
+        )];
+        let invalid_token_extension_ix =
+            spl_token_2022::instruction::initialize_non_transferable_mint(
+                &spl_token_2022::ID,
+                &mint.pubkey(),
+            )
+            .unwrap();
+        instructions.push(invalid_token_extension_ix);
+        instructions.push(
+            spl_token_2022::instruction::initialize_mint(
+                &spl_token_2022::ID,
+                &mint.pubkey(),
+                &token_authority.pubkey(),
+                None,
+                2,
+            )
+            .unwrap(),
+        );
+        instructions.push(create_create_token_pool_instruction(
+            &payer_pubkey,
+            &mint.pubkey(),
+            true,
+        ));
+
+        let result = rpc
+            .create_and_send_transaction(&instructions, &payer_pubkey, &[&payer, &mint])
+            .await;
+        assert_rpc_error(result, 3, ErrorCode::MintWithInvalidExtension.into()).unwrap();
+    }
+    // functional create token pool account with token 2022 mint with allowed metadata pointer extension
+    {
+        let payer = rpc.get_payer().insecure_clone();
+        // create_mint_helper(&mut rpc, &payer).await;
+        let payer_pubkey = payer.pubkey();
+
+        let mint = Keypair::new();
+        let token_authority = payer.insecure_clone();
+        let space = ExtensionType::try_calculate_account_len::<spl_token_2022::state::Mint>(&[
+            ExtensionType::MetadataPointer,
+        ])
+        .unwrap();
+
+        let mut instructions = vec![system_instruction::create_account(
+            &payer.pubkey(),
+            &mint.pubkey(),
+            rpc.get_minimum_balance_for_rent_exemption(space)
+                .await
+                .unwrap(),
+            space as u64,
+            &spl_token_2022::ID,
+        )];
+        let token_extension_ix =
+            spl_token_2022::extension::metadata_pointer::instruction::initialize(
+                &spl_token_2022::ID,
+                &mint.pubkey(),
+                Some(token_authority.pubkey()),
+                None,
+            )
+            .unwrap();
+        instructions.push(token_extension_ix);
+        instructions.push(
+            spl_token_2022::instruction::initialize_mint(
+                &spl_token_2022::ID,
+                &mint.pubkey(),
+                &token_authority.pubkey(),
+                None,
+                2,
+            )
+            .unwrap(),
+        );
+        instructions.push(create_create_token_pool_instruction(
+            &payer_pubkey,
+            &mint.pubkey(),
+            true,
+        ));
+        rpc.create_and_send_transaction(&instructions, &payer_pubkey, &[&payer, &mint])
+            .await
+            .unwrap();
+
+        let token_pool_pubkey = get_token_pool_pda(&mint.pubkey());
+        let token_pool_account = rpc.get_account(token_pool_pubkey).await.unwrap().unwrap();
+        check_spl_token_pool_derivation_with_index(
+            &mint.pubkey().to_bytes(),
+            &token_pool_pubkey,
+            &[0],
+        )
+        .unwrap();
+        // MetadataPointer is a mint-only extension, so token account has base size (165 bytes)
+        assert_eq!(token_pool_account.data.len(), TokenAccount::LEN);
+    }
+}
+
+#[serial]
+#[tokio::test]
+async fn failing_tests_add_token_pool() {
+    for is_token_22 in [false, true] {
+        let mut rpc = LightProgramTest::new(ProgramTestConfig::new(false, None))
+            .await
+            .unwrap();
+        let payer = rpc.get_payer().insecure_clone();
+
+        let mint = if !is_token_22 {
+            create_mint_helper(&mut rpc, &payer).await
+        } else {
+            create_mint_22_helper(&mut rpc, &payer).await
+        };
+        let invalid_mint = if !is_token_22 {
+            create_mint_helper(&mut rpc, &payer).await
+        } else {
+            create_mint_22_helper(&mut rpc, &payer).await
+        };
+        let mut current_token_pool_bump = 1;
+        create_additional_token_pools(&mut rpc, &payer, &mint, is_token_22, 2)
+            .await
+            .unwrap();
+        create_additional_token_pools(&mut rpc, &payer, &invalid_mint, is_token_22, 2)
+            .await
+            .unwrap();
+        current_token_pool_bump += 2;
+        // 1. failing invalid existing token pool pda
+        {
+            let result = add_token_pool(
+                &mut rpc,
+                &payer,
+                &mint,
+                None,
+                current_token_pool_bump,
+                is_token_22,
+                FailingTestsAddTokenPool::InvalidExistingTokenPoolPda,
+            )
+            .await;
+            assert_rpc_error(result, 0, ErrorCode::InvalidTokenPoolPda.into()).unwrap();
+        }
+        // 2. failing InvalidTokenPoolPda
+        {
+            let result = add_token_pool(
+                &mut rpc,
+                &payer,
+                &mint,
+                None,
+                current_token_pool_bump,
+                is_token_22,
+                FailingTestsAddTokenPool::InvalidTokenPoolPda,
+            )
+            .await;
+            assert_rpc_error(
+                result,
+                0,
+                anchor_lang::error::ErrorCode::ConstraintSeeds.into(),
+            )
+            .unwrap();
+        }
+        // 3. failing invalid system program id
+        {
+            let result = add_token_pool(
+                &mut rpc,
+                &payer,
+                &mint,
+                None,
+                current_token_pool_bump,
+                is_token_22,
+                FailingTestsAddTokenPool::InvalidSystemProgramId,
+            )
+            .await;
+            assert_rpc_error(
+                result,
+                0,
+                anchor_lang::error::ErrorCode::InvalidProgramId.into(),
+            )
+            .unwrap();
+        }
+        // 4. failing invalid mint - now fails with ConstraintSeeds because mint validation
+        // happens after PDA derivation (mint changed from InterfaceAccount to AccountInfo)
+        {
+            let result = add_token_pool(
+                &mut rpc,
+                &payer,
+                &mint,
+                None,
+                current_token_pool_bump,
+                is_token_22,
+                FailingTestsAddTokenPool::InvalidMint,
+            )
+            .await;
+            assert_rpc_error(
+                result,
+                0,
+                anchor_lang::error::ErrorCode::ConstraintSeeds.into(),
+            )
+            .unwrap();
+        }
+        // 5. failing inconsistent mints
+        {
+            let result = add_token_pool(
+                &mut rpc,
+                &payer,
+                &mint,
+                Some(invalid_mint),
+                current_token_pool_bump,
+                is_token_22,
+                FailingTestsAddTokenPool::InconsistentMints,
+            )
+            .await;
+            assert_rpc_error(result, 0, ErrorCode::InvalidTokenPoolPda.into()).unwrap();
+        }
+        // 6. failing invalid program id
+        {
+            let result = add_token_pool(
+                &mut rpc,
+                &payer,
+                &mint,
+                None,
+                current_token_pool_bump,
+                is_token_22,
+                FailingTestsAddTokenPool::InvalidTokenProgramId,
+            )
+            .await;
+            assert_rpc_error(
+                result,
+                0,
+                anchor_lang::error::ErrorCode::InvalidProgramId.into(),
+            )
+            .unwrap();
+        }
+        // 7. failing invalid cpi authority pda
+        {
+            let result = add_token_pool(
+                &mut rpc,
+                &payer,
+                &mint,
+                None,
+                current_token_pool_bump,
+                is_token_22,
+                FailingTestsAddTokenPool::InvalidCpiAuthorityPda,
+            )
+            .await;
+            assert_rpc_error(
+                result,
+                0,
+                anchor_lang::error::ErrorCode::ConstraintSeeds.into(),
+            )
+            .unwrap();
+        }
+        // create all remaining token pools
+        create_additional_token_pools(&mut rpc, &payer, &mint, is_token_22, 5)
+            .await
+            .unwrap();
+        // 8. failing invalid token pool bump (too large)
+        {
+            let result = add_token_pool(
+                &mut rpc,
+                &payer,
+                &mint,
+                None,
+                NUM_MAX_POOL_ACCOUNTS,
+                is_token_22,
+                FailingTestsAddTokenPool::Functional,
+            )
+            .await;
+            assert_rpc_error(result, 0, ErrorCode::InvalidTokenPoolBump.into()).unwrap();
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum FailingTestsAddTokenPool {
+    Functional,
+    InvalidMint,
+    InconsistentMints,
+    InvalidTokenPoolPda,
+    InvalidSystemProgramId,
+    InvalidExistingTokenPoolPda,
+    InvalidCpiAuthorityPda,
+    InvalidTokenProgramId,
+}
+
+pub async fn add_token_pool<R: Rpc>(
+    rpc: &mut R,
+    fee_payer: &Keypair,
+    mint: &Pubkey,
+    invalid_mint: Option<Pubkey>,
+    token_pool_index: u8,
+    is_token_22: bool,
+    mode: FailingTestsAddTokenPool,
+) -> Result<Signature, RpcError> {
+    let token_pool_pda = if mode == FailingTestsAddTokenPool::InvalidTokenPoolPda {
+        Pubkey::new_unique()
+    } else {
+        get_token_pool_pda_with_index(mint, token_pool_index)
+    };
+    let existing_token_pool_pda = if mode == FailingTestsAddTokenPool::InvalidExistingTokenPoolPda {
+        get_token_pool_pda_with_index(mint, token_pool_index.saturating_sub(2))
+    } else if let Some(invalid_mint) = invalid_mint {
+        get_token_pool_pda_with_index(&invalid_mint, token_pool_index.saturating_sub(1))
+    } else {
+        get_token_pool_pda_with_index(mint, token_pool_index.saturating_sub(1))
+    };
+    let instruction_data = light_compressed_token::instruction::AddTokenPool { token_pool_index };
+
+    let token_program: Pubkey = if mode == FailingTestsAddTokenPool::InvalidTokenProgramId {
+        Pubkey::new_unique()
+    } else if is_token_22 {
+        anchor_spl::token_2022::ID
+    } else {
+        anchor_spl::token::ID
+    };
+    let cpi_authority_pda = if mode == FailingTestsAddTokenPool::InvalidCpiAuthorityPda {
+        Pubkey::new_unique()
+    } else {
+        get_cpi_authority_pda().0
+    };
+    let system_program = if mode == FailingTestsAddTokenPool::InvalidSystemProgramId {
+        Pubkey::new_unique()
+    } else {
+        system_program::ID
+    };
+    let mint = if mode == FailingTestsAddTokenPool::InvalidMint {
+        Pubkey::new_unique()
+    } else {
+        *mint
+    };
+
+    let accounts = light_compressed_token::accounts::AddTokenPoolInstruction {
+        fee_payer: fee_payer.pubkey(),
+        token_pool_pda,
+        system_program,
+        mint,
+        token_program,
+        cpi_authority_pda,
+        existing_token_pool_pda,
+    };
+
+    let instruction = Instruction {
+        program_id: light_compressed_token::ID,
+        accounts: accounts.to_account_metas(Some(true)),
+        data: instruction_data.data(),
+    };
+    rpc.create_and_send_transaction(&[instruction], &fee_payer.pubkey(), &[fee_payer])
+        .await
+}
+
+/// Test that restricted extensions are properly detected and use different pool derivations.
+///
+/// This test verifies:
+/// 1. Mints with restricted extensions (Pausable, PermanentDelegate, TransferFeeConfig, TransferHook)
+///    are detected by `has_restricted_extensions()`
+/// 2. Restricted and non-restricted pool PDAs are different
+/// 3. The anchor `create_token_pool` instruction still works for restricted mints
+///    (uses normal derivation, which is intentional for backward compatibility)
+#[serial]
+#[tokio::test]
+async fn test_restricted_mint_pool_derivation() {
+    let mut rpc = LightProgramTest::new(ProgramTestConfig::new(false, None))
+        .await
+        .unwrap();
+    let payer = rpc.get_payer().insecure_clone();
+
+    // Test PermanentDelegate (a restricted extension)
+    let extension_type = ExtensionType::PermanentDelegate;
+    println!("Testing restricted extension: {:?}", extension_type);
+
+    // Create mint with restricted extension
+    let mint = Keypair::new();
+    let space =
+        ExtensionType::try_calculate_account_len::<spl_token_2022::state::Mint>(&[extension_type])
+            .unwrap();
+
+    let instructions = vec![
+        system_instruction::create_account(
+            &payer.pubkey(),
+            &mint.pubkey(),
+            rpc.get_minimum_balance_for_rent_exemption(space)
+                .await
+                .unwrap(),
+            space as u64,
+            &spl_token_2022::ID,
+        ),
+        spl_token_2022::instruction::initialize_permanent_delegate(
+            &spl_token_2022::ID,
+            &mint.pubkey(),
+            &payer.pubkey(),
+        )
+        .unwrap(),
+        spl_token_2022::instruction::initialize_mint(
+            &spl_token_2022::ID,
+            &mint.pubkey(),
+            &payer.pubkey(),
+            None,
+            2,
+        )
+        .unwrap(),
+    ];
+
+    rpc.create_and_send_transaction(&instructions, &payer.pubkey(), &[&payer, &mint])
+        .await
+        .unwrap();
+
+    // Fetch mint account and verify restricted extensions are detected
+    let mint_account = rpc.get_account(mint.pubkey()).await.unwrap().unwrap();
+    assert!(
+        has_restricted_extensions(&mint_account.data),
+        "Mint with PermanentDelegate should be detected as restricted"
+    );
+
+    // Verify that restricted and non-restricted PDAs are different
+    let (regular_pda, _) = find_spl_interface_pda(&mint.pubkey(), false);
+    let (restricted_pda, _) = find_spl_interface_pda(&mint.pubkey(), true);
+    assert_ne!(
+        regular_pda, restricted_pda,
+        "Regular and restricted PDAs should be different"
+    );
+
+    // Verify with index derivation as well
+    for index in 0..NUM_MAX_POOL_ACCOUNTS {
+        let (regular_pda_idx, _) = find_spl_interface_pda_with_index(&mint.pubkey(), index, false);
+        let (restricted_pda_idx, _) =
+            find_spl_interface_pda_with_index(&mint.pubkey(), index, true);
+        assert_ne!(
+            regular_pda_idx, restricted_pda_idx,
+            "Regular and restricted PDAs for index {} should be different",
+            index
+        );
+    }
+
+    // The anchor create_token_pool instruction automatically uses restricted derivation
+    // for mints with restricted extensions (detected via restricted_seed() function)
+    let create_pool_ix = CreateSplInterfacePda::new(
+        payer.pubkey(),
+        mint.pubkey(),
+        spl_token_2022::ID,
+        true, // restricted = true for mints with restricted extensions
+    )
+    .instruction();
+
+    rpc.create_and_send_transaction(&[create_pool_ix], &payer.pubkey(), &[&payer])
+        .await
+        .unwrap();
+
+    // Verify pool was created at restricted derivation
+    let token_pool_account = rpc.get_account(restricted_pda).await.unwrap();
+    assert!(
+        token_pool_account.is_some(),
+        "Token pool should exist at restricted derivation"
+    );
+
+    println!(
+        "Successfully tested PermanentDelegate: regular_pda={}, restricted_pda={}",
+        regular_pda, restricted_pda
+    );
+}
+
+/// Test that non-restricted mints are correctly identified.
+#[serial]
+#[tokio::test]
+async fn test_non_restricted_mint_detection() {
+    let mut rpc = LightProgramTest::new(ProgramTestConfig::new(false, None))
+        .await
+        .unwrap();
+    let payer = rpc.get_payer().insecure_clone();
+
+    // Create a regular SPL token mint (not Token-2022)
+    let spl_mint = create_mint_helper(&mut rpc, &payer).await;
+    let spl_mint_account = rpc.get_account(spl_mint).await.unwrap().unwrap();
+    assert!(
+        !has_restricted_extensions(&spl_mint_account.data),
+        "Regular SPL mint should not be restricted"
+    );
+
+    // Create a Token-2022 mint with only non-restricted extensions
+    let mint = Keypair::new();
+    let space = ExtensionType::try_calculate_account_len::<spl_token_2022::state::Mint>(&[
+        ExtensionType::MetadataPointer,
+    ])
+    .unwrap();
+
+    let instructions = vec![
+        system_instruction::create_account(
+            &payer.pubkey(),
+            &mint.pubkey(),
+            rpc.get_minimum_balance_for_rent_exemption(space)
+                .await
+                .unwrap(),
+            space as u64,
+            &spl_token_2022::ID,
+        ),
+        spl_token_2022::extension::metadata_pointer::instruction::initialize(
+            &spl_token_2022::ID,
+            &mint.pubkey(),
+            Some(payer.pubkey()),
+            None,
+        )
+        .unwrap(),
+        spl_token_2022::instruction::initialize_mint(
+            &spl_token_2022::ID,
+            &mint.pubkey(),
+            &payer.pubkey(),
+            None,
+            2,
+        )
+        .unwrap(),
+    ];
+
+    rpc.create_and_send_transaction(&instructions, &payer.pubkey(), &[&payer, &mint])
+        .await
+        .unwrap();
+
+    // Verify non-restricted extension is not detected as restricted
+    let mint_account = rpc.get_account(mint.pubkey()).await.unwrap().unwrap();
+    assert!(
+        !has_restricted_extensions(&mint_account.data),
+        "Mint with MetadataPointer should not be restricted"
+    );
+}
+
+/// Test creating all 5 SPL interface PDAs (index 0-4) using the SDK.
+/// Tests both regular and restricted mints.
+#[serial]
+#[tokio::test]
+async fn test_create_all_spl_interface_pdas_with_sdk() {
+    let mut rpc = LightProgramTest::new(ProgramTestConfig::new(false, None))
+        .await
+        .unwrap();
+    let payer = rpc.get_payer().insecure_clone();
+
+    // Test 1: Regular SPL mint (non-restricted)
+    {
+        // Create mint without a pool
+        let mint = Keypair::new();
+        let rent = rpc
+            .get_minimum_balance_for_rent_exemption(Mint::LEN)
+            .await
+            .unwrap();
+
+        let instructions = vec![
+            system_instruction::create_account(
+                &payer.pubkey(),
+                &mint.pubkey(),
+                rent,
+                Mint::LEN as u64,
+                &spl_token::ID,
+            ),
+            initialize_mint(&spl_token::ID, &mint.pubkey(), &payer.pubkey(), None, 2).unwrap(),
+        ];
+
+        rpc.create_and_send_transaction(&instructions, &payer.pubkey(), &[&payer, &mint])
+            .await
+            .unwrap();
+
+        println!("Testing regular SPL mint: {}", mint.pubkey());
+
+        // Create all 5 pools using SDK
+        for index in 0..NUM_MAX_POOL_ACCOUNTS {
+            let create_pool_ix = CreateSplInterfacePda::new_with_index(
+                payer.pubkey(),
+                mint.pubkey(),
+                spl_token::ID,
+                index,
+                false, // not restricted
+            )
+            .instruction();
+
+            rpc.create_and_send_transaction(&[create_pool_ix], &payer.pubkey(), &[&payer])
+                .await
+                .unwrap();
+
+            // Verify pool was created at correct derivation
+            let (expected_pda, _) = find_spl_interface_pda_with_index(&mint.pubkey(), index, false);
+            let pool_account = rpc.get_account(expected_pda).await.unwrap();
+            assert!(
+                pool_account.is_some(),
+                "Pool at index {} should exist for regular mint",
+                index
+            );
+            println!("Created pool at index {}: {}", index, expected_pda);
+        }
+    }
+
+    // Test 2: Token-2022 mint with restricted extension (PermanentDelegate)
+    {
+        let mint = Keypair::new();
+        let space = ExtensionType::try_calculate_account_len::<spl_token_2022::state::Mint>(&[
+            ExtensionType::PermanentDelegate,
+        ])
+        .unwrap();
+
+        let instructions = vec![
+            system_instruction::create_account(
+                &payer.pubkey(),
+                &mint.pubkey(),
+                rpc.get_minimum_balance_for_rent_exemption(space)
+                    .await
+                    .unwrap(),
+                space as u64,
+                &spl_token_2022::ID,
+            ),
+            spl_token_2022::instruction::initialize_permanent_delegate(
+                &spl_token_2022::ID,
+                &mint.pubkey(),
+                &payer.pubkey(),
+            )
+            .unwrap(),
+            spl_token_2022::instruction::initialize_mint(
+                &spl_token_2022::ID,
+                &mint.pubkey(),
+                &payer.pubkey(),
+                None,
+                2,
+            )
+            .unwrap(),
+        ];
+
+        rpc.create_and_send_transaction(&instructions, &payer.pubkey(), &[&payer, &mint])
+            .await
+            .unwrap();
+
+        println!(
+            "Testing restricted Token-2022 mint (PermanentDelegate): {}",
+            mint.pubkey()
+        );
+
+        // Verify it's detected as restricted
+        let mint_account = rpc.get_account(mint.pubkey()).await.unwrap().unwrap();
+        assert!(
+            has_restricted_extensions(&mint_account.data),
+            "Mint should be detected as restricted"
+        );
+
+        // Create all 5 pools using SDK with restricted = true
+        for index in 0..NUM_MAX_POOL_ACCOUNTS {
+            let create_pool_ix = CreateSplInterfacePda::new_with_index(
+                payer.pubkey(),
+                mint.pubkey(),
+                spl_token_2022::ID,
+                index,
+                true, // restricted
+            )
+            .instruction();
+
+            rpc.create_and_send_transaction(&[create_pool_ix], &payer.pubkey(), &[&payer])
+                .await
+                .unwrap();
+
+            // Verify pool was created at restricted derivation
+            let (restricted_pda, _) =
+                find_spl_interface_pda_with_index(&mint.pubkey(), index, true);
+            let pool_account = rpc.get_account(restricted_pda).await.unwrap();
+            assert!(
+                pool_account.is_some(),
+                "Pool at index {} should exist for restricted mint",
+                index
+            );
+
+            // Verify it's NOT at the regular derivation
+            let (regular_pda, _) = find_spl_interface_pda_with_index(&mint.pubkey(), index, false);
+            let regular_account = rpc.get_account(regular_pda).await.unwrap();
+            assert!(
+                regular_account.is_none(),
+                "Pool at index {} should NOT exist at regular derivation",
+                index
+            );
+
+            println!(
+                "Created restricted pool at index {}: {}",
+                index, restricted_pda
+            );
+        }
+    }
+
+    println!("Successfully created all SPL interface PDAs for both regular and restricted mints");
+}
diff --git a/program-tests/compressed-token-test/tests/transfer2/compress_failing.rs b/program-tests/compressed-token-test/tests/transfer2/compress_failing.rs
index b56bb2b48a..08544544ef 100644
--- a/program-tests/compressed-token-test/tests/transfer2/compress_failing.rs
+++ b/program-tests/compressed-token-test/tests/transfer2/compress_failing.rs
@@ -48,7 +48,9 @@ use light_ctoken_sdk::{
     ctoken::{derive_ctoken_ata, CompressibleParams, CreateAssociatedCTokenAccount},
     ValidityProof,
 };
-use light_program_test::{LightProgramTest, ProgramTestConfig, Rpc};
+use light_program_test::{
+    utils::assert::assert_rpc_error, LightProgramTest, ProgramTestConfig, Rpc,
+};
 use light_sdk::instruction::PackedAccounts;
 use light_test_utils::RpcError;
 use solana_sdk::{pubkey::Pubkey, signature::Keypair, signer::Signer};
@@ -98,6 +100,7 @@ async fn setup_compression_test(token_amount: u64) -> Result<CompressionTestCont
         lamports_per_write: Some(1000),
         compress_to_account_pubkey: None,
         token_account_version: TokenDataVersion::ShaFlat,
+        compression_only: false,
     };
 
     let create_ata_instruction =
@@ -234,6 +237,7 @@ fn create_compression_inputs(
         in_lamports: None,
         out_lamports: None,
         output_queue: output_merkle_tree_index,
+        in_tlv: None,
     })
 }
 
@@ -372,16 +376,8 @@ async fn test_compression_invalid_authority_signed() -> Result<(), RpcError> {
         .create_and_send_transaction(&[ix], &payer.pubkey(), &[&payer, &invalid_authority])
         .await;
 
-    // Should fail with OwnerMismatch (custom program error 0x4b = 75) - Authority doesn't match account owner or delegate
-    assert!(
-        result
-            .as_ref()
-            .unwrap_err()
-            .to_string()
-            .contains("custom program error: 0x4b"),
-        "Expected custom program error 0x4b, got: {}",
-        result.unwrap_err().to_string()
-    );
+    // Should fail with OwnerMismatch (6075) - Authority doesn't match account owner or delegate
+    assert_rpc_error(result, 0, 6075).unwrap();
 
     Ok(())
 }
@@ -622,6 +618,7 @@ async fn test_compression_max_top_up_exceeded() -> Result<(), RpcError> {
         lamports_per_write: Some(1000),
         compress_to_account_pubkey: None,
         token_account_version: TokenDataVersion::ShaFlat,
+        compression_only: false,
     };
 
     let create_ata_instruction =
@@ -696,6 +693,7 @@ async fn test_compression_max_top_up_exceeded() -> Result<(), RpcError> {
         in_lamports: None,
         out_lamports: None,
         output_queue: 0,
+        in_tlv: None,
     };
 
     // Create instruction
diff --git a/program-tests/compressed-token-test/tests/transfer2/compress_spl_failing.rs b/program-tests/compressed-token-test/tests/transfer2/compress_spl_failing.rs
index d88c5748c7..baba769d27 100644
--- a/program-tests/compressed-token-test/tests/transfer2/compress_spl_failing.rs
+++ b/program-tests/compressed-token-test/tests/transfer2/compress_spl_failing.rs
@@ -45,7 +45,9 @@ use light_program_test::{utils::assert::assert_rpc_error, LightProgramTest, Prog
 use light_sdk::instruction::PackedAccounts;
 use light_test_utils::{
     airdrop_lamports,
-    spl::{create_mint_helper, create_token_2022_account, mint_spl_tokens},
+    spl::{
+        create_mint_helper, create_token_2022_account, mint_spl_tokens, CREATE_MINT_HELPER_DECIMALS,
+    },
     Rpc, RpcError,
 };
 use solana_sdk::{pubkey::Pubkey, signature::Keypair, signer::Signer};
@@ -192,7 +194,7 @@ fn create_spl_compression_inputs(
 
     // Derive SPL interface PDA using SDK function
     let pool_index = 0u8;
-    let (spl_interface_pda, bump) = find_spl_interface_pda_with_index(&mint, pool_index);
+    let (spl_interface_pda, bump) = find_spl_interface_pda_with_index(&mint, pool_index, false);
     let pool_account_index = packed_tree_accounts.insert_or_get(spl_interface_pda);
 
     // Compress from SPL token account
@@ -204,6 +206,7 @@ fn create_spl_compression_inputs(
             pool_account_index,
             pool_index,
             bump,
+            CREATE_MINT_HELPER_DECIMALS,
         )
         .map_err(|e| RpcError::AssertRpcError(format!("Failed to compress SPL: {:?}", e)))?;
 
@@ -221,6 +224,7 @@ fn create_spl_compression_inputs(
         in_lamports: None,
         out_lamports: None,
         output_queue: shared_output_queue,
+        in_tlv: None,
     })
 }
 
@@ -454,7 +458,7 @@ async fn test_spl_compression_invalid_pool_bump() -> Result<(), RpcError> {
 
     // Derive pool with correct seed but wrong bump
     let pool_index = 0u8;
-    let (_, correct_bump) = find_spl_interface_pda_with_index(&mint, pool_index);
+    let (_, correct_bump) = find_spl_interface_pda_with_index(&mint, pool_index, false);
 
     // Modify the bump in the compression data to an incorrect value
     if let Some(compression) = &mut compression_inputs.token_accounts[0].compression {
@@ -489,7 +493,8 @@ async fn test_spl_compression_invalid_pool_index() -> Result<(), RpcError> {
 
     // Derive pool with index 1 instead of 0
     let wrong_pool_index = 1u8;
-    let (wrong_pool_pda, wrong_bump) = find_spl_interface_pda_with_index(&mint, wrong_pool_index);
+    let (wrong_pool_pda, wrong_bump) =
+        find_spl_interface_pda_with_index(&mint, wrong_pool_index, false);
 
     // Update the compression data with wrong pool index
     if let Some(compression) = &mut compression_inputs.token_accounts[0].compression {
diff --git a/program-tests/compressed-token-test/tests/transfer2/decompress_failing.rs b/program-tests/compressed-token-test/tests/transfer2/decompress_failing.rs
index c545cc5279..1272570cb7 100644
--- a/program-tests/compressed-token-test/tests/transfer2/decompress_failing.rs
+++ b/program-tests/compressed-token-test/tests/transfer2/decompress_failing.rs
@@ -102,6 +102,7 @@ async fn setup_decompression_test(
         lamports_per_write: Some(1000),
         compress_to_account_pubkey: None,
         token_account_version: TokenDataVersion::ShaFlat,
+        compression_only: false,
     };
 
     let create_ata_instruction =
@@ -266,6 +267,7 @@ async fn create_decompression_inputs(
         in_lamports: None,
         out_lamports: None,
         output_queue: queue_index,
+        in_tlv: None,
     })
 }
 
@@ -532,8 +534,8 @@ async fn test_decompression_has_delegate_false_but_delegate_nonzero() -> Result<
         .create_and_send_transaction(&[ix], &payer.pubkey(), &[&payer])
         .await;
 
-    // Should fail with InvalidSigner (20009) since owner must sign                                                                                                  ╎│
-    light_program_test::utils::assert::assert_rpc_error(result, 0, 20009).unwrap();
+    // Should fail with OwnerMismatch (6075 = 6000 + 75) since owner must sign
+    light_program_test::utils::assert::assert_rpc_error(result, 0, 6075).unwrap();
 
     Ok(())
 }
diff --git a/program-tests/compressed-token-test/tests/transfer2/no_system_program_cpi_failing.rs b/program-tests/compressed-token-test/tests/transfer2/no_system_program_cpi_failing.rs
index 65c9da7ca5..8f6683fd1a 100644
--- a/program-tests/compressed-token-test/tests/transfer2/no_system_program_cpi_failing.rs
+++ b/program-tests/compressed-token-test/tests/transfer2/no_system_program_cpi_failing.rs
@@ -33,11 +33,11 @@
 // 9. Decompress with nonzero authority → InvalidInstructionData (string match, not error code)
 //
 // Multi-Mint Validation:
-// 10. Too many mints (>5) → TooManyMints (6039)
+// 10. Too many mints (>5) → MintCacheCapacityExceeded (6126)
 // 11. Duplicate mint validation → DuplicateMint (6102)
 //
 // Index Out of Bounds:
-// 12. Mint index out of bounds → DuplicateMint (6102) - out of bounds masked in validate_mint_uniqueness
+// 12. Mint index out of bounds → NotEnoughAccountKeys (20014) - mint extension cache validates bounds
 // 13. Account index out of bounds → NotEnoughAccountKeys (20014)
 // 14. Authority index out of bounds → SigningError - client-side error, can't send transaction
 //
@@ -229,8 +229,9 @@ fn build_compressions_only_instruction(
     packed_account_metas: Vec<solana_sdk::instruction::AccountMeta>,
 ) -> Result<solana_sdk::instruction::Instruction, RpcError> {
     use anchor_lang::AnchorSerialize;
-    use light_ctoken_interface::instructions::transfer2::CompressedTokenInstructionDataTransfer2;
-    use light_ctoken_types::{CPI_AUTHORITY_PDA, TRANSFER2};
+    use light_ctoken_interface::{
+        instructions::transfer2::CompressedTokenInstructionDataTransfer2, CPI_AUTHORITY, TRANSFER2,
+    };
     use solana_sdk::instruction::AccountMeta;
 
     // For compressions-only mode (decompressed_accounts_only), the account order is:
@@ -238,7 +239,7 @@ fn build_compressions_only_instruction(
     // 2. fee_payer (signer, not writable)
     // 3. ...packed accounts
     let mut account_metas = vec![
-        AccountMeta::new_readonly(Pubkey::new_from_array(CPI_AUTHORITY_PDA), false),
+        AccountMeta::new_readonly(Pubkey::new_from_array(CPI_AUTHORITY), false),
         AccountMeta::new_readonly(fee_payer, true),
     ];
     account_metas.extend(packed_account_metas);
@@ -332,9 +333,9 @@ async fn test_empty_compressions_array() -> Result<(), RpcError> {
         .create_and_send_transaction(&[ix], &payer.pubkey(), &[&payer, &owner])
         .await;
 
-    // Should fail with NoInputsProvided (error code 25, which is 6025 - 6000)
+    // Should fail with NoInputsProvided (error code 6025)
     assert_rpc_error(
-        result, 0, 25, // NoInputsProvided
+        result, 0, 6025, // NoInputsProvided
     )?;
 
     Ok(())
@@ -545,8 +546,8 @@ async fn test_invalid_authority_compress() {
         .create_and_send_transaction(&[ix], &payer.pubkey(), &[&payer, &wrong_authority])
         .await;
 
-    // Should fail with OwnerMismatch (error code 75, which is 6075 - 6000)
-    assert_rpc_error(result, 0, 75).unwrap();
+    // Should fail with OwnerMismatch (error code 6075)
+    assert_rpc_error(result, 0, 6075).unwrap();
 }
 
 #[tokio::test]
@@ -829,8 +830,8 @@ async fn test_too_many_mints() {
         )
         .await;
 
-    // Should fail with TooManyMints
-    assert_rpc_error(result, 0, 6039).unwrap();
+    // Should fail with TooManyMints (6144 = 6000 + 144)
+    assert_rpc_error(result, 0, 6144).unwrap();
 }
 
 /// Test 13: Duplicate mint validation
@@ -897,7 +898,7 @@ async fn test_duplicate_mint_validation() {
 }
 
 /// Test 14: Mint index out of bounds
-/// Expected: DuplicateMint (6102) - out of bounds is masked as DuplicateMint in validate_mint_uniqueness
+/// Expected: NotEnoughAccountKeys (20014) - mint extension cache validates account bounds
 #[tokio::test]
 async fn test_mint_index_out_of_bounds() {
     let mut context = setup_no_system_program_cpi_test(1000).await.unwrap();
@@ -937,8 +938,8 @@ async fn test_mint_index_out_of_bounds() {
         )
         .await;
 
-    // Should fail with DuplicateMint (out of bounds is masked)
-    assert_rpc_error(result, 0, 6102).unwrap();
+    // Should fail with NotEnoughAccountKeys - mint extension cache validates bounds first
+    assert_rpc_error(result, 0, 20014).unwrap();
 }
 
 /// Test 15: Account index out of bounds
@@ -981,8 +982,8 @@ async fn test_account_index_out_of_bounds() {
         )
         .await;
 
-    // Should fail with TooManyCompressionTransfers (account index 99 >= 40)
-    assert_rpc_error(result, 0, 95).unwrap();
+    // Should fail with AccountIndexOutOfBounds (account index 99 >= 40)
+    assert_rpc_error(result, 0, 6095).unwrap();
 }
 
 /// Test 16: Authority index out of bounds
diff --git a/program-tests/compressed-token-test/tests/transfer2/shared.rs b/program-tests/compressed-token-test/tests/transfer2/shared.rs
index f0c2a932c4..26a8e2237c 100644
--- a/program-tests/compressed-token-test/tests/transfer2/shared.rs
+++ b/program-tests/compressed-token-test/tests/transfer2/shared.rs
@@ -16,6 +16,7 @@ use light_test_utils::{
     assert_transfer2::assert_transfer2,
     spl::{
         create_additional_token_pools, create_mint_helper, create_token_account, mint_spl_tokens,
+        CREATE_MINT_HELPER_DECIMALS,
     },
 };
 use light_token_client::{
@@ -457,6 +458,7 @@ impl TestContext {
                     lamports_per_write: None,
                     compress_to_account_pubkey: None,
                     token_account_version: TokenDataVersion::ShaFlat, // CompressAndClose requires ShaFlat
+                    compression_only: false,
                 };
                 CreateAssociatedCTokenAccount::new(payer.pubkey(), signer.pubkey(), mint)
                     .with_compressible(compressible_params)
@@ -471,7 +473,7 @@ impl TestContext {
                     owner: signer.pubkey(),
                     mint,
                     associated_token_account: ata,
-                    compressible: None,
+                    compressible: CompressibleParams::default(),
                 }
                 .instruction()
                 .unwrap()
@@ -656,6 +658,7 @@ impl TestContext {
                                 authority: signer.pubkey(),
                                 output_queue,
                                 pool_index: None,
+                                decimals: CREATE_MINT_HELPER_DECIMALS,
                             };
 
                             // Create and execute the compress instruction
@@ -713,6 +716,7 @@ impl TestContext {
                             authority: signer.pubkey(),
                             output_queue,
                             pool_index: None,
+                            decimals: CREATE_MINT_HELPER_DECIMALS,
                         };
 
                         let ix = create_generic_transfer2_instruction(
@@ -1204,6 +1208,7 @@ impl TestContext {
             authority: self.keypairs[meta.signer_index].pubkey(),
             output_queue,
             pool_index: meta.pool_index,
+            decimals: CREATE_MINT_HELPER_DECIMALS,
         })
     }
 
@@ -1257,6 +1262,8 @@ impl TestContext {
             solana_token_account: recipient_account,
             amount: meta.amount,
             pool_index: meta.pool_index,
+            decimals: CREATE_MINT_HELPER_DECIMALS,
+            in_tlv: None,
         })
     }
 
diff --git a/program-tests/compressed-token-test/tests/transfer2/spl_ctoken.rs b/program-tests/compressed-token-test/tests/transfer2/spl_ctoken.rs
index dbd2cfcbc1..8ce6a3bc10 100644
--- a/program-tests/compressed-token-test/tests/transfer2/spl_ctoken.rs
+++ b/program-tests/compressed-token-test/tests/transfer2/spl_ctoken.rs
@@ -2,7 +2,9 @@ use anchor_lang::prelude::{AccountMeta, ProgramError};
 // Re-export all necessary imports for test modules
 pub use anchor_spl::token_2022::spl_token_2022;
 use light_ctoken_interface::instructions::transfer2::{Compression, MultiTokenTransferOutputData};
-pub use light_ctoken_sdk::ctoken::{derive_ctoken_ata, CreateAssociatedCTokenAccount};
+pub use light_ctoken_sdk::ctoken::{
+    derive_ctoken_ata, CompressibleParams, CreateAssociatedCTokenAccount,
+};
 use light_ctoken_sdk::{
     compressed_token::{
         transfer2::{
@@ -18,7 +20,9 @@ use light_program_test::utils::assert::assert_rpc_error;
 pub use light_program_test::{LightProgramTest, ProgramTestConfig};
 pub use light_test_utils::{
     airdrop_lamports,
-    spl::{create_mint_helper, create_token_2022_account, mint_spl_tokens},
+    spl::{
+        create_mint_helper, create_token_2022_account, mint_spl_tokens, CREATE_MINT_HELPER_DECIMALS,
+    },
     Rpc, RpcError,
 };
 pub use light_token_client::actions::transfer2::{self};
@@ -89,6 +93,7 @@ async fn test_spl_to_ctoken_transfer() {
     assert_eq!(initial_spl_balance, amount);
 
     // Use the new spl_to_ctoken_transfer action from light-token-client
+    // Note: create_mint_helper creates mints with 2 decimals
     transfer2::spl_to_ctoken_transfer(
         &mut rpc,
         spl_token_account_keypair.pubkey(),
@@ -96,6 +101,7 @@ async fn test_spl_to_ctoken_transfer() {
         transfer_amount,
         &sender,
         &payer,
+        2, // decimals - must match mint decimals (create_mint_helper uses 2)
     )
     .await
     .unwrap();
@@ -148,6 +154,7 @@ async fn test_spl_to_ctoken_transfer() {
         &recipient,
         mint,
         &payer,
+        2, // decimals - must match mint decimals (create_mint_helper uses 2)
     )
     .await
     .unwrap();
@@ -244,7 +251,7 @@ async fn test_failing_ctoken_to_spl_with_compress_and_close() {
         owner: recipient.pubkey(),
         mint,
         associated_token_account,
-        compressible: None,
+        compressible: CompressibleParams::default(),
     }
     .instruction()
     .map_err(|e| RpcError::AssertRpcError(format!("Failed to create ATA instruction: {}", e)))
@@ -261,6 +268,7 @@ async fn test_failing_ctoken_to_spl_with_compress_and_close() {
         transfer_amount,
         &sender,
         &payer,
+        2, // decimals - must match mint decimals (create_mint_helper uses 2)
     )
     .await
     .unwrap();
@@ -289,7 +297,8 @@ async fn test_failing_ctoken_to_spl_with_compress_and_close() {
     // Now transfer back using CompressAndClose instead of regular transfer
     println!("Testing reverse transfer with CompressAndClose: ctoken to SPL");
 
-    let (spl_interface_pda, spl_interface_pda_bump) = find_spl_interface_pda_with_index(&mint, 0);
+    let (spl_interface_pda, spl_interface_pda_bump) =
+        find_spl_interface_pda_with_index(&mint, 0, false);
 
     let transfer_ix = CtokenToSplTransferAndClose {
         source_ctoken_account: associated_token_account,
@@ -301,6 +310,7 @@ async fn test_failing_ctoken_to_spl_with_compress_and_close() {
         spl_interface_pda,
         spl_interface_pda_bump,
         spl_token_program: anchor_spl::token::ID,
+        decimals: CREATE_MINT_HELPER_DECIMALS,
     }
     .instruction()
     .unwrap();
@@ -322,6 +332,7 @@ pub struct CtokenToSplTransferAndClose {
     pub spl_interface_pda: Pubkey,
     pub spl_interface_pda_bump: u8,
     pub spl_token_program: Pubkey,
+    pub decimals: u8,
 }
 
 impl CtokenToSplTransferAndClose {
@@ -369,6 +380,7 @@ impl CtokenToSplTransferAndClose {
                 4, // pool_account_index
                 0, // pool_index (TODO: make dynamic)
                 self.spl_interface_pda_bump,
+                self.decimals,
             )),
             delegate_is_set: false,
             method_used: true,
@@ -385,6 +397,7 @@ impl CtokenToSplTransferAndClose {
             out_lamports: None,
             token_accounts: vec![compress_to_pool, decompress_to_spl],
             output_queue: 0, // Decompressed accounts only, no output queue needed
+            in_tlv: None,
         };
 
         create_transfer2_instruction(inputs).map_err(ProgramError::from)
diff --git a/program-tests/compressed-token-test/tests/transfer2/transfer_failing.rs b/program-tests/compressed-token-test/tests/transfer2/transfer_failing.rs
index 297bf69855..640da866c5 100644
--- a/program-tests/compressed-token-test/tests/transfer2/transfer_failing.rs
+++ b/program-tests/compressed-token-test/tests/transfer2/transfer_failing.rs
@@ -227,6 +227,7 @@ fn create_transfer2_inputs(
         in_lamports: None,
         out_lamports: None,
         output_queue: output_merkle_tree_index,
+        in_tlv: None,
     })
 }
 
@@ -297,8 +298,8 @@ async fn test_owner_not_signer() -> Result<(), RpcError> {
         .create_and_send_transaction(&[ix], &payer.pubkey(), &[&payer])
         .await;
 
-    // Should fail with InvalidSigner
-    assert_rpc_error(result, 0, 20009).unwrap();
+    // Should fail with OwnerMismatch (6075 = 6000 + 75)
+    assert_rpc_error(result, 0, 6075).unwrap();
 
     Ok(())
 }
@@ -921,8 +922,8 @@ async fn test_has_delegate_flag_mismatch() -> Result<(), RpcError> {
             .create_and_send_transaction(&[ix], &payer.pubkey(), &[&payer])
             .await;
 
-        // Should fail with InvalidSigner (20009) because no valid authority signed
-        assert_rpc_error(result, 0, 20009).unwrap();
+        // Should fail with OwnerMismatch (6075) because no valid authority signed
+        assert_rpc_error(result, 0, 6075).unwrap();
     }
 
     // 11.5. Valid delegate signing (should succeed)
@@ -1067,8 +1068,8 @@ async fn test_has_delegate_flag_mismatch() -> Result<(), RpcError> {
 // ============================================================================
 //
 // These fields must be None - testing they properly reject Some values:
-// 1. in_lamports = Some(vec![100]) → TokenDataTlvUnimplemented (18035)
-// 2. out_lamports = Some(vec![100]) → TokenDataTlvUnimplemented (18035)
+// 1. in_lamports = Some(vec![100]) → InLamportsUnimplemented (18050)
+// 2. out_lamports = Some(vec![100]) → OutLamportsUnimplemented (18051)
 // 3. in_tlv = Some(vec![vec![1,2,3]]) → CompressedTokenAccountTlvUnimplemented (18021)
 // 4. out_tlv = Some(vec![vec![1,2,3]]) → CompressedTokenAccountTlvUnimplemented (18021)
 //
diff --git a/program-tests/compressed-token-test/tests/v1.rs b/program-tests/compressed-token-test/tests/v1.rs
index 917ef63276..3d00a53deb 100644
--- a/program-tests/compressed-token-test/tests/v1.rs
+++ b/program-tests/compressed-token-test/tests/v1.rs
@@ -7,10 +7,10 @@ use anchor_lang::{
     InstructionData, ToAccountMetas,
 };
 use anchor_spl::{
-    token::{Mint, TokenAccount},
-    token_2022::spl_token_2022::{self, extension::ExtensionType},
+    token::TokenAccount,
+    token_2022::spl_token_2022::{self},
 };
-use forester_utils::{instructions::create_account_instruction, utils::airdrop_lamports};
+use forester_utils::utils::airdrop_lamports;
 use light_client::{
     indexer::Indexer,
     local_test_validator::{spawn_validator, LightValidatorConfig},
@@ -35,7 +35,6 @@ use light_compressed_token::{
     process_transfer::{
         get_cpi_authority_pda, transfer_sdk::create_transfer_instruction, TokenTransferOutputData,
     },
-    spl_compression::check_spl_token_pool_derivation_with_index,
     ErrorCode, TokenData,
 };
 use light_ctoken_sdk::compat::{AccountState, TokenDataWithMerkleContext};
@@ -70,526 +69,9 @@ use solana_sdk::{
     pubkey::Pubkey,
     signature::{Keypair, Signature},
     signer::Signer,
-    system_instruction,
     transaction::Transaction,
 };
-use spl_token::{error::TokenError, instruction::initialize_mint};
-#[serial]
-#[tokio::test]
-async fn test_create_mint() {
-    let mut rpc = LightProgramTest::new(ProgramTestConfig::new(false, None))
-        .await
-        .unwrap();
-    let payer = rpc.get_payer().insecure_clone();
-    let mint = create_mint_helper(&mut rpc, &payer).await;
-    create_additional_token_pools(&mut rpc, &payer, &mint, false, NUM_MAX_POOL_ACCOUNTS)
-        .await
-        .unwrap();
-    let mint_22 = create_mint_22_helper(&mut rpc, &payer).await;
-    create_additional_token_pools(&mut rpc, &payer, &mint_22, true, NUM_MAX_POOL_ACCOUNTS)
-        .await
-        .unwrap();
-}
-
-#[serial]
-#[tokio::test]
-async fn test_failing_create_token_pool() {
-    let mut rpc = LightProgramTest::new(ProgramTestConfig::new(false, None))
-        .await
-        .unwrap();
-    let payer = rpc.get_payer().insecure_clone();
-
-    let rent = rpc
-        .get_minimum_balance_for_rent_exemption(Mint::LEN)
-        .await
-        .unwrap();
-
-    let mint_1_keypair = Keypair::new();
-    let mint_1_account_create_ix = create_account_instruction(
-        &payer.pubkey(),
-        Mint::LEN,
-        rent,
-        &spl_token::ID,
-        Some(&mint_1_keypair),
-    );
-    let create_mint_1_ix = initialize_mint(
-        &spl_token::ID,
-        &mint_1_keypair.pubkey(),
-        &payer.pubkey(),
-        Some(&payer.pubkey()),
-        2,
-    )
-    .unwrap();
-    rpc.create_and_send_transaction(
-        &[mint_1_account_create_ix, create_mint_1_ix],
-        &payer.pubkey(),
-        &[&payer, &mint_1_keypair],
-    )
-    .await
-    .unwrap();
-    let mint_1_pool_pda = get_token_pool_pda(&mint_1_keypair.pubkey());
-
-    let mint_2_keypair = Keypair::new();
-    let mint_2_account_create_ix = create_account_instruction(
-        &payer.pubkey(),
-        Mint::LEN,
-        rent,
-        &spl_token::ID,
-        Some(&mint_2_keypair),
-    );
-    let create_mint_2_ix = initialize_mint(
-        &spl_token::ID,
-        &mint_2_keypair.pubkey(),
-        &payer.pubkey(),
-        Some(&payer.pubkey()),
-        2,
-    )
-    .unwrap();
-    rpc.create_and_send_transaction(
-        &[mint_2_account_create_ix, create_mint_2_ix],
-        &payer.pubkey(),
-        &[&payer, &mint_2_keypair],
-    )
-    .await
-    .unwrap();
-    let mint_2_pool_pda = get_token_pool_pda(&mint_2_keypair.pubkey());
-
-    // Try to create pool for `mint_1` while using seeds of `mint_2` for PDAs.
-    {
-        let instruction_data = light_compressed_token::instruction::CreateTokenPool {};
-        let accounts = light_compressed_token::accounts::CreateTokenPoolInstruction {
-            fee_payer: payer.pubkey(),
-            token_pool_pda: mint_2_pool_pda,
-            system_program: system_program::ID,
-            mint: mint_1_keypair.pubkey(),
-            token_program: anchor_spl::token::ID,
-            cpi_authority_pda: get_cpi_authority_pda().0,
-        };
-        let instruction = Instruction {
-            program_id: light_compressed_token::ID,
-            accounts: accounts.to_account_metas(Some(true)),
-            data: instruction_data.data(),
-        };
-        let result = rpc
-            .create_and_send_transaction(&[instruction], &payer.pubkey(), &[&payer])
-            .await;
-        assert_rpc_error(
-            result,
-            0,
-            anchor_lang::error::ErrorCode::ConstraintSeeds.into(),
-        )
-        .unwrap();
-    }
-    // Invalid program id.
-    {
-        let instruction_data = light_compressed_token::instruction::CreateTokenPool {};
-        let accounts = light_compressed_token::accounts::CreateTokenPoolInstruction {
-            fee_payer: payer.pubkey(),
-            token_pool_pda: mint_1_pool_pda,
-            system_program: system_program::ID,
-            mint: mint_1_keypair.pubkey(),
-            token_program: light_system_program::ID, // invalid program id should be spl token program or token 2022 program
-            cpi_authority_pda: get_cpi_authority_pda().0,
-        };
-        let instruction = Instruction {
-            program_id: light_compressed_token::ID,
-            accounts: accounts.to_account_metas(Some(true)),
-            data: instruction_data.data(),
-        };
-        let result = rpc
-            .create_and_send_transaction(&[instruction], &payer.pubkey(), &[&payer])
-            .await;
-        assert_rpc_error(
-            result,
-            0,
-            anchor_lang::error::ErrorCode::InvalidProgramId.into(),
-        )
-        .unwrap();
-    }
-    // Try to create pool for `mint_2` while using seeds of `mint_1` for PDAs.
-    {
-        let instruction_data = light_compressed_token::instruction::CreateTokenPool {};
-        let accounts = light_compressed_token::accounts::CreateTokenPoolInstruction {
-            fee_payer: payer.pubkey(),
-            token_pool_pda: mint_1_pool_pda,
-            system_program: system_program::ID,
-            mint: mint_2_keypair.pubkey(),
-            token_program: anchor_spl::token::ID,
-            cpi_authority_pda: get_cpi_authority_pda().0,
-        };
-        let instruction = Instruction {
-            program_id: light_compressed_token::ID,
-            accounts: accounts.to_account_metas(Some(true)),
-            data: instruction_data.data(),
-        };
-        let result = rpc
-            .create_and_send_transaction(&[instruction], &payer.pubkey(), &[&payer])
-            .await;
-        assert_rpc_error(
-            result,
-            0,
-            anchor_lang::error::ErrorCode::ConstraintSeeds.into(),
-        )
-        .unwrap();
-    }
-    // failing test try to create a token pool with mint with non-whitelisted token extension
-    {
-        let payer = rpc.get_payer().insecure_clone();
-        let payer_pubkey = payer.pubkey();
-        let mint = Keypair::new();
-        let token_authority = payer.insecure_clone();
-        let space = ExtensionType::try_calculate_account_len::<spl_token_2022::state::Mint>(&[
-            ExtensionType::MintCloseAuthority,
-        ])
-        .unwrap();
-
-        let mut instructions = vec![system_instruction::create_account(
-            &payer.pubkey(),
-            &mint.pubkey(),
-            rpc.get_minimum_balance_for_rent_exemption(space)
-                .await
-                .unwrap(),
-            space as u64,
-            &spl_token_2022::ID,
-        )];
-        let invalid_token_extension_ix =
-            spl_token_2022::instruction::initialize_mint_close_authority(
-                &spl_token_2022::ID,
-                &mint.pubkey(),
-                Some(&token_authority.pubkey()),
-            )
-            .unwrap();
-        instructions.push(invalid_token_extension_ix);
-        instructions.push(
-            spl_token_2022::instruction::initialize_mint(
-                &spl_token_2022::ID,
-                &mint.pubkey(),
-                &token_authority.pubkey(),
-                None,
-                2,
-            )
-            .unwrap(),
-        );
-        instructions.push(create_create_token_pool_instruction(
-            &payer_pubkey,
-            &mint.pubkey(),
-            true,
-        ));
-
-        let result = rpc
-            .create_and_send_transaction(&instructions, &payer_pubkey, &[&payer, &mint])
-            .await;
-        assert_rpc_error(result, 3, ErrorCode::MintWithInvalidExtension.into()).unwrap();
-    }
-    // functional create token pool account with token 2022 mint with allowed metadata pointer extension
-    {
-        let payer = rpc.get_payer().insecure_clone();
-        // create_mint_helper(&mut rpc, &payer).await;
-        let payer_pubkey = payer.pubkey();
-
-        let mint = Keypair::new();
-        let token_authority = payer.insecure_clone();
-        let space = ExtensionType::try_calculate_account_len::<spl_token_2022::state::Mint>(&[
-            ExtensionType::MetadataPointer,
-        ])
-        .unwrap();
-
-        let mut instructions = vec![system_instruction::create_account(
-            &payer.pubkey(),
-            &mint.pubkey(),
-            rpc.get_minimum_balance_for_rent_exemption(space)
-                .await
-                .unwrap(),
-            space as u64,
-            &spl_token_2022::ID,
-        )];
-        let token_extension_ix =
-            spl_token_2022::extension::metadata_pointer::instruction::initialize(
-                &spl_token_2022::ID,
-                &mint.pubkey(),
-                Some(token_authority.pubkey()),
-                None,
-            )
-            .unwrap();
-        instructions.push(token_extension_ix);
-        instructions.push(
-            spl_token_2022::instruction::initialize_mint(
-                &spl_token_2022::ID,
-                &mint.pubkey(),
-                &token_authority.pubkey(),
-                None,
-                2,
-            )
-            .unwrap(),
-        );
-        instructions.push(create_create_token_pool_instruction(
-            &payer_pubkey,
-            &mint.pubkey(),
-            true,
-        ));
-        rpc.create_and_send_transaction(&instructions, &payer_pubkey, &[&payer, &mint])
-            .await
-            .unwrap();
-
-        let token_pool_pubkey = get_token_pool_pda(&mint.pubkey());
-        let token_pool_account = rpc.get_account(token_pool_pubkey).await.unwrap().unwrap();
-        check_spl_token_pool_derivation_with_index(
-            &mint.pubkey().to_bytes(),
-            &token_pool_pubkey,
-            &[0],
-        )
-        .unwrap();
-        assert_eq!(token_pool_account.data.len(), TokenAccount::LEN);
-    }
-}
-
-#[serial]
-#[tokio::test]
-async fn failing_tests_add_token_pool() {
-    for is_token_22 in [false, true] {
-        let mut rpc = LightProgramTest::new(ProgramTestConfig::new(false, None))
-            .await
-            .unwrap();
-        let payer = rpc.get_payer().insecure_clone();
-
-        let mint = if !is_token_22 {
-            create_mint_helper(&mut rpc, &payer).await
-        } else {
-            create_mint_22_helper(&mut rpc, &payer).await
-        };
-        let invalid_mint = if !is_token_22 {
-            create_mint_helper(&mut rpc, &payer).await
-        } else {
-            create_mint_22_helper(&mut rpc, &payer).await
-        };
-        let mut current_token_pool_bump = 1;
-        create_additional_token_pools(&mut rpc, &payer, &mint, is_token_22, 2)
-            .await
-            .unwrap();
-        create_additional_token_pools(&mut rpc, &payer, &invalid_mint, is_token_22, 2)
-            .await
-            .unwrap();
-        current_token_pool_bump += 2;
-        // 1. failing invalid existing token pool pda
-        {
-            let result = add_token_pool(
-                &mut rpc,
-                &payer,
-                &mint,
-                None,
-                current_token_pool_bump,
-                is_token_22,
-                FailingTestsAddTokenPool::InvalidExistingTokenPoolPda,
-            )
-            .await;
-            assert_rpc_error(result, 0, ErrorCode::InvalidTokenPoolPda.into()).unwrap();
-        }
-        // 2. failing InvalidTokenPoolPda
-        {
-            let result = add_token_pool(
-                &mut rpc,
-                &payer,
-                &mint,
-                None,
-                current_token_pool_bump,
-                is_token_22,
-                FailingTestsAddTokenPool::InvalidTokenPoolPda,
-            )
-            .await;
-            assert_rpc_error(
-                result,
-                0,
-                anchor_lang::error::ErrorCode::ConstraintSeeds.into(),
-            )
-            .unwrap();
-        }
-        // 3. failing invalid system program id
-        {
-            let result = add_token_pool(
-                &mut rpc,
-                &payer,
-                &mint,
-                None,
-                current_token_pool_bump,
-                is_token_22,
-                FailingTestsAddTokenPool::InvalidSystemProgramId,
-            )
-            .await;
-            assert_rpc_error(
-                result,
-                0,
-                anchor_lang::error::ErrorCode::InvalidProgramId.into(),
-            )
-            .unwrap();
-        }
-        // 4. failing invalid mint
-        {
-            let result = add_token_pool(
-                &mut rpc,
-                &payer,
-                &mint,
-                None,
-                current_token_pool_bump,
-                is_token_22,
-                FailingTestsAddTokenPool::InvalidMint,
-            )
-            .await;
-            assert_rpc_error(
-                result,
-                0,
-                anchor_lang::error::ErrorCode::AccountNotInitialized.into(),
-            )
-            .unwrap();
-        }
-        // 5. failing inconsistent mints
-        {
-            let result = add_token_pool(
-                &mut rpc,
-                &payer,
-                &mint,
-                Some(invalid_mint),
-                current_token_pool_bump,
-                is_token_22,
-                FailingTestsAddTokenPool::InconsistentMints,
-            )
-            .await;
-            assert_rpc_error(result, 0, ErrorCode::InvalidTokenPoolPda.into()).unwrap();
-        }
-        // 6. failing invalid program id
-        {
-            let result = add_token_pool(
-                &mut rpc,
-                &payer,
-                &mint,
-                None,
-                current_token_pool_bump,
-                is_token_22,
-                FailingTestsAddTokenPool::InvalidTokenProgramId,
-            )
-            .await;
-            assert_rpc_error(
-                result,
-                0,
-                anchor_lang::error::ErrorCode::InvalidProgramId.into(),
-            )
-            .unwrap();
-        }
-        // 7. failing invalid cpi authority pda
-        {
-            let result = add_token_pool(
-                &mut rpc,
-                &payer,
-                &mint,
-                None,
-                current_token_pool_bump,
-                is_token_22,
-                FailingTestsAddTokenPool::InvalidCpiAuthorityPda,
-            )
-            .await;
-            assert_rpc_error(
-                result,
-                0,
-                anchor_lang::error::ErrorCode::ConstraintSeeds.into(),
-            )
-            .unwrap();
-        }
-        // create all remaining token pools
-        create_additional_token_pools(&mut rpc, &payer, &mint, is_token_22, 5)
-            .await
-            .unwrap();
-        // 8. failing invalid token pool bump (too large)
-        {
-            let result = add_token_pool(
-                &mut rpc,
-                &payer,
-                &mint,
-                None,
-                NUM_MAX_POOL_ACCOUNTS,
-                is_token_22,
-                FailingTestsAddTokenPool::Functional,
-            )
-            .await;
-            assert_rpc_error(result, 0, ErrorCode::InvalidTokenPoolBump.into()).unwrap();
-        }
-    }
-}
-
-#[derive(Debug, Clone, Copy, PartialEq)]
-pub enum FailingTestsAddTokenPool {
-    Functional,
-    InvalidMint,
-    InconsistentMints,
-    InvalidTokenPoolPda,
-    InvalidSystemProgramId,
-    InvalidExistingTokenPoolPda,
-    InvalidCpiAuthorityPda,
-    InvalidTokenProgramId,
-}
-
-pub async fn add_token_pool<R: Rpc>(
-    rpc: &mut R,
-    fee_payer: &Keypair,
-    mint: &Pubkey,
-    invalid_mint: Option<Pubkey>,
-    token_pool_index: u8,
-    is_token_22: bool,
-    mode: FailingTestsAddTokenPool,
-) -> Result<Signature, RpcError> {
-    let token_pool_pda = if mode == FailingTestsAddTokenPool::InvalidTokenPoolPda {
-        Pubkey::new_unique()
-    } else {
-        get_token_pool_pda_with_index(mint, token_pool_index)
-    };
-    let existing_token_pool_pda = if mode == FailingTestsAddTokenPool::InvalidExistingTokenPoolPda {
-        get_token_pool_pda_with_index(mint, token_pool_index.saturating_sub(2))
-    } else if let Some(invalid_mint) = invalid_mint {
-        get_token_pool_pda_with_index(&invalid_mint, token_pool_index.saturating_sub(1))
-    } else {
-        get_token_pool_pda_with_index(mint, token_pool_index.saturating_sub(1))
-    };
-    let instruction_data = light_compressed_token::instruction::AddTokenPool { token_pool_index };
-
-    let token_program: Pubkey = if mode == FailingTestsAddTokenPool::InvalidTokenProgramId {
-        Pubkey::new_unique()
-    } else if is_token_22 {
-        anchor_spl::token_2022::ID
-    } else {
-        anchor_spl::token::ID
-    };
-    let cpi_authority_pda = if mode == FailingTestsAddTokenPool::InvalidCpiAuthorityPda {
-        Pubkey::new_unique()
-    } else {
-        get_cpi_authority_pda().0
-    };
-    let system_program = if mode == FailingTestsAddTokenPool::InvalidSystemProgramId {
-        Pubkey::new_unique()
-    } else {
-        system_program::ID
-    };
-    let mint = if mode == FailingTestsAddTokenPool::InvalidMint {
-        Pubkey::new_unique()
-    } else {
-        *mint
-    };
-
-    let accounts = light_compressed_token::accounts::AddTokenPoolInstruction {
-        fee_payer: fee_payer.pubkey(),
-        token_pool_pda,
-        system_program,
-        mint,
-        token_program,
-        cpi_authority_pda,
-        existing_token_pool_pda,
-    };
-
-    let instruction = Instruction {
-        program_id: light_compressed_token::ID,
-        accounts: accounts.to_account_metas(Some(true)),
-        data: instruction_data.data(),
-    };
-    rpc.create_and_send_transaction(&[instruction], &fee_payer.pubkey(), &[fee_payer])
-        .await
-}
+use spl_token::error::TokenError;
 
 #[serial]
 #[tokio::test]
diff --git a/program-tests/registry-test/tests/compressible.rs b/program-tests/registry-test/tests/compressible.rs
index 87cd16fee7..1f941ea8b1 100644
--- a/program-tests/registry-test/tests/compressible.rs
+++ b/program-tests/registry-test/tests/compressible.rs
@@ -6,9 +6,10 @@ use anchor_lang::{AnchorDeserialize, InstructionData, ToAccountMetas};
 use light_compressible::{
     config::CompressibleConfig, error::CompressibleError, rent::SLOTS_PER_EPOCH,
 };
-use light_ctoken_interface::state::{CToken, ExtensionStruct};
-use light_ctoken_sdk::ctoken::{
-    derive_ctoken_ata, CompressibleParams, CreateAssociatedCTokenAccount,
+use light_ctoken_interface::state::CToken;
+use light_ctoken_sdk::{
+    compressed_token::create_compressed_mint::find_cmint_address,
+    ctoken::{derive_ctoken_ata, CTokenMintTo, CompressibleParams, CreateAssociatedCTokenAccount},
 };
 use light_program_test::{
     forester::claim_forester, program_test::TestRpc, utils::assert::assert_rpc_error,
@@ -21,8 +22,12 @@ use light_registry::accounts::{
 use light_test_utils::{
     airdrop_lamports, assert_claim::assert_claim, spl::create_mint_helper, Rpc, RpcError,
 };
-use light_token_client::actions::{
-    create_compressible_token_account, transfer_ctoken, CreateCompressibleTokenAccountInputs,
+use light_token_client::{
+    actions::{
+        create_compressible_token_account, mint_action_comprehensive, transfer_ctoken,
+        CreateCompressibleTokenAccountInputs,
+    },
+    instructions::mint_action::{DecompressMintParams, NewMint},
 };
 use solana_sdk::{
     instruction::Instruction,
@@ -493,6 +498,7 @@ async fn test_pause_compressible_config_with_valid_authority() -> Result<(), Rpc
         lamports_per_write: None,
         compress_to_account_pubkey: None,
         token_account_version: light_ctoken_interface::state::TokenDataVersion::ShaFlat,
+        compression_only: false,
     };
 
     let compressible_instruction =
@@ -626,6 +632,7 @@ async fn test_unpause_compressible_config_with_valid_authority() -> Result<(), R
         lamports_per_write: None,
         compress_to_account_pubkey: None,
         token_account_version: light_ctoken_interface::state::TokenDataVersion::ShaFlat,
+        compression_only: false,
     };
 
     let compressible_instruction =
@@ -672,6 +679,7 @@ async fn test_unpause_compressible_config_with_valid_authority() -> Result<(), R
         lamports_per_write: None,
         compress_to_account_pubkey: None,
         token_account_version: light_ctoken_interface::state::TokenDataVersion::ShaFlat,
+        compression_only: false,
     };
 
     let compressible_instruction =
@@ -761,6 +769,7 @@ async fn test_deprecate_compressible_config_with_valid_authority() -> Result<(),
         lamports_per_write: None,
         compress_to_account_pubkey: None,
         token_account_version: light_ctoken_interface::state::TokenDataVersion::ShaFlat,
+        compression_only: false,
     };
 
     let compressible_instruction =
@@ -808,6 +817,7 @@ async fn test_deprecate_compressible_config_with_valid_authority() -> Result<(),
         lamports_per_write: None,
         compress_to_account_pubkey: None,
         token_account_version: light_ctoken_interface::state::TokenDataVersion::ShaFlat,
+        compression_only: false,
     };
 
     let compressible_instruction =
@@ -1123,74 +1133,147 @@ async fn assert_not_compressible<R: Rpc>(
     name: &str,
 ) -> Result<(), RpcError> {
     use borsh::BorshDeserialize;
-    use light_ctoken_interface::state::{CToken, ExtensionStruct};
+    use light_ctoken_interface::state::CToken;
 
     let account = rpc
         .get_account(account_pubkey)
         .await?
         .ok_or_else(|| RpcError::AssertRpcError(format!("{} account not found", name)))?;
 
+    let rent_exemption = rpc
+        .get_minimum_balance_for_rent_exemption(account.data.len())
+        .await?;
+
     let ctoken = CToken::deserialize(&mut account.data.as_slice())
         .map_err(|e| RpcError::AssertRpcError(format!("Failed to deserialize CToken: {:?}", e)))?;
 
-    if let Some(extensions) = ctoken.extensions.as_ref() {
-        for ext in extensions.iter() {
-            if let ExtensionStruct::Compressible(compressible_ext) = ext {
-                let current_slot = rpc.get_slot().await?;
-
-                // Check if account is compressible using AccountRentState
-                let state = light_compressible::rent::AccountRentState {
-                    num_bytes: account.data.len() as u64,
-                    current_slot,
-                    current_lamports: account.lamports,
-                    last_claimed_slot: compressible_ext.info.last_claimed_slot,
-                };
-                let is_compressible = state.is_compressible(
-                    &compressible_ext.info.rent_config,
-                    light_ctoken_interface::COMPRESSIBLE_TOKEN_RENT_EXEMPTION,
-                );
-
-                assert!(
-                    is_compressible.is_none(),
-                    "{} should NOT be compressible (well-funded), but has deficit: {:?}",
-                    name,
-                    is_compressible
-                );
-
-                // Also verify last_funded_epoch is ahead of current
-                let last_funded_epoch = compressible_ext
-                    .info
-                    .get_last_funded_epoch(
-                        account.data.len() as u64,
-                        account.lamports,
-                        light_ctoken_interface::COMPRESSIBLE_TOKEN_RENT_EXEMPTION,
-                    )
-                    .map_err(|e| {
-                        RpcError::AssertRpcError(format!(
-                            "Failed to get last funded epoch: {:?}",
-                            e
-                        ))
-                    })?;
-
-                let current_epoch = slot_to_epoch(current_slot);
-
-                assert!(
-                    last_funded_epoch >= current_epoch,
-                    "{} last_funded_epoch ({}) should be >= current_epoch ({})",
-                    name,
-                    last_funded_epoch,
-                    current_epoch
-                );
-
-                return Ok(());
-            }
-        }
+    // CompressionInfo is now embedded directly in ctoken.compression
+    let compression_info = &ctoken.compression;
+    let current_slot = rpc.get_slot().await?;
+
+    // Check if account is compressible using AccountRentState
+    let state = light_compressible::rent::AccountRentState {
+        num_bytes: account.data.len() as u64,
+        current_slot,
+        current_lamports: account.lamports,
+        last_claimed_slot: compression_info.last_claimed_slot,
+    };
+    let is_compressible = state.is_compressible(&compression_info.rent_config, rent_exemption);
+
+    assert!(
+        is_compressible.is_none(),
+        "{} should NOT be compressible (well-funded), but has deficit: {:?}",
+        name,
+        is_compressible
+    );
+
+    // Also verify last_funded_epoch is ahead of current
+    let last_funded_epoch = compression_info
+        .get_last_funded_epoch(account.data.len() as u64, account.lamports, rent_exemption)
+        .map_err(|e| {
+            RpcError::AssertRpcError(format!("Failed to get last funded epoch: {:?}", e))
+        })?;
+
+    let current_epoch = slot_to_epoch(current_slot);
+
+    assert!(
+        last_funded_epoch >= current_epoch,
+        "{} last_funded_epoch ({}) should be >= current_epoch ({})",
+        name,
+        last_funded_epoch,
+        current_epoch
+    );
+
+    Ok(())
+}
+
+/// Helper function to assert that a compressible CMint account is NOT compressible (well-funded)
+async fn assert_not_compressible_cmint<R: Rpc>(
+    rpc: &mut R,
+    account_pubkey: Pubkey,
+    name: &str,
+) -> Result<(), RpcError> {
+    use borsh::BorshDeserialize;
+    use light_ctoken_interface::state::CompressedMint;
+
+    let account = rpc
+        .get_account(account_pubkey)
+        .await?
+        .ok_or_else(|| RpcError::AssertRpcError(format!("{} account not found", name)))?;
+
+    let rent_exemption = rpc
+        .get_minimum_balance_for_rent_exemption(account.data.len())
+        .await?;
+
+    let cmint = CompressedMint::deserialize(&mut account.data.as_slice())
+        .map_err(|e| RpcError::AssertRpcError(format!("Failed to deserialize CMint: {:?}", e)))?;
+
+    // CompressionInfo is embedded directly in cmint.compression
+    let compression_info = &cmint.compression;
+    let current_slot = rpc.get_slot().await?;
+
+    // Check if account is compressible using AccountRentState
+    let state = light_compressible::rent::AccountRentState {
+        num_bytes: account.data.len() as u64,
+        current_slot,
+        current_lamports: account.lamports,
+        last_claimed_slot: compression_info.last_claimed_slot,
+    };
+    let is_compressible = state.is_compressible(&compression_info.rent_config, rent_exemption);
+
+    assert!(
+        is_compressible.is_none(),
+        "{} should NOT be compressible (well-funded), but has deficit: {:?}",
+        name,
+        is_compressible
+    );
+
+    // Also verify last_funded_epoch is ahead of current
+    let last_funded_epoch = compression_info
+        .get_last_funded_epoch(account.data.len() as u64, account.lamports, rent_exemption)
+        .map_err(|e| {
+            RpcError::AssertRpcError(format!("Failed to get last funded epoch: {:?}", e))
+        })?;
+
+    let current_epoch = slot_to_epoch(current_slot);
+
+    assert!(
+        last_funded_epoch >= current_epoch,
+        "{} last_funded_epoch ({}) should be >= current_epoch ({})",
+        name,
+        last_funded_epoch,
+        current_epoch
+    );
+
+    Ok(())
+}
+
+/// Helper function to mint tokens to a CToken account using CTokenMintTo instruction
+async fn mint_to_ctoken<R: Rpc>(
+    rpc: &mut R,
+    cmint: Pubkey,
+    destination: Pubkey,
+    amount: u64,
+    mint_authority: &Keypair,
+    payer: &Keypair,
+) -> Result<Signature, RpcError> {
+    let ix = CTokenMintTo {
+        cmint,
+        destination,
+        amount,
+        authority: mint_authority.pubkey(),
+        max_top_up: None,
     }
+    .instruction()
+    .map_err(|e| {
+        RpcError::CustomError(format!(
+            "Failed to create CTokenMintTo instruction: {:?}",
+            e
+        ))
+    })?;
 
-    Err(RpcError::AssertRpcError(format!(
-        "{} does not have compressible extension",
-        name
-    )))
+    rpc.create_and_send_transaction(&[ix], &payer.pubkey(), &[payer, mint_authority])
+        .await
 }
 
 #[tokio::test]
@@ -1201,7 +1284,41 @@ async fn test_compressible_account_infinite_funding() -> Result<(), RpcError> {
         .await
         .unwrap();
     let payer = rpc.get_payer().insecure_clone();
-    let mint = create_mint_helper(&mut rpc, &payer).await;
+
+    // Create a CMint with compressible config (will be tested alongside CToken accounts)
+    let mint_seed = Keypair::new();
+    let mint_authority = payer.insecure_clone();
+    let (cmint_pda, _) = find_cmint_address(&mint_seed.pubkey());
+
+    // Create CMint with write_top_up for infinite funding
+    mint_action_comprehensive(
+        &mut rpc,
+        &mint_seed,
+        &mint_authority,
+        &payer,
+        Some(DecompressMintParams {
+            rent_payment: 2,
+            write_top_up: 400, // Top-up on each write (MintTo)
+        }),
+        false,
+        vec![],
+        vec![],
+        None,
+        None,
+        Some(NewMint {
+            decimals: 9,
+            supply: 0,
+            mint_authority: mint_authority.pubkey(),
+            freeze_authority: None,
+            metadata: None,
+            version: 3,
+        }),
+    )
+    .await
+    .unwrap();
+
+    // Use the CMint PDA as the mint for CToken accounts
+    let mint = cmint_pda;
 
     // Create owner for both accounts
     let owner_keypair = Keypair::new();
@@ -1225,7 +1342,7 @@ async fn test_compressible_account_infinite_funding() -> Result<(), RpcError> {
             num_prepaid_epochs: 2,
             payer: &payer,
             token_account_keypair: None,
-            lamports_per_write: Some(100),
+            lamports_per_write: Some(400),
             token_account_version: light_ctoken_interface::state::TokenDataVersion::ShaFlat,
         },
     )
@@ -1241,43 +1358,31 @@ async fn test_compressible_account_infinite_funding() -> Result<(), RpcError> {
             num_prepaid_epochs: 2,
             payer: &payer,
             token_account_keypair: None,
-            lamports_per_write: Some(100),
+            lamports_per_write: Some(400),
             token_account_version: light_ctoken_interface::state::TokenDataVersion::ShaFlat,
         },
     )
     .await
     .unwrap();
 
-    // Mint 1,000,000 tokens to Account A
+    // Mint initial tokens to Account A via CTokenMintTo (this also writes to the CMint, triggering top-up)
     let transfer_amount = 1_000_000u64;
-    {
-        use light_ctoken_interface::state::CToken;
-        use light_zero_copy::traits::ZeroCopyAtMut;
-
-        let mut account_data = rpc.get_account(account_a).await?.unwrap();
-        let (mut ctoken, _) = CToken::zero_copy_at_mut(&mut account_data.data)
-            .map_err(|e| RpcError::AssertRpcError(format!("Failed to parse CToken: {:?}", e)))?;
-        *ctoken.amount = transfer_amount.into();
-        rpc.set_account(account_a, account_data);
-    }
+    mint_to_ctoken(
+        &mut rpc,
+        cmint_pda,
+        account_a,
+        transfer_amount,
+        &mint_authority,
+        &payer,
+    )
+    .await?;
 
     let account_a_data = rpc.get_account(account_a).await?.unwrap();
     let ctoken_a = CToken::deserialize(&mut account_a_data.data.as_slice())
         .map_err(|e| RpcError::AssertRpcError(format!("Failed to deserialize CToken: {:?}", e)))?;
 
-    let rent_config = ctoken_a
-        .extensions
-        .as_ref()
-        .and_then(|exts| {
-            exts.iter().find_map(|ext| {
-                if let ExtensionStruct::Compressible(comp) = ext {
-                    Some(comp.info.rent_config)
-                } else {
-                    None
-                }
-            })
-        })
-        .ok_or_else(|| RpcError::AssertRpcError("No compressible extension found".to_string()))?;
+    // CompressionInfo is now embedded directly in ctoken.compression
+    let rent_config = ctoken_a.compression.rent_config;
 
     let account_size = account_a_data.data.len() as u64;
     let rent_per_epoch = rent_config.rent_curve_per_epoch(account_size);
@@ -1292,27 +1397,37 @@ async fn test_compressible_account_infinite_funding() -> Result<(), RpcError> {
     // Get initial slot and last_claimed_slot from both accounts
     let initial_slot = rpc.get_slot().await?;
 
-    let get_last_claimed_slot = |account_data: &[u8]| -> Result<u64, RpcError> {
+    let get_last_claimed_slot_ctoken = |account_data: &[u8]| -> Result<u64, RpcError> {
         let ctoken = CToken::deserialize(&mut &account_data[..]).map_err(|e| {
             RpcError::AssertRpcError(format!("Failed to deserialize CToken: {:?}", e))
         })?;
+        Ok(ctoken.compression.last_claimed_slot)
+    };
 
-        if let Some(extensions) = ctoken.extensions.as_ref() {
-            for ext in extensions.iter() {
-                if let ExtensionStruct::Compressible(comp) = ext {
-                    return Ok(comp.info.last_claimed_slot);
-                }
-            }
-        }
-        Err(RpcError::AssertRpcError(
-            "No compressible extension".to_string(),
-        ))
+    let get_last_claimed_slot_cmint = |account_data: &[u8]| -> Result<u64, RpcError> {
+        use borsh::BorshDeserialize;
+        use light_ctoken_interface::state::CompressedMint;
+        let cmint = CompressedMint::deserialize(&mut &account_data[..]).map_err(|e| {
+            RpcError::AssertRpcError(format!("Failed to deserialize CMint: {:?}", e))
+        })?;
+        Ok(cmint.compression.last_claimed_slot)
     };
 
     let initial_last_claimed_a =
-        get_last_claimed_slot(&rpc.get_account(account_a).await?.unwrap().data)?;
+        get_last_claimed_slot_ctoken(&rpc.get_account(account_a).await?.unwrap().data)?;
     let initial_last_claimed_b =
-        get_last_claimed_slot(&rpc.get_account(account_b).await?.unwrap().data)?;
+        get_last_claimed_slot_ctoken(&rpc.get_account(account_b).await?.unwrap().data)?;
+    let initial_last_claimed_cmint =
+        get_last_claimed_slot_cmint(&rpc.get_account(cmint_pda).await?.unwrap().data)?;
+
+    // Get CMint size and rent config for final verification
+    let cmint_account = rpc.get_account(cmint_pda).await?.unwrap();
+    let cmint_size = cmint_account.data.len() as u64;
+    let cmint_data = light_ctoken_interface::state::CompressedMint::deserialize(
+        &mut cmint_account.data.as_slice(),
+    )
+    .map_err(|e| RpcError::AssertRpcError(format!("Failed to deserialize CMint: {:?}", e)))?;
+    let cmint_rent_config = cmint_data.compression.rent_config;
 
     println!("Initial slot: {}", initial_slot);
     println!(
@@ -1323,6 +1438,10 @@ async fn test_compressible_account_infinite_funding() -> Result<(), RpcError> {
         "Account B initial last_claimed_slot: {}",
         initial_last_claimed_b
     );
+    println!(
+        "CMint initial last_claimed_slot: {}",
+        initial_last_claimed_cmint
+    );
 
     // Main loop: 1000 iterations = 100 epochs * 10 iterations per epoch
     for i in 0..1000 {
@@ -1356,48 +1475,209 @@ async fn test_compressible_account_infinite_funding() -> Result<(), RpcError> {
         assert_not_compressible(&mut rpc, source, source_name).await?;
         assert_not_compressible(&mut rpc, dest, dest_name).await?;
 
+        // Mint 0 tokens every 10 iterations (once per epoch) to trigger CMint write_top_up
+        // This keeps the CMint funded through its write_top_up mechanism
+        mint_to_ctoken(&mut rpc, cmint_pda, dest, 0, &mint_authority, &payer).await?;
+
         // Advance by 1/10 of an epoch (630 slots)
         let advance_slots = SLOTS_PER_EPOCH / 10; // 630 slots
         rpc.warp_slot_forward(advance_slots).await.unwrap();
 
-        // Log progress every 100 iterations
+        // Log progress and assert CMint every 100 iterations
         if i % 100 == 0 && i > 0 {
             println!("Completed iteration {}/1000 (epoch {})", i, epoch);
+            // Assert CMint is still well-funded (write_top_up should keep it funded)
+            assert_not_compressible_cmint(&mut rpc, cmint_pda, "CMint").await?;
         }
     }
 
     println!("Test completed successfully!");
-    println!("Both accounts remained well-funded through 100 epochs of continuous transfers");
+    println!("All accounts (CToken A, CToken B, CMint) remained well-funded through 100 epochs");
 
     // Final verification
     assert_not_compressible(&mut rpc, account_a, "Account A (final)").await?;
     assert_not_compressible(&mut rpc, account_b, "Account B (final)").await?;
+    assert_not_compressible_cmint(&mut rpc, cmint_pda, "CMint (final)").await?;
 
     // Verify total rent claimed
     let final_rent_sponsor_balance = rpc.get_account(rent_sponsor).await?.unwrap().lamports;
     let total_rent_claimed = final_rent_sponsor_balance - initial_rent_sponsor_balance;
 
-    // Get final last_claimed_slot from both accounts
+    // Get final last_claimed_slot from all accounts (CToken A, CToken B, CMint)
     let final_last_claimed_a =
-        get_last_claimed_slot(&rpc.get_account(account_a).await?.unwrap().data)?;
+        get_last_claimed_slot_ctoken(&rpc.get_account(account_a).await?.unwrap().data)?;
     let final_last_claimed_b =
-        get_last_claimed_slot(&rpc.get_account(account_b).await?.unwrap().data)?;
+        get_last_claimed_slot_ctoken(&rpc.get_account(account_b).await?.unwrap().data)?;
+    let final_last_claimed_cmint =
+        get_last_claimed_slot_cmint(&rpc.get_account(cmint_pda).await?.unwrap().data)?;
 
     // Calculate exact number of completed epochs that were claimed for each account
     use light_compressible::rent::SLOTS_PER_EPOCH;
     let completed_epochs_a = (final_last_claimed_a - initial_last_claimed_a) / SLOTS_PER_EPOCH;
     let completed_epochs_b = (final_last_claimed_b - initial_last_claimed_b) / SLOTS_PER_EPOCH;
+    let completed_epochs_cmint =
+        (final_last_claimed_cmint - initial_last_claimed_cmint) / SLOTS_PER_EPOCH;
 
     // Calculate exact expected rent using RentConfig's rent_curve_per_epoch
     let expected_rent_a = rent_config.get_rent(account_size, completed_epochs_a);
     let expected_rent_b = rent_config.get_rent(account_size, completed_epochs_b);
-    let expected_total_rent = expected_rent_a + expected_rent_b;
+    let expected_rent_cmint = cmint_rent_config.get_rent(cmint_size, completed_epochs_cmint);
+    let expected_total_rent = expected_rent_a + expected_rent_b + expected_rent_cmint;
+
+    println!(
+        "Rent claimed: {} (A: {}, B: {}, CMint: {})",
+        total_rent_claimed, expected_rent_a, expected_rent_b, expected_rent_cmint
+    );
 
     // Assert exact match
     assert_eq!(
         total_rent_claimed, expected_total_rent,
-        "Rent claimed should exactly match expected rent"
+        "Rent claimed should exactly match expected rent (CToken A + CToken B + CMint)"
     );
 
     Ok(())
 }
+
+#[tokio::test]
+async fn test_claim_from_cmint_account() -> Result<(), RpcError> {
+    let mut rpc = LightProgramTest::new(ProgramTestConfig::new_v2(false, None))
+        .await
+        .unwrap();
+    let payer = rpc.get_payer().insecure_clone();
+    let mint_seed = Keypair::new();
+    let mint_authority = payer.insecure_clone();
+
+    // Create compressed mint + decompress to CMint with rent prepaid
+    let (cmint_pda, _) = find_cmint_address(&mint_seed.pubkey());
+    mint_action_comprehensive(
+        &mut rpc,
+        &mint_seed,
+        &mint_authority,
+        &payer,
+        Some(DecompressMintParams {
+            rent_payment: 5,
+            write_top_up: 0,
+        }),
+        false,
+        vec![],
+        vec![],
+        None,
+        None,
+        Some(NewMint {
+            decimals: 9,
+            supply: 0,
+            mint_authority: mint_authority.pubkey(),
+            freeze_authority: None,
+            metadata: None,
+            version: 3,
+        }),
+    )
+    .await
+    .unwrap();
+
+    // Warp forward 2 epochs (use warp_to_slot to avoid auto-claim)
+    let current_slot = rpc.get_slot().await.unwrap();
+    let target_slot = current_slot + 2 * SLOTS_PER_EPOCH;
+    rpc.warp_to_slot(target_slot).unwrap();
+
+    // Claim rent from CMint
+    let forester_keypair = rpc.test_accounts.protocol.forester.insecure_clone();
+    claim_forester(&mut rpc, &[cmint_pda], &forester_keypair, &payer)
+        .await
+        .unwrap();
+
+    // Verify claim
+    let config = rpc.test_accounts.funding_pool_config;
+    assert_claim(
+        &mut rpc,
+        &[cmint_pda],
+        config.rent_sponsor_pda,
+        config.compression_authority_pda,
+    )
+    .await;
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn test_claim_mixed_ctoken_and_cmint() -> Result<(), RpcError> {
+    let mut rpc = LightProgramTest::new(ProgramTestConfig::new_v2(false, None))
+        .await
+        .unwrap();
+    let payer = rpc.get_payer().insecure_clone();
+
+    // Create CToken account with prepaid rent
+    let ctoken_owner = Keypair::new();
+    let mint = Pubkey::new_unique();
+    let ctoken_pubkey = create_compressible_token_account(
+        &mut rpc,
+        CreateCompressibleTokenAccountInputs {
+            owner: ctoken_owner.pubkey(),
+            mint,
+            num_prepaid_epochs: 5,
+            payer: &payer,
+            token_account_keypair: None,
+            lamports_per_write: Some(100),
+            token_account_version: light_ctoken_interface::state::TokenDataVersion::ShaFlat,
+        },
+    )
+    .await
+    .unwrap();
+
+    // Create CMint account with prepaid rent
+    let mint_seed = Keypair::new();
+    let (cmint_pda, _) = find_cmint_address(&mint_seed.pubkey());
+    mint_action_comprehensive(
+        &mut rpc,
+        &mint_seed,
+        &payer,
+        &payer,
+        Some(DecompressMintParams {
+            rent_payment: 5,
+            write_top_up: 0,
+        }),
+        false,
+        vec![],
+        vec![],
+        None,
+        None,
+        Some(NewMint {
+            decimals: 9,
+            supply: 0,
+            mint_authority: payer.pubkey(),
+            freeze_authority: None,
+            metadata: None,
+            version: 3,
+        }),
+    )
+    .await
+    .unwrap();
+
+    // Warp forward 2 epochs (use warp_to_slot to avoid auto-claim)
+    let current_slot = rpc.get_slot().await.unwrap();
+    let target_slot = current_slot + 2 * SLOTS_PER_EPOCH;
+    rpc.warp_to_slot(target_slot).unwrap();
+
+    // Claim rent from BOTH accounts in single instruction
+    let forester_keypair = rpc.test_accounts.protocol.forester.insecure_clone();
+    claim_forester(
+        &mut rpc,
+        &[ctoken_pubkey, cmint_pda],
+        &forester_keypair,
+        &payer,
+    )
+    .await
+    .unwrap();
+
+    // Verify both claims succeeded
+    let config = rpc.test_accounts.funding_pool_config;
+    assert_claim(
+        &mut rpc,
+        &[ctoken_pubkey, cmint_pda],
+        config.rent_sponsor_pda,
+        config.compression_authority_pda,
+    )
+    .await;
+
+    Ok(())
+}
diff --git a/program-tests/utils/Cargo.toml b/program-tests/utils/Cargo.toml
index 699a7d3103..224583e94b 100644
--- a/program-tests/utils/Cargo.toml
+++ b/program-tests/utils/Cargo.toml
@@ -18,6 +18,7 @@ anchor-spl = { workspace = true }
 num-bigint = { workspace = true, features = ["rand"] }
 num-traits = { workspace = true }
 solana-sdk = { workspace = true }
+solana-system-interface = { workspace = true }
 thiserror = { workspace = true }
 account-compression = { workspace = true, features = ["cpi"] }
 light-compressed-token = { workspace = true, features = ["cpi"] }
@@ -41,6 +42,7 @@ log = { workspace = true }
 light-client = { workspace = true, features = ["devenv"] }
 create-address-test-program = { workspace = true }
 spl-token-2022 = { workspace = true }
+spl-pod = { workspace = true }
 light-batched-merkle-tree = { workspace = true, features = ["test-only"] }
 light-merkle-tree-metadata = { workspace = true }
 reqwest = { workspace = true }
diff --git a/program-tests/utils/src/assert_claim.rs b/program-tests/utils/src/assert_claim.rs
index 1461b01f38..b179c5c5d4 100644
--- a/program-tests/utils/src/assert_claim.rs
+++ b/program-tests/utils/src/assert_claim.rs
@@ -1,12 +1,109 @@
 use light_client::rpc::Rpc;
-use light_ctoken_interface::{
-    state::{CToken, ZExtensionStruct, ZExtensionStructMut},
-    COMPRESSIBLE_TOKEN_ACCOUNT_SIZE,
+use light_ctoken_interface::state::{
+    CToken, CompressedMint, ACCOUNT_TYPE_MINT, ACCOUNT_TYPE_TOKEN_ACCOUNT,
 };
 use light_program_test::LightProgramTest;
 use light_zero_copy::traits::{ZeroCopyAt, ZeroCopyAtMut};
 use solana_sdk::{clock::Clock, pubkey::Pubkey};
 
+/// Determines account type from account data.
+/// - If account is exactly 165 bytes: CToken (legacy size without extensions)
+/// - If account is > 165 bytes: read byte 165 for discriminator
+/// - If account is < 165 bytes: invalid (returns None)
+fn determine_account_type(data: &[u8]) -> Option<u8> {
+    const ACCOUNT_TYPE_OFFSET: usize = 165;
+
+    match data.len().cmp(&ACCOUNT_TYPE_OFFSET) {
+        std::cmp::Ordering::Less => None,
+        std::cmp::Ordering::Equal => Some(ACCOUNT_TYPE_TOKEN_ACCOUNT),
+        std::cmp::Ordering::Greater => Some(data[ACCOUNT_TYPE_OFFSET]),
+    }
+}
+
+/// Helper struct to hold extracted compression info for assertions
+struct CompressionAssertData {
+    last_claimed_slot: u64,
+    compression_authority: Pubkey,
+    rent_sponsor: Pubkey,
+    claimable_lamports: Option<u64>,
+    claim_failed: bool,
+}
+
+/// Extract compression info from pre-transaction account data (mutable, computes claim)
+fn extract_pre_compression_mut(
+    data: &mut [u8],
+    account_size: u64,
+    current_slot: u64,
+    account_lamports: u64,
+    base_lamports: u64,
+    pubkey: &Pubkey,
+) -> CompressionAssertData {
+    let account_type = determine_account_type(data)
+        .unwrap_or_else(|| panic!("Failed to determine account type for {}", pubkey));
+
+    match account_type {
+        ACCOUNT_TYPE_TOKEN_ACCOUNT => {
+            let (mut ctoken, _) = CToken::zero_copy_at_mut(data)
+                .unwrap_or_else(|e| panic!("Failed to parse ctoken account {}: {:?}", pubkey, e));
+            let compression = &mut ctoken.compression;
+            let last_claimed_slot = u64::from(compression.last_claimed_slot);
+            let compression_authority = Pubkey::from(compression.compression_authority);
+            let rent_sponsor = Pubkey::from(compression.rent_sponsor);
+            let lamports_result =
+                compression.claim(account_size, current_slot, account_lamports, base_lamports);
+            let claim_failed = lamports_result.is_err();
+            let claimable_lamports = lamports_result.ok().flatten();
+            CompressionAssertData {
+                last_claimed_slot,
+                compression_authority,
+                rent_sponsor,
+                claimable_lamports,
+                claim_failed,
+            }
+        }
+        ACCOUNT_TYPE_MINT => {
+            let (mut cmint, _) = CompressedMint::zero_copy_at_mut(data)
+                .unwrap_or_else(|e| panic!("Failed to parse cmint account {}: {:?}", pubkey, e));
+            let compression = &mut cmint.base.compression;
+            let last_claimed_slot = u64::from(compression.last_claimed_slot);
+            let compression_authority = Pubkey::from(compression.compression_authority);
+            let rent_sponsor = Pubkey::from(compression.rent_sponsor);
+            let lamports_result =
+                compression.claim(account_size, current_slot, account_lamports, base_lamports);
+            let claim_failed = lamports_result.is_err();
+            let claimable_lamports = lamports_result.ok().flatten();
+            CompressionAssertData {
+                last_claimed_slot,
+                compression_authority,
+                rent_sponsor,
+                claimable_lamports,
+                claim_failed,
+            }
+        }
+        _ => panic!("Unknown account type {} for {}", account_type, pubkey),
+    }
+}
+
+/// Extract post-transaction compression info (immutable)
+fn extract_post_compression(data: &[u8], pubkey: &Pubkey) -> u64 {
+    let account_type = determine_account_type(data)
+        .unwrap_or_else(|| panic!("Failed to determine account type for {}", pubkey));
+
+    match account_type {
+        ACCOUNT_TYPE_TOKEN_ACCOUNT => {
+            let (ctoken, _) = CToken::zero_copy_at(data)
+                .unwrap_or_else(|e| panic!("Failed to parse ctoken account {}: {:?}", pubkey, e));
+            u64::from(ctoken.compression.last_claimed_slot)
+        }
+        ACCOUNT_TYPE_MINT => {
+            let (cmint, _) = CompressedMint::zero_copy_at(data)
+                .unwrap_or_else(|e| panic!("Failed to parse cmint account {}: {:?}", pubkey, e));
+            u64::from(cmint.base.compression.last_claimed_slot)
+        }
+        _ => panic!("Unknown account type {} for {}", account_type, pubkey),
+    }
+}
+
 pub async fn assert_claim(
     rpc: &mut LightProgramTest,
     token_account_pubkeys: &[Pubkey],
@@ -25,113 +122,71 @@ pub async fn assert_claim(
         let mut pre_token_account = rpc
             .get_pre_transaction_account(token_account_pubkey)
             .expect("Token account should exist in pre-transaction context");
-        assert_eq!(
-            pre_token_account.data.len(),
-            COMPRESSIBLE_TOKEN_ACCOUNT_SIZE as usize
+        // Must have > 165 bytes to include account_type discriminator
+        assert!(
+            pre_token_account.data.len() > 165,
+            "Account must have > 165 bytes for CToken/CMint"
         );
-        // Parse pre-transaction token account data
-        let (mut pre_compressed_token, _) = CToken::zero_copy_at_mut(&mut pre_token_account.data)
-            .expect("Failed to deserialize pre-transaction token account");
-
-        // Find and extract pre-transaction compressible extension data
-        let mut pre_last_claimed_slot = 0u64;
-        let mut pre_compression_authority: Option<Pubkey> = None;
-        let mut pre_rent_sponsor: Option<Pubkey> = None;
-        let mut not_claimed_was_none = false;
-
-        if let Some(extensions) = pre_compressed_token.extensions.as_mut() {
-            for extension in extensions {
-                if let ZExtensionStructMut::Compressible(compressible_ext) = extension {
-                    pre_last_claimed_slot = u64::from(compressible_ext.info.last_claimed_slot);
-                    // Check if compression_authority is set (non-zero)
-                    pre_compression_authority =
-                        if compressible_ext.info.compression_authority != [0u8; 32] {
-                            Some(Pubkey::from(compressible_ext.info.compression_authority))
-                        } else {
-                            None
-                        };
-                    // Check if rent_sponsor is set (non-zero)
-                    pre_rent_sponsor = if compressible_ext.info.rent_sponsor != [0u8; 32] {
-                        Some(Pubkey::from(compressible_ext.info.rent_sponsor))
-                    } else {
-                        None
-                    };
-                    let current_slot = rpc.pre_context.as_ref().unwrap().get_sysvar::<Clock>().slot;
-                    let base_lamports = rpc
-                        .get_minimum_balance_for_rent_exemption(
-                            COMPRESSIBLE_TOKEN_ACCOUNT_SIZE as usize,
-                        )
-                        .await
-                        .unwrap();
-                    let lamports_result = compressible_ext.info.claim(
-                        COMPRESSIBLE_TOKEN_ACCOUNT_SIZE,
-                        current_slot,
-                        pre_token_account.lamports,
-                        base_lamports,
-                    );
-                    not_claimed_was_none = lamports_result.is_err();
-                    if let Ok(Some(lamports)) = lamports_result {
-                        expected_lamports_claimed += lamports;
-                    }
-
-                    break;
-                }
-            }
-        } else {
-            panic!("Token account should have compressible extension");
+        // Get account size and lamports before parsing (to avoid borrow conflicts)
+        let account_size = pre_token_account.data.len() as u64;
+        let account_lamports = pre_token_account.lamports;
+        let current_slot = rpc.pre_context.as_ref().unwrap().get_sysvar::<Clock>().slot;
+        let base_lamports = rpc
+            .get_minimum_balance_for_rent_exemption(account_size as usize)
+            .await
+            .unwrap();
+
+        // Extract compression info (handles both CToken and CMint)
+        let pre_data = extract_pre_compression_mut(
+            &mut pre_token_account.data,
+            account_size,
+            current_slot,
+            account_lamports,
+            base_lamports,
+            token_account_pubkey,
+        );
+
+        if let Some(lamports) = pre_data.claimable_lamports {
+            expected_lamports_claimed += lamports;
         }
+
         // Verify rent authority matches
         assert_eq!(
-            pre_compression_authority,
-            Some(compression_authority),
-            "Rent authority should match the one in the extension"
+            pre_data.compression_authority, compression_authority,
+            "Rent authority should match the one in the compression info"
         );
 
         // Verify rent recipient matches pool PDA
         assert_eq!(
-            pre_rent_sponsor,
-            Some(pool_pda),
+            pre_data.rent_sponsor, pool_pda,
             "Rent recipient should match the pool PDA"
         );
+
         // Get post-transaction state
         let post_token_account = rpc
             .get_account(*token_account_pubkey)
             .await
-            .expect("Failed to get post-transaction token account")
-            .expect("Token account should still exist after claim");
-
-        // Parse post-transaction token account data
-        let (post_compressed_token, _) = CToken::zero_copy_at(&post_token_account.data)
-            .expect("Failed to deserialize post-transaction token account");
+            .expect("Failed to get post-transaction account")
+            .expect("Account should still exist after claim");
 
-        // Find and extract post-transaction compressible extension data
-        let mut post_last_claimed_slot = 0u64;
+        // Extract post-transaction compression info
+        let post_last_claimed_slot =
+            extract_post_compression(&post_token_account.data, token_account_pubkey);
 
-        if let Some(extensions) = post_compressed_token.extensions.as_ref() {
-            for extension in extensions {
-                if let ZExtensionStruct::Compressible(compressible_ext) = extension {
-                    post_last_claimed_slot = u64::from(compressible_ext.info.last_claimed_slot);
-                    println!("post_last_claimed_slot {}", post_last_claimed_slot);
-
-                    break;
-                }
-            }
-        } else {
-            panic!("Token account should still have compressible extension after claim");
-        }
-        if !not_claimed_was_none {
+        println!("post_last_claimed_slot {}", post_last_claimed_slot);
+        if !pre_data.claim_failed {
             // Verify last_claimed_slot was updated
             assert!(
-                post_last_claimed_slot > pre_last_claimed_slot,
+                post_last_claimed_slot > pre_data.last_claimed_slot,
                 "last_claimed_slot should be updated to a higher slot {} {}",
                 post_last_claimed_slot,
-                pre_last_claimed_slot
+                pre_data.last_claimed_slot
             );
         } else {
             assert_eq!(
-                post_last_claimed_slot, pre_last_claimed_slot,
+                post_last_claimed_slot, pre_data.last_claimed_slot,
                 "last_claimed_slot should not be updated to a higher slot {} {}",
-                post_last_claimed_slot, pre_last_claimed_slot
+                post_last_claimed_slot, pre_data.last_claimed_slot
             );
         }
     }
diff --git a/program-tests/utils/src/assert_close_token_account.rs b/program-tests/utils/src/assert_close_token_account.rs
index 7bd36b5155..9189813ffc 100644
--- a/program-tests/utils/src/assert_close_token_account.rs
+++ b/program-tests/utils/src/assert_close_token_account.rs
@@ -1,6 +1,6 @@
 use light_client::rpc::Rpc;
 use light_compressible::rent::AccountRentState;
-use light_ctoken_interface::state::{ctoken::CToken, ZExtensionStruct};
+use light_ctoken_interface::state::ctoken::CToken;
 use light_program_test::LightProgramTest;
 use light_zero_copy::traits::ZeroCopyAt;
 use solana_sdk::{pubkey::Pubkey, signer::Signer};
@@ -43,66 +43,21 @@ pub async fn assert_close_token_account(
         .get_pre_transaction_account(&authority_pubkey)
         .map(|acc| acc.lamports)
         .unwrap_or(0);
-    // Verify authority received correct amount (account may not exist if never funded)
-    let final_authority_lamports = rpc
-        .get_account(authority_pubkey)
-        .await
-        .expect("Failed to get authority account")
-        .map(|acc| acc.lamports)
-        .unwrap_or(0);
-    // Validate compressible account closure (we already have the parsed data)
-    // Extract the compressible extension (already parsed above)
-    if let Some(extension) = compressed_token.extensions.as_ref() {
-        assert_compressible_extension(
-            rpc,
-            extension,
-            authority_pubkey,
-            account_data_before_close,
-            account_lamports_before_close,
-            initial_authority_lamports,
-            destination,
-        )
-        .await;
-    } else {
-        // For non-compressible accounts, all lamports go to the destination
-        // Get initial destination balance from pre-transaction context
-        let initial_destination_lamports = rpc
-            .get_pre_transaction_account(&destination)
-            .map(|acc| acc.lamports)
-            .unwrap_or(0);
 
-        // Get final destination balance
-        let final_destination_lamports = rpc
-            .get_account(destination)
-            .await
-            .expect("Failed to get destination account")
-            .expect("Destination account should exist")
-            .lamports;
-
-        assert_eq!(
-            final_destination_lamports,
-            initial_destination_lamports + account_lamports_before_close,
-            "Destination should receive all {} lamports from closed account",
-            account_lamports_before_close
-        );
-
-        // For non-compressible accounts, authority balance check depends on if they're also the destination
-        if authority_pubkey == destination {
-            // Authority is the destination, they receive the lamports
-            assert_eq!(
-                final_authority_lamports,
-                initial_authority_lamports + account_lamports_before_close,
-                "Authority (as destination) should receive all {} lamports for non-compressible account closure",
-                account_lamports_before_close
-            );
-        } else {
-            // Authority is not the destination, shouldn't receive anything
-            assert_eq!(
-                final_authority_lamports, initial_authority_lamports,
-                "Authority (not destination) should not receive any lamports for non-compressible account closure"
-            );
-        }
-    };
+    // Validate compressible account closure using embedded compression info
+    // Check if compression info is present (non-zero compression_authority indicates compressible)
+    let compression = &compressed_token.compression;
+
+    assert_compressible_extension(
+        rpc,
+        compression,
+        authority_pubkey,
+        account_data_before_close,
+        account_lamports_before_close,
+        initial_authority_lamports,
+        destination,
+    )
+    .await;
 }
 
 /// 1. if authority is owner
@@ -113,23 +68,13 @@ pub async fn assert_close_token_account(
 ///     - all funds (rent exemption + remaining) should go to rent recipient
 async fn assert_compressible_extension(
     rpc: &mut LightProgramTest,
-    extension: &[ZExtensionStruct<'_>],
+    compression: &light_compressible::compression_info::ZCompressionInfo<'_>,
     authority_pubkey: Pubkey,
     account_data_before_close: &[u8],
     account_lamports_before_close: u64,
     initial_authority_lamports: u64,
     destination_pubkey: Pubkey,
 ) {
-    let compressible_extension = extension
-        .iter()
-        .find_map(|ext| match ext {
-            light_ctoken_interface::state::extensions::ZExtensionStruct::Compressible(comp) => {
-                Some(comp)
-            }
-            _ => None,
-        })
-        .expect("If a token account has extensions it must be a compressible extension");
-
     // Get initial destination balance from pre-transaction context
     let initial_destination_lamports = rpc
         .get_pre_transaction_account(&destination_pubkey)
@@ -158,20 +103,20 @@ async fn assert_compressible_extension(
     // Get the transaction payer (who pays the tx fee)
     let payer_pubkey = rpc.get_payer().pubkey();
 
-    // Verify compressible extension fields are valid
+    // Verify compression info fields are valid
     let current_slot = rpc.get_slot().await.expect("Failed to get current slot");
     assert!(
-        u64::from(compressible_extension.info.last_claimed_slot) <= current_slot,
+        u64::from(compression.last_claimed_slot) <= current_slot,
         "Last claimed slot ({}) should not be greater than current slot ({})",
-        u64::from(compressible_extension.info.last_claimed_slot),
+        u64::from(compression.last_claimed_slot),
         current_slot
     );
 
     // Verify config_account_version is initialized
     assert!(
-        compressible_extension.info.config_account_version == 1,
+        compression.config_account_version == 1,
         "Config account version should be 1 (initialized), got {}",
-        compressible_extension.info.config_account_version
+        compression.config_account_version
     );
 
     // Calculate expected lamport distribution using the same function as the program
@@ -186,31 +131,21 @@ async fn assert_compressible_extension(
         num_bytes: account_size,
         current_slot,
         current_lamports: account_lamports_before_close,
-        last_claimed_slot: u64::from(compressible_extension.info.last_claimed_slot),
+        last_claimed_slot: u64::from(compression.last_claimed_slot),
     };
 
-    let distribution =
-        state.calculate_close_distribution(&compressible_extension.info.rent_config, base_lamports);
+    let distribution = state.calculate_close_distribution(&compression.rent_config, base_lamports);
     let (mut lamports_to_rent_sponsor, mut lamports_to_destination) =
         (distribution.to_rent_sponsor, distribution.to_user);
 
-    let compression_cost: u64 = compressible_extension
-        .info
-        .rent_config
-        .compression_cost
-        .into();
+    let compression_cost: u64 = compression.rent_config.compression_cost.into();
 
-    // Get the rent recipient from the extension
-    let rent_sponsor = Pubkey::from(compressible_extension.info.rent_sponsor);
+    // Get the rent recipient from the compression info
+    let rent_sponsor = Pubkey::from(compression.rent_sponsor);
 
-    // Check if rent authority is the signer
-    // Check if compression_authority is set (non-zero)
+    // Check if compression_authority is the signer
     let is_compression_authority_signer =
-        if compressible_extension.info.compression_authority != [0u8; 32] {
-            authority_pubkey == Pubkey::from(compressible_extension.info.compression_authority)
-        } else {
-            false
-        };
+        authority_pubkey == Pubkey::from(compression.compression_authority);
 
     // Adjust distribution based on who signed (matching processor logic)
     if is_compression_authority_signer {
diff --git a/program-tests/utils/src/assert_create_token_account.rs b/program-tests/utils/src/assert_create_token_account.rs
index c4bda51a12..c0564bac66 100644
--- a/program-tests/utils/src/assert_create_token_account.rs
+++ b/program-tests/utils/src/assert_create_token_account.rs
@@ -1,18 +1,25 @@
-use anchor_spl::token_2022::spl_token_2022;
 use light_client::rpc::Rpc;
-use light_compressible::rent::RentConfig;
+use light_compressible::{compression_info::CompressionInfo, rent::RentConfig};
 use light_ctoken_interface::{
     state::{
-        ctoken::CToken,
-        extensions::{CompressibleExtension, CompressionInfo},
-        AccountState,
+        ctoken::CToken, AccountState, ExtensionStruct, PausableAccountExtension,
+        PermanentDelegateAccountExtension, TransferFeeAccountExtension,
+        TransferHookAccountExtension, ACCOUNT_TYPE_TOKEN_ACCOUNT,
     },
-    BASE_TOKEN_ACCOUNT_SIZE, COMPRESSIBLE_TOKEN_ACCOUNT_SIZE,
+    BASE_TOKEN_ACCOUNT_SIZE,
 };
 use light_ctoken_sdk::ctoken::derive_ctoken_ata;
 use light_program_test::LightProgramTest;
 use light_zero_copy::traits::ZeroCopyAt;
 use solana_sdk::{program_pack::Pack, pubkey::Pubkey};
+use spl_token_2022::{
+    extension::{
+        default_account_state::DefaultAccountState, permanent_delegate::PermanentDelegate,
+        transfer_fee::TransferFeeConfig, transfer_hook::TransferHook, BaseStateWithExtensions,
+        ExtensionType, StateWithExtensions,
+    },
+    state::Mint,
+};
 
 #[derive(Debug, Clone)]
 pub struct CompressibleData {
@@ -25,11 +32,101 @@ pub struct CompressibleData {
     pub payer: Pubkey,
 }
 
+/// Derive expected Token-2022 extensions, state, and compression_only from the mint account
+/// Returns (decimals, expected_state, expected_extensions, compression_only)
+async fn get_expected_extensions_from_mint(
+    rpc: &mut LightProgramTest,
+    mint_pubkey: Pubkey,
+) -> (Option<u8>, AccountState, Option<Vec<ExtensionStruct>>, bool) {
+    let mint_account = match rpc.get_account(mint_pubkey).await {
+        Ok(Some(account)) => account,
+        _ => {
+            // Mint account doesn't exist or can't be read - use defaults
+            return (None, AccountState::Initialized, None, false);
+        }
+    };
+
+    // Check if this is a Token-2022 mint (program owner)
+    if mint_account.owner != spl_token_2022::ID {
+        // Regular SPL Token mint - no extensions, not compression_only
+        return (None, AccountState::Initialized, None, false);
+    }
+
+    // Parse mint with extensions
+    let mint_state = StateWithExtensions::<Mint>::unpack(&mint_account.data)
+        .expect("Failed to unpack Token-2022 mint");
+
+    let decimals = mint_state.base.decimals;
+
+    // Determine expected account state from DefaultAccountState extension
+    let expected_state = mint_state
+        .get_extension::<DefaultAccountState>()
+        .map(|ext| {
+            let frozen_state: u8 = spl_token_2022::state::AccountState::Frozen.into();
+            if ext.state == frozen_state {
+                AccountState::Frozen
+            } else {
+                AccountState::Initialized
+            }
+        })
+        .unwrap_or(AccountState::Initialized);
+
+    // Build expected extensions based on mint extensions
+    // Use ExtensionType checks for version compatibility
+    let mut extensions = Vec::new();
+
+    // Check for Pausable extension on mint -> PausableAccount on token
+    // Use ExtensionType for compatibility with different spl-token-2022 versions
+    let extension_types = mint_state.get_extension_types().unwrap_or_default();
+
+    if extension_types.contains(&ExtensionType::Pausable) {
+        extensions.push(ExtensionStruct::PausableAccount(PausableAccountExtension));
+    }
+
+    // Check for PermanentDelegate extension on mint -> PermanentDelegateAccount on token
+    if mint_state.get_extension::<PermanentDelegate>().is_ok() {
+        extensions.push(ExtensionStruct::PermanentDelegateAccount(
+            PermanentDelegateAccountExtension,
+        ));
+    }
+
+    // Check for TransferFee extension on mint -> TransferFeeAccount on token
+    if mint_state.get_extension::<TransferFeeConfig>().is_ok() {
+        extensions.push(ExtensionStruct::TransferFeeAccount(
+            TransferFeeAccountExtension { withheld_amount: 0 },
+        ));
+    }
+
+    // Check for TransferHook extension on mint -> TransferHookAccount on token
+    if mint_state.get_extension::<TransferHook>().is_ok() {
+        extensions.push(ExtensionStruct::TransferHookAccount(
+            TransferHookAccountExtension { transferring: 0 },
+        ));
+    }
+
+    // compression_only is true if the mint has any extensions that require it
+    let compression_only = !extensions.is_empty();
+
+    let expected_extensions = if extensions.is_empty() {
+        None
+    } else {
+        Some(extensions)
+    };
+
+    (
+        Some(decimals),
+        expected_state,
+        expected_extensions,
+        compression_only,
+    )
+}
+
 /// Assert that a token account was created correctly.
 /// If compressible_data is provided, validates compressible token account with extensions.
 /// If compressible_data is None, validates basic SPL token account.
 /// If is_ata is true, expects 1 signer (payer only), otherwise expects 2 signers (token_account_keypair + payer).
 /// Automatically detects idempotent mode by checking if account existed before transaction.
+/// If expected_extensions is provided, uses those; otherwise reads mint account to derive expected Token-2022 extensions.
 pub async fn assert_create_token_account_internal(
     rpc: &mut LightProgramTest,
     token_account_pubkey: Pubkey,
@@ -37,6 +134,7 @@ pub async fn assert_create_token_account_internal(
     owner_pubkey: Pubkey,
     compressible_data: Option<CompressibleData>,
     is_ata: bool,
+    expected_extensions: Option<Vec<ExtensionStruct>>,
 ) {
     // Get the token account data
     let account_info = rpc
@@ -53,19 +151,16 @@ pub async fn assert_create_token_account_internal(
     match compressible_data {
         Some(compressible_info) => {
             // Validate compressible token account
-            assert_eq!(
-                account_info.data.len(),
-                COMPRESSIBLE_TOKEN_ACCOUNT_SIZE as usize
-            );
+            let account_size = account_info.data.len();
 
             // Calculate expected lamports balance
             let rent_exemption = rpc
-                .get_minimum_balance_for_rent_exemption(COMPRESSIBLE_TOKEN_ACCOUNT_SIZE as usize)
+                .get_minimum_balance_for_rent_exemption(account_size)
                 .await
                 .expect("Failed to get rent exemption");
 
             let rent_with_compression = RentConfig::default().get_rent_with_compression_cost(
-                COMPRESSIBLE_TOKEN_ACCOUNT_SIZE,
+                account_size as u64,
                 compressible_info.num_prepaid_epochs as u64,
             );
             let expected_lamports = rent_exemption + rent_with_compression;
@@ -83,37 +178,47 @@ pub async fn assert_create_token_account_internal(
             // Get current slot for validation (program sets this to current slot)
             let current_slot = rpc.get_slot().await.expect("Failed to get current slot");
 
-            // Create expected compressible token account
+            // Get expected extensions from mint account or use provided extensions
+            let (decimals, expected_state, final_extensions, compression_only) =
+                if let Some(provided_extensions) = expected_extensions {
+                    // Use provided extensions - derive decimals and state from mint
+                    let (decimals, expected_state, _, _) =
+                        get_expected_extensions_from_mint(rpc, mint_pubkey).await;
+                    let compression_only = !provided_extensions.is_empty();
+                    (
+                        decimals,
+                        expected_state,
+                        Some(provided_extensions),
+                        compression_only,
+                    )
+                } else {
+                    get_expected_extensions_from_mint(rpc, mint_pubkey).await
+                };
+
+            // Create expected compressible token account with embedded compression info
             let expected_token_account = CToken {
                 mint: mint_pubkey.into(),
                 owner: owner_pubkey.into(),
                 amount: 0,
                 delegate: None,
-                state: AccountState::Initialized, // Initialized
+                state: expected_state,
                 is_native: None,
                 delegated_amount: 0,
                 close_authority: None,
-                extensions: Some(vec![
-                    light_ctoken_interface::state::extensions::ExtensionStruct::Compressible(
-                        CompressibleExtension {
-                            compression_only: false,
-                            info: CompressionInfo {
-                                config_account_version: 1,
-                                last_claimed_slot: current_slot,
-                                rent_config: RentConfig::default(),
-                                lamports_per_write: compressible_info
-                                    .lamports_per_write
-                                    .unwrap_or(0),
-                                compression_authority: compressible_info
-                                    .compression_authority
-                                    .to_bytes(),
-                                rent_sponsor: compressible_info.rent_sponsor.to_bytes(),
-                                compress_to_pubkey: compressible_info.compress_to_pubkey as u8,
-                                account_version: compressible_info.account_version as u8,
-                            },
-                        },
-                    ),
-                ]),
+                account_type: ACCOUNT_TYPE_TOKEN_ACCOUNT,
+                decimals,
+                compression_only,
+                compression: CompressionInfo {
+                    config_account_version: 1,
+                    last_claimed_slot: current_slot,
+                    rent_config: RentConfig::default(),
+                    lamports_per_write: compressible_info.lamports_per_write.unwrap_or(0),
+                    compression_authority: compressible_info.compression_authority.to_bytes(),
+                    rent_sponsor: compressible_info.rent_sponsor.to_bytes(),
+                    compress_to_pubkey: compressible_info.compress_to_pubkey as u8,
+                    account_version: compressible_info.account_version as u8,
+                },
+                extensions: final_extensions,
             };
 
             assert_eq!(actual_token_account, expected_token_account);
@@ -214,11 +319,11 @@ pub async fn assert_create_token_account_internal(
         }
         None => {
             // Validate basic SPL token account
-            assert_eq!(account_info.data.len(), 165); // SPL token account size
+            assert_eq!(account_info.data.len(), BASE_TOKEN_ACCOUNT_SIZE as usize); // SPL token account size
 
             // Use SPL token Pack trait for basic account
             let actual_spl_token_account =
-                spl_token_2022::state::Account::unpack(&account_info.data)
+                spl_token_2022::state::Account::unpack(&account_info.data[..165])
                     .expect("Failed to unpack basic token account data");
 
             // Create expected SPL token account
@@ -252,12 +357,14 @@ pub async fn assert_create_token_account_internal(
 
 /// Assert that a regular token account was created correctly.
 /// Public wrapper for non-ATA token accounts (expects 2 signers).
+/// If expected_extensions is provided, uses those; otherwise derives from mint.
 pub async fn assert_create_token_account(
     rpc: &mut LightProgramTest,
     token_account_pubkey: Pubkey,
     mint_pubkey: Pubkey,
     owner_pubkey: Pubkey,
     compressible_data: Option<CompressibleData>,
+    expected_extensions: Option<Vec<ExtensionStruct>>,
 ) {
     assert_create_token_account_internal(
         rpc,
@@ -266,6 +373,7 @@ pub async fn assert_create_token_account(
         owner_pubkey,
         compressible_data,
         false, // Not an ATA
+        expected_extensions,
     )
     .await;
 }
@@ -274,11 +382,13 @@ pub async fn assert_create_token_account(
 /// Automatically derives the ATA address from owner and mint.
 /// If compressible_data is provided, validates compressible ATA with extensions.
 /// If compressible_data is None, validates basic SPL ATA.
+/// If expected_extensions is provided, uses those; otherwise derives from mint.
 pub async fn assert_create_associated_token_account(
     rpc: &mut LightProgramTest,
     owner_pubkey: Pubkey,
     mint_pubkey: Pubkey,
     compressible_data: Option<CompressibleData>,
+    expected_extensions: Option<Vec<ExtensionStruct>>,
 ) {
     // Derive the associated token account address
     let (ata_pubkey, _bump) = derive_ctoken_ata(&owner_pubkey, &mint_pubkey);
@@ -305,6 +415,7 @@ pub async fn assert_create_associated_token_account(
         owner_pubkey,
         compressible_data,
         true, // Is an ATA
+        expected_extensions,
     )
     .await;
 }
diff --git a/program-tests/utils/src/assert_ctoken_approve_revoke.rs b/program-tests/utils/src/assert_ctoken_approve_revoke.rs
new file mode 100644
index 0000000000..5791215849
--- /dev/null
+++ b/program-tests/utils/src/assert_ctoken_approve_revoke.rs
@@ -0,0 +1,99 @@
+//! Assertion helpers for CToken approve and revoke operations.
+//!
+//! These functions verify that approve/revoke operations correctly modify
+//! only the delegate and delegated_amount fields while preserving all other
+//! account state including compression info and extensions.
+
+use anchor_lang::AnchorDeserialize;
+use light_client::rpc::Rpc;
+use light_ctoken_interface::state::CToken;
+use light_program_test::LightProgramTest;
+use solana_sdk::pubkey::Pubkey;
+
+/// Assert that a CToken approve operation was successful.
+///
+/// Pattern: Get pre-state, build expected by modifying only changed fields,
+/// single assert_eq against post-state.
+///
+/// # Arguments
+/// * `rpc` - RPC client (must be LightProgramTest for pre-transaction cache)
+/// * `token_account` - The token account that was approved
+/// * `delegate` - The delegate pubkey that was approved
+/// * `amount` - The amount that was approved
+pub async fn assert_ctoken_approve(
+    rpc: &mut LightProgramTest,
+    token_account: Pubkey,
+    delegate: Pubkey,
+    amount: u64,
+) {
+    // Get pre-transaction state from cache
+    let pre_account = rpc
+        .get_pre_transaction_account(&token_account)
+        .expect("Token account should exist in pre-transaction context");
+
+    // Get post-transaction state
+    let post_account = rpc
+        .get_account(token_account)
+        .await
+        .expect("Failed to get account after transaction")
+        .expect("Token account should exist after transaction");
+
+    // Parse pre and post CToken states
+    let pre_ctoken =
+        CToken::deserialize(&mut &pre_account.data[..]).expect("Failed to deserialize pre CToken");
+    let post_ctoken = CToken::deserialize(&mut &post_account.data[..])
+        .expect("Failed to deserialize post CToken");
+
+    // Build expected by modifying only the changed fields from pre-state
+    let expected_ctoken = CToken {
+        delegate: Some(delegate.to_bytes().into()),
+        delegated_amount: amount,
+        ..pre_ctoken
+    };
+
+    assert_eq!(
+        post_ctoken, expected_ctoken,
+        "CToken after approve should have delegate={} and delegated_amount={}, all other fields unchanged",
+        delegate, amount
+    );
+}
+
+/// Assert that a CToken revoke operation was successful.
+///
+/// Pattern: Get pre-state, build expected by modifying only changed fields,
+/// single assert_eq against post-state.
+///
+/// # Arguments
+/// * `rpc` - RPC client (must be LightProgramTest for pre-transaction cache)
+/// * `token_account` - The token account that was revoked
+pub async fn assert_ctoken_revoke(rpc: &mut LightProgramTest, token_account: Pubkey) {
+    // Get pre-transaction state from cache
+    let pre_account = rpc
+        .get_pre_transaction_account(&token_account)
+        .expect("Token account should exist in pre-transaction context");
+
+    // Get post-transaction state
+    let post_account = rpc
+        .get_account(token_account)
+        .await
+        .expect("Failed to get account after transaction")
+        .expect("Token account should exist after transaction");
+
+    // Parse pre and post CToken states
+    let pre_ctoken =
+        CToken::deserialize(&mut &pre_account.data[..]).expect("Failed to deserialize pre CToken");
+    let post_ctoken = CToken::deserialize(&mut &post_account.data[..])
+        .expect("Failed to deserialize post CToken");
+
+    // Build expected by modifying only the changed fields from pre-state
+    let expected_ctoken = CToken {
+        delegate: None,
+        delegated_amount: 0,
+        ..pre_ctoken
+    };
+
+    assert_eq!(
+        post_ctoken, expected_ctoken,
+        "CToken after revoke should have delegate=None and delegated_amount=0, all other fields unchanged"
+    );
+}
diff --git a/program-tests/utils/src/assert_ctoken_burn.rs b/program-tests/utils/src/assert_ctoken_burn.rs
index de750e9700..8de49e4577 100644
--- a/program-tests/utils/src/assert_ctoken_burn.rs
+++ b/program-tests/utils/src/assert_ctoken_burn.rs
@@ -1,6 +1,6 @@
 use anchor_lang::prelude::borsh::BorshDeserialize;
 use light_client::rpc::Rpc;
-use light_ctoken_interface::state::{extensions::ExtensionStruct, CToken, CompressedMint};
+use light_ctoken_interface::state::{CToken, CompressedMint};
 use light_program_test::LightProgramTest;
 use solana_sdk::pubkey::Pubkey;
 
@@ -85,7 +85,7 @@ pub async fn assert_ctoken_burn(
 
     let expected_ctoken_lamport_change = calculate_expected_lamport_change(
         rpc,
-        &ctoken_parsed_before.extensions,
+        &ctoken_parsed_before.compression,
         ctoken_before.data.len(),
         current_slot,
         ctoken_before.lamports,
@@ -94,7 +94,7 @@ pub async fn assert_ctoken_burn(
 
     let expected_cmint_lamport_change = calculate_expected_lamport_change(
         rpc,
-        &cmint_parsed_before.extensions,
+        &cmint_parsed_before.compression,
         cmint_before.data.len(),
         current_slot,
         cmint_before.lamports,
@@ -117,35 +117,21 @@ pub async fn assert_ctoken_burn(
 
 async fn calculate_expected_lamport_change(
     rpc: &mut LightProgramTest,
-    extensions: &Option<Vec<ExtensionStruct>>,
+    compression: &light_compressible::compression_info::CompressionInfo,
     data_len: usize,
     current_slot: u64,
     current_lamports: u64,
 ) -> u64 {
-    if let Some(exts) = extensions {
-        let compressible = exts.iter().find_map(|ext| {
-            if let ExtensionStruct::Compressible(comp) = ext {
-                Some(comp)
-            } else {
-                None
-            }
-        });
-
-        if let Some(comp) = compressible {
-            let rent_exemption = rpc
-                .get_minimum_balance_for_rent_exemption(data_len)
-                .await
-                .unwrap();
-            return comp
-                .info
-                .calculate_top_up_lamports(
-                    data_len as u64,
-                    current_slot,
-                    current_lamports,
-                    rent_exemption,
-                )
-                .unwrap();
-        }
-    }
-    0
+    let rent_exemption = rpc
+        .get_minimum_balance_for_rent_exemption(data_len)
+        .await
+        .unwrap();
+    compression
+        .calculate_top_up_lamports(
+            data_len as u64,
+            current_slot,
+            current_lamports,
+            rent_exemption,
+        )
+        .unwrap()
 }
diff --git a/program-tests/utils/src/assert_ctoken_freeze_thaw.rs b/program-tests/utils/src/assert_ctoken_freeze_thaw.rs
new file mode 100644
index 0000000000..016bb30436
--- /dev/null
+++ b/program-tests/utils/src/assert_ctoken_freeze_thaw.rs
@@ -0,0 +1,89 @@
+//! Assertion helpers for CToken freeze and thaw operations.
+//!
+//! These functions verify that freeze/thaw operations correctly modify
+//! only the state field while preserving all other account state including
+//! compression info and extensions.
+
+use anchor_lang::AnchorDeserialize;
+use light_client::rpc::Rpc;
+use light_ctoken_interface::state::{AccountState, CToken};
+use light_program_test::LightProgramTest;
+use solana_sdk::pubkey::Pubkey;
+
+/// Assert that a CToken freeze operation was successful.
+///
+/// Pattern: Get pre-state, build expected by modifying only changed fields,
+/// single assert_eq against post-state.
+///
+/// # Arguments
+/// * `rpc` - RPC client (must be LightProgramTest for pre-transaction cache)
+/// * `token_account` - The token account that was frozen
+pub async fn assert_ctoken_freeze(rpc: &mut LightProgramTest, token_account: Pubkey) {
+    // Get pre-transaction state from cache
+    let pre_account = rpc
+        .get_pre_transaction_account(&token_account)
+        .expect("Token account should exist in pre-transaction context");
+
+    // Get post-transaction state
+    let post_account = rpc
+        .get_account(token_account)
+        .await
+        .expect("Failed to get account after transaction")
+        .expect("Token account should exist after transaction");
+
+    // Parse pre and post CToken states
+    let pre_ctoken =
+        CToken::deserialize(&mut &pre_account.data[..]).expect("Failed to deserialize pre CToken");
+    let post_ctoken = CToken::deserialize(&mut &post_account.data[..])
+        .expect("Failed to deserialize post CToken");
+
+    // Build expected by modifying only the changed fields from pre-state
+    let expected_ctoken = CToken {
+        state: AccountState::Frozen,
+        ..pre_ctoken
+    };
+
+    assert_eq!(
+        post_ctoken, expected_ctoken,
+        "CToken after freeze should have state=Frozen, all other fields unchanged"
+    );
+}
+
+/// Assert that a CToken thaw operation was successful.
+///
+/// Pattern: Get pre-state, build expected by modifying only changed fields,
+/// single assert_eq against post-state.
+///
+/// # Arguments
+/// * `rpc` - RPC client (must be LightProgramTest for pre-transaction cache)
+/// * `token_account` - The token account that was thawed
+pub async fn assert_ctoken_thaw(rpc: &mut LightProgramTest, token_account: Pubkey) {
+    // Get pre-transaction state from cache
+    let pre_account = rpc
+        .get_pre_transaction_account(&token_account)
+        .expect("Token account should exist in pre-transaction context");
+
+    // Get post-transaction state
+    let post_account = rpc
+        .get_account(token_account)
+        .await
+        .expect("Failed to get account after transaction")
+        .expect("Token account should exist after transaction");
+
+    // Parse pre and post CToken states
+    let pre_ctoken =
+        CToken::deserialize(&mut &pre_account.data[..]).expect("Failed to deserialize pre CToken");
+    let post_ctoken = CToken::deserialize(&mut &post_account.data[..])
+        .expect("Failed to deserialize post CToken");
+
+    // Build expected by modifying only the changed fields from pre-state
+    let expected_ctoken = CToken {
+        state: AccountState::Initialized,
+        ..pre_ctoken
+    };
+
+    assert_eq!(
+        post_ctoken, expected_ctoken,
+        "CToken after thaw should have state=Initialized, all other fields unchanged"
+    );
+}
diff --git a/program-tests/utils/src/assert_ctoken_mint_to.rs b/program-tests/utils/src/assert_ctoken_mint_to.rs
index 5ba9c3eb68..c399eef352 100644
--- a/program-tests/utils/src/assert_ctoken_mint_to.rs
+++ b/program-tests/utils/src/assert_ctoken_mint_to.rs
@@ -1,6 +1,6 @@
 use anchor_lang::prelude::borsh::BorshDeserialize;
 use light_client::rpc::Rpc;
-use light_ctoken_interface::state::{extensions::ExtensionStruct, CToken, CompressedMint};
+use light_ctoken_interface::state::{CToken, CompressedMint};
 use light_program_test::LightProgramTest;
 use solana_sdk::pubkey::Pubkey;
 
@@ -85,7 +85,7 @@ pub async fn assert_ctoken_mint_to(
 
     let expected_ctoken_lamport_change = calculate_expected_lamport_change(
         rpc,
-        &ctoken_parsed_before.extensions,
+        &ctoken_parsed_before.compression,
         ctoken_before.data.len(),
         current_slot,
         ctoken_before.lamports,
@@ -94,7 +94,7 @@ pub async fn assert_ctoken_mint_to(
 
     let expected_cmint_lamport_change = calculate_expected_lamport_change(
         rpc,
-        &cmint_parsed_before.extensions,
+        &cmint_parsed_before.compression,
         cmint_before.data.len(),
         current_slot,
         cmint_before.lamports,
@@ -117,35 +117,21 @@ pub async fn assert_ctoken_mint_to(
 
 async fn calculate_expected_lamport_change(
     rpc: &mut LightProgramTest,
-    extensions: &Option<Vec<ExtensionStruct>>,
+    compression: &light_compressible::compression_info::CompressionInfo,
     data_len: usize,
     current_slot: u64,
     current_lamports: u64,
 ) -> u64 {
-    if let Some(exts) = extensions {
-        let compressible = exts.iter().find_map(|ext| {
-            if let ExtensionStruct::Compressible(comp) = ext {
-                Some(comp)
-            } else {
-                None
-            }
-        });
-
-        if let Some(comp) = compressible {
-            let rent_exemption = rpc
-                .get_minimum_balance_for_rent_exemption(data_len)
-                .await
-                .unwrap();
-            return comp
-                .info
-                .calculate_top_up_lamports(
-                    data_len as u64,
-                    current_slot,
-                    current_lamports,
-                    rent_exemption,
-                )
-                .unwrap();
-        }
-    }
-    0
+    let rent_exemption = rpc
+        .get_minimum_balance_for_rent_exemption(data_len)
+        .await
+        .unwrap();
+    compression
+        .calculate_top_up_lamports(
+            data_len as u64,
+            current_slot,
+            current_lamports,
+            rent_exemption,
+        )
+        .unwrap()
 }
diff --git a/program-tests/utils/src/assert_ctoken_transfer.rs b/program-tests/utils/src/assert_ctoken_transfer.rs
index d0eb050681..47e4a40e28 100644
--- a/program-tests/utils/src/assert_ctoken_transfer.rs
+++ b/program-tests/utils/src/assert_ctoken_transfer.rs
@@ -11,7 +11,6 @@ pub async fn assert_compressible_for_account(
     name: &str,
     account_pubkey: Pubkey,
 ) {
-    println!("account_pubkey {:?}", account_pubkey);
     // Get pre-transaction state from cache
     let pre_account = rpc
         .get_pre_transaction_account(&account_pubkey)
@@ -30,17 +29,12 @@ pub async fn assert_compressible_for_account(
     let data_after = post_account.data.as_slice();
     let lamports_after = post_account.lamports;
 
-    // Get current slot
-    let current_slot = rpc.get_slot().await.unwrap();
-
-    println!("{} current_slot", current_slot);
     // Parse tokens
     let token_before = if data_before.len() > 165 {
         CToken::zero_copy_at(data_before).ok()
     } else {
         None
     };
-    println!("{:?} token_before", token_before);
 
     let token_after = if data_after.len() > 165 {
         CToken::zero_copy_at(data_after).ok()
@@ -49,86 +43,60 @@ pub async fn assert_compressible_for_account(
     };
 
     if let (Some((token_before, _)), Some((token_after, _))) = (&token_before, &token_after) {
-        if let Some(extensions_before) = &token_before.extensions {
-            if let Some(compressible_before) = extensions_before.iter().find_map(|ext| {
-                if let light_ctoken_interface::state::ZExtensionStruct::Compressible(comp) = ext {
-                    Some(comp)
-                } else {
-                    None
-                }
-            }) {
-                let compressible_after = token_after
-                    .extensions
-                    .as_ref()
-                    .and_then(|extensions| {
-                        extensions.iter().find_map(|ext| {
-                            if let light_ctoken_interface::state::ZExtensionStruct::Compressible(
-                                comp,
-                            ) = ext
-                            {
-                                Some(comp)
-                            } else {
-                                None
-                            }
-                        })
-                    })
-                    .unwrap_or_else(|| {
-                        panic!("{} should have compressible extension after transfer", name)
-                    });
-
-                assert_eq!(
-                    u64::from(compressible_after.info.last_claimed_slot),
-                    u64::from(compressible_before.info.last_claimed_slot),
-                    "{} last_claimed_slot should be different from current slot before transfer",
-                    name
-                );
-
-                assert_eq!(
-                    compressible_before.info.compression_authority,
-                    compressible_after.info.compression_authority,
-                    "{} compression_authority should not change",
-                    name
-                );
-                assert_eq!(
-                    compressible_before.info.rent_sponsor, compressible_after.info.rent_sponsor,
-                    "{} rent_sponsor should not change",
-                    name
-                );
-                assert_eq!(
-                    compressible_before.info.config_account_version,
-                    compressible_after.info.config_account_version,
-                    "{} config_account_version should not change",
-                    name
-                );
-                let current_slot = rpc.get_slot().await.unwrap();
-                let top_up = compressible_before
-                    .info
-                    .calculate_top_up_lamports(
-                        light_ctoken_interface::COMPRESSIBLE_TOKEN_ACCOUNT_SIZE,
-                        current_slot,
-                        lamports_before,
-                        light_ctoken_interface::COMPRESSIBLE_TOKEN_RENT_EXEMPTION,
-                    )
-                    .unwrap();
-                // Check if top-up was applied
-                if top_up != 0 {
-                    assert_eq!(
-                        lamports_before + top_up,
-                        lamports_after,
-                        "{} account should be topped up by {} lamports",
-                        name,
-                        top_up
-                    );
-                } else {
-                    assert_eq!(
-                        lamports_before, lamports_after,
-                        "{} account should not be topped up",
-                        name
-                    );
-                }
-                println!("{:?} compressible_before", compressible_before);
-                println!("{:?} compressible_after", compressible_after);
-            }
+        // Get compression info from compression
+        let compression_before = &token_before.compression;
+        let compression_after = &token_after.compression;
+
+        assert_eq!(
+            u64::from(compression_after.last_claimed_slot),
+            u64::from(compression_before.last_claimed_slot),
+            "{} last_claimed_slot should be different from current slot before transfer",
+            name
+        );
+
+        assert_eq!(
+            compression_before.compression_authority, compression_after.compression_authority,
+            "{} compression_authority should not change",
+            name
+        );
+        assert_eq!(
+            compression_before.rent_sponsor, compression_after.rent_sponsor,
+            "{} rent_sponsor should not change",
+            name
+        );
+        assert_eq!(
+            compression_before.config_account_version, compression_after.config_account_version,
+            "{} config_account_version should not change",
+            name
+        );
+        let current_slot = rpc.get_slot().await.unwrap();
+        let rent_exemption = rpc
+            .get_minimum_balance_for_rent_exemption(data_before.len())
+            .await
+            .unwrap();
+        let top_up = compression_before
+            .calculate_top_up_lamports(
+                data_before.len() as u64,
+                current_slot,
+                lamports_before,
+                rent_exemption,
+            )
+            .unwrap();
+        // Check if top-up was applied
+        if top_up != 0 {
+            assert_eq!(
+                lamports_before + top_up,
+                lamports_after,
+                "{} account should be topped up by {} lamports",
+                name,
+                top_up
+            );
+        } else {
+            assert_eq!(
+                lamports_before, lamports_after,
+                "{} account should not be topped up",
+                name
+            );
         }
     }
 }
diff --git a/program-tests/utils/src/assert_mint_action.rs b/program-tests/utils/src/assert_mint_action.rs
index 348536fc4a..e24cc86ded 100644
--- a/program-tests/utils/src/assert_mint_action.rs
+++ b/program-tests/utils/src/assert_mint_action.rs
@@ -4,8 +4,7 @@ use anchor_lang::prelude::borsh::BorshDeserialize;
 use light_client::indexer::Indexer;
 use light_compressed_account::compressed_account::CompressedAccountData;
 use light_ctoken_interface::state::{
-    extensions::{AdditionalMetadata, ExtensionStruct},
-    CToken, CompressedMint,
+    extensions::AdditionalMetadata, CToken, CompressedMint, ExtensionStruct,
 };
 use light_program_test::{LightProgramTest, Rpc};
 use light_token_client::instructions::mint_action::MintActionType;
@@ -115,13 +114,9 @@ pub async fn assert_mint_action(
             }
             MintActionType::CompressAndCloseCMint { .. } => {
                 expected_mint.metadata.cmint_decompressed = false;
-                // Remove Compressible extension
-                if let Some(ref mut extensions) = expected_mint.extensions {
-                    extensions.retain(|e| !matches!(e, ExtensionStruct::Compressible(_)));
-                    if extensions.is_empty() {
-                        expected_mint.extensions = None;
-                    }
-                }
+                // When compressed, the compression info should be default (zeroed)
+                expected_mint.compression =
+                    light_compressible::compression_info::CompressionInfo::default();
             }
         }
     }
@@ -158,16 +153,11 @@ pub async fn assert_mint_action(
             "CMint metadata should match expected mint metadata"
         );
 
-        // CMint should have Compressible extension
-        assert!(
-            cmint
-                .extensions
-                .as_ref()
-                .map(|exts| exts
-                    .iter()
-                    .any(|e| matches!(e, ExtensionStruct::Compressible(_))))
-                .unwrap_or(false),
-            "CMint should have Compressible extension when decompressed"
+        // CMint compression info should be set (non-default) when decompressed
+        assert_ne!(
+            cmint.compression,
+            light_compressible::compression_info::CompressionInfo::default(),
+            "CMint compression info should be set when decompressed"
         );
 
         // Compressed account should have zero sentinel values
@@ -206,16 +196,12 @@ pub async fn assert_mint_action(
             "Compressed mint state after mint_action should match expected"
         );
 
-        // Compressed mint should NEVER have Compressible extension
-        // (Compressible only lives in CMint Solana account, not in compressed account)
-        if let Some(ref extensions) = actual_mint.extensions {
-            assert!(
-                !extensions
-                    .iter()
-                    .any(|e| matches!(e, ExtensionStruct::Compressible(_))),
-                "Compressed mint should NEVER have Compressible extension"
-            );
-        }
+        // Compressed mint compression info should be default (not set)
+        assert_eq!(
+            actual_mint.compression,
+            light_compressible::compression_info::CompressionInfo::default(),
+            "Compressed mint compression info should be default when compressed"
+        );
     }
 
     // If CompressAndCloseCMint, verify CMint Solana account is closed
@@ -265,61 +251,32 @@ pub async fn assert_mint_action(
         let pre_lamports = pre_account.lamports;
         let post_lamports = account_data.lamports;
 
-        // Check if account has compressible extension (reuse pre_ctoken parsed earlier)
-        if let Some(extensions) = pre_ctoken.extensions.as_ref() {
-            // Look for compressible extension
-            let compressible_ext = extensions.iter().find_map(|ext| {
-                if let ExtensionStruct::Compressible(comp) = ext {
-                    Some(comp)
-                } else {
-                    None
-                }
-            });
-
-            if let Some(compressible) = compressible_ext {
-                // Account has compressible extension - calculate expected top-up
-                let current_slot = rpc.get_slot().await.unwrap();
-                let account_size = pre_account.data.len() as u64;
+        // Calculate expected top-up using embedded compression info
+        let current_slot = rpc.get_slot().await.unwrap();
+        let account_size = pre_account.data.len() as u64;
+        let rent_exemption = rpc
+            .get_minimum_balance_for_rent_exemption(pre_account.data.len())
+            .await
+            .unwrap();
 
-                let expected_top_up = compressible
-                    .info
-                    .calculate_top_up_lamports(
-                        account_size,
-                        current_slot,
-                        pre_lamports,
-                        light_ctoken_interface::COMPRESSIBLE_TOKEN_RENT_EXEMPTION,
-                    )
-                    .unwrap();
+        let expected_top_up = pre_ctoken
+            .compression
+            .calculate_top_up_lamports(account_size, current_slot, pre_lamports, rent_exemption)
+            .unwrap();
 
-                let actual_lamport_change = post_lamports
-                    .checked_sub(pre_lamports)
-                    .expect("Post lamports should be >= pre lamports");
+        let actual_lamport_change = post_lamports
+            .checked_sub(pre_lamports)
+            .expect("Post lamports should be >= pre lamports");
 
-                assert_eq!(
-                    actual_lamport_change, expected_top_up,
-                    "CToken account at {} should receive {} lamports top-up for compressible extension, got {}",
-                    account_pubkey, expected_top_up, actual_lamport_change
-                );
+        assert_eq!(
+            actual_lamport_change, expected_top_up,
+            "CToken account at {} should receive {} lamports top-up, got {}",
+            account_pubkey, expected_top_up, actual_lamport_change
+        );
 
-                println!(
-                        "✓ Lamport top-up validated: {} lamports transferred to compressible ctoken account {}",
-                        expected_top_up, account_pubkey
-                    );
-            } else {
-                // Has extensions but no compressible extension - lamports should not change
-                assert_eq!(
-                    pre_lamports, post_lamports,
-                    "Non-compressible CToken account at {} should not receive lamport top-up",
-                    account_pubkey
-                );
-            }
-        } else {
-            // No extensions - lamports should not change
-            assert_eq!(
-                pre_lamports, post_lamports,
-                "CToken account without extensions at {} should not receive lamport top-up",
-                account_pubkey
-            );
-        }
+        println!(
+            "✓ Lamport top-up validated: {} lamports transferred to compressible ctoken account {}",
+            expected_top_up, account_pubkey
+        );
     }
 }
diff --git a/program-tests/utils/src/assert_transfer2.rs b/program-tests/utils/src/assert_transfer2.rs
index 2e1d4456eb..0c1783bd4c 100644
--- a/program-tests/utils/src/assert_transfer2.rs
+++ b/program-tests/utils/src/assert_transfer2.rs
@@ -2,7 +2,7 @@ use std::collections::HashMap;
 
 use anchor_spl::token_2022::spl_token_2022;
 use light_client::{indexer::Indexer, rpc::Rpc};
-use light_ctoken_interface::CTOKEN_PROGRAM_ID;
+use light_ctoken_interface::{BASE_TOKEN_ACCOUNT_SIZE, CTOKEN_PROGRAM_ID};
 use light_program_test::LightProgramTest;
 use light_token_client::instructions::transfer2::{
     CompressInput, DecompressInput, Transfer2InstructionType, TransferInput,
@@ -55,7 +55,8 @@ pub async fn assert_transfer2_with_delegate(
                         .get_pre_transaction_account(&pubkey)
                         .expect("SPL token account should exist in pre-transaction context");
 
-                    spl_token_2022::state::Account::unpack(&pre_account_data.data)
+                    // CToken accounts are 166 bytes, SPL token expects 165 bytes
+                    spl_token_2022::state::Account::unpack(&pre_account_data.data[..165])
                         .expect("Failed to unpack SPL token account")
                 });
 
@@ -385,28 +386,16 @@ pub async fn assert_transfer2_with_delegate(
                 let pre_token_account = SplTokenAccount::unpack(&pre_account_data.data[..165])
                     .expect("Failed to unpack SPL token account");
 
-                // Check if compress_to_pubkey is set in the compressible extension
-                use light_ctoken_interface::state::{ctoken::CToken, ZExtensionStruct};
+                // Check if compress_to_pubkey is set in the compression info
+                use light_ctoken_interface::state::ctoken::CToken;
                 use light_zero_copy::traits::ZeroCopyAt;
 
                 let compress_to_pubkey = if pre_account_data.data.len() > 165 {
-                    // Has extensions, check for compressible extension
+                    // Parse ctoken account and get compress_to_pubkey from embedded compression info
                     let (ctoken, _) = CToken::zero_copy_at(&pre_account_data.data)
                         .expect("Failed to deserialize ctoken account");
 
-                    if let Some(extensions) = ctoken.extensions.as_ref() {
-                        extensions
-                            .iter()
-                            .find_map(|ext| match ext {
-                                ZExtensionStruct::Compressible(comp) => {
-                                    Some(comp.info.compress_to_pubkey == 1)
-                                }
-                                _ => None,
-                            })
-                            .unwrap_or(false)
-                    } else {
-                        false
-                    }
+                    ctoken.compression.compress_to_pubkey == 1
                 } else {
                     false
                 };
@@ -455,39 +444,61 @@ pub async fn assert_transfer2_with_delegate(
 
                 let compressed_account = mint_accounts[0];
 
-                // Verify the compressed account has the correct data
-                assert_eq!(
-                    compressed_account.token.amount, expected_amount,
-                    "CompressAndClose compressed amount should match original balance"
-                );
+                // Determine expected state - frozen state should be preserved
+                let is_frozen =
+                    pre_token_account.state == spl_token_2022::state::AccountState::Frozen;
+                let expected_state = if is_frozen {
+                    light_ctoken_sdk::compat::AccountState::Frozen
+                } else {
+                    light_ctoken_sdk::compat::AccountState::Initialized
+                };
+
+                // Delegate is preserved from the original account
+                use spl_token_2022::solana_program::program_option::COption;
+                let expected_delegate: Option<Pubkey> = match pre_token_account.delegate {
+                    COption::Some(d) => Some(d),
+                    COption::None => None,
+                };
+
+                // Build expected TLV based on account state
+                // TLV contains CompressedOnly extension when:
+                // - Account is frozen (is_frozen=true)
+                // - Account has delegate set (even if delegated_amount=0)
+                // - Account has extensions beyond base (size > BASE_TOKEN_ACCOUNT_SIZE)
+                // - Account has withheld_transfer_fee > 0 (from TransferFeeAccount extension)
+                let has_delegate = expected_delegate.is_some();
+                let has_extra_extensions =
+                    pre_account_data.data.len() > BASE_TOKEN_ACCOUNT_SIZE as usize;
+                let needs_tlv = is_frozen || has_delegate || has_extra_extensions;
+
+                let expected_tlv = if needs_tlv {
+                    Some(vec![
+                        light_ctoken_interface::state::ExtensionStruct::CompressedOnly(
+                            light_ctoken_interface::state::CompressedOnlyExtension {
+                                delegated_amount: pre_token_account.delegated_amount,
+                                withheld_transfer_fee: 0, // TODO: extract from TransferFeeAccount if present
+                            },
+                        ),
+                    ])
+                } else {
+                    None
+                };
+
+                // Build expected token data for single assert comparison
+                let expected_token = light_ctoken_sdk::compat::TokenData {
+                    mint: expected_mint,
+                    owner: expected_owner,
+                    amount: expected_amount,
+                    delegate: expected_delegate,
+                    state: expected_state,
+                    tlv: expected_tlv,
+                };
+
                 assert_eq!(
-                    compressed_account.token.owner,
-                    expected_owner,
-                    "CompressAndClose owner should be {} (compress_to_pubkey={})",
-                    if compress_to_pubkey {
-                        "account pubkey"
-                    } else {
-                        "original owner"
-                    },
+                    compressed_account.token, expected_token,
+                    "CompressAndClose compressed token should match expected (compress_to_pubkey={})",
                     compress_to_pubkey
                 );
-                assert_eq!(
-                    compressed_account.token.mint, expected_mint,
-                    "CompressAndClose mint should match original mint"
-                );
-                assert_eq!(
-                    compressed_account.token.delegate, None,
-                    "CompressAndClose compressed account should have no delegate"
-                );
-                assert_eq!(
-                    compressed_account.token.state,
-                    light_ctoken_sdk::compat::AccountState::Initialized,
-                    "CompressAndClose compressed account should be initialized"
-                );
-                assert_eq!(
-                    compressed_account.token.tlv, None,
-                    "CompressAndClose compressed account should have no TLV data"
-                );
 
                 // Verify compressed account metadata
                 assert_eq!(
diff --git a/program-tests/utils/src/lib.rs b/program-tests/utils/src/lib.rs
index c0df566e50..1eeaf67a37 100644
--- a/program-tests/utils/src/lib.rs
+++ b/program-tests/utils/src/lib.rs
@@ -22,7 +22,9 @@ pub mod assert_claim;
 pub mod assert_close_token_account;
 pub mod assert_compressed_tx;
 pub mod assert_create_token_account;
+pub mod assert_ctoken_approve_revoke;
 pub mod assert_ctoken_burn;
+pub mod assert_ctoken_freeze_thaw;
 pub mod assert_ctoken_mint_to;
 pub mod assert_ctoken_transfer;
 pub mod assert_epoch;
@@ -40,6 +42,7 @@ pub mod conversions;
 pub mod create_address_test_program_sdk;
 pub mod e2e_test_env;
 pub mod legacy_cpi_context_account;
+pub mod mint_2022;
 pub mod mint_assert;
 pub mod mock_batched_forester;
 pub mod pack;
diff --git a/program-tests/utils/src/mint_2022.rs b/program-tests/utils/src/mint_2022.rs
new file mode 100644
index 0000000000..0db029842c
--- /dev/null
+++ b/program-tests/utils/src/mint_2022.rs
@@ -0,0 +1,758 @@
+//! Helper functions for creating Token 2022 mints with multiple extensions.
+//!
+//! This module provides utilities to create Token 2022 mints with various extensions
+//! enabled for testing purposes.
+
+use forester_utils::instructions::create_account::create_account_instruction;
+use light_client::rpc::Rpc;
+use light_ctoken_interface::RESTRICTED_EXTENSION_TYPES;
+use light_ctoken_sdk::spl_interface::{find_spl_interface_pda, CreateSplInterfacePda};
+use solana_sdk::{
+    instruction::Instruction,
+    pubkey::Pubkey,
+    signature::{Keypair, Signer},
+};
+use spl_token_2022::{
+    extension::{
+        confidential_transfer::{
+            instruction::initialize_mint as initialize_confidential_transfer_mint,
+            ConfidentialTransferMint,
+        },
+        confidential_transfer_fee::{
+            instruction::initialize_confidential_transfer_fee_config, ConfidentialTransferFeeConfig,
+        },
+        default_account_state::{
+            instruction::initialize_default_account_state, DefaultAccountState,
+        },
+        metadata_pointer::{
+            instruction::initialize as initialize_metadata_pointer, MetadataPointer,
+        },
+        mint_close_authority::MintCloseAuthority,
+        pausable::{instruction::initialize as initialize_pausable, PausableConfig},
+        permanent_delegate::PermanentDelegate,
+        transfer_fee::{instruction::initialize_transfer_fee_config, TransferFeeConfig},
+        transfer_hook::{instruction::initialize as initialize_transfer_hook, TransferHook},
+        BaseStateWithExtensions, ExtensionType, StateWithExtensions, StateWithExtensionsMut,
+    },
+    instruction::{
+        initialize_mint, initialize_mint_close_authority, initialize_permanent_delegate,
+    },
+    solana_zk_sdk::encryption::pod::elgamal::PodElGamalPubkey,
+    state::{AccountState, Mint},
+};
+
+/// Configuration returned after creating a Token 2022 mint with extensions.
+/// Contains the mint pubkey and all the authorities for the various extensions.
+#[derive(Debug, Clone)]
+pub struct Token22ExtensionConfig {
+    /// The mint pubkey
+    pub mint: Pubkey,
+    /// The token pool PDA for compressed tokens
+    pub token_pool: Pubkey,
+    /// Authority that can close the mint account
+    pub close_authority: Pubkey,
+    /// Authority that can update transfer fee configuration
+    pub transfer_fee_config_authority: Pubkey,
+    /// Authority that can withdraw withheld transfer fees
+    pub withdraw_withheld_authority: Pubkey,
+    /// Permanent delegate that can transfer/burn any tokens
+    pub permanent_delegate: Pubkey,
+    /// Authority that can update metadata
+    pub metadata_update_authority: Pubkey,
+    /// Authority that can pause/unpause the mint
+    pub pause_authority: Pubkey,
+    /// Authority for confidential transfer configuration
+    pub confidential_transfer_authority: Pubkey,
+    /// Authority for confidential transfer fee withdraw
+    pub confidential_transfer_fee_authority: Pubkey,
+    /// Whether the mint has DefaultAccountState set to Frozen
+    pub default_account_state_frozen: bool,
+}
+
+/// All restricted extension types for Token 2022 mints.
+/// These extensions restrict token transfers and require compression_only mode.
+pub const RESTRICTED_EXTENSIONS: &[ExtensionType] = RESTRICTED_EXTENSION_TYPES.as_slice();
+
+/// Non-restricted extension types for Token 2022 mints.
+/// These extensions don't restrict transfers and work with normal compression.
+pub const NON_RESTRICTED_EXTENSIONS: &[ExtensionType] = &[
+    ExtensionType::MintCloseAuthority,
+    ExtensionType::MetadataPointer,
+    ExtensionType::ConfidentialTransferMint,
+    ExtensionType::ConfidentialTransferFeeConfig,
+];
+
+/// All supported extension types (restricted + non-restricted).
+pub const ALL_EXTENSIONS: &[ExtensionType] = &[
+    // Non-restricted
+    ExtensionType::MintCloseAuthority,
+    ExtensionType::DefaultAccountState,
+    ExtensionType::MetadataPointer,
+    ExtensionType::ConfidentialTransferMint,
+    ExtensionType::ConfidentialTransferFeeConfig,
+    // Restricted
+    ExtensionType::TransferFeeConfig,
+    ExtensionType::PermanentDelegate,
+    ExtensionType::TransferHook,
+    ExtensionType::Pausable,
+];
+
+/// Creates a Token 2022 mint with all extensions initialized.
+///
+/// # Arguments
+/// * `rpc` - RPC client
+/// * `payer` - Transaction fee payer and authority for all extensions
+/// * `decimals` - Token decimals
+///
+/// # Returns
+/// A tuple of (mint_keypair, extension_config)
+pub async fn create_mint_22_with_extensions<R: Rpc>(
+    rpc: &mut R,
+    payer: &Keypair,
+    decimals: u8,
+) -> (Keypair, Token22ExtensionConfig) {
+    create_mint_22_with_extension_types(rpc, payer, decimals, ALL_EXTENSIONS).await
+}
+
+/// Creates a Token 2022 mint with the specified extension types.
+///
+/// # Arguments
+/// * `rpc` - RPC client
+/// * `payer` - Transaction fee payer and authority for all extensions
+/// * `decimals` - Token decimals
+/// * `extensions` - Slice of extension types to initialize
+///
+/// # Returns
+/// A tuple of (mint_keypair, extension_config)
+pub async fn create_mint_22_with_extension_types<R: Rpc>(
+    rpc: &mut R,
+    payer: &Keypair,
+    decimals: u8,
+    extensions: &[ExtensionType],
+) -> (Keypair, Token22ExtensionConfig) {
+    let mint_keypair = Keypair::new();
+    let mint_pubkey = mint_keypair.pubkey();
+    let authority = payer.pubkey();
+
+    // Calculate the account size needed for requested extensions
+    let mint_len = ExtensionType::try_calculate_account_len::<Mint>(extensions).unwrap();
+
+    let rent = rpc
+        .get_minimum_balance_for_rent_exemption(mint_len)
+        .await
+        .unwrap();
+
+    // Create the mint account
+    let create_account_ix = create_account_instruction(
+        &authority,
+        mint_len,
+        rent,
+        &spl_token_2022::ID,
+        Some(&mint_keypair),
+    );
+
+    // Build instructions based on requested extensions
+    let mut instructions: Vec<Instruction> = vec![create_account_ix];
+    let mut config = Token22ExtensionConfig {
+        mint: mint_pubkey,
+        token_pool: Pubkey::default(),
+        close_authority: Pubkey::default(),
+        transfer_fee_config_authority: Pubkey::default(),
+        withdraw_withheld_authority: Pubkey::default(),
+        permanent_delegate: Pubkey::default(),
+        metadata_update_authority: Pubkey::default(),
+        pause_authority: Pubkey::default(),
+        confidential_transfer_authority: Pubkey::default(),
+        confidential_transfer_fee_authority: Pubkey::default(),
+        default_account_state_frozen: false,
+    };
+
+    // Add extension init instructions in correct order
+    for ext in extensions {
+        match ext {
+            ExtensionType::MintCloseAuthority => {
+                instructions.push(
+                    initialize_mint_close_authority(
+                        &spl_token_2022::ID,
+                        &mint_pubkey,
+                        Some(&authority),
+                    )
+                    .unwrap(),
+                );
+                config.close_authority = authority;
+            }
+            ExtensionType::TransferFeeConfig => {
+                instructions.push(
+                    initialize_transfer_fee_config(
+                        &spl_token_2022::ID,
+                        &mint_pubkey,
+                        Some(&authority),
+                        Some(&authority),
+                        0,
+                        0,
+                    )
+                    .unwrap(),
+                );
+                config.transfer_fee_config_authority = authority;
+                config.withdraw_withheld_authority = authority;
+            }
+            ExtensionType::DefaultAccountState => {
+                instructions.push(
+                    initialize_default_account_state(
+                        &spl_token_2022::ID,
+                        &mint_pubkey,
+                        &AccountState::Initialized,
+                    )
+                    .unwrap(),
+                );
+            }
+            ExtensionType::PermanentDelegate => {
+                instructions.push(
+                    initialize_permanent_delegate(&spl_token_2022::ID, &mint_pubkey, &authority)
+                        .unwrap(),
+                );
+                config.permanent_delegate = authority;
+            }
+            ExtensionType::TransferHook => {
+                instructions.push(
+                    initialize_transfer_hook(
+                        &spl_token_2022::ID,
+                        &mint_pubkey,
+                        Some(authority),
+                        None,
+                    )
+                    .unwrap(),
+                );
+            }
+            ExtensionType::MetadataPointer => {
+                instructions.push(
+                    initialize_metadata_pointer(
+                        &spl_token_2022::ID,
+                        &mint_pubkey,
+                        Some(authority),
+                        Some(mint_pubkey),
+                    )
+                    .unwrap(),
+                );
+                config.metadata_update_authority = authority;
+            }
+            ExtensionType::Pausable => {
+                instructions.push(
+                    initialize_pausable(&spl_token_2022::ID, &mint_pubkey, &authority).unwrap(),
+                );
+                config.pause_authority = authority;
+            }
+            ExtensionType::ConfidentialTransferMint => {
+                instructions.push(
+                    initialize_confidential_transfer_mint(
+                        &spl_token_2022::ID,
+                        &mint_pubkey,
+                        Some(authority),
+                        false,
+                        None,
+                    )
+                    .unwrap(),
+                );
+                config.confidential_transfer_authority = authority;
+            }
+            ExtensionType::ConfidentialTransferFeeConfig => {
+                instructions.push(
+                    initialize_confidential_transfer_fee_config(
+                        &spl_token_2022::ID,
+                        &mint_pubkey,
+                        Some(authority),
+                        &PodElGamalPubkey::default(),
+                    )
+                    .unwrap(),
+                );
+                config.confidential_transfer_fee_authority = authority;
+            }
+            _ => {} // Ignore unsupported extensions
+        }
+    }
+
+    // Initialize mint (must come after extension inits)
+    // freeze_authority required if DefaultAccountState is present
+    let needs_freeze_authority = extensions.contains(&ExtensionType::DefaultAccountState);
+    instructions.push(
+        initialize_mint(
+            &spl_token_2022::ID,
+            &mint_pubkey,
+            &authority,
+            if needs_freeze_authority {
+                Some(&authority)
+            } else {
+                None
+            },
+            decimals,
+        )
+        .unwrap(),
+    );
+
+    // Create token pool for compressed tokens (restricted=true if any restricted extension)
+    let has_restricted = !extensions.is_empty();
+    let (token_pool_pubkey, _) = find_spl_interface_pda(&mint_pubkey, has_restricted);
+    instructions.push(
+        CreateSplInterfacePda::new(authority, mint_pubkey, spl_token_2022::ID, has_restricted)
+            .instruction(),
+    );
+    config.token_pool = token_pool_pubkey;
+
+    // Send transaction
+    rpc.create_and_send_transaction(&instructions, &authority, &[payer, &mint_keypair])
+        .await
+        .unwrap();
+
+    (mint_keypair, config)
+}
+
+/// Creates a Token 2022 mint with DefaultAccountState set to Frozen.
+/// This creates a minimal mint with only the extensions needed for testing frozen default state.
+///
+/// Extensions initialized:
+/// - DefaultAccountState (Frozen)
+/// - PermanentDelegate (required for frozen accounts - allows transfers by delegate)
+/// - Pausable (for testing pausable + frozen combination)
+///
+/// # Arguments
+/// * `rpc` - RPC client
+/// * `payer` - Transaction fee payer and authority for all extensions
+/// * `decimals` - Token decimals
+///
+/// # Returns
+/// A tuple of (mint_keypair, extension_config)
+pub async fn create_mint_22_with_frozen_default_state<R: Rpc>(
+    rpc: &mut R,
+    payer: &Keypair,
+    decimals: u8,
+) -> (Keypair, Token22ExtensionConfig) {
+    let mint_keypair = Keypair::new();
+    let mint_pubkey = mint_keypair.pubkey();
+    let authority = payer.pubkey();
+
+    // Extensions for frozen default state testing
+    let extension_types = [
+        ExtensionType::DefaultAccountState,
+        ExtensionType::PermanentDelegate,
+        ExtensionType::Pausable,
+    ];
+
+    let mint_len = ExtensionType::try_calculate_account_len::<Mint>(&extension_types).unwrap();
+
+    let rent = rpc
+        .get_minimum_balance_for_rent_exemption(mint_len)
+        .await
+        .unwrap();
+
+    let create_account_ix = create_account_instruction(
+        &authority,
+        mint_len,
+        rent,
+        &spl_token_2022::ID,
+        Some(&mint_keypair),
+    );
+
+    // 1. Default account state (Frozen)
+    let init_default_state_ix =
+        initialize_default_account_state(&spl_token_2022::ID, &mint_pubkey, &AccountState::Frozen)
+            .unwrap();
+
+    // 2. Permanent delegate (useful for frozen accounts)
+    let init_permanent_delegate_ix =
+        initialize_permanent_delegate(&spl_token_2022::ID, &mint_pubkey, &authority).unwrap();
+
+    // 3. Pausable
+    let init_pausable_ix =
+        initialize_pausable(&spl_token_2022::ID, &mint_pubkey, &authority).unwrap();
+
+    // 4. Initialize mint (freeze_authority required for DefaultAccountState)
+    let init_mint_ix = initialize_mint(
+        &spl_token_2022::ID,
+        &mint_pubkey,
+        &authority,       // mint_authority
+        Some(&authority), // freeze_authority (required for DefaultAccountState)
+        decimals,
+    )
+    .unwrap();
+
+    // 5. Create token pool for compressed tokens (restricted=true for mints with restricted extensions)
+    let (token_pool_pubkey, _) = find_spl_interface_pda(&mint_pubkey, true);
+    let create_token_pool_ix =
+        CreateSplInterfacePda::new(authority, mint_pubkey, spl_token_2022::ID, true).instruction();
+
+    let instructions: Vec<Instruction> = vec![
+        create_account_ix,
+        init_default_state_ix,
+        init_permanent_delegate_ix,
+        init_pausable_ix,
+        init_mint_ix,
+        create_token_pool_ix,
+    ];
+
+    rpc.create_and_send_transaction(&instructions, &authority, &[payer, &mint_keypair])
+        .await
+        .unwrap();
+
+    let config = Token22ExtensionConfig {
+        mint: mint_pubkey,
+        token_pool: token_pool_pubkey,
+        close_authority: Pubkey::default(),
+        transfer_fee_config_authority: Pubkey::default(),
+        withdraw_withheld_authority: Pubkey::default(),
+        permanent_delegate: authority,
+        metadata_update_authority: Pubkey::default(),
+        pause_authority: authority,
+        confidential_transfer_authority: Pubkey::default(),
+        confidential_transfer_fee_authority: Pubkey::default(),
+        default_account_state_frozen: true,
+    };
+
+    (mint_keypair, config)
+}
+
+/// Asserts that a Token 2022 mint with all extensions is correctly configured.
+///
+/// Verifies:
+/// - All extensions are present on the mint
+/// - Token pool account exists
+/// - All authorities match the expected payer
+///
+/// # Arguments
+/// * `rpc` - RPC client
+/// * `mint_pubkey` - The mint pubkey
+/// * `extension_config` - The extension configuration to verify
+/// * `expected_authority` - The expected authority for all extensions
+pub async fn assert_mint_22_with_all_extensions<R: Rpc>(
+    rpc: &mut R,
+    mint_pubkey: &Pubkey,
+    extension_config: &Token22ExtensionConfig,
+    expected_authority: &Pubkey,
+) {
+    // Verify all extensions are present
+    verify_mint_extensions(rpc, mint_pubkey).await.unwrap();
+
+    // Verify the extension config has correct values
+    assert_eq!(
+        extension_config.mint, *mint_pubkey,
+        "Extension config mint should match"
+    );
+
+    // Verify token pool was created
+    let token_pool_account = rpc.get_account(extension_config.token_pool).await.unwrap();
+    assert!(
+        token_pool_account.is_some(),
+        "Token pool account should exist"
+    );
+
+    // Verify all authorities match expected
+    assert_eq!(
+        extension_config.close_authority, *expected_authority,
+        "Close authority mismatch"
+    );
+    assert_eq!(
+        extension_config.transfer_fee_config_authority, *expected_authority,
+        "Transfer fee config authority mismatch"
+    );
+    assert_eq!(
+        extension_config.withdraw_withheld_authority, *expected_authority,
+        "Withdraw withheld authority mismatch"
+    );
+    assert_eq!(
+        extension_config.permanent_delegate, *expected_authority,
+        "Permanent delegate mismatch"
+    );
+    assert_eq!(
+        extension_config.metadata_update_authority, *expected_authority,
+        "Metadata update authority mismatch"
+    );
+    assert_eq!(
+        extension_config.pause_authority, *expected_authority,
+        "Pause authority mismatch"
+    );
+    assert_eq!(
+        extension_config.confidential_transfer_authority, *expected_authority,
+        "Confidential transfer authority mismatch"
+    );
+    assert_eq!(
+        extension_config.confidential_transfer_fee_authority, *expected_authority,
+        "Confidential transfer fee authority mismatch"
+    );
+}
+
+/// Verifies that a mint has all expected extensions by reading the account data.
+///
+/// # Arguments
+/// * `rpc` - RPC client
+/// * `mint` - The mint pubkey to verify
+///
+/// # Returns
+/// Ok(()) if all extensions are present, or an error message describing what's missing
+pub async fn verify_mint_extensions<R: Rpc>(rpc: &mut R, mint: &Pubkey) -> Result<(), String> {
+    let account = rpc
+        .get_account(*mint)
+        .await
+        .map_err(|e| format!("Failed to get mint account: {:?}", e))?
+        .ok_or_else(|| "Mint account not found".to_string())?;
+
+    let mint_state = StateWithExtensions::<Mint>::unpack(&account.data)
+        .map_err(|e| format!("Failed to unpack mint: {:?}", e))?;
+
+    // Verify each extension is present using concrete types
+    let mut missing = Vec::new();
+
+    if mint_state.get_extension::<MintCloseAuthority>().is_err() {
+        missing.push("MintCloseAuthority");
+    }
+    if mint_state.get_extension::<TransferFeeConfig>().is_err() {
+        missing.push("TransferFeeConfig");
+    }
+    if mint_state.get_extension::<DefaultAccountState>().is_err() {
+        missing.push("DefaultAccountState");
+    }
+    if mint_state.get_extension::<PermanentDelegate>().is_err() {
+        missing.push("PermanentDelegate");
+    }
+    if mint_state.get_extension::<TransferHook>().is_err() {
+        missing.push("TransferHook");
+    }
+    if mint_state.get_extension::<MetadataPointer>().is_err() {
+        missing.push("MetadataPointer");
+    }
+    if mint_state.get_extension::<PausableConfig>().is_err() {
+        missing.push("PausableConfig");
+    }
+    if mint_state
+        .get_extension::<ConfidentialTransferMint>()
+        .is_err()
+    {
+        missing.push("ConfidentialTransferMint");
+    }
+    if mint_state
+        .get_extension::<ConfidentialTransferFeeConfig>()
+        .is_err()
+    {
+        missing.push("ConfidentialTransferFeeConfig");
+    }
+
+    if missing.is_empty() {
+        Ok(())
+    } else {
+        Err(format!("Missing extensions: {:?}", missing))
+    }
+}
+
+/// Creates a Token 2022 token account for the given mint.
+///
+/// # Arguments
+/// * `rpc` - RPC client
+/// * `payer` - Transaction fee payer
+/// * `mint` - The mint pubkey
+/// * `owner` - The owner of the new token account
+///
+/// # Returns
+/// The pubkey of the created token account
+pub async fn create_token_22_account<R: Rpc>(
+    rpc: &mut R,
+    payer: &Keypair,
+    mint: &Pubkey,
+    owner: &Pubkey,
+) -> Pubkey {
+    use solana_system_interface::instruction as system_instruction;
+
+    let token_account = Keypair::new();
+
+    // Get mint account to determine extensions needed for token account
+    let mint_account = rpc.get_account(*mint).await.unwrap().unwrap();
+    let mint_state = StateWithExtensions::<Mint>::unpack(&mint_account.data).unwrap();
+    let mint_extensions = mint_state.get_extension_types().unwrap();
+
+    // Calculate token account size with required extensions
+    let account_len = ExtensionType::try_calculate_account_len::<spl_token_2022::state::Account>(
+        &mint_extensions,
+    )
+    .unwrap();
+
+    let rent = rpc
+        .get_minimum_balance_for_rent_exemption(account_len)
+        .await
+        .unwrap();
+
+    // Create account instruction
+    let create_account_ix = system_instruction::create_account(
+        &payer.pubkey(),
+        &token_account.pubkey(),
+        rent,
+        account_len as u64,
+        &spl_token_2022::ID,
+    );
+
+    // Initialize token account
+    let init_account_ix = spl_token_2022::instruction::initialize_account3(
+        &spl_token_2022::ID,
+        &token_account.pubkey(),
+        mint,
+        owner,
+    )
+    .unwrap();
+
+    rpc.create_and_send_transaction(
+        &[create_account_ix, init_account_ix],
+        &payer.pubkey(),
+        &[payer, &token_account],
+    )
+    .await
+    .unwrap();
+
+    token_account.pubkey()
+}
+
+/// Mints Token 2022 tokens to a token account.
+///
+/// # Arguments
+/// * `rpc` - RPC client
+/// * `mint_authority` - The mint authority keypair (must sign)
+/// * `mint` - The mint pubkey
+/// * `token_account` - The destination token account
+/// * `amount` - Amount to mint
+pub async fn mint_spl_tokens_22<R: Rpc>(
+    rpc: &mut R,
+    mint_authority: &Keypair,
+    mint: &Pubkey,
+    token_account: &Pubkey,
+    amount: u64,
+) {
+    let mint_to_ix = spl_token_2022::instruction::mint_to(
+        &spl_token_2022::ID,
+        mint,
+        token_account,
+        &mint_authority.pubkey(),
+        &[],
+        amount,
+    )
+    .unwrap();
+
+    rpc.create_and_send_transaction(&[mint_to_ix], &mint_authority.pubkey(), &[mint_authority])
+        .await
+        .unwrap();
+}
+
+/// Pause a Token 2022 mint by modifying the PausableConfig extension.
+///
+/// This function reads the mint account, locates the PausableConfig extension,
+/// sets paused = true, and writes the modified data back using set_account.
+///
+/// # Arguments
+/// * `rpc` - RPC client (must support set_account, e.g., LightProgramTest)
+/// * `mint_pubkey` - The mint pubkey to pause
+pub async fn pause_mint(rpc: &mut light_program_test::LightProgramTest, mint_pubkey: &Pubkey) {
+    use spl_token_2022::extension::BaseStateWithExtensionsMut;
+
+    // Read mint account
+    let mut account = rpc.get_account(*mint_pubkey).await.unwrap().unwrap();
+
+    // Parse mint and get extension offset
+    {
+        let mut mint_state = StateWithExtensionsMut::<Mint>::unpack(&mut account.data).unwrap();
+        let pausable_config = mint_state.get_extension_mut::<PausableConfig>().unwrap();
+        pausable_config.paused = true.into();
+    }
+
+    // Write back modified account
+    rpc.context.set_account(*mint_pubkey, account).unwrap();
+}
+
+/// Modify the TransferFeeConfig extension on a Token 2022 mint.
+///
+/// This function modifies both older and newer transfer fee configs
+/// to set non-zero fees for testing validation failures.
+///
+/// # Arguments
+/// * `rpc` - RPC client (must support set_account, e.g., LightProgramTest)
+/// * `mint_pubkey` - The mint pubkey to modify
+/// * `basis_points` - Transfer fee basis points (e.g., 100 = 1%)
+/// * `max_fee` - Maximum fee in token amount
+pub async fn set_mint_transfer_fee(
+    rpc: &mut light_program_test::LightProgramTest,
+    mint_pubkey: &Pubkey,
+    basis_points: u16,
+    max_fee: u64,
+) {
+    use spl_token_2022::extension::BaseStateWithExtensionsMut;
+
+    // Read mint account
+    let mut account = rpc.get_account(*mint_pubkey).await.unwrap().unwrap();
+
+    // Parse mint and modify extension
+    {
+        let mut mint_state = StateWithExtensionsMut::<Mint>::unpack(&mut account.data).unwrap();
+        let transfer_fee_config = mint_state.get_extension_mut::<TransferFeeConfig>().unwrap();
+        // Set newer_transfer_fee (active fee schedule)
+        transfer_fee_config
+            .newer_transfer_fee
+            .transfer_fee_basis_points = basis_points.into();
+        transfer_fee_config.newer_transfer_fee.maximum_fee = max_fee.into();
+        // Also set older_transfer_fee for completeness
+        transfer_fee_config
+            .older_transfer_fee
+            .transfer_fee_basis_points = basis_points.into();
+        transfer_fee_config.older_transfer_fee.maximum_fee = max_fee.into();
+    }
+
+    // Write back modified account
+    rpc.context.set_account(*mint_pubkey, account).unwrap();
+}
+
+/// Modify the TransferHook extension on a Token 2022 mint.
+///
+/// This function sets the transfer hook program_id to a non-nil value
+/// for testing validation failures.
+///
+/// # Arguments
+/// * `rpc` - RPC client (must support set_account, e.g., LightProgramTest)
+/// * `mint_pubkey` - The mint pubkey to modify
+/// * `program_id` - The transfer hook program_id to set
+pub async fn set_mint_transfer_hook(
+    rpc: &mut light_program_test::LightProgramTest,
+    mint_pubkey: &Pubkey,
+    program_id: Pubkey,
+) {
+    use spl_token_2022::extension::BaseStateWithExtensionsMut;
+
+    // Read mint account
+    let mut account = rpc.get_account(*mint_pubkey).await.unwrap().unwrap();
+
+    // Parse mint and modify extension
+    {
+        let mut mint_state = StateWithExtensionsMut::<Mint>::unpack(&mut account.data).unwrap();
+        let transfer_hook = mint_state.get_extension_mut::<TransferHook>().unwrap();
+        transfer_hook.program_id = Some(program_id).try_into().unwrap();
+    }
+
+    // Write back modified account
+    rpc.context.set_account(*mint_pubkey, account).unwrap();
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_extension_config_struct() {
+        // Basic struct test
+        let config = Token22ExtensionConfig {
+            mint: Pubkey::new_unique(),
+            token_pool: Pubkey::new_unique(),
+            close_authority: Pubkey::new_unique(),
+            transfer_fee_config_authority: Pubkey::new_unique(),
+            withdraw_withheld_authority: Pubkey::new_unique(),
+            permanent_delegate: Pubkey::new_unique(),
+            metadata_update_authority: Pubkey::new_unique(),
+            pause_authority: Pubkey::new_unique(),
+            confidential_transfer_authority: Pubkey::new_unique(),
+            confidential_transfer_fee_authority: Pubkey::new_unique(),
+            default_account_state_frozen: false,
+        };
+
+        assert_ne!(config.mint, config.close_authority);
+    }
+}
diff --git a/program-tests/utils/src/mint_assert.rs b/program-tests/utils/src/mint_assert.rs
index 37d4ada41e..bd50457e7f 100644
--- a/program-tests/utils/src/mint_assert.rs
+++ b/program-tests/utils/src/mint_assert.rs
@@ -1,7 +1,7 @@
 use anchor_lang::prelude::borsh::BorshDeserialize;
 use light_ctoken_interface::{
     instructions::extensions::TokenMetadataInstructionData,
-    state::{BaseMint, CompressedMint, CompressedMintMetadata, ExtensionStruct},
+    state::{BaseMint, CompressedMint, CompressedMintMetadata, ExtensionStruct, ACCOUNT_TYPE_MINT},
 };
 use solana_sdk::pubkey::Pubkey;
 
@@ -47,6 +47,9 @@ pub fn assert_compressed_mint_account(
             mint: spl_mint_pda.into(),
             cmint_decompressed: false,
         },
+        reserved: [0u8; 49],
+        account_type: ACCOUNT_TYPE_MINT,
+        compression: light_compressible::compression_info::CompressionInfo::default(),
         extensions: expected_extensions,
     };
 
diff --git a/program-tests/utils/src/spl.rs b/program-tests/utils/src/spl.rs
index 8ca3f35f73..fbcfe0391e 100644
--- a/program-tests/utils/src/spl.rs
+++ b/program-tests/utils/src/spl.rs
@@ -1,4 +1,7 @@
 use anchor_spl::token::{Mint, TokenAccount};
+
+/// Default decimals used by `create_mint_helper` and related functions
+pub const CREATE_MINT_HELPER_DECIMALS: u8 = 2;
 use forester_utils::instructions::create_account::create_account_instruction;
 use light_client::{
     fee::TransactionParams,
@@ -273,8 +276,13 @@ pub async fn create_mint_helper_with_keypair<R: Rpc>(
         .await
         .unwrap();
 
-    let (instructions, pool) =
-        create_initialize_mint_instructions(&payer_pubkey, &payer_pubkey, rent, 2, mint);
+    let (instructions, pool) = create_initialize_mint_instructions(
+        &payer_pubkey,
+        &payer_pubkey,
+        rent,
+        CREATE_MINT_HELPER_DECIMALS,
+        mint,
+    );
 
     let _ = rpc
         .create_and_send_transaction(&instructions, &payer_pubkey, &[payer, mint])
diff --git a/programs/compressed-token/anchor/src/constants.rs b/programs/compressed-token/anchor/src/constants.rs
index ac3123c22a..413f87a0bb 100644
--- a/programs/compressed-token/anchor/src/constants.rs
+++ b/programs/compressed-token/anchor/src/constants.rs
@@ -8,6 +8,7 @@ pub const TOKEN_COMPRESSED_ACCOUNT_V3_DISCRIMINATOR: [u8; 8] = [0, 0, 0, 0, 0, 0
 pub const BUMP_CPI_AUTHORITY: u8 = 254;
 pub const NOT_FROZEN: bool = false;
 pub const POOL_SEED: &[u8] = b"pool";
+pub const RESTRICTED_POOL_SEED: &[u8] = b"restricted";
 
 /// Maximum number of pool accounts that can be created for each mint.
 pub const NUM_MAX_POOL_ACCOUNTS: u8 = 5;
diff --git a/programs/compressed-token/anchor/src/instructions/create_token_pool.rs b/programs/compressed-token/anchor/src/instructions/create_token_pool.rs
index 325f33cbf3..ba94393ca8 100644
--- a/programs/compressed-token/anchor/src/instructions/create_token_pool.rs
+++ b/programs/compressed-token/anchor/src/instructions/create_token_pool.rs
@@ -1,43 +1,113 @@
 use account_compression::utils::constants::CPI_AUTHORITY_PDA_SEED;
 use anchor_lang::prelude::*;
-use anchor_spl::token_interface::{Mint, TokenAccount, TokenInterface};
+use anchor_spl::token_interface::{TokenAccount, TokenInterface};
+use light_ctoken_interface::{is_restricted_extension, ALLOWED_EXTENSION_TYPES};
 use spl_token_2022::{
-    extension::{BaseStateWithExtensions, ExtensionType, PodStateWithExtensions},
+    extension::{
+        transfer_fee::TransferFeeConfig, transfer_hook::TransferHook, BaseStateWithExtensions,
+        ExtensionType, PodStateWithExtensions,
+    },
     pod::PodMint,
 };
 
 use crate::{
-    constants::{NUM_MAX_POOL_ACCOUNTS, POOL_SEED},
+    constants::{NUM_MAX_POOL_ACCOUNTS, POOL_SEED, RESTRICTED_POOL_SEED},
     spl_compression::is_valid_token_pool_pda,
 };
 
+/// Returns RESTRICTED_POOL_SEED if mint has restricted extensions, empty vec otherwise.
+/// For mints with restricted extensions (Pausable, PermanentDelegate, TransferFeeConfig, TransferHook, DefaultAccountState),
+/// returns the restricted seed to include in PDA derivation.
+pub fn restricted_seed(mint: &AccountInfo) -> Vec<u8> {
+    let mint_data = mint.try_borrow_data().unwrap();
+    let has_restricted =
+        if let Ok(mint_state) = PodStateWithExtensions::<PodMint>::unpack(&mint_data) {
+            mint_state
+                .get_extension_types()
+                .unwrap_or_default()
+                .iter()
+                .any(is_restricted_extension)
+        } else {
+            false
+        };
+
+    if has_restricted {
+        RESTRICTED_POOL_SEED.to_vec()
+    } else {
+        vec![]
+    }
+}
+
 /// Creates an SPL or token-2022 token pool account, which is owned by the token authority PDA.
+/// We use manual token account initialization via CPI instead of Anchor's `token::mint` constraint
+/// because Anchor's constraint internally deserializes the mint account, which fails for Token 2022
+/// mints with variable-length extensions like ConfidentialTransferMint.
 #[derive(Accounts)]
 pub struct CreateTokenPoolInstruction<'info> {
     /// UNCHECKED: only pays fees.
     #[account(mut)]
     pub fee_payer: Signer<'info>,
+    /// CHECK: Token pool account. Initialized manually via CPI because Anchor's token::mint
+    /// constraint cannot handle Token 2022 mints with variable-length extensions.
     #[account(
         init,
-        seeds = [
-        POOL_SEED, &mint.key().to_bytes(),
-        ],
+        seeds = [POOL_SEED, &mint.key().to_bytes(), restricted_seed(&mint).as_slice()],
         bump,
         payer = fee_payer,
-          token::mint = mint,
-          token::authority = cpi_authority_pda,
+        space = get_token_account_space(&mint)?,
+        owner = token_program.key(),
     )]
-    pub token_pool_pda: InterfaceAccount<'info, TokenAccount>,
+    pub token_pool_pda: AccountInfo<'info>,
     pub system_program: Program<'info, System>,
-    /// CHECK: is mint account.
-    #[account(mut)]
-    pub mint: InterfaceAccount<'info, Mint>,
+    /// CHECK: Mint account. We use AccountInfo instead of InterfaceAccount<Mint> because
+    /// Anchor's InterfaceAccount cannot deserialize Token 2022 mints with variable-length
+    /// extensions like ConfidentialTransferMint. The mint is validated manually using
+    /// PodStateWithExtensions<PodMint>::unpack() in assert_mint_extensions().
+    #[account(owner = token_program.key())]
+    pub mint: AccountInfo<'info>,
     pub token_program: Interface<'info, TokenInterface>,
     /// CHECK: (seeds anchor constraint).
     #[account(seeds = [CPI_AUTHORITY_PDA_SEED], bump)]
     pub cpi_authority_pda: AccountInfo<'info>,
 }
 
+/// Calculates the space needed for a token account based on the mint's extensions.
+/// Uses `get_required_init_account_extensions` to map mint extensions to required token account extensions.
+pub fn get_token_account_space(mint: &AccountInfo) -> Result<usize> {
+    let mint_data = mint.try_borrow_data()?;
+    let mint_state = PodStateWithExtensions::<PodMint>::unpack(&mint_data)
+        .map_err(|_| crate::ErrorCode::InvalidMint)?;
+    let mint_extensions = mint_state.get_extension_types().unwrap_or_default();
+    let account_extensions = ExtensionType::get_required_init_account_extensions(&mint_extensions);
+    ExtensionType::try_calculate_account_len::<spl_token_2022::state::Account>(&account_extensions)
+        .map_err(|_| crate::ErrorCode::InvalidMint.into())
+}
+
+/// Initializes a token account via CPI to the token program.
+pub fn initialize_token_account<'info>(
+    token_account: &AccountInfo<'info>,
+    mint: &AccountInfo<'info>,
+    authority: &AccountInfo<'info>,
+    token_program: &AccountInfo<'info>,
+) -> Result<()> {
+    let ix = spl_token_2022::instruction::initialize_account3(
+        token_program.key,
+        token_account.key,
+        mint.key,
+        authority.key,
+    )?;
+    anchor_lang::solana_program::program::invoke(
+        &ix,
+        &[
+            token_account.clone(),
+            mint.clone(),
+            authority.clone(),
+            token_program.clone(),
+        ],
+    )?;
+    Ok(())
+}
+
 pub fn get_token_pool_pda(mint: &Pubkey) -> Pubkey {
     get_token_pool_pda_with_index(mint, 0)
 }
@@ -56,51 +126,74 @@ pub fn get_token_pool_pda_with_index(mint: &Pubkey, token_pool_index: u8) -> Pub
     find_token_pool_pda_with_index(mint, token_pool_index).0
 }
 
-const ALLOWED_EXTENSION_TYPES: [ExtensionType; 7] = [
-    ExtensionType::MetadataPointer,
-    ExtensionType::TokenMetadata,
-    ExtensionType::InterestBearingConfig,
-    ExtensionType::GroupPointer,
-    ExtensionType::GroupMemberPointer,
-    ExtensionType::TokenGroup,
-    ExtensionType::TokenGroupMember,
-];
-
 pub fn assert_mint_extensions(account_data: &[u8]) -> Result<()> {
-    let mint = PodStateWithExtensions::<PodMint>::unpack(account_data).unwrap();
-    let mint_extensions = mint.get_extension_types().unwrap();
+    let mint = PodStateWithExtensions::<PodMint>::unpack(account_data)
+        .map_err(|_| crate::ErrorCode::InvalidMint)?;
+    let mint_extensions = mint.get_extension_types().unwrap_or_default();
+
+    // Check all extensions are in the allowed list
     if !mint_extensions
         .iter()
         .all(|item| ALLOWED_EXTENSION_TYPES.contains(item))
     {
         return err!(crate::ErrorCode::MintWithInvalidExtension);
     }
+
+    // TransferFeeConfig: fees must be zero
+    if let Ok(transfer_fee_config) = mint.get_extension::<TransferFeeConfig>() {
+        let older_fee = &transfer_fee_config.older_transfer_fee;
+        let newer_fee = &transfer_fee_config.newer_transfer_fee;
+        if u16::from(older_fee.transfer_fee_basis_points) != 0
+            || u64::from(older_fee.maximum_fee) != 0
+            || u16::from(newer_fee.transfer_fee_basis_points) != 0
+            || u64::from(newer_fee.maximum_fee) != 0
+        {
+            return err!(crate::ErrorCode::NonZeroTransferFeeNotSupported);
+        }
+    }
+
+    // TransferHook: program_id must be nil
+    if let Ok(transfer_hook) = mint.get_extension::<TransferHook>() {
+        if Option::<spl_token_2022::solana_program::pubkey::Pubkey>::from(transfer_hook.program_id)
+            .is_some()
+        {
+            return err!(crate::ErrorCode::TransferHookNotSupported);
+        }
+    }
+
     Ok(())
 }
 
-/// Creates an SPL or token-2022 token pool account, which is owned by the token authority PDA.
+/// Creates an additional SPL or token-2022 token pool account, which is owned by the token authority PDA.
+/// We use manual token account initialization via CPI instead of Anchor's `token::mint` constraint
+/// because Anchor's constraint internally deserializes the mint account, which fails for Token 2022
+/// mints with variable-length extensions like ConfidentialTransferMint.
 #[derive(Accounts)]
 #[instruction(token_pool_index: u8)]
 pub struct AddTokenPoolInstruction<'info> {
     /// UNCHECKED: only pays fees.
     #[account(mut)]
     pub fee_payer: Signer<'info>,
+    /// CHECK: Token pool account. Initialized manually via CPI because Anchor's token::mint
+    /// constraint cannot handle Token 2022 mints with variable-length extensions.
+    /// For mints with restricted extensions, the PDA includes "restricted" seed.
     #[account(
         init,
-        seeds = [
-        POOL_SEED, &mint.key().to_bytes(), &[token_pool_index],
-        ],
+        seeds = [POOL_SEED, &mint.key().to_bytes(), restricted_seed(&mint).as_slice(), &[token_pool_index]],
         bump,
         payer = fee_payer,
-          token::mint = mint,
-          token::authority = cpi_authority_pda,
+        space = get_token_account_space(&mint)?,
+        owner = token_program.key(),
     )]
-    pub token_pool_pda: InterfaceAccount<'info, TokenAccount>,
+    pub token_pool_pda: AccountInfo<'info>,
     pub existing_token_pool_pda: InterfaceAccount<'info, TokenAccount>,
     pub system_program: Program<'info, System>,
-    /// CHECK: is mint account.
-    #[account(mut)]
-    pub mint: InterfaceAccount<'info, Mint>,
+    /// CHECK: Mint account. We use AccountInfo instead of InterfaceAccount<Mint> because
+    /// Anchor's InterfaceAccount cannot deserialize Token 2022 mints with variable-length
+    /// extensions like ConfidentialTransferMint. The mint is validated manually using
+    /// PodStateWithExtensions<PodMint>::unpack() in assert_mint_extensions().
+    #[account(owner = token_program.key())]
+    pub mint: AccountInfo<'info>,
     pub token_program: Interface<'info, TokenInterface>,
     /// CHECK: (seeds anchor constraint).
     #[account(seeds = [CPI_AUTHORITY_PDA_SEED], bump)]
diff --git a/programs/compressed-token/anchor/src/lib.rs b/programs/compressed-token/anchor/src/lib.rs
index 3e2e475f7c..9bf01c80ee 100644
--- a/programs/compressed-token/anchor/src/lib.rs
+++ b/programs/compressed-token/anchor/src/lib.rs
@@ -37,8 +37,9 @@ solana_security_txt::security_txt! {
 pub mod light_compressed_token {
 
     use constants::{NOT_FROZEN, NUM_MAX_POOL_ACCOUNTS};
+    use instructions::create_token_pool::restricted_seed;
+    use light_ctoken_interface::is_valid_spl_interface_pda;
     use light_zero_copy::traits::ZeroCopyAt;
-    use spl_compression::check_spl_token_pool_derivation_with_index;
 
     use super::*;
 
@@ -51,11 +52,19 @@ pub mod light_compressed_token {
     ) -> Result<()> {
         instructions::create_token_pool::assert_mint_extensions(
             &ctx.accounts.mint.to_account_info().try_borrow_data()?,
+        )?;
+        // Initialize the token account via CPI (Anchor's init constraint only allocated space)
+        instructions::create_token_pool::initialize_token_account(
+            &ctx.accounts.token_pool_pda,
+            &ctx.accounts.mint,
+            &ctx.accounts.cpi_authority_pda,
+            &ctx.accounts.token_program.to_account_info(),
         )
     }
 
     /// This instruction creates an additional token pool for a given mint.
     /// The maximum number of token pools per mint is 5.
+    /// For mints with restricted extensions, uses restricted PDA derivation.
     pub fn add_token_pool<'info>(
         ctx: Context<'_, '_, '_, 'info, AddTokenPoolInstruction<'info>>,
         token_pool_index: u8,
@@ -63,11 +72,25 @@ pub mod light_compressed_token {
         if token_pool_index >= NUM_MAX_POOL_ACCOUNTS {
             return err!(ErrorCode::InvalidTokenPoolBump);
         }
-        // Check that token pool account with previous bump already exists.
-        check_spl_token_pool_derivation_with_index(
+        // Check that token pool account with previous index already exists.
+        // Use the same restricted derivation as the new pool.
+        let is_restricted = !restricted_seed(&ctx.accounts.mint).is_empty();
+        let prev_index = token_pool_index.saturating_sub(1);
+        if !is_valid_spl_interface_pda(
             &ctx.accounts.mint.key().to_bytes(),
             &ctx.accounts.existing_token_pool_pda.key(),
-            &[token_pool_index.saturating_sub(1)],
+            prev_index,
+            None,
+            is_restricted,
+        ) {
+            return err!(ErrorCode::InvalidTokenPoolPda);
+        }
+        // Initialize the token account via CPI (Anchor's init constraint only allocated space)
+        instructions::create_token_pool::initialize_token_account(
+            &ctx.accounts.token_pool_pda,
+            &ctx.accounts.mint,
+            &ctx.accounts.cpi_authority_pda,
+            &ctx.accounts.token_program.to_account_info(),
         )
     }
 
@@ -294,7 +317,8 @@ pub enum ErrorCode {
     InvalidExtensionType,
     InstructionDataExpectedDelegate,
     ZeroCopyExpectedDelegate,
-    TokenDataTlvUnimplemented,
+    #[msg("Unsupported TLV extension type - only CompressedOnly is currently implemented")]
+    UnsupportedTlvExtensionType,
     // Mint Action specific errors
     #[msg("Mint action requires at least one action")]
     MintActionNoActionsProvided,
@@ -467,11 +491,65 @@ pub enum ErrorCode {
     InvalidCMintAccount,
     #[msg("Mint data required in instruction when not decompressed")]
     MintDataRequired,
+    // Extension validation errors
+    #[msg("Invalid mint account data")]
+    InvalidMint,
+    #[msg("Token operations blocked - mint is paused")]
+    MintPaused,
+    #[msg("Mint account required for transfer when account has PausableAccount extension")]
+    MintRequiredForTransfer,
+    #[msg("Non-zero transfer fees are not supported")]
+    NonZeroTransferFeeNotSupported,
+    #[msg("Transfer hooks with non-nil program_id are not supported")]
+    TransferHookNotSupported,
+    #[msg("Mint has extensions that require compression_only mode")]
+    CompressionOnlyRequired,
+    #[msg("CompressAndClose: Compressed token mint does not match source token account mint")]
+    CompressAndCloseInvalidMint,
+    #[msg("CompressAndClose: Missing required CompressedOnly extension in output TLV")]
+    CompressAndCloseMissingCompressedOnlyExtension,
+    #[msg("CompressAndClose: CompressedOnly mint_account_index must be 0")]
+    CompressAndCloseInvalidMintAccountIndex,
+    #[msg(
+        "CompressAndClose: Delegated amount mismatch between ctoken and CompressedOnly extension"
+    )]
+    CompressAndCloseDelegatedAmountMismatch,
+    #[msg("CompressAndClose: Delegate mismatch between ctoken and compressed token output")]
+    CompressAndCloseInvalidDelegate,
+    #[msg("CompressAndClose: Withheld transfer fee mismatch")]
+    CompressAndCloseWithheldFeeMismatch,
+    #[msg("CompressAndClose: Frozen state mismatch")]
+    CompressAndCloseFrozenMismatch,
+    #[msg("TLV extensions require version 3 (ShaFlat)")]
+    TlvRequiresVersion3,
+    #[msg("CToken account has extensions that cannot be compressed. Only Compressible extension or no extensions allowed.")]
+    CTokenHasDisallowedExtensions,
+    #[msg("CompressAndClose: rent_sponsor_is_signer flag does not match actual signer")]
+    RentSponsorIsSignerMismatch,
+    #[msg("Mint has restricted extensions (Pausable, PermanentDelegate, TransferFee, TransferHook, DefaultAccountState) must not create compressed token accounts.")]
+    MintHasRestrictedExtensions,
+    #[msg("Decompress: CToken delegate does not match input compressed account delegate")]
+    DecompressDelegateMismatch,
+    #[msg("Mint cache capacity exceeded (max 5 unique mints)")]
+    MintCacheCapacityExceeded,
+    #[msg("in_lamports field is not yet implemented")]
+    InLamportsUnimplemented,
+    #[msg("out_lamports field is not yet implemented")]
+    OutLamportsUnimplemented,
+    #[msg("Mints with restricted extensions require compressible accounts")]
+    CompressibleRequired,
+    #[msg("CMint account not found")]
+    CMintNotFound,
+    #[msg("CompressedOnly inputs must decompress to CToken account, not SPL token account")]
+    CompressedOnlyRequiresCTokenDecompress,
 }
 
+/// Anchor error code offset - error codes start at 6000
+pub const ERROR_CODE_OFFSET: u32 = 6000;
+
 impl From<ErrorCode> for ProgramError {
     fn from(e: ErrorCode) -> Self {
-        ProgramError::Custom(e as u32)
+        ProgramError::Custom(ERROR_CODE_OFFSET + e as u32)
     }
 }
 
diff --git a/programs/compressed-token/program/CLAUDE.md b/programs/compressed-token/program/CLAUDE.md
index 84ac18d241..01b7bffa39 100644
--- a/programs/compressed-token/program/CLAUDE.md
+++ b/programs/compressed-token/program/CLAUDE.md
@@ -46,38 +46,68 @@ Every instruction description must include the sections:
 
 ### Account Management
 1. **Create CToken Account** - [`docs/instructions/CREATE_TOKEN_ACCOUNT.md`](docs/instructions/CREATE_TOKEN_ACCOUNT.md)
-   - Create regular token account (discriminator: 18, enum: `CTokenInstruction::CreateTokenAccount`)
-   - Create associated token account (discriminator: 6, enum: `CTokenInstruction::CreateAssociatedCTokenAccount`)
-   - Create associated token account idempotent (discriminator: 101, enum: `CTokenInstruction::CreateAssociatedTokenAccountIdempotent`)
+   - Create regular token account (discriminator: 18, enum: `InstructionType::CreateTokenAccount`)
+   - Create associated token account (discriminator: 100, enum: `InstructionType::CreateAssociatedCTokenAccount`)
+   - Create associated token account idempotent (discriminator: 102, enum: `InstructionType::CreateAssociatedTokenAccountIdempotent`)
    - **Config validation:** Requires ACTIVE config only
 
-2. **Close Token Account** - `src/close_token_account.rs` (discriminator: 9, enum: `CTokenInstruction::CloseTokenAccount`)
+2. **Close Token Account** - [`docs/instructions/CLOSE_TOKEN_ACCOUNT.md`](docs/instructions/CLOSE_TOKEN_ACCOUNT.md) (discriminator: 9, enum: `InstructionType::CloseTokenAccount`)
    - Close decompressed token accounts
    - Returns rent exemption to rent recipient if compressible
    - Returns remaining lamports to destination account
 
 ### Rent Management
 3. **Claim** - [`docs/instructions/CLAIM.md`](docs/instructions/CLAIM.md)
-   - Claims rent from expired compressible accounts (discriminator: 104, enum: `CTokenInstruction::Claim`)
+   - Claims rent from expired compressible accounts (discriminator: 104, enum: `InstructionType::Claim`)
    - **Config validation:** Not inactive (active or deprecated OK)
 
 4. **Withdraw Funding Pool** - [`docs/instructions/WITHDRAW_FUNDING_POOL.md`](docs/instructions/WITHDRAW_FUNDING_POOL.md)
-   - Withdraws funds from rent recipient pool (discriminator: 105, enum: `CTokenInstruction::WithdrawFundingPool`)
+   - Withdraws funds from rent recipient pool (discriminator: 105, enum: `InstructionType::WithdrawFundingPool`)
    - **Config validation:** Not inactive (active or deprecated OK)
 
 ### Token Operations
 5. **Transfer2** - [`docs/instructions/TRANSFER2.md`](docs/instructions/TRANSFER2.md)
-   - Batch transfer instruction for compressed/decompressed operations (discriminator: 101, enum: `CTokenInstruction::Transfer2`)
+   - Batch transfer instruction for compressed/decompressed operations (discriminator: 101, enum: `InstructionType::Transfer2`)
    - Supports Compress, Decompress, CompressAndClose operations
    - Multi-mint support with sum checks
 
 6. **MintAction** - [`docs/instructions/MINT_ACTION.md`](docs/instructions/MINT_ACTION.md)
-   - Batch instruction for compressed mint management and mint operations (discriminator: 103, enum: `CTokenInstruction::MintAction`)
+   - Batch instruction for compressed mint management and mint operations (discriminator: 103, enum: `InstructionType::MintAction`)
    - Supports 9 action types: CreateCompressedMint, MintTo, UpdateMintAuthority, UpdateFreezeAuthority, CreateSplMint, MintToCToken, UpdateMetadataField, UpdateMetadataAuthority, RemoveMetadataKey
    - Handles both compressed and decompressed token minting
 
-7. **CTokenTransfer** - `src/ctoken_transfer.rs` (discriminator: 3, enum: `CTokenInstruction::CTokenTransfer`)
-   - Transfer between decompressed accounts
+7. **CTokenTransfer** - [`docs/instructions/CTOKEN_TRANSFER.md`](docs/instructions/CTOKEN_TRANSFER.md)
+   - Transfer between decompressed accounts (discriminator: 3, enum: `InstructionType::CTokenTransfer`)
+
+8. **CTokenTransferChecked** - [`docs/instructions/CTOKEN_TRANSFER_CHECKED.md`](docs/instructions/CTOKEN_TRANSFER_CHECKED.md)
+   - Transfer with decimals validation (discriminator: 6, enum: `InstructionType::CTokenTransferChecked`)
+
+9. **CTokenApprove** - [`docs/instructions/CTOKEN_APPROVE.md`](docs/instructions/CTOKEN_APPROVE.md)
+   - Approve delegate on decompressed CToken account (discriminator: 4, enum: `InstructionType::CTokenApprove`)
+
+10. **CTokenRevoke** - [`docs/instructions/CTOKEN_REVOKE.md`](docs/instructions/CTOKEN_REVOKE.md)
+   - Revoke delegate on decompressed CToken account (discriminator: 5, enum: `InstructionType::CTokenRevoke`)
+
+11. **CTokenMintTo** - [`docs/instructions/CTOKEN_MINT_TO.md`](docs/instructions/CTOKEN_MINT_TO.md)
+   - Mint tokens to decompressed CToken account (discriminator: 7, enum: `InstructionType::CTokenMintTo`)
+
+12. **CTokenBurn** - [`docs/instructions/CTOKEN_BURN.md`](docs/instructions/CTOKEN_BURN.md)
+   - Burn tokens from decompressed CToken account (discriminator: 8, enum: `InstructionType::CTokenBurn`)
+
+13. **CTokenFreezeAccount** - [`docs/instructions/CTOKEN_FREEZE_ACCOUNT.md`](docs/instructions/CTOKEN_FREEZE_ACCOUNT.md)
+   - Freeze decompressed CToken account (discriminator: 10, enum: `InstructionType::CTokenFreezeAccount`)
+
+14. **CTokenThawAccount** - [`docs/instructions/CTOKEN_THAW_ACCOUNT.md`](docs/instructions/CTOKEN_THAW_ACCOUNT.md)
+   - Thaw frozen decompressed CToken account (discriminator: 11, enum: `InstructionType::CTokenThawAccount`)
+
+15. **CTokenApproveChecked** - [`docs/instructions/CTOKEN_APPROVE_CHECKED.md`](docs/instructions/CTOKEN_APPROVE_CHECKED.md)
+   - Approve delegate with decimals validation (discriminator: 12, enum: `InstructionType::CTokenApproveChecked`)
+
+16. **CTokenMintToChecked** - [`docs/instructions/CTOKEN_MINT_TO_CHECKED.md`](docs/instructions/CTOKEN_MINT_TO_CHECKED.md)
+   - Mint tokens with decimals validation (discriminator: 14, enum: `InstructionType::CTokenMintToChecked`)
+
+17. **CTokenBurnChecked** - [`docs/instructions/CTOKEN_BURN_CHECKED.md`](docs/instructions/CTOKEN_BURN_CHECKED.md)
+   - Burn tokens with decimals validation (discriminator: 15, enum: `InstructionType::CTokenBurnChecked`)
 
 ## Config State Requirements Summary
 - **Active only:** Create token account, Create associated token account
@@ -89,16 +119,26 @@ Every instruction description must include the sections:
 - **`create_token_account.rs`** - Create regular ctoken accounts with optional compressible extension
 - **`create_associated_token_account.rs`** - Create deterministic ATA accounts
 - **`close_token_account/`** - Close ctoken accounts, handle rent distribution
-- **`ctoken_transfer.rs`** - SPL-compatible transfers between decompressed accounts
+- **`transfer/`** - SPL-compatible transfers between decompressed accounts
+  - `default.rs` - CTokenTransfer (discriminator: 3)
+  - `checked.rs` - CTokenTransferChecked (discriminator: 6)
+  - `shared.rs` - Common transfer utilities
 
 ## Token Operations
 - **`transfer2/`** - Unified transfer instruction supporting multiple modes
-  - `native_compression/` - Compress & close functionality
-  - `delegate/` - Delegated transfer authorization
+  - `compression/` - Compress & decompress functionality
+    - `ctoken/` - CToken-specific compression (compress_and_close.rs, decompress.rs, etc.)
+    - `spl.rs` - SPL token compression
+  - `processor.rs` - Main instruction processor
+  - `accounts.rs` - Account validation and parsing
 - **`mint_action/`** - Mint tokens to compressed/decompressed accounts
+- **`ctoken_approve_revoke.rs`** - CTokenApprove (4), CTokenRevoke (5), CTokenApproveChecked (12)
+- **`ctoken_mint_to.rs`** - CTokenMintTo (7), CTokenMintToChecked (14)
+- **`ctoken_burn.rs`** - CTokenBurn (8), CTokenBurnChecked (15)
+- **`ctoken_freeze_thaw.rs`** - CTokenFreezeAccount (10), CTokenThawAccount (11)
 
 ## Rent Management
-- **`claim/`** - Claim rent from expired compressible accounts
+- **`claim.rs`** - Claim rent from expired compressible accounts
 - **`withdraw_funding_pool.rs`** - Withdraw funds from rent recipient pool
 
 ## Shared Components
@@ -106,15 +146,27 @@ Every instruction description must include the sections:
   - `initialize_ctoken_account.rs` - Token account initialization with extensions
   - `create_pda_account.rs` - PDA creation and validation
   - `transfer_lamports.rs` - Safe lamport transfer helpers
-- **`extensions/`** - Extension handling (compressible, metadata)
-- **`constants.rs`** - Program seeds and constants
-- **`lib.rs`** - Main entry point and instruction dispatch
+  - `compressible_top_up.rs` - Rent top-up calculations for compressible accounts
+  - `owner_validation.rs` - Owner and delegate authority checks
+  - `token_input.rs` / `token_output.rs` - Token data handling utilities
+- **`extensions/`** - Extension handling (compressible, metadata, mint extensions)
+  - `mod.rs` - Extension validation and processing
+  - `check_mint_extensions.rs` - T22 mint extension validation
+  - `token_metadata.rs` - Token metadata extension handling
+  - `processor.rs` - Extension processing utilities
+- **`lib.rs`** - Main entry point and instruction dispatch (contains `InstructionType` enum)
 
 ## Data Structures
-All state and instruction data structures are defined in **`program-libs/ctoken-types/`** (`light-ctoken-interface` crate):
-- **`state/`** - Account state structures (CompressedToken, TokenData, CompressedMint)
+All state and instruction data structures are defined in **`program-libs/ctoken-interface/`** (`light-ctoken-interface` crate):
+- **`state/`** - Account state structures
+  - `compressed_token/` - TokenData, hashing
+  - `ctoken/` - CToken (decompressed account) structure
+  - `mint/` - CompressedMint structure
+  - `extensions/` - Extension data (Compressible, TokenMetadata, CompressedOnly, etc.)
 - **`instructions/`** - Instruction data structures for all operations
-- **`state/extensions/`** - Extension data (Compressible, TokenMetadata)
+  - `transfer2/` - Transfer2 instruction data
+  - `mint_action/` - MintAction instruction data
+  - `extensions/` - Extension instruction data
 
 **Why separate crate:** Data structures are isolated from program logic so SDKs can import types without pulling in program dependencies.
 
@@ -122,10 +174,12 @@ All state and instruction data structures are defined in **`program-libs/ctoken-
 Custom error codes are defined in **`programs/compressed-token/anchor/src/lib.rs`** (`anchor_compressed_token::ErrorCode` enum):
 - Contains all program-specific error codes used across compressed token operations
 - Errors are returned as `ProgramError::Custom(error_code as u32)` on-chain
+- CToken-specific errors are also defined in **`program-libs/ctoken-interface/src/error.rs`** (`CTokenError` enum)
 
 ## SDKs (`sdk-libs/`)
-- **`compressed-token-sdk/`** - SDK for programs to interact with compressed tokens (CPIs, instruction builders)
+- **`ctoken-sdk/`** - SDK for programs to interact with compressed tokens (CPIs, instruction builders)
 - **`token-client/`** - Client SDK for Rust applications (test helpers, transaction builders)
+- **`ctoken-types/`** - Lightweight types for client-side usage
 
 ## Compressible Extension Documentation
 When working with ctoken accounts that have the compressible extension (rent management), you **MUST** read:
diff --git a/programs/compressed-token/program/Cargo.toml b/programs/compressed-token/program/Cargo.toml
index 654be30a12..f0e37f57ab 100644
--- a/programs/compressed-token/program/Cargo.toml
+++ b/programs/compressed-token/program/Cargo.toml
@@ -36,9 +36,6 @@ cpi-without-program-ids = []
 [dependencies]
 light-program-profiler = { workspace = true }
 
-light-token-22 = { package = "spl-token-2022", git = "https://github.com/Lightprotocol/token-2022", rev = "06d12f50a06db25d73857d253b9a82857d6f4cdf", features = [
-    "no-entrypoint",
-] }
 anchor-lang = { workspace = true }
 spl-token = { workspace = true, features = ["no-entrypoint"] }
 account-compression = { workspace = true, features = ["cpi", "no-idl"] }
diff --git a/programs/compressed-token/program/docs/CLAUDE.md b/programs/compressed-token/program/docs/CLAUDE.md
index 5753baa06c..461b7bf356 100644
--- a/programs/compressed-token/program/docs/CLAUDE.md
+++ b/programs/compressed-token/program/docs/CLAUDE.md
@@ -7,9 +7,29 @@ This documentation is organized to provide clear navigation through the compress
 - **`CLAUDE.md`** (this file) - Documentation structure guide
 - **`../CLAUDE.md`** (parent) - Main entry point with summary and instruction index
 - **`ACCOUNTS.md`** - Complete account layouts and data structures
+- **`EXTENSIONS.md`** - Token-2022 extension validation across ctoken instructions
+- **`RESTRICTED_T22_EXTENSIONS.md`** - SPL Token-2022 behavior for 5 restricted extensions
+- **`T22_VS_CTOKEN_COMPARISON.md`** - Comparison of T22 vs ctoken extension behavior
 - **`instructions/`** - Detailed instruction documentation
   - `CREATE_TOKEN_ACCOUNT.md` - Create token account & associated token account instructions
-  - Additional instruction docs to be added as needed
+  - `MINT_ACTION.md` - Mint operations and compressed mint management
+  - `TRANSFER2.md` - Batch transfer instruction for compressed/decompressed operations
+  - `CLAIM.md` - Claim rent from expired compressible accounts
+  - `CLOSE_TOKEN_ACCOUNT.md` - Close decompressed token accounts
+  - `CTOKEN_TRANSFER.md` - Transfer between decompressed accounts
+  - `CTOKEN_TRANSFER_CHECKED.md` - Transfer with decimals validation
+  - `CTOKEN_APPROVE.md` - Approve delegate on decompressed CToken account
+  - `CTOKEN_REVOKE.md` - Revoke delegate on decompressed CToken account
+  - `CTOKEN_MINT_TO.md` - Mint tokens to decompressed CToken account
+  - `CTOKEN_BURN.md` - Burn tokens from decompressed CToken account
+  - `CTOKEN_FREEZE_ACCOUNT.md` - Freeze decompressed CToken account
+  - `CTOKEN_THAW_ACCOUNT.md` - Thaw frozen decompressed CToken account
+  - `CTOKEN_APPROVE_CHECKED.md` - Approve delegate with decimals validation
+  - `CTOKEN_MINT_TO_CHECKED.md` - Mint tokens with decimals validation
+  - `CTOKEN_BURN_CHECKED.md` - Burn tokens with decimals validation
+  - `WITHDRAW_FUNDING_POOL.md` - Withdraw funds from rent recipient pool
+  - `CREATE_TOKEN_POOL.md` - Create initial token pool for SPL/T22 mint compression
+  - `ADD_TOKEN_POOL.md` - Add additional token pools (up to 5 per mint)
 
 ## Navigation Tips
 - Start with `../CLAUDE.md` for the instruction index and overview
diff --git a/programs/compressed-token/program/docs/EXTENSIONS.md b/programs/compressed-token/program/docs/EXTENSIONS.md
new file mode 100644
index 0000000000..cf70935947
--- /dev/null
+++ b/programs/compressed-token/program/docs/EXTENSIONS.md
@@ -0,0 +1,498 @@
+# Token-2022 Extensions
+
+This document describes how Token-2022 extensions are validated across compressed token instructions.
+
+## Overview
+
+The compressed token program supports 16 Token-2022 extension types. **5 restricted extensions** require instruction-level validation checks. Pure mint extensions (metadata, group, etc.) are allowed without explicit instruction support.
+
+**Allowed extensions** (defined in `program-libs/ctoken-interface/src/token_2022_extensions.rs:24-44`):
+
+1. MetadataPointer
+2. TokenMetadata
+3. InterestBearingConfig
+4. GroupPointer
+5. GroupMemberPointer
+6. TokenGroup
+7. TokenGroupMember
+8. MintCloseAuthority
+9. TransferFeeConfig *(restricted)*
+10. DefaultAccountState *(restricted)*
+11. PermanentDelegate *(restricted)*
+12. TransferHook *(restricted)*
+13. Pausable *(restricted)*
+14. ConfidentialTransferMint
+15. ConfidentialTransferFeeConfig
+16. ConfidentialMintBurn
+
+**Restricted extensions** require `compression_only` mode when creating token accounts, and have runtime checks during transfers.
+- restricted extensions are only supported in ctoken accounts not compressed accounts.
+- compression only prevents compressed transfers once ctoken accounts are compressed and closed.
+
+## Quick Reference
+
+| Instruction              | TransferFee       | DefaultState       | PermanentDelegate  | TransferHook      | Pausable           |
+|--------------------------|-------------------|--------------------|--------------------|-------------------|--------------------|
+| CreateTokenAccount       | requires comp_only| applies frozen     | requires comp_only | requires comp_only| requires comp_only |
+| Transfer2 (→compressed)  | blocked           | -                  | blocked            | blocked           | blocked if paused  |
+| Transfer2 (c→c)          | blocked           | -                  | blocked            | blocked           | blocked            |
+| Transfer2 (SPL→CToken)   | fees must be 0    | -                  | -                  | hook must be nil  | blocked if paused  |
+| Transfer2 (CToken→SPL)   | fees must be 0    | -                  | -                  | hook must be nil  | blocked if paused  |
+| Transfer2 (decompress)   | allowed           | restores frozen    | allowed            | allowed           | allowed            |
+| Transfer2 (C&C)          | allowed           | preserved          | allowed            | allowed           | allowed            |
+| CTokenTransfer           | fees must be 0    | frozen blocked     | authority check    | hook must be nil  | blocked if paused  |
+| CTokenApprove            | -                 | frozen blocked     | -                  | -                 | -                  |
+| CTokenRevoke             | -                 | frozen blocked     | -                  | -                 | -                  |
+| CTokenBurn               | N/A (CMint-only)  | frozen blocked     | N/A (CMint-only)   | N/A (CMint-only)  | N/A (CMint-only)   |
+| CTokenMintTo             | N/A (CMint-only)  | -                  | N/A (CMint-only)   | N/A (CMint-only)  | N/A (CMint-only)   |
+| CTokenFreeze/Thaw        | -                 | -                  | -                  | -                 | -                  |
+| CloseTokenAccount        | -                 | -                  | -                  | -                 | -                  |
+| CreateTokenPool          | fees must be 0    | -                  | -                  | hook must be nil  | -                  |
+
+**Transfer2 Mode Definitions:**
+- `→compressed` = Compress to output compressed account (Compress mode with compressed outputs)
+- `c→c` = Transfer between compressed accounts
+- `SPL→CToken` = Transfer from SPL token account to CToken account (uses Compress mode)
+- `CToken→SPL` = Transfer from CToken account to SPL token account (uses Compress+Decompress)
+- `decompress` = Decompress from compressed account to SPL/CToken (pure Decompress, no Compress)
+- `C&C` = CompressAndClose mode
+
+**Key:**
+- `requires comp_only` = Extension triggers compression_only requirement with CompressionOnlyRequired (6131)
+- `blocked` = Operation fails with MintHasRestrictedExtensions (6142)
+- `fees must be 0` / `hook must be nil` = Specific validation check (errors: 6129, 6130)
+- `blocked if paused` = Fails with MintPaused (6127) when mint is paused
+- `frozen blocked` = Account frozen state prevents operation (pinocchio check)
+- `allowed` = Bypasses extension state checks (decompress/C&C exit paths)
+- `N/A (CMint-only)` = Instruction only works with CMints which don't support restricted extensions
+- `-` = No extension-specific behavior
+
+---
+
+## Restricted Extensions
+
+### 1. TransferFeeConfig
+
+**Constraint:** Both `older_transfer_fee` and `newer_transfer_fee` must have `transfer_fee_basis_points == 0` and `maximum_fee == 0`.
+
+| Instruction | Validation Function | Check | Error |
+|-------------|---------------------|-------|-------|
+| CreateTokenPool | `assert_mint_extensions()` | Fees must be zero | `NonZeroTransferFeeNotSupported` (6129) |
+| Transfer2 | `check_mint_extensions()` | Fees must be zero | `NonZeroTransferFeeNotSupported` (6129) |
+| CTokenTransfer | `check_mint_extensions()` | Fees must be zero | `NonZeroTransferFeeNotSupported` (6129) |
+| CreateTokenAccount | `has_mint_extensions()` | Flags restricted extension | `CompressionOnlyRequired` (6131) |
+
+**Validation paths:**
+- `programs/compressed-token/anchor/src/instructions/create_token_pool.rs:142-153` - `assert_mint_extensions()` checks TransferFeeConfig
+- `programs/compressed-token/program/src/extensions/check_mint_extensions.rs:86-99` - `parse_mint_extensions()` checks TransferFeeConfig
+
+**Unchecked instructions:**
+1. CTokenApprove
+2. CTokenRevoke
+3. CTokenBurn
+4. CTokenMintTo
+5. CTokenFreezeAccount
+6. CTokenThawAccount
+7. CloseTokenAccount
+
+---
+
+### 2. TransferHook
+
+**Constraint:** `program_id` must be nil (no active hook program).
+
+| Instruction | Validation Function | Check | Error |
+|-------------|---------------------|-------|-------|
+| CreateTokenPool | `assert_mint_extensions()` | program_id must be nil | `TransferHookNotSupported` (6130) |
+| Transfer2 | `check_mint_extensions()` | program_id must be nil | `TransferHookNotSupported` (6130) |
+| CTokenTransfer | `check_mint_extensions()` | program_id must be nil | `TransferHookNotSupported` (6130) |
+| CreateTokenAccount | `has_mint_extensions()` | Flags restricted extension | `CompressionOnlyRequired` (6131) |
+
+**Validation paths:**
+- `programs/compressed-token/anchor/src/instructions/create_token_pool.rs:155-162` - `assert_mint_extensions()` checks TransferHook
+- `programs/compressed-token/program/src/extensions/check_mint_extensions.rs:101-107` - `parse_mint_extensions()` checks TransferHook
+
+**Unchecked instructions:**
+1. CTokenApprove
+2. CTokenRevoke
+3. CTokenBurn
+4. CTokenMintTo
+5. CTokenFreezeAccount
+6. CTokenThawAccount
+7. CloseTokenAccount
+
+---
+
+### 3. PermanentDelegate
+
+**Behavior:** Permanent delegate can authorize transfers/burns in addition to owner.
+
+| Instruction | Validation Function | Check | Error |
+|-------------|---------------------|-------|-------|
+| CreateTokenAccount | `has_mint_extensions()` | Flags restricted extension | `CompressionOnlyRequired` (6131) |
+| Transfer2 | `parse_mint_extensions()` → `verify_owner_or_delegate_signer()` | Extract delegate pubkey, then validate authority is owner OR delegate. If authority matches permanent delegate, that account must be a signer. | `OwnerMismatch` (6075) or `MissingRequiredSignature` |
+| CTokenTransfer | `parse_mint_extensions()` → `verify_owner_or_delegate_signer()` | Extract delegate pubkey, then validate authority is owner OR delegate. If authority matches permanent delegate, that account must be a signer. | `OwnerMismatch` (6075) or `MissingRequiredSignature` |
+
+**Validation paths:**
+- `programs/compressed-token/program/src/extensions/check_mint_extensions.rs:77-84` - Extracts delegate pubkey in `parse_mint_extensions()`
+- `programs/compressed-token/program/src/shared/owner_validation.rs:30-78` - `verify_owner_or_delegate_signer()` validates delegate/permanent delegate signer
+- `programs/compressed-token/program/src/transfer/shared.rs:164-179` - `validate_permanent_delegate()`
+
+**Unchecked instructions:**
+1. CTokenApprove
+2. CTokenRevoke
+3. CTokenBurn - permanent delegate cannot burn without owner signature
+4. CTokenMintTo
+5. CTokenFreezeAccount
+6. CTokenThawAccount
+7. CloseTokenAccount
+
+---
+
+### 4. Pausable
+
+**Constraint:** If `pausable_config.paused == true`, all transfer operations fail immediately.
+
+| Instruction | Validation Function | Check | Error |
+|-------------|---------------------|-------|-------|
+| CreateTokenAccount | `has_mint_extensions()` | Flags restricted extension | `CompressionOnlyRequired` (6131) |
+| Transfer2 | `check_mint_extensions()` | `pausable_config.paused == false` | `MintPaused` (6127) |
+| CTokenTransfer | `check_mint_extensions()` | `pausable_config.paused == false` | `MintPaused` (6127) |
+
+**Validation path:**
+- `programs/compressed-token/program/src/extensions/check_mint_extensions.rs:71-74` - `parse_mint_extensions()` checks PausableConfig.paused
+- `programs/compressed-token/program/src/extensions/check_mint_extensions.rs:147-149` - `check_mint_extensions()` throws MintPaused error
+
+**Unchecked instructions:**
+1. CTokenApprove - allowed when paused (only affects delegation, not token movement)
+2. CTokenRevoke - allowed when paused (only affects delegation, not token movement)
+3. CTokenBurn - N/A (CMint-only instruction, CMints don't support Pausable)
+4. CTokenMintTo - N/A (CMint-only instruction, CMints don't support Pausable)
+5. CTokenFreezeAccount - allowed when paused (freeze authority can still manage accounts)
+6. CTokenThawAccount - allowed when paused (freeze authority can still manage accounts)
+7. CloseTokenAccount - allowed when paused (account management, not token movement)
+
+**Note:** CTokenMintTo and CTokenBurn only work with CMints (compressed mints). CMints do not support restricted extensions - only TokenMetadata is allowed. T22 mints with Pausable extension can only be used with CToken accounts via Transfer2 and CTokenTransfer.
+
+---
+
+### 5. DefaultAccountState
+
+**Behavior:** When a mint has DefaultAccountState extension, new CToken accounts inherit the frozen state at creation time.
+
+| Instruction | Validation Function | Check | Error |
+|-------------|---------------------|-------|-------|
+| CreateTokenAccount | `has_mint_extensions()` | Flags restricted extension, applies frozen state | `CompressionOnlyRequired` (6131) |
+| Transfer2 (Decompress) | - | Restores frozen state from CompressedOnly extension | - |
+
+**Validation paths:**
+- `programs/compressed-token/program/src/extensions/check_mint_extensions.rs:211-220` - Detects `default_state_frozen`
+- `programs/compressed-token/program/src/shared/initialize_ctoken_account.rs:96-100` - Applies frozen state
+
+**Account Initialization:**
+```rust
+state: if mint_extensions.default_state_frozen {
+    AccountState::Frozen as u8  // 2
+} else {
+    AccountState::Initialized as u8  // 1
+}
+```
+
+**Frozen Account Behavior (pinocchio checks):**
+- Transfer: Blocked (source or destination frozen)
+- Approve: Blocked (source frozen)
+- Revoke: Blocked (source frozen)
+- Burn: Blocked (source frozen)
+- Freeze/Thaw: Can override frozen state
+
+**Unchecked instructions:**
+1. CTokenMintTo - no frozen check
+2. CTokenFreezeAccount - sets frozen state
+3. CTokenThawAccount - clears frozen state
+4. CloseTokenAccount - no frozen check
+
+**Note:** Unlike other restricted extensions, DefaultAccountState does NOT have runtime validation in `check_mint_extensions()`. The frozen state is applied at account creation and checked by pinocchio during token operations.
+
+---
+
+## CompressedOnly Extension
+
+The CompressedOnly extension preserves CToken account state during CompressAndClose operations, enabling full state restoration during Decompress.
+
+### Data Structures
+
+**State Extension** (`program-libs/ctoken-interface/src/state/extensions/compressed_only.rs`):
+```rust
+pub struct CompressedOnlyExtension {
+    /// The delegated amount from the source CToken account's delegate field.
+    pub delegated_amount: u64,
+    /// Withheld transfer fee amount from the source CToken account.
+    pub withheld_transfer_fee: u64,
+}
+```
+
+**Instruction Data** (`program-libs/ctoken-interface/src/instructions/extensions/compressed_only.rs`):
+```rust
+pub struct CompressedOnlyExtensionInstructionData {
+    /// The delegated amount from the source CToken account's delegate field.
+    pub delegated_amount: u64,
+    /// Withheld transfer fee amount
+    pub withheld_transfer_fee: u64,
+    /// Whether the source CToken account was frozen when compressed.
+    pub is_frozen: bool,
+    /// Index of the compression operation that consumes this input.
+    pub compression_index: u8,
+}
+```
+
+### When Created (CompressAndClose)
+
+**Path:** `programs/compressed-token/program/src/transfer2/compression/ctoken/compress_and_close.rs`
+
+**Trigger:** `ZCompressionMode::CompressAndClose` with `compression_only=true` on source CToken account.
+
+**Requirements:**
+- Source CToken must have `compression_only` flag set
+- Output compressed token must include CompressedOnly extension in TLV data
+- Extension values must match source CToken state
+
+**Validation (lines 168-277 in `validate_compressed_token_account`):**
+1. If source has `compression_only=true`, CompressedOnly extension is required (line 173-175)
+2. `delegated_amount` must match source CToken's `delegated_amount` (lines 181-188)
+3. Delegate pubkey must match if delegated_amount > 0 (lines 189-210)
+4. `withheld_transfer_fee` must match source's TransferFeeAccount withheld amount (lines 211-237)
+5. `is_frozen` must match source CToken's frozen state (`state == 2`) (lines 239-251)
+6. If source is frozen but extension missing → `CompressAndCloseMissingCompressedOnlyExtension` (lines 253-259)
+
+**Source CToken Reset (lines 71-74 in `process_compress_and_close`):**
+```rust
+ctoken.base.amount.set(0);
+// Unfreeze the account if frozen (frozen state is preserved in compressed token TLV)
+// This allows the close_token_account validation to pass for frozen accounts
+ctoken.base.set_initialized();
+```
+
+### When Consumed (Decompress)
+
+**Path:** `programs/compressed-token/program/src/transfer2/compression/ctoken/decompress.rs`
+
+**Trigger:** Decompressing a compressed token that has CompressedOnly extension.
+
+**State Restoration (`apply_decompress_extension_state` function, lines 56-128):**
+1. Extract CompressedOnly data from input TLV (lines 65-77)
+2. Validate destination is fresh with matching owner via `validate_decompression_destination` (lines 15-50)
+3. Restore delegate pubkey from instruction input account (lines 85-96)
+4. Restore `delegated_amount` to destination CToken (lines 99-101)
+5. Restore `withheld_transfer_fee` to TransferFeeAccount extension (lines 104-120)
+6. Restore frozen state via `ctoken.base.set_frozen()` (lines 122-125)
+
+**Validation (`validate_decompression_destination`, lines 15-50):**
+- Destination owner must match input owner
+- Destination amount must be 0
+- Destination must not have delegate
+- Destination delegated_amount must be 0
+- Destination must not have close_authority
+
+### State Preservation Matrix
+
+| Field | Preserved (C&C) | Restored (Decompress) | Notes |
+|-------|-----------------|----------------------|-------|
+| delegated_amount | ✅ | ✅ | Stored in extension |
+| withheld_transfer_fee | ✅ | ✅ | Restored to TransferFeeAccount |
+| is_frozen | ✅ | ✅ | Restored via `set_frozen()` |
+| delegate pubkey | Validated | From input | Passed as instruction account |
+| amount | ❌ (set to 0) | From compression | New amount from compressed token |
+| close_authority | ❌ | ❌ | Not preserved |
+
+### Error Codes
+
+| Error | Code | Description |
+|-------|------|-------------|
+| `CompressAndCloseMissingCompressedOnlyExtension` | 6133 | Restricted mint CompressAndClose lacks CompressedOnly output |
+| `CompressAndCloseDelegatedAmountMismatch` | 6135 | delegated_amount doesn't match source |
+| `CompressAndCloseWithheldFeeMismatch` | 6137 | withheld_transfer_fee doesn't match source |
+| `CompressAndCloseFrozenMismatch` | 6138 | is_frozen doesn't match source frozen state |
+
+---
+
+## Validation Functions
+
+### `assert_mint_extensions()`
+**Path:** `programs/compressed-token/anchor/src/instructions/create_token_pool.rs:129-165`
+
+**Used by:** CreateTokenPool (Anchor layer, pool creation time)
+
+**Behavior:**
+1. Deserialize mint with `PodStateWithExtensions<PodMint>::unpack()` (line 130-131)
+2. Validate all extensions are in `ALLOWED_EXTENSION_TYPES` → `MintWithInvalidExtension` (lines 134-140)
+3. If TransferFeeConfig exists: check fees are zero → `NonZeroTransferFeeNotSupported` (lines 142-153)
+4. If TransferHook exists: check program_id is nil → `TransferHookNotSupported` (lines 155-162)
+
+**Does NOT check:** Pausable state, PermanentDelegate (allowed at pool creation)
+
+---
+
+### `has_mint_extensions()`
+**Path:** `programs/compressed-token/program/src/extensions/check_mint_extensions.rs:175-230`
+
+**Used by:** CreateTokenAccount (detection only)
+
+**Behavior:**
+1. Return default flags if not Token-2022 mint (lines 177-179)
+2. Deserialize mint with `PodStateWithExtensions<PodMint>::unpack()` (lines 181-184)
+3. Get all extension types in a single call (line 187)
+4. Validate all extensions are in `ALLOWED_EXTENSION_TYPES` → `MintWithInvalidExtension` (lines 196-200)
+5. Detect which restricted extensions are present (lines 201-209)
+6. Check if DefaultAccountState is set to Frozen (lines 213-220)
+7. Return `MintExtensionFlags` with boolean flags
+
+**Returns** (defined in `program-libs/ctoken-interface/src/token_2022_extensions.rs:59-74`):
+```rust
+MintExtensionFlags {
+    has_pausable: bool,
+    has_permanent_delegate: bool,
+    has_default_account_state: bool,  // Extension exists (restricted)
+    default_state_frozen: bool,       // Current state is Frozen (for CToken creation)
+    has_transfer_fee: bool,
+    has_transfer_hook: bool,
+}
+```
+
+**Does NOT validate:** Extension values (fees, program_id, paused state). Only detects presence.
+
+---
+
+### `parse_mint_extensions()`
+**Path:** `programs/compressed-token/program/src/extensions/check_mint_extensions.rs:53-117`
+
+**Used by:** Internal helper for `check_mint_extensions()` and `build_mint_extension_cache()`
+
+**Behavior:**
+1. Return default if not Token-2022 mint (lines 57-59)
+2. Deserialize mint with `PodStateWithExtensions<PodMint>::unpack()` (lines 61-64)
+3. Compute `has_restricted_extensions` from extension types (lines 66-68)
+4. Check if Pausable extension exists and paused state (lines 71-74)
+5. Extract PermanentDelegate pubkey if exists (lines 77-84)
+6. Check TransferFeeConfig for non-zero fees (lines 87-99)
+7. Check TransferHook for non-nil program_id (lines 102-107)
+
+**Returns** (defined in `check_mint_extensions.rs:21-40`):
+```rust
+MintExtensionChecks {
+    permanent_delegate: Option<Pubkey>,  // For signer validation
+    has_transfer_fee: bool,
+    has_restricted_extensions: bool,     // For CompressAndClose validation
+    is_paused: bool,                     // CompressAndClose bypasses this check
+    has_non_zero_transfer_fee: bool,     // CompressAndClose bypasses this check
+    has_non_nil_transfer_hook: bool,     // CompressAndClose bypasses this check
+}
+```
+
+---
+
+### `check_mint_extensions()`
+**Path:** `programs/compressed-token/program/src/extensions/check_mint_extensions.rs:134-159`
+
+**Used by:** Transfer2, CTokenTransfer (runtime validation)
+
+**Parameters:**
+- `mint_account: &AccountInfo` - The SPL Token 2022 mint
+- `deny_restricted_extensions: bool` - If true, fails when mint has restricted extensions
+
+**Behavior:** Wrapper around `parse_mint_extensions()` that throws errors for invalid states:
+1. Call `parse_mint_extensions()` (line 138)
+2. If `deny_restricted_extensions && has_restricted_extensions` → `MintHasRestrictedExtensions` (6142) (lines 141-145)
+3. If `is_paused == true` → `MintPaused` (6127) (lines 148-150)
+4. If `has_non_zero_transfer_fee` → `NonZeroTransferFeeNotSupported` (6129) (lines 151-153)
+5. If `has_non_nil_transfer_hook` → `TransferHookNotSupported` (6130) (lines 154-156)
+
+---
+
+### `build_mint_extension_cache()`
+**Path:** `programs/compressed-token/program/src/transfer2/check_extensions.rs:77-145`
+
+**Used by:** Transfer2 (batch validation)
+
+**Behavior:**
+1. For each unique mint in inputs (lines 85-97):
+   - If no outputs: call `parse_mint_extensions()` (bypass state checks for pure decompress)
+   - Otherwise: call `check_mint_extensions()` with `deny_restricted_extensions`
+   - Cache result in `ArrayMap<u8, MintExtensionChecks, 5>`
+2. For each unique mint in compressions (lines 100-142):
+   - CompressAndClose and full Decompress: use `parse_mint_extensions()` (bypass state checks)
+   - Otherwise: use `check_mint_extensions()` with `deny_restricted_extensions`
+3. Special handling for CompressAndClose mode (lines 116-137):
+   - Mints with restricted extensions require CompressedOnly output extension
+   - If missing → `CompressAndCloseMissingCompressedOnlyExtension` (6133)
+
+**Returns:** `MintExtensionCache` (type alias defined at line 46) - Cached checks keyed by mint account index
+
+---
+
+## Error Codes
+
+| Error | Code | Description |
+|-------|------|-------------|
+| `OwnerMismatch` | 6075 | Authority signature does not match owner/delegate |
+| `MintPaused` | 6127 | Mint is paused |
+| `NonZeroTransferFeeNotSupported` | 6129 | TransferFeeConfig has non-zero fees |
+| `TransferHookNotSupported` | 6130 | TransferHook has non-nil program_id |
+| `CompressionOnlyRequired` | 6131 | Restricted extension requires compression_only mode |
+| `MintHasRestrictedExtensions` | 6142 | Cannot create compressed outputs with restricted extensions |
+
+
+## Restricted Extension Enforcement for Compression
+
+### Transfer2
+
+**Enforcement:** `build_mint_extension_cache()` is called with `deny_restricted_extensions = !out_token_data.is_empty()`
+
+**Flow:**
+1. `build_mint_extension_cache()` computes `deny_restricted_extensions = !inputs.out_token_data.is_empty()` (line 82)
+2. For input mints: calls `check_mint_extensions(mint, deny_restricted_extensions)` (line 93)
+3. If `deny_restricted_extensions=true` and mint has restricted extensions → `MintHasRestrictedExtensions` (6142)
+
+**Exception - CompressAndClose and Decompress modes:**
+- CompressAndClose: calls `parse_mint_extensions()` to bypass state checks (line 111)
+- Full Decompress (no outputs): calls `parse_mint_extensions()` to bypass state checks (lines 89-91)
+- CompressAndClose still requires CompressedOnly output extension for restricted mints (lines 116-137)
+- If missing → `CompressAndCloseMissingCompressedOnlyExtension` (6133)
+
+**Path:** `programs/compressed-token/program/src/transfer2/processor.rs:61` calls `build_mint_extension_cache()`
+
+### Anchor Instructions
+
+**NOT ENFORCED** - The following anchor instructions do NOT check for restricted extensions:
+
+1. `mint_to` - Can mint to compressed accounts from T22 mints with restricted extensions
+2. `batch_compress` - Can compress SPL tokens from T22 mints with restricted extensions
+3. `compress_spl_token_account` - Can compress SPL token account balance from T22 mints with restricted extensions
+4. `transfer` (anchor) - Can compress/decompress with T22 mints with restricted extensions
+
+**Gap:** These anchor instructions should either:
+- Check for restricted extensions and fail with `MintHasRestrictedExtensions`
+- Or be deprecated in favor of Transfer2 which properly enforces restrictions
+
+## Open Questions
+
+### 1. ~~Should DefaultAccountState be a restricted extension?~~ ✅ IMPLEMENTED
+
+**Status:** Implemented. `DefaultAccountState` is now in `RESTRICTED_EXTENSION_TYPES`.
+
+When a mint has the `DefaultAccountState` extension (regardless of current state), the `has_restricted_extensions()` flag is set to true via `has_default_account_state`, which enforces `compression_only` mode. This is necessary because:
+1. The default state can be changed by mint authority at any time
+2. Once compressed, we don't re-check the mint's DefaultAccountState when creating outputs
+3. CToken accounts still respect the current frozen state for proper initialization
+
+### 2. ~~How to enforce restricted extensions in anchor instructions?~~ ✅ IMPLEMENTED
+
+**Status:** Implemented via different pool PDA derivation for restricted mints.
+
+**Implementation:**
+- `CreateTokenPool` uses `restricted_seed()` function (lines 21-39) to detect restricted extensions
+- If mint has restricted extensions: `seeds = [b"pool", mint_pubkey, RESTRICTED_POOL_SEED]`
+- Otherwise: `seeds = [b"pool", mint_pubkey]`
+- `AddTokenPoolInstruction` follows same derivation pattern (lines 171-201)
+- Anchor instructions use normal derivation → pool not found → CPI fails automatically
+
+**Path:** `programs/compressed-token/anchor/src/instructions/create_token_pool.rs:17-39`
diff --git a/programs/compressed-token/program/docs/RESTRICTED_T22_EXTENSIONS.md b/programs/compressed-token/program/docs/RESTRICTED_T22_EXTENSIONS.md
new file mode 100644
index 0000000000..9248afb053
--- /dev/null
+++ b/programs/compressed-token/program/docs/RESTRICTED_T22_EXTENSIONS.md
@@ -0,0 +1,378 @@
+# Restricted Token-2022 Extensions
+
+This document describes the behavior of the 5 restricted Token-2022 extensions as implemented in SPL Token-2022. These extensions are classified as "restricted" because they require special handling during compression operations.
+
+## Quick Reference
+
+| Instruction       | TransferFee     | DefaultState        | PermanentDelegate | TransferHook  | Pausable          |
+|-------------------|-----------------|---------------------|-------------------|---------------|-------------------|
+| InitializeAccount | adds FeeAmount  | applies frozen state| -                 | adds marker   | adds marker       |
+| Transfer          | fee deducted   | frozen blocked      | authority check   | CPI invoked  | blocked if paused |
+| Approve           | -              | frozen blocked      | owner only        | -            | allowed           |
+| Revoke            | -              | frozen blocked      | owner only        | -            | allowed           |
+| Burn              | -              | frozen blocked      | authority check   | -            | blocked if paused |
+| MintTo            | -              | -                   | -                 | -            | blocked if paused |
+| CloseAccount      | withheld check | -                   | -                 | -            | -                 |
+| Freeze/Thaw       | -              | -                   | -                 | -            | allowed           |
+
+---
+
+## 1. TransferFeeConfig
+
+### Overview
+
+The TransferFeeConfig extension enables mints to automatically assess fees on token transfers, with fees calculated as a percentage (basis points) of the transfer amount, capped at a configurable maximum. Fees are withheld in the destination account and can be collected by a designated authority.
+
+### Data Structures
+
+#### TransferFeeConfig (Mint Extension)
+
+```rust
+pub struct TransferFeeConfig {
+    /// Authority that can update the fee configuration
+    pub transfer_fee_config_authority: OptionalNonZeroPubkey,
+    /// Authority that can withdraw withheld fees
+    pub withdraw_withheld_authority: OptionalNonZeroPubkey,
+    /// Accumulated fees harvested from accounts, awaiting withdrawal
+    pub withheld_amount: PodU64,
+    /// Fee schedule used when current_epoch < newer_transfer_fee.epoch
+    pub older_transfer_fee: TransferFee,
+    /// Fee schedule used when current_epoch >= newer_transfer_fee.epoch
+    pub newer_transfer_fee: TransferFee,
+}
+```
+
+#### TransferFee
+
+```rust
+pub struct TransferFee {
+    /// Epoch when this fee schedule becomes active
+    pub epoch: PodU64,
+    /// Maximum fee in token amount (absolute cap)
+    pub maximum_fee: PodU64,
+    /// Fee rate in basis points (0.01% increments, max 10,000 = 100%)
+    pub transfer_fee_basis_points: PodU16,
+}
+```
+
+#### TransferFeeAmount (Account Extension)
+
+```rust
+pub struct TransferFeeAmount {
+    /// Fees withheld on this account from incoming transfers
+    pub withheld_amount: PodU64,
+}
+```
+
+### Instruction Behavior
+
+#### Transfer (TransferCheckedWithFee)
+
+**Fee Calculation:**
+```
+fee = ceil(amount * transfer_fee_basis_points / 10,000)
+fee = min(fee, maximum_fee)
+```
+
+The ceiling division ensures the protocol never undercharges.
+
+**Token Flow:**
+- Source account: debited full `amount`
+- Destination account balance: credited `amount - fee`
+- Destination account `withheld_amount`: increased by `fee`
+
+The client must provide the expected `fee` parameter, which is validated against the on-chain calculation.
+
+#### CloseAccount
+
+Blocked if `withheld_amount > 0`. Returns `TokenError::AccountHasWithheldTransferFees`. Fees must be harvested or withdrawn before closing.
+
+#### HarvestWithheldTokensToMint
+
+- **Permissionless** - anyone can call this instruction
+- Moves `withheld_amount` from specified token accounts to the mint's `withheld_amount`
+- Works on frozen accounts
+
+#### WithdrawWithheldTokensFromMint
+
+- Requires signature from `withdraw_withheld_authority`
+- Transfers mint's `withheld_amount` to a specified destination token account
+- Destination must not be frozen
+
+#### SetTransferFee
+
+- Requires signature from `transfer_fee_config_authority`
+- **2-epoch delay**: new fee takes effect at `current_epoch + 2`
+- Prevents "rug pulls" where fees could be changed at epoch boundaries
+
+### Validation Rules
+
+| Rule | Error |
+|------|-------|
+| `transfer_fee_basis_points > 10,000` | `TransferFeeExceedsMaximum` |
+| Fee mismatch during transfer | `FeeMismatch` |
+| Close account with `withheld_amount > 0` | `AccountHasWithheldTransferFees` |
+| Withdraw to frozen account | `AccountFrozen` |
+| Missing authority for SetTransferFee/Withdraw | `NoAuthorityExists` |
+| Transfer without mint when TransferFeeAmount exists | `MintRequiredForTransfer` |
+
+---
+
+## 2. DefaultAccountState
+
+### Overview
+
+The DefaultAccountState extension allows mint authorities to configure new token accounts to be created in a specific state (Initialized or Frozen) by default. This enables scenarios such as requiring KYC verification before users can interact with their tokens.
+
+### Data Structures
+
+#### DefaultAccountState (Mint Extension)
+
+```rust
+pub struct DefaultAccountState {
+    /// Default Account::state in which new Accounts should be initialized
+    pub state: PodAccountState,  // u8
+}
+```
+
+#### AccountState Enum
+
+```rust
+pub enum AccountState {
+    /// Account is not yet initialized (value: 0)
+    Uninitialized,
+    /// Account is initialized; permitted operations allowed (value: 1)
+    Initialized,
+    /// Account has been frozen by the mint freeze authority (value: 2)
+    Frozen,
+}
+```
+
+### Instruction Behavior
+
+#### Initialize
+
+- Must be called before `InitializeMint`
+- Sets the default state for all new token accounts
+- Cannot set state to `Uninitialized`
+
+#### InitializeAccount Interaction
+
+New accounts automatically inherit the mint's default state:
+```rust
+let starting_state = if let Ok(default_account_state) = mint.get_extension::<DefaultAccountState>() {
+    AccountState::try_from(default_account_state.state)?
+} else {
+    AccountState::Initialized
+};
+```
+
+#### Operations Blocked When Account is Frozen
+
+| Operation | Source Account | Destination Account |
+|-----------|----------------|---------------------|
+| Transfer | Blocked | Blocked |
+| Approve | Blocked | N/A |
+| Revoke | Blocked | N/A |
+| Burn | Blocked | N/A |
+| MintTo | N/A | Blocked |
+
+#### Freeze/Thaw Operations
+
+- `FreezeAccount`: Changes state from `Initialized` to `Frozen`
+- `ThawAccount`: Changes state from `Frozen` to `Initialized`
+- Both require the mint's `freeze_authority` signature
+- Can override any default state
+
+#### Update
+
+- Changes the default state for future token accounts
+- Requires the mint's `freeze_authority` signature
+- Cannot set state to `Uninitialized`
+
+### Validation Rules
+
+1. **Cannot set to Uninitialized**: Both Initialize and Update reject `Uninitialized` with `InvalidState`
+2. **Freeze authority required for Frozen default**: If default is Frozen, mint must have freeze authority
+3. **Update requires freeze authority**: Only freeze authority can change default state
+4. **Extension before mint**: Initialize only works on uninitialized mints
+
+---
+
+## 3. PermanentDelegate
+
+### Overview
+
+The PermanentDelegate extension allows a mint authority to designate an address that has permanent, irrevocable transfer and burn authority over all token accounts for that mint. Unlike regular delegates which are per-account and can be revoked by account owners, the permanent delegate operates at the mint level and cannot be removed by token holders.
+
+### Data Structures
+
+#### PermanentDelegate (Mint Extension)
+
+```rust
+pub struct PermanentDelegate {
+    /// Optional permanent delegate for transferring or burning tokens
+    pub delegate: OptionalNonZeroPubkey,
+}
+```
+
+### Instruction Behavior
+
+#### Transfer
+
+The authority hierarchy for transfers is:
+
+1. **Permanent Delegate (highest priority)**: If signer matches mint's permanent delegate, transfer authorized immediately. No `delegated_amount` consumed.
+2. **Regular Delegate**: If signer matches account's delegate, `delegated_amount` is decremented.
+3. **Owner (default)**: Account owner must sign.
+
+#### Burn
+
+Same authority hierarchy as Transfer. Permanent delegate can burn without consuming `delegated_amount`.
+
+#### Approve/Revoke
+
+The permanent delegate has **no special privileges**:
+- **Approve**: Only account owner can set a delegate
+- **Revoke**: Only account owner can revoke delegation
+
+#### SetAuthority (PermanentDelegate type)
+
+The permanent delegate can transfer or renounce their authority. Can be set to `None` to permanently renounce.
+
+### Validation Rules
+
+| Check | Description |
+|-------|-------------|
+| Extension initialized before mint | Must be called on uninitialized mint |
+| Authority signature | Permanent delegate must sign when acting as authority |
+| No delegated_amount consumption | Transfers/burns do not affect account's delegated_amount |
+
+### Key Differences from Regular Delegate
+
+| Aspect | Regular Delegate | Permanent Delegate |
+|--------|------------------|-------------------|
+| Scope | Per-account | Mint-wide (all accounts) |
+| Set by | Account owner | Mint authority (at initialization) |
+| Revocable | Yes (by owner) | Only by itself (SetAuthority) |
+| Amount limit | `delegated_amount` | Unlimited |
+
+---
+
+## 4. TransferHook
+
+### Overview
+
+The TransferHook extension enables mints to specify an external program that gets invoked during token transfers, allowing custom validation logic or side effects to be executed as part of every transfer operation.
+
+### Data Structures
+
+#### TransferHook (Mint Extension)
+
+```rust
+pub struct TransferHook {
+    /// Authority that can set the transfer hook program id
+    pub authority: OptionalNonZeroPubkey,
+    /// Program that authorizes the transfer
+    pub program_id: OptionalNonZeroPubkey,
+}
+```
+
+#### TransferHookAccount (Account Extension)
+
+```rust
+pub struct TransferHookAccount {
+    /// Flag to indicate that the account is in the middle of a transfer
+    pub transferring: PodBool,
+}
+```
+
+A reentrancy guard flag set to `true` during the hook CPI and unset afterward.
+
+### Instruction Behavior
+
+#### Transfer
+
+The transfer hook is invoked **after** balance updates:
+
+1. Source and destination account balances are updated
+2. The `transferring` flag is set on both accounts
+3. CPI is made to hook program via `spl_transfer_hook_interface::onchain::invoke_execute()`
+4. The `transferring` flag is unset
+
+#### Burn / MintTo
+
+Transfer hooks are **not** invoked during burn or mint_to operations.
+
+#### Update
+
+- Requires signature from current `authority`
+- Supports multisig authorities
+- Can set program_id to `None` to disable the hook
+
+### Validation Rules
+
+1. **Program ID Self-Reference Prevention**: Hook program_id cannot be Token-2022 program itself
+2. **Initialization Requirements**: At least one of `authority` or `program_id` must be provided
+3. **Reentrancy Protection**: `transferring` flag prevents recursive transfers
+4. **Mint Required**: Transfers with `TransferHookAccount` extension must include mint account
+
+---
+
+## 5. Pausable
+
+### Overview
+
+The Pausable extension enables a mint authority to temporarily halt all token movements (transfers, minting, and burning) for an entire token mint. When paused, tokens cannot be moved but other account management operations remain functional.
+
+### Data Structures
+
+#### PausableConfig (Mint Extension)
+
+```rust
+pub struct PausableConfig {
+    /// Authority that can pause or resume activity on the mint
+    pub authority: OptionalNonZeroPubkey,
+    /// Whether minting / transferring / burning tokens is paused
+    pub paused: PodBool,
+}
+```
+
+#### PausableAccount (Account Extension)
+
+```rust
+pub struct PausableAccount;
+```
+
+A zero-sized marker extension added to token accounts belonging to a pausable mint.
+
+### Instruction Behavior
+
+| Instruction | When Paused | Notes |
+|-------------|-------------|-------|
+| **Transfer** | Blocked | Returns `MintPaused` error |
+| **MintTo** | Blocked | Returns `MintPaused` error |
+| **Burn** | Blocked | Returns `MintPaused` error |
+| **Approve** | Allowed | No pause check performed |
+| **Revoke** | Allowed | No pause check performed |
+| **FreezeAccount** | Allowed | No pause check performed |
+| **ThawAccount** | Allowed | No pause check performed |
+
+### Pause/Resume Instructions
+
+**Pause**:
+- Accounts: `[writable] mint`, `[signer] pause_authority`
+- Sets `paused = true`
+- Supports multisig authority
+
+**Resume**:
+- Accounts: `[writable] mint`, `[signer] pause_authority`
+- Sets `paused = false`
+- Supports multisig authority
+
+### Validation Rules
+
+1. **Authority Validation**: Pause/Resume require authority signature. Returns `AuthorityTypeNotSupported` if authority is `None`.
+2. **Transfer Validation**: When paused, returns `TokenError::MintPaused`
+3. **Account Extension Enforcement**: Accounts with `PausableAccount` must include mint during transfer
+4. **Initialization Order**: Initialize must be called before `InitializeMint`
diff --git a/programs/compressed-token/program/docs/T22_VS_CTOKEN_COMPARISON.md b/programs/compressed-token/program/docs/T22_VS_CTOKEN_COMPARISON.md
new file mode 100644
index 0000000000..c19de8a46a
--- /dev/null
+++ b/programs/compressed-token/program/docs/T22_VS_CTOKEN_COMPARISON.md
@@ -0,0 +1,234 @@
+# T22 vs CToken: Restricted Extensions Comparison
+
+This document compares the behavior of 5 restricted Token-2022 extensions between SPL Token-2022 (T22) and the CToken implementation.
+
+**Reference Documents:**
+- T22 behavior: `RESTRICTED_T22_EXTENSIONS.md`
+- CToken behavior: `EXTENSIONS.md`
+
+---
+
+## Quick Reference
+
+| Aspect                    | T22                          | CToken                              |
+|---------------------------|------------------------------|-------------------------------------|
+| TransferFee handling      | Fees deducted & withheld     | Fees must be 0 (blocked otherwise)  |
+| TransferHook execution    | CPI invoked on transfer      | program_id must be nil (no CPI)     |
+| PermanentDelegate scope   | Transfer + Burn              | Transfer + Burn (same)              |
+| Pausable: MintTo/Burn     | Blocked when paused          | N/A (CMint-only, no extensions)     |
+| Account extensions        | Per-extension markers        | All restricted add markers          |
+| Compression bypass        | N/A                          | CompressAndClose/FullDecompress bypass |
+
+---
+
+## 1. TransferFeeConfig
+
+### Shared Behavior
+
+- Both read TransferFeeConfig extension from mint
+- Both check `older_transfer_fee` and `newer_transfer_fee` fields
+
+### Key Differences
+
+| Aspect            | T22                                              | CToken                                           |
+|-------------------|--------------------------------------------------|--------------------------------------------------|
+| Fee handling      | Deducted from transfer, withheld in destination  | Must be 0, otherwise `NonZeroTransferFeeNotSupported` |
+| CloseAccount      | Blocked if `withheld_amount > 0`                 | No withheld check (fees always 0)                |
+| Account extension | TransferFeeAmount with `withheld_amount` field   | TransferFeeAccount marker (no withheld tracking) |
+
+### T22 Features Not Implemented
+
+1. `HarvestWithheldTokensToMint` - Move withheld fees from accounts to mint
+2. `WithdrawWithheldTokensFromMint` - Withdraw accumulated fees to authority
+3. `SetTransferFee` - Update fee configuration (2-epoch delay)
+4. `TransferCheckedWithFee` - Transfer with fee parameter validation
+
+### Design Rationale
+
+CToken requires zero fees because compressed tokens cannot track withheld amounts per-account in compressed state. The CompressedOnlyExtension preserves `withheld_transfer_fee` for tokens that had fees before compression, but no new fees can accrue.
+
+---
+
+## 2. DefaultAccountState
+
+### Shared Behavior
+
+- Both apply frozen state at account initialization
+- Both allow Freeze/Thaw to override state
+- Frozen accounts block: Transfer, Approve, Revoke, Burn
+
+### Key Differences
+
+| Aspect            | T22                                    | CToken                                |
+|-------------------|----------------------------------------|---------------------------------------|
+| Account extension | None (state stored in base Account)    | No marker added                       |
+| Update capability | `UpdateDefaultAccountState` instruction | No update (reads mint state directly) |
+| MintTo to frozen  | Blocked                                | Blocked (pinocchio check)             |
+
+### T22 Features Not Implemented
+
+1. `InitializeDefaultAccountState` - Initialize extension on mint
+2. `UpdateDefaultAccountState` - Change default state for future accounts
+
+### Design Rationale
+
+CToken reads the DefaultAccountState from the T22 mint directly at account creation time. Mint-level instructions (Initialize/Update) are executed on the T22 mint, not through CToken.
+
+---
+
+## 3. PermanentDelegate
+
+### Shared Behavior
+
+- Permanent delegate can authorize transfers (same authority hierarchy: permanent delegate > regular delegate > owner)
+- Permanent delegate can authorize burns
+- Approve/Revoke: owner only (permanent delegate has no special privileges)
+- Transfers/burns by permanent delegate do not consume `delegated_amount`
+
+### Key Differences
+
+| Aspect            | T22                                | CToken                                  |
+|-------------------|------------------------------------|-----------------------------------------|
+| Account extension | None                               | PermanentDelegateAccountExtension marker |
+| SetAuthority      | Delegate can renounce authority    | Not implemented (T22 mint instruction)  |
+
+### T22 Features Not Implemented
+
+1. `SetAuthority(PermanentDelegate)` - Transfer or renounce permanent delegate authority
+
+### Design Rationale
+
+CToken adds an account marker to identify accounts belonging to mints with permanent delegate. This enables `compression_only` enforcement - accounts must be explicitly created in compression_only mode to ensure state is preserved during CompressAndClose.
+
+---
+
+## 4. TransferHook
+
+### Shared Behavior
+
+- Both check for TransferHook extension on mint
+- Both add marker extension to accounts (though with different contents)
+
+### Key Differences
+
+| Aspect            | T22                                           | CToken                                       |
+|-------------------|-----------------------------------------------|----------------------------------------------|
+| Hook execution    | CPI to program_id after balance update        | No CPI (program_id must be nil)              |
+| Reentrancy guard  | `transferring` flag in TransferHookAccount    | No guard needed (no CPI)                     |
+| Account extension | TransferHookAccount with `transferring` field | TransferHookAccount marker (no transferring) |
+
+### T22 Features Not Implemented
+
+1. `spl_transfer_hook_interface::onchain::invoke_execute()` - Hook CPI execution
+2. `Update` - Change hook program_id after initialization
+
+### Design Rationale
+
+Transfer hooks invoke external programs that cannot access compressed state. Since compressed tokens aren't visible to external programs, hooks cannot validate or act on compressed transfers. CToken requires `program_id = nil` to ensure hooks are disabled before compression.
+
+---
+
+## 5. Pausable
+
+### Shared Behavior
+
+- Both read `paused` state from PausableConfig extension
+- Transfers blocked when paused (CTokenTransfer, Transfer2 compress)
+- Approve/Revoke/Freeze/Thaw allowed when paused
+
+### Key Differences
+
+| Aspect                   | T22                       | CToken                            |
+|--------------------------|---------------------------|-----------------------------------|
+| MintTo when paused       | Blocked (`MintPaused`)    | N/A (CTokenMintTo is CMint-only)  |
+| Burn when paused         | Blocked (`MintPaused`)    | N/A (CTokenBurn is CMint-only)    |
+| Pause/Resume             | Direct instructions       | Not implemented (T22 mint instr)  |
+| Full Decompress (paused) | N/A                       | ALLOWED (bypasses check)          |
+| CompressAndClose         | N/A                       | ALLOWED (bypasses check)          |
+
+### T22 Features Not Implemented
+
+1. `Pause` - Set `paused = true` on mint
+2. `Resume` - Set `paused = false` on mint
+
+### Design Rationale
+
+**CTokenMintTo/CTokenBurn - CMint only:**
+CTokenMintTo and CTokenBurn instructions only work with CMints (compressed mints). CMints do not support restricted extensions - only TokenMetadata is allowed. Therefore, pausable checks are not applicable to these instructions. T22 mints with Pausable extension can only be used with CToken accounts via Transfer2 (compress/decompress).
+
+**Full Decompress/CompressAndClose bypass:**
+Users who compressed tokens before a pause should be able to recover them. CompressAndClose allows foresters to reclaim rent even when paused. These operations use `parse_mint_extensions()` (extract data only) instead of `check_mint_extensions()` (validate state).
+
+**Note:** "Full decompress" means decompress operations with no compressed outputs (`inputs.out_token_data.is_empty()`). Decompress operations that also create new compressed outputs are subject to normal validation.
+
+---
+
+## 6. Cross-Cutting Differences
+
+### CMint vs T22 Mint Limitations
+
+**CMints (Compressed Mints):**
+- Only support TokenMetadata extension
+- No restricted extensions (Pausable, TransferFee, TransferHook, PermanentDelegate, DefaultAccountState)
+- Used by: CTokenMintTo, CTokenBurn
+
+**T22 Mints with Restricted Extensions:**
+- Supported only via CToken accounts (not CMints)
+- CToken accounts for restricted mints require `compression_only` mode
+- Used by: Transfer2 (compress/decompress), CTokenTransfer, CTokenApprove, CTokenRevoke, etc.
+
+**Implication:** CTokenMintTo and CTokenBurn do not need pausable/extension checks because they only operate on CMints which cannot have those extensions.
+
+### compression_only Mode (CToken-specific)
+
+Required when mint has any restricted extension:
+- Enforced at CreateTokenAccount via `has_mint_extensions()`
+- Prevents creation of regular compressed token outputs for restricted mints
+- Error: `CompressionOnlyRequired` (6131)
+
+Enables:
+- State preservation during CompressAndClose (delegated_amount, withheld_transfer_fee, frozen state)
+- Safe round-trip compression/decompression without losing account state
+
+### CompressAndClose/Decompress Bypass (CToken-specific)
+
+```rust
+// Path: src/transfer2/check_extensions.rs:106-114
+let is_full_decompress =
+    compression.mode.is_decompress() && inputs.out_token_data.is_empty();
+let checks = if compression.mode.is_compress_and_close() || is_full_decompress {
+    // CompressAndClose and Decompress bypass extension state checks
+    parse_mint_extensions(mint_account)?  // Extract data only
+} else {
+    check_mint_extensions(mint_account, deny_restricted_extensions)?  // Validate state
+};
+```
+
+**Note:** Only "full decompress" (decompress without creating new compressed outputs) bypasses
+state checks. Decompress operations that create additional compressed outputs are subject to
+normal validation via `check_mint_extensions`.
+
+This allows:
+- **Full Decompress when paused:** Users can recover tokens compressed before pause (when no compressed outputs)
+- **CompressAndClose when paused:** Foresters can reclaim rent exemption
+- **Operations after fee/hook changes:** Users aren't locked out by mint config changes
+
+### Account Extension Markers
+
+| Extension           | T22 Adds Marker     | CToken Adds Marker               |
+|---------------------|---------------------|----------------------------------|
+| TransferFeeConfig   | TransferFeeAmount   | TransferFeeAccount               |
+| DefaultAccountState | None                | None                             |
+| PermanentDelegate   | None                | PermanentDelegateAccountExtension |
+| TransferHook        | TransferHookAccount | TransferHookAccount              |
+| Pausable            | PausableAccount     | PausableAccount                  |
+
+**Key difference:** T22's TransferFeeAmount and TransferHookAccount have data fields. CToken uses zero-sized markers.
+
+### Validation Function Comparison
+
+| Validation Point | T22 | CToken |
+|------------------|-----|--------|
+| Account creation | Extension-specific initialization | `has_mint_extensions()` - flags restricted extensions |
+| Transfer | Extension-specific processors | `check_mint_extensions()` - validates all extension state |
+| Pool creation | N/A | `assert_mint_extensions()` - fees=0, hook=nil |
diff --git a/programs/compressed-token/program/docs/instructions/ADD_TOKEN_POOL.md b/programs/compressed-token/program/docs/instructions/ADD_TOKEN_POOL.md
new file mode 100644
index 0000000000..978028cdf0
--- /dev/null
+++ b/programs/compressed-token/program/docs/instructions/ADD_TOKEN_POOL.md
@@ -0,0 +1,66 @@
+# Add Token Pool
+
+**path:** programs/compressed-token/anchor/src/lib.rs:68-95
+
+**description:**
+Token pool pda is renamed to spl interface pda in the light-token-sdk.
+1. Creates additional token pools for a mint (indexes 1-4) after the initial pool (index 0) exists
+2. Requires the previous pool (index-1) to exist, enforcing sequential pool creation. This ensures mint extensions were already validated during `create_token_pool` for pool index 0
+3. Maximum 5 pools per mint (NUM_MAX_POOL_ACCOUNTS = 5, defined in programs/compressed-token/anchor/src/constants.rs)
+4. Multiple pools enable scaling for high-volume mints by distributing token storage across accounts
+5. For mints with restricted extensions (Pausable, PermanentDelegate, TransferFeeConfig, TransferHook, DefaultAccountState), uses a separate PDA derivation path with "restricted" seed to prevent accidental compression via legacy anchor instructions
+
+**Instruction data:**
+- `token_pool_index`: u8 - Pool index to create (valid values: 1-4)
+
+**Accounts:**
+1. fee_payer
+   - (signer, mutable)
+   - Pays for account creation (rent-exempt deposit + transaction fees)
+2. token_pool_pda
+   - (mutable)
+   - New token pool account being created
+   - PDA derivation (regular mints): seeds=[b"pool", mint_pubkey, token_pool_index], program=light_compressed_token
+   - PDA derivation (restricted mints): seeds=[b"pool", mint_pubkey, b"restricted", token_pool_index], program=light_compressed_token
+   - Owner set to token_program
+3. existing_token_pool_pda
+   - Existing token pool at index (token_pool_index - 1)
+   - Must be a valid SPL/Token-2022 TokenAccount
+   - Validates sequential pool creation
+4. system_program
+   - System program for account allocation
+5. mint
+   - SPL Token or Token-2022 mint account
+   - Validated: must be owned by token_program
+6. token_program
+   - Token program interface (SPL Token or Token-2022)
+7. cpi_authority_pda
+   - CPI authority PDA
+   - PDA derivation: seeds=[b"light_cpi_authority"], program=light_compressed_token
+   - Becomes the owner/authority of the new token pool account
+
+**Instruction Logic and Checks:**
+1. Validate token_pool_index < NUM_MAX_POOL_ACCOUNTS (5)
+   - Error: InvalidTokenPoolBump if index >= 5
+2. Determine if mint has restricted extensions via `restricted_seed()` (programs/compressed-token/anchor/src/instructions/create_token_pool.rs:21-39)
+   - Checks for: Pausable, PermanentDelegate, TransferFeeConfig, TransferHook, DefaultAccountState extensions
+3. Validate previous pool exists via `is_valid_spl_interface_pda()` (program-libs/ctoken-interface/src/pool_derivation.rs:95-148)
+   - Uses `token_pool_index.saturating_sub(1)` as the previous index
+   - Verifies existing_token_pool_pda matches PDA derivation with (token_pool_index - 1)
+   - Uses the same restricted/regular derivation path as the new pool
+   - Error: InvalidTokenPoolPda if previous pool doesn't exist or has wrong derivation
+4. Initialize token account via CPI to `spl_token_2022::instruction::initialize_account3` (same as create_token_pool)
+
+**CPIs:**
+- `spl_token_2022::instruction::initialize_account3`
+  - Target program: token_program (SPL Token or Token-2022)
+  - Accounts: [token_pool_pda, mint, cpi_authority_pda, token_program]
+  - Purpose: Initializes the new token pool as a valid SPL token account with cpi_authority_pda as owner
+
+**Errors:**
+- `InvalidTokenPoolBump` (6029) - token_pool_index >= NUM_MAX_POOL_ACCOUNTS (max 5 pools reached)
+- `InvalidTokenPoolPda` (6023) - Previous pool at (index-1) doesn't exist or has invalid PDA derivation
+- `InvalidMint` (6126) - Mint account fails to deserialize (from `get_token_account_space`)
+- Anchor `ConstraintSeeds` - PDA derivation failed
+- Anchor `AccountAlreadyInUse` - Token pool already exists at this index
+- `InsufficientFunds` - Fee payer has insufficient lamports
diff --git a/programs/compressed-token/program/docs/instructions/CLAIM.md b/programs/compressed-token/program/docs/instructions/CLAIM.md
index 39d075132a..d827c6ce92 100644
--- a/programs/compressed-token/program/docs/instructions/CLAIM.md
+++ b/programs/compressed-token/program/docs/instructions/CLAIM.md
@@ -5,9 +5,11 @@
 **path:** programs/compressed-token/program/src/claim/
 
 **description:**
-1. Claims rent from compressible ctoken solana accounts that have passed their rent expiration epochs
-2. Account layout `CToken` is defined in path: program-libs/ctoken-types/src/state/ctoken/ctoken_struct.rs
-3. Extension layout `CompressionInfo` is defined in path: program-libs/ctoken-types/src/state/extensions/compressible.rs
+1. Claims rent from compressible CToken and CMint solana accounts that have passed their rent expiration epochs
+2. Supports both account types:
+   - CToken (account_type = 2): decompressed token accounts, layout defined in program-libs/ctoken-interface/src/state/ctoken/ctoken_struct.rs
+   - CMint (account_type = 1): decompressed mint accounts, layout defined in program-libs/ctoken-interface/src/state/mint/compressed_mint.rs
+3. CompressionInfo is embedded directly in both account types (not as an extension), defined in program-libs/compressible/src/compression_info.rs
 4. Processes multiple token accounts in a single instruction for efficiency
 5. For each eligible compressible account:
    - Updates the account's RentConfig from the CompressibleConfig
@@ -47,12 +49,12 @@
    - Owner must be Registry program (Lighton6oQpVkeewmo2mcPTQQp7kYHr4fWpAgJyEmDX)
    - Must not be in inactive state
 
-4. token_accounts (remaining accounts)
+4. accounts (remaining accounts)
    - (mutable, variable number)
-   - CToken accounts to claim rent from
+   - CToken or CMint accounts to claim rent from
+   - Account type determined by byte 165 (1 = CMint, 2 = CToken) or size (165 bytes = CToken)
    - Each account is processed independently
-   - Accounts without compressible extension are skipped
-   - Invalid accounts (wrong authority/recipient) are skipped without error
+   - Invalid accounts (wrong authority/recipient/type) are skipped without error
 
 **Instruction Logic and Checks:**
 
@@ -71,35 +73,39 @@
 3. **Get current slot:**
    - Fetch from Clock sysvar for epoch calculation
 
-4. **Process each token account:**
+4. **Process each account:**
    For each account in remaining accounts:
 
-   a. **Parse account data:**
+   a. **Determine account type:**
+      - If account size < 165 bytes: invalid, skip
+      - If account size == 165 bytes: CToken (legacy)
+      - If account size > 165 bytes: read byte 165 for discriminator (1 = CMint, 2 = CToken)
+
+   b. **Parse account data:**
       - Borrow mutable data
-      - Deserialize as CToken with zero-copy
+      - Deserialize as CToken or CMint based on account type with zero-copy
 
-   b. **Find and validate compressible extension:**
-      - Search extensions for Compressible variant
-      - Skip if no compressible extension found
+   c. **Validate compression info:**
+      - Access embedded CompressionInfo from account
       - Validate compression_authority matches
       - Validate rent_sponsor matches
 
-   c. **Validate version:**
-      - Verify `compressible_ext.config_account_version` matches CompressibleConfig version
+   d. **Validate version:**
+      - Verify `compression.config_account_version` matches CompressibleConfig version
       - Error if versions don't match (prevents cross-version claims)
 
-   d. **Calculate and claim rent:**
+   e. **Calculate and claim rent:**
       - Get account size and current lamports
       - Calculate rent exemption for account size
-      - Call `compressible_ext.claim()` which:
+      - Call `compression.claim()` which:
         - Determines completed epochs since last claim using CURRENT RentConfig
         - Calculates claimable lamports
         - Updates last_claimed_slot if there's claimable rent
       - Returns None if no rent to claim (account not yet compressible)
-      - After claim calculation, always update `compressible_ext.rent_config` from CompressibleConfig for future operations
+      - After claim calculation, always update `compression.rent_config` from CompressibleConfig for future operations
 
-   e. **Transfer lamports:**
-      - If claim amount > 0, transfer from token account to rent_sponsor
+   f. **Transfer lamports:**
+      - If claim amount > 0, transfer from account to rent_sponsor
       - Update both account balances
 
 5. **Complete successfully:**
diff --git a/programs/compressed-token/program/docs/instructions/CLAUDE.md b/programs/compressed-token/program/docs/instructions/CLAUDE.md
index 956b9e2f08..2dbccb11a1 100644
--- a/programs/compressed-token/program/docs/instructions/CLAUDE.md
+++ b/programs/compressed-token/program/docs/instructions/CLAUDE.md
@@ -13,8 +13,44 @@ This documentation is organized to provide clear navigation through the compress
   - `TRANSFER2.md` - Batch transfer instruction for compressed/decompressed operations
   - `CLAIM.md` - Claim rent from expired compressible accounts
   - `CLOSE_TOKEN_ACCOUNT.md` - Close decompressed token accounts
-  - `DECOMPRESSED_TRANSFER.md` - Transfer between decompressed accounts
+  - `CTOKEN_TRANSFER.md` - Transfer between decompressed accounts
+  - `CTOKEN_TRANSFER_CHECKED.md` - Transfer with decimals validation
   - `WITHDRAW_FUNDING_POOL.md` - Withdraw funds from rent recipient pool
+  - `CREATE_TOKEN_POOL.md` - Create initial token pool for SPL/T22 mint compression
+  - `ADD_TOKEN_POOL.md` - Add additional token pools (up to 5 per mint)
+  - `CTOKEN_APPROVE.md` - Approve delegate on decompressed CToken account
+  - `CTOKEN_REVOKE.md` - Revoke delegate on decompressed CToken account
+  - `CTOKEN_MINT_TO.md` - Mint tokens to decompressed CToken account
+  - `CTOKEN_BURN.md` - Burn tokens from decompressed CToken account
+  - `CTOKEN_FREEZE_ACCOUNT.md` - Freeze decompressed CToken account
+  - `CTOKEN_THAW_ACCOUNT.md` - Thaw frozen decompressed CToken account
+  - `CTOKEN_APPROVE_CHECKED.md` - Approve delegate with decimals validation
+  - `CTOKEN_MINT_TO_CHECKED.md` - Mint tokens with decimals validation
+  - `CTOKEN_BURN_CHECKED.md` - Burn tokens with decimals validation
+
+## Discriminator Reference
+
+| Instruction | Discriminator | Enum Variant |
+|-------------|---------------|--------------|
+| CTokenTransfer | 3 | `InstructionType::CTokenTransfer` |
+| CTokenApprove | 4 | `InstructionType::CTokenApprove` |
+| CTokenRevoke | 5 | `InstructionType::CTokenRevoke` |
+| CTokenTransferChecked | 6 | `InstructionType::CTokenTransferChecked` |
+| CTokenMintTo | 7 | `InstructionType::CTokenMintTo` |
+| CTokenBurn | 8 | `InstructionType::CTokenBurn` |
+| CloseTokenAccount | 9 | `InstructionType::CloseTokenAccount` |
+| CTokenFreezeAccount | 10 | `InstructionType::CTokenFreezeAccount` |
+| CTokenThawAccount | 11 | `InstructionType::CTokenThawAccount` |
+| CTokenApproveChecked | 12 | `InstructionType::CTokenApproveChecked` |
+| CTokenMintToChecked | 14 | `InstructionType::CTokenMintToChecked` |
+| CTokenBurnChecked | 15 | `InstructionType::CTokenBurnChecked` |
+| CreateTokenAccount | 18 | `InstructionType::CreateTokenAccount` |
+| CreateAssociatedCTokenAccount | 100 | `InstructionType::CreateAssociatedCTokenAccount` |
+| Transfer2 | 101 | `InstructionType::Transfer2` |
+| CreateAssociatedTokenAccountIdempotent | 102 | `InstructionType::CreateAssociatedTokenAccountIdempotent` |
+| MintAction | 103 | `InstructionType::MintAction` |
+| Claim | 104 | `InstructionType::Claim` |
+| WithdrawFundingPool | 105 | `InstructionType::WithdrawFundingPool` |
 
 ## Navigation Tips
 - Start with `../../CLAUDE.md` for the instruction index and overview
@@ -40,3 +76,10 @@ every instruction description must include the sections:
 5. **Close Token Account** - Close decompressed token accounts with rent distribution
 6. **Decompressed Transfer** - SPL-compatible transfers between decompressed accounts
 7. **Withdraw Funding Pool** - Withdraw funds from rent recipient pool
+8. **Create Token Pool** - Create initial token pool PDA for SPL/T22 mint compression
+9. **Add Token Pool** - Add additional token pools for a mint (up to 5 per mint)
+10. **CToken MintTo** - Mint tokens to decompressed CToken account
+11. **CToken Burn** - Burn tokens from decompressed CToken account
+12. **CToken Freeze/Thaw** - Freeze and thaw decompressed CToken accounts
+13. **CToken Approve/Revoke** - Approve and revoke delegate on decompressed CToken accounts
+14. **CToken Checked Operations** - ApproveChecked, MintToChecked, BurnChecked with decimals validation
diff --git a/programs/compressed-token/program/docs/instructions/CREATE_TOKEN_POOL.md b/programs/compressed-token/program/docs/instructions/CREATE_TOKEN_POOL.md
new file mode 100644
index 0000000000..0f812180b4
--- /dev/null
+++ b/programs/compressed-token/program/docs/instructions/CREATE_TOKEN_POOL.md
@@ -0,0 +1,66 @@
+# Create Token Pool
+
+**path:** programs/compressed-token/anchor/src/lib.rs:50-63
+
+**description:**
+Token pool pda is renamed to spl interface pda in the light-token-sdk.
+1. Creates a token pool PDA for a given SPL or Token-2022 mint
+2. Token pools store underlying SPL/T22 tokens when users compress them into compressed tokens or convert them into ctokens. When tokens are compressed, they are transferred to the pool; when decompressed, tokens are transferred back from the pool to the user
+3. Each mint can have up to 5 token pools (this instruction creates the first pool at index 0)
+4. Validates mint extensions against the allowed list (16 supported Token-2022 extensions)
+5. Initializes the token account via CPI to the token program with `cpi_authority_pda` as the account owner/authority
+
+**Instruction data:**
+- No instruction parameters (all configuration derived from accounts)
+
+**Accounts:**
+1. fee_payer
+   - (signer, mutable)
+   - Pays for account creation (rent-exempt deposit + transaction fees)
+2. token_pool_pda
+   - (mutable)
+   - New token pool account being created
+   - PDA derivation for standard mints: seeds=[b"pool", mint_pubkey], program=light_compressed_token
+   - PDA derivation for restricted mints: seeds=[b"pool", mint_pubkey, b"restricted"], program=light_compressed_token
+   - Owner set to token_program
+3. system_program
+   - System program for account allocation
+4. mint
+   - SPL Token or Token-2022 mint account
+   - Validated: must be owned by token_program
+   - Extensions are checked against ALLOWED_EXTENSION_TYPES
+5. token_program
+   - Token program interface (SPL Token or Token-2022)
+6. cpi_authority_pda
+   - CPI authority PDA
+   - PDA derivation: seeds=[b"light_cpi_authority"], program=light_compressed_token
+   - Becomes the owner/authority of the token pool account
+
+**Instruction Logic and Checks:**
+1. Validate mint extensions via `assert_mint_extensions()` (programs/compressed-token/anchor/src/instructions/create_token_pool.rs:129-165)
+   - All extensions must be in ALLOWED_EXTENSION_TYPES (program-libs/ctoken-interface/src/token_2022_extensions.rs:24-44)
+   - Allowed extensions (16 types): MetadataPointer, TokenMetadata, InterestBearingConfig, GroupPointer, GroupMemberPointer, TokenGroup, TokenGroupMember, MintCloseAuthority, TransferFeeConfig, DefaultAccountState, PermanentDelegate, TransferHook, Pausable, ConfidentialTransferMint, ConfidentialTransferFeeConfig, ConfidentialMintBurn
+   - **Restricted extensions (5 types) require compression_only mode:**
+     - `Pausable` - pause state checked at transfer time from SPL mint
+     - `PermanentDelegate` - marks token for compression_only mode at runtime
+     - `TransferFeeConfig` - fees must be zero at pool creation (both `older_transfer_fee` and `newer_transfer_fee` must have `transfer_fee_basis_points == 0` and `maximum_fee == 0`)
+     - `TransferHook` - program_id must be nil at pool creation (no active transfer hook program)
+     - `DefaultAccountState` - restricted regardless of state (Initialized or Frozen)
+   - Mints with restricted extensions use separate PDA derivation with `RESTRICTED_POOL_SEED` (b"restricted")
+2. Anchor allocates account space based on mint extensions via `get_token_account_space()` (programs/compressed-token/anchor/src/instructions/create_token_pool.rs:76-84)
+3. Initialize token account via CPI to `spl_token_2022::instruction::initialize_account3` (programs/compressed-token/anchor/src/instructions/create_token_pool.rs:87-109)
+
+**CPIs:**
+- `spl_token_2022::instruction::initialize_account3`
+  - Target program: token_program (SPL Token or Token-2022)
+  - Accounts: [token_pool_pda, mint, cpi_authority_pda, token_program]
+  - Purpose: Initializes the token pool as a valid SPL token account with cpi_authority_pda as owner
+
+**Errors:**
+- `InvalidMint` (6126) - Mint account fails to deserialize as PodStateWithExtensions<PodMint>
+- `MintWithInvalidExtension` (6027) - Mint has an extension not in ALLOWED_EXTENSION_TYPES
+- `NonZeroTransferFeeNotSupported` (6129) - Mint has TransferFeeConfig with non-zero transfer_fee_basis_points or maximum_fee
+- `TransferHookNotSupported` (6130) - Mint has TransferHook extension with non-nil program_id
+- Anchor `ConstraintSeeds` - PDA derivation failed (wrong mint key or bump)
+- Anchor `AccountAlreadyInUse` - Token pool already exists for this mint
+- `InsufficientFunds` - Fee payer has insufficient lamports for rent-exempt deposit
diff --git a/programs/compressed-token/program/docs/instructions/CTOKEN_APPROVE.md b/programs/compressed-token/program/docs/instructions/CTOKEN_APPROVE.md
new file mode 100644
index 0000000000..285b814db7
--- /dev/null
+++ b/programs/compressed-token/program/docs/instructions/CTOKEN_APPROVE.md
@@ -0,0 +1,262 @@
+## CToken Approve
+
+**discriminator:** 4
+**enum:** `InstructionType::CTokenApprove`
+**path:** programs/compressed-token/program/src/ctoken_approve_revoke.rs
+
+### SPL Instruction Format Compatibility
+
+**Important:** This instruction is only compatible with the SPL Token instruction format (using `spl_token_2022::instruction::approve` with changed program ID) when **no top-up is required**.
+
+If the CToken account has a compressible extension and requires a rent top-up, the instruction needs the **system program account** to perform the lamports transfer. Without the system program account, the top-up CPI will fail.
+
+**Compatibility scenarios:**
+- **SPL-compatible (no system program needed):** Non-compressible accounts, or compressible accounts with sufficient prepaid rent
+- **NOT SPL-compatible (system program required):** Compressible accounts that need rent top-up based on current slot
+
+**description:**
+Delegates a specified amount to a delegate authority on a decompressed ctoken account (account layout `CToken` defined in program-libs/ctoken-interface/src/state/ctoken/ctoken_struct.rs). Before the approve operation, automatically tops up compressible accounts (extension layout `CompressionInfo` defined in program-libs/compressible/src/compression_info.rs) with additional lamports if needed to prevent accounts from becoming compressible during normal operations. The instruction supports a max_top_up parameter (0 = no limit) that enforces transaction failure if the calculated top-up exceeds this limit. Uses pinocchio-token-program for SPL-compatible approve semantics. Supports backwards-compatible instruction data format (8 bytes legacy vs 10 bytes with max_top_up).
+
+**Instruction data:**
+Path: programs/compressed-token/program/src/ctoken_approve_revoke.rs (lines 34-58)
+
+- Bytes 0-7: `amount` (u64, little-endian) - Number of tokens to delegate
+- Bytes 8-9 (optional): `max_top_up` (u16, little-endian) - Maximum lamports for top-up (0 = no limit, default for legacy format)
+
+**Accounts:**
+1. source
+   - (mutable)
+   - The source ctoken account to approve delegation on
+   - May receive rent top-up if compressible
+
+2. delegate
+   - (immutable)
+   - The delegate authority who will be granted spending rights
+   - Does not need to sign
+
+3. owner
+   - (signer, mutable)
+   - Owner of the source account
+   - Must sign the transaction
+   - Acts as payer for rent top-up if compressible extension present
+
+**Instruction Logic and Checks:**
+
+1. **Validate minimum accounts:**
+   - Require source account (index 0) and owner account (index 2)
+   - Return NotEnoughAccountKeys if either account is missing
+   - Note: delegate (index 1) is validated by pinocchio during SPL approve
+
+2. **Parse instruction data:**
+   - If 8 bytes: legacy format, set max_top_up = 0 (no limit)
+   - If 10 bytes: parse amount (first 8 bytes) and max_top_up (last 2 bytes)
+   - Return InvalidInstructionData for any other length
+
+3. **Process compressible top-up:**
+   - Borrow source account data mutably
+   - Deserialize CToken using zero-copy validation
+   - Initialize lamports_budget based on max_top_up:
+     - If max_top_up == 0: budget = u64::MAX (no limit)
+     - Otherwise: budget = max_top_up + 1 (allows exact match)
+   - Call process_compression_top_up with source account's compression info
+   - Drop borrow before CPI
+   - If transfer_amount > 0:
+     - Check that transfer_amount <= lamports_budget
+     - Return MaxTopUpExceeded if budget exceeded
+     - Transfer lamports from owner to source via CPI
+
+4. **Process SPL approve:**
+   - Pass only first 8 bytes (amount) to pinocchio-token-program
+   - Call process_approve with accounts and amount data
+   - Delegate is granted spending rights for the specified amount
+
+**Errors:**
+
+- `ProgramError::InvalidInstructionData` (error code: 3) - Instruction data is not 8 or 10 bytes
+- `ProgramError::NotEnoughAccountKeys` (error code: 11) - Less than 3 accounts provided
+- `CTokenError::InvalidAccountData` (error code: 18002) - Failed to deserialize CToken account
+- `CTokenError::SysvarAccessError` (error code: 18020) - Failed to get Clock or Rent sysvar for top-up calculation
+- `CTokenError::MaxTopUpExceeded` (error code: 18043) - Calculated top-up exceeds max_top_up parameter
+- `ProgramError::MissingRequiredSignature` (error code: 8) - Owner did not sign the transaction (SPL Token error)
+- Pinocchio token errors (converted to ProgramError::Custom):
+  - `TokenError::OwnerMismatch` (error code: 4) - Authority doesn't match account owner
+  - `TokenError::AccountFrozen` (error code: 17) - Account is frozen
+
+## Comparison with Token-2022
+
+### Functional Parity
+
+CToken Approve maintains compatibility with SPL Token-2022's core approve functionality:
+
+**Shared Features:**
+- **Delegate Authorization**: Both instructions delegate spending authority to a delegate pubkey for a specified token amount
+- **Owner Signature Requirement**: Transaction must be signed by the account owner (single owner only, no multisig support in CToken)
+- **Account State Validation**: Both check that the source account is initialized and not frozen
+- **Delegate Field Update**: Sets `source_account.delegate` and `source_account.delegated_amount` fields
+- **Backwards Compatible Data Format**: CToken supports 8-byte instruction data (amount only) for legacy compatibility
+
+**Account Layout:**
+- CToken accounts use identical base fields to Token-2022 (mint, owner, amount, delegate, state, delegated_amount, close_authority)
+- Both store delegate information in the same account structure fields
+
+### CToken-Specific Features
+
+**1. Compressible Extension Top-Up Logic**
+
+CToken Approve includes automatic rent top-up for accounts with the Compressible extension:
+
+```rust
+// Before SPL approve operation
+process_compression_top_up(
+    &ctoken.base.compression,
+    account,
+    &mut 0,
+    &mut transfer_amount,
+    &mut lamports_budget,
+)?;
+
+// Transfer lamports from owner to source if needed
+if transfer_amount > 0 {
+    transfer_lamports_via_cpi(transfer_amount, payer, account)?;
+}
+```
+
+**Purpose**: Prevents accounts from becoming compressible during normal operations by maintaining minimum rent balance.
+
+**Reference**: See `/home/ananas/dev/light-protocol/program-libs/compressible/docs/RENT.md` for rent calculation details.
+
+**2. max_top_up Parameter**
+
+Extended instruction data format (10 bytes total):
+- Bytes 0-7: amount (u64)
+- Bytes 8-9: max_top_up (u16, 0 = no limit)
+
+**Enforcement**:
+```rust
+let lamports_budget = if max_top_up == 0 {
+    u64::MAX  // No limit
+} else {
+    (max_top_up as u64).saturating_add(1)  // Allow exact match
+};
+
+if lamports_budget != 0 && transfer_amount > lamports_budget {
+    return Err(CTokenError::MaxTopUpExceeded);
+}
+```
+
+**Use Case**: Allows callers to cap unexpected rent costs and fail transactions that exceed budget.
+
+### Missing Features
+
+**1. No Multisig Support**
+
+**Token-2022 Multisig Flow:**
+```
+Accounts (Multisig):
+0. [writable] Source account
+1. [] Delegate
+2. [] Multisignature owner account
+3. ..3+M [signer] M signer accounts
+```
+
+**CToken Limitation:**
+- Only supports single owner signature
+- No multisignature account validation
+- Requires exactly 3 accounts (source, delegate, owner)
+
+**Impact**: Users requiring M-of-N signature schemes cannot use CToken accounts for approval operations.
+
+**2. No CPI Guard Extension Check**
+
+**Token-2022 CPI Guard Protection:**
+```rust
+// Token-2022 processor.rs:611-615
+if let Ok(cpi_guard) = source_account.get_extension::<CpiGuard>() {
+    if cpi_guard.lock_cpi.into() && in_cpi() {
+        return Err(TokenError::CpiGuardApproveBlocked);
+    }
+}
+```
+
+**CToken Behavior:**
+- Does NOT check for CPI Guard extension
+- Does NOT prevent approval via Cross-Program Invocation
+- No extension validation beyond Compressible
+
+**Security Implication**: CToken accounts cannot use CPI Guard to prevent opaque programs from gaining approval authority during CPIs. This is a deliberate design choice as CToken focuses on compression functionality rather than all Token-2022 extensions.
+
+**3. No ApproveChecked Variant**
+
+**Token-2022 ApproveChecked:**
+```
+Instruction Data:
+- amount: u64
+- decimals: u8
+
+Additional Account:
+1. [] The token mint
+
+Additional Checks:
+- Validates source_account.mint == mint_info.key
+- Validates expected_decimals == mint.base.decimals
+```
+
+**CToken Status:**
+- Only implements basic Approve (no mint/decimals validation)
+- No ApproveChecked instruction variant
+- Relies on caller to ensure correct mint context
+
+**Risk**: Without mint validation, callers could potentially approve on wrong token accounts if not carefully validating mint addresses externally.
+
+### Extension Handling Differences
+
+| Extension | Token-2022 Approve | CToken Approve |
+|-----------|-------------------|----------------|
+| **CPI Guard** | Blocks approval via CPI when enabled | Not checked, allows approval via CPI |
+| **Compressible** | N/A (Token-2022 extension, not in standard T22) | Auto top-up with max_top_up enforcement |
+| **Account State** | Checks initialized and frozen state | Delegates to pinocchio (same checks) |
+| **Multisig** | Validates M-of-N signatures with position matching | Not supported |
+
+### Security Property Comparison
+
+Based on Token-2022 security analysis (`/home/ananas/dev/token-2022/analysis/approve.md`):
+
+**Shared Security Properties:**
+1. **Account Initialization Check**: Both verify source account is initialized (via unpack validation)
+2. **Account Frozen State Validation**: Both prevent approval when account is frozen
+3. **Owner Authority Validation**: Both validate owner signature matches account owner field
+
+**Token-2022 Additional Security:**
+1. **Mint Validation** (ApproveChecked): Validates source account mint matches provided mint
+2. **Decimals Validation** (ApproveChecked): Validates expected decimals match mint decimals
+3. **CPI Guard Check**: Prevents approval via CPI when guard enabled
+4. **Multisig Validation**: M-of-N signature validation with position matching
+
+**CToken Additional Security:**
+1. **Rent Budget Enforcement**: max_top_up parameter prevents unexpected rent costs
+2. **Compressible State Management**: Ensures accounts maintain minimum rent to prevent compression
+
+**Critical Security Gap (Token-2022):**
+According to the security analysis, Token-2022's Approve instruction is missing explicit account ownership validation (`check_program_account(source_account_info.owner)?`). CToken delegates to pinocchio-token-program, which inherits this same gap. This is MEDIUM severity as the owner validation check provides significant protection, but the missing program ownership check creates potential attack surface if combined with account confusion attacks.
+
+**Recommendation for CToken:**
+- Current implementation correctly delegates to pinocchio for SPL compatibility
+- If pinocchio addresses the account ownership validation gap, CToken will automatically inherit the fix
+- Consider adding explicit ownership validation in CToken layer before delegating to pinocchio
+
+### Summary
+
+**Use CToken Approve when:**
+- Working with compressed token accounts that may need rent top-up
+- Need to enforce maximum rent cost budget (max_top_up parameter)
+- Only require single owner signature
+- CPI Guard protection is not required
+
+**Use Token-2022 Approve when:**
+- Need multisignature approval support
+- Require CPI Guard protection against opaque CPI approvals
+- Want mint/decimals validation (ApproveChecked variant)
+- Working with standard Token-2022 accounts without compression
+
+**Migration Path:**
+Users can decompress CToken accounts to Token-2022 accounts to gain access to multisig and CPI Guard features, then recompress after approval operations if needed.
diff --git a/programs/compressed-token/program/docs/instructions/CTOKEN_APPROVE_CHECKED.md b/programs/compressed-token/program/docs/instructions/CTOKEN_APPROVE_CHECKED.md
new file mode 100644
index 0000000000..55cb3f430b
--- /dev/null
+++ b/programs/compressed-token/program/docs/instructions/CTOKEN_APPROVE_CHECKED.md
@@ -0,0 +1,140 @@
+## CToken ApproveChecked
+
+**discriminator:** 12
+**enum:** `InstructionType::CTokenApproveChecked`
+**path:** programs/compressed-token/program/src/ctoken_approve_revoke.rs
+
+**description:**
+Delegates a specified amount to a delegate authority on a decompressed ctoken account with decimals validation, fully compatible with SPL Token ApproveChecked semantics. Account layout `CToken` is defined in program-libs/ctoken-interface/src/state/ctoken/ctoken_struct.rs. Extension layout `CompressionInfo` is defined in program-libs/compressible/src/compression_info.rs. Uses pinocchio-token-program to process the approve operation. Before the approve operation, automatically tops up compressible accounts with additional lamports if needed to prevent accounts from becoming compressible during normal operations. Supports max_top_up parameter (0 = no limit) that enforces transaction failure if the calculated top-up exceeds this limit. Uses cached decimals optimization: if source CToken has cached decimals, validates against instruction decimals and skips mint read.
+
+**Instruction data:**
+Path: programs/compressed-token/program/src/ctoken_approve_revoke.rs (lines 150-189)
+
+- Bytes 0-7: `amount` (u64, little-endian) - Number of tokens to delegate
+- Byte 8: `decimals` (u8) - Expected token decimals
+- Bytes 9-10 (optional): `max_top_up` (u16, little-endian) - Maximum lamports for top-up (0 = no limit)
+
+Format variants:
+- 9 bytes: amount + decimals (legacy, no max_top_up enforcement)
+- 11 bytes: amount + decimals + max_top_up
+
+**Accounts:**
+1. source
+   - (mutable)
+   - The source ctoken account to approve delegation on
+   - May receive rent top-up if compressible
+   - May have cached decimals for validation optimization
+
+2. mint
+   - (immutable)
+   - The mint account for the token
+   - Must match source account's mint
+   - Decimals field must match instruction data decimals parameter
+   - Only read if source account has no cached decimals
+
+3. delegate
+   - (immutable)
+   - The delegate authority who will be granted spending rights
+   - Does not need to sign
+
+4. owner
+   - (signer, mutable)
+   - Owner of the source account
+   - Must sign the transaction
+   - Acts as payer for rent top-up if compressible extension present
+
+**Instruction Logic and Checks:**
+
+1. **Validate minimum accounts:**
+   - Require at least 4 accounts (source, mint, delegate, owner)
+   - Return NotEnoughAccountKeys if insufficient
+
+2. **Parse instruction data:**
+   - Require at least 9 bytes (amount + decimals)
+   - Parse amount (u64) and decimals (u8) using unpack_amount_and_decimals
+   - If 11 bytes: parse max_top_up from bytes 9-10
+   - If 9 bytes: set max_top_up = 0 (no limit)
+   - Return InvalidInstructionData for any other length
+
+3. **Get cached decimals and process compressible top-up:**
+   - Borrow source account data mutably
+   - Deserialize CToken using zero-copy validation
+   - Get cached decimals via `ctoken.base.decimals()` (returns Option<u8>)
+   - Initialize lamports_budget based on max_top_up:
+     - If max_top_up == 0: budget = u64::MAX (no limit)
+     - Otherwise: budget = max_top_up + 1 (allows exact match)
+   - Call process_compression_top_up with source account's compression info
+   - Drop borrow before CPI
+   - If transfer_amount > 0:
+     - Check that transfer_amount <= lamports_budget
+     - Return MaxTopUpExceeded if budget exceeded
+     - Transfer lamports from owner to source via CPI
+
+4. **Process SPL approve based on cached decimals:**
+   - **If cached decimals present:**
+     - Validate cached_decimals == instruction decimals
+     - Return InvalidInstructionData if mismatch
+     - Create 3-account slice [source, delegate, owner] (skip mint)
+     - Call process_approve with expected_decimals = None (skip pinocchio mint validation)
+   - **If no cached decimals:**
+     - Validate mint is owned by valid token program (SPL, Token-2022, or CToken)
+     - Call process_approve with full 4-account layout and expected_decimals = Some(decimals)
+
+**Errors:**
+
+- `ProgramError::NotEnoughAccountKeys` (error code: 11) - Less than 4 accounts provided
+- `ProgramError::InvalidInstructionData` (error code: 3) - Instruction data is not 9 or 11 bytes, or cached decimals != instruction decimals
+- `ProgramError::IncorrectProgramId` (error code: 7) - Mint is not owned by a valid token program (when no cached decimals)
+- `CTokenError::InvalidAccountData` (error code: 18002) - Failed to deserialize CToken account
+- `CTokenError::SysvarAccessError` (error code: 18020) - Failed to get Clock or Rent sysvar for top-up calculation
+- `CTokenError::MaxTopUpExceeded` (error code: 18043) - Calculated top-up exceeds max_top_up parameter
+- `ProgramError::MissingRequiredSignature` (error code: 8) - Owner did not sign the transaction (SPL Token error)
+- Pinocchio token errors (converted to ProgramError::Custom):
+  - `TokenError::OwnerMismatch` (error code: 4) - Authority doesn't match account owner
+  - `TokenError::AccountFrozen` (error code: 17) - Account is frozen
+  - `TokenError::MintMismatch` (error code: 3) - Mint doesn't match source account's mint
+  - `TokenError::MintDecimalsMismatch` (error code: 18) - Decimals don't match mint's decimals
+
+## Comparison with Token-2022
+
+### Functional Parity
+
+CToken ApproveChecked maintains compatibility with SPL Token-2022's ApproveChecked:
+
+- **Delegate Authorization**: Both delegate spending authority to a delegate pubkey for a specified token amount
+- **Owner Signature**: Transaction must be signed by the account owner (single owner only, no multisig support in CToken)
+- **Account State Validation**: Both check that the source account is initialized and not frozen
+- **Decimals Validation**: Both validate instruction decimals against mint decimals
+
+### CToken-Specific Features
+
+1. **Cached Decimals Optimization**: If source CToken has cached decimals, validates against instruction and skips mint read
+2. **Compressible Top-Up Logic**: Automatically tops up accounts with the Compressible extension
+3. **max_top_up Parameter**: Limits rent top-up costs (0 = no limit)
+4. **Static 4-Account Layout**: Always requires mint account, but may skip reading it when cached decimals are available
+
+### Missing Features
+
+1. **No Multisig Support**: Token-2022 supports M-of-N multisig accounts as the authority
+2. **No CPI Guard Extension Check**: Token-2022 blocks approval via CPI when CPI Guard is enabled
+
+### Account Layout Comparison
+
+| Token-2022 ApproveChecked | CToken ApproveChecked |
+|---------------------------|----------------------|
+| [source, mint, delegate, owner, ...signers] | [source, mint, delegate, owner] |
+| Variable (3+ for multisig) | Fixed 4 accounts |
+
+### Security Properties
+
+**Shared:**
+- Account initialization check via unpack validation
+- Frozen account protection
+- Owner authority validation
+- Decimals validation against mint
+
+**CToken-Specific:**
+- Rent budget enforcement via max_top_up
+- Compressibility prevention via top-up
+- Zero-copy validation for CToken account structure
+- Cached decimals validation for optimization
diff --git a/programs/compressed-token/program/docs/instructions/CTOKEN_BURN.md b/programs/compressed-token/program/docs/instructions/CTOKEN_BURN.md
new file mode 100644
index 0000000000..64934474e2
--- /dev/null
+++ b/programs/compressed-token/program/docs/instructions/CTOKEN_BURN.md
@@ -0,0 +1,272 @@
+## CToken Burn
+
+**discriminator:** 8
+**enum:** `InstructionType::CTokenBurn`
+**path:** programs/compressed-token/program/src/ctoken_burn.rs
+
+**description:**
+Burns tokens from a decompressed CToken account and decreases the CMint supply, fully compatible with SPL Token burn semantics. Account layout `CToken` is defined in `program-libs/ctoken-interface/src/state/ctoken/ctoken_struct.rs`. Account layout `CompressedMint` (CMint) is defined in `program-libs/ctoken-interface/src/state/mint/compressed_mint.rs`. Extension layout `CompressionInfo` is defined in `program-libs/compressible/src/compression_info.rs` and is embedded in both CToken and CMint structs. Uses pinocchio-token-program to process the burn (handles balance/supply updates, authority check, frozen check). After the burn, automatically tops up compressible accounts with additional lamports if needed. Top-up is calculated for both CMint and source CToken based on current slot and account balance. Top-up prevents accounts from becoming compressible during normal operations. Enforces max_top_up limit if provided (transaction fails if exceeded). Account order is REVERSED from mint_to instruction: [source_ctoken, cmint, authority] vs mint_to's [cmint, destination_ctoken, authority]. Supports max_top_up parameter to limit rent top-up costs (0 = no limit). Instruction data is backwards-compatible: 8-byte format (legacy, no max_top_up enforcement) and 10-byte format (with max_top_up). This instruction only works with CMints (compressed mints). CMints do not support restricted Token-2022 extensions (Pausable, TransferFee, TransferHook, PermanentDelegate, DefaultAccountState) - only TokenMetadata is allowed. To burn tokens from T22 mints with restricted extensions, use Transfer2 with decompress mode to convert to SPL tokens first, then burn via SPL Token-2022.
+
+**Instruction data:**
+
+Format 1 (8 bytes, legacy):
+- Bytes 0-7: `amount` (u64, little-endian) - Number of tokens to burn
+- No max_top_up enforcement (effectively unlimited)
+
+Format 2 (10 bytes):
+- Bytes 0-7: `amount` (u64, little-endian) - Number of tokens to burn
+- Bytes 8-9: `max_top_up` (u16, little-endian) - Maximum lamports for combined CMint + CToken top-ups (0 = no limit)
+
+**Accounts:**
+1. source CToken
+   - (mutable)
+   - The CToken account to burn from
+   - Must have sufficient balance for the burn
+   - May receive rent top-up if compressible
+   - Must not be frozen
+
+2. CMint
+   - (mutable)
+   - The compressed mint account
+   - Supply is decreased by burn amount
+   - May receive rent top-up if compressible
+
+3. authority
+   - (signer)
+   - Owner of the source CToken account
+   - Must sign the transaction
+   - Also serves as payer for rent top-ups if needed
+
+**Instruction Logic and Checks:**
+
+1. **Validate minimum accounts:**
+   - Require at least 3 accounts (source CToken, CMint, authority/payer)
+   - Return NotEnoughAccountKeys if insufficient
+
+2. **Parse instruction data:**
+   - Require at least 8 bytes for amount
+   - Parse max_top_up:
+     - If instruction_data.len() == 8: max_top_up = 0 (no limit, legacy format)
+     - If instruction_data.len() == 10: parse u16 from bytes 8-9 as max_top_up
+     - Otherwise: return InvalidInstructionData
+
+3. **Process SPL burn via pinocchio-token-program:**
+   - Call `process_burn` with first 8 bytes (amount only)
+   - Validates authority signature matches source CToken owner
+   - Checks source CToken balance is sufficient for burn amount
+   - Checks source CToken is not frozen
+   - Decreases source CToken balance by amount
+   - Decreases CMint supply by amount
+   - Errors are converted from pinocchio errors to ProgramError::Custom
+
+4. **Calculate and execute top-up transfers:**
+   Called via `calculate_and_execute_compressible_top_ups(cmint, ctoken, payer, max_top_up)`:
+
+   a. **Initialize transfer array and budget:**
+      - Create Transfer array for [cmint, ctoken] with amounts initialized to 0
+      - Initialize lamports_budget to max_top_up + 1 (allowing exact match when total == max_top_up)
+
+   b. **Calculate CMint top-up:**
+      - Borrow CMint data and deserialize using `CompressedMint::zero_copy_at`
+      - Access compression info directly from mint.base.compression (embedded in all CMints)
+      - Lazy load Clock sysvar for current_slot and Rent sysvar if not yet loaded (current_slot == 0)
+      - Call `compression.calculate_top_up_lamports(data_len, current_slot, lamports, rent_exemption)`
+      - Subtract calculated top-up from lamports_budget
+
+   c. **Calculate CToken top-up:**
+      - Borrow CToken data and deserialize using `CToken::zero_copy_at_checked`
+      - Access compression info directly from token.compression (embedded in all CTokens)
+      - Lazy load Clock sysvar for current_slot and Rent sysvar if not yet loaded (current_slot == 0)
+      - Call `compression.calculate_top_up_lamports(data_len, current_slot, lamports, rent_exemption)`
+      - Subtract calculated top-up from lamports_budget
+
+   d. **Validate budget:**
+      - If no compressible accounts were found (current_slot == 0), exit early
+      - If both top-up amounts are 0, exit early
+      - If max_top_up != 0 and lamports_budget == 0, fail with MaxTopUpExceeded
+
+   e. **Execute transfers:**
+      - Call `multi_transfer_lamports(payer, &transfers)` to atomically transfer lamports
+      - Updates account balances for both CMint and CToken if needed
+
+**Errors:**
+
+- `ProgramError::NotEnoughAccountKeys` (error code: 11) - Less than 3 accounts provided
+- `ProgramError::InvalidInstructionData` (error code: 3) - Instruction data length is not 8 or 10 bytes
+- `ProgramError::InsufficientFunds` (error code: 6) - Source CToken balance less than burn amount (from pinocchio burn), or payer has insufficient funds for top-up transfers
+- `ProgramError::ArithmeticOverflow` (error code: 24) - Overflow when calculating total top-up amount
+- Pinocchio token errors (converted to ProgramError::Custom):
+  - `TokenError::OwnerMismatch` (error code: 4) - Authority is not owner or delegate
+  - `TokenError::MintMismatch` (error code: 3) - CToken mint doesn't match CMint
+  - `TokenError::AccountFrozen` (error code: 17) - CToken account is frozen
+- `CTokenError::CMintDeserializationFailed` (error code: 18047) - Failed to deserialize CMint account using zero-copy
+- `CTokenError::InvalidAccountData` (error code: 18002) - Account data length is too small, calculate top-up failed, or invalid account format
+- `CTokenError::InvalidAccountState` (error code: 18036) - CToken account is not initialized
+- `CTokenError::InvalidAccountType` (error code: 18053) - Account is not a CToken account type
+- `CTokenError::SysvarAccessError` (error code: 18020) - Failed to get Clock or Rent sysvar for top-up calculation
+- `CTokenError::MaxTopUpExceeded` (error code: 18043) - Total top-up amount (CMint + CToken) exceeds max_top_up limit
+
+## Comparison with Token-2022
+
+CToken Burn implements similar core functionality to SPL Token-2022's Burn instruction, with key differences to support Light Protocol's compressed token model.
+
+### Functional Parity
+
+Both implementations share these core behaviors:
+
+1. **Balance/Supply Updates**: Decrease token account balance and mint supply by burn amount
+2. **Authority Validation**: Verify owner signature or delegate authority using multisig support
+3. **Account State Checks**:
+   - Frozen account check (fails if account is frozen)
+   - Native mint check (native SOL burning not supported)
+   - Mint mismatch validation (account must belong to specified mint)
+   - Insufficient funds check (account must have sufficient balance)
+4. **Delegate Handling**: Support for burning via delegate with delegated amount tracking
+5. **Permanent Delegate**: Honor permanent delegate authority if configured on mint
+6. **BurnChecked Variant**: Both support decimal validation (Token-2022's BurnChecked, CToken's optional decimals parameter in pinocchio burn)
+
+**Implementation Note**: CToken Burn delegates core burn logic to `pinocchio_token_program::processor::burn::process_burn`, which implements SPL-compatible burn semantics including all checks above.
+
+### CToken-Specific Features
+
+#### 1. Compressible Top-Up Logic
+
+CToken Burn automatically tops up compressible accounts with rent lamports after burning:
+
+```rust
+// After burn, calculate and execute top-ups for both CMint and CToken
+calculate_and_execute_compressible_top_ups(cmint, ctoken, payer, max_top_up)
+```
+
+**Top-up flow:**
+1. Calculate lamports needed for CMint based on compression state (current slot, balance, data length)
+2. Calculate lamports needed for CToken based on compression state
+3. Validate total against `max_top_up` budget
+4. Transfer lamports from payer (authority account) to both accounts if needed
+
+**Purpose**: Prevents accounts from becoming compressible during normal operations by maintaining sufficient rent balance.
+
+#### 2. max_top_up Parameter
+
+Instruction data supports two formats:
+- **Legacy (8 bytes)**: `amount` only, no top-up limit (max_top_up = 0)
+- **Extended (10 bytes)**: `amount` + `max_top_up` (u16), enforces combined CMint+CToken top-up limit
+
+```rust
+let max_top_up = match instruction_data.len() {
+    8 => 0u16,      // no limit
+    10 => u16::from_le_bytes(instruction_data[8..10])?,
+    _ => return Err(InvalidInstructionData),
+};
+```
+
+If `max_top_up != 0` and total required lamports exceed limit, transaction fails with `MaxTopUpExceeded` (18043).
+
+### Missing Features (vs Token-2022)
+
+#### 1. No Multisig Support
+
+**Token-2022**: Supports multisignature authorities with M-of-N signature validation
+```
+Accounts (multisig variant):
+0. source account (writable)
+1. mint (writable)
+2. multisig authority account
+3..3+M. signer accounts (M signers required)
+```
+
+**CToken Burn**: Only supports single-signer authority
+```
+Accounts:
+0. source CToken (writable)
+1. CMint (writable)
+2. authority (signer, also payer)
+```
+
+**Reason**: Pinocchio burn implementation handles multisig through `validate_owner()`, but CToken Burn only provides 3 accounts minimum. Multisig would require additional signer accounts and explicit multisig account validation.
+
+#### 2. No BurnChecked Instruction Variant
+
+**Token-2022**: Separate `BurnChecked` instruction (discriminator 15) with explicit decimals parameter in instruction data
+```rust
+BurnChecked {
+    amount: u64,
+    decimals: u8,  // Must match mint decimals
+}
+```
+
+**CToken Burn**: Single instruction (discriminator 8) with optional decimals validation in pinocchio layer
+```rust
+// Pinocchio burn signature:
+pub fn process_burn(
+    accounts: &[AccountInfo],
+    instruction_data: &[u8],  // 8 bytes: amount only
+) -> Result<(), TokenError>
+```
+
+**Implication**: CToken Burn relies on pinocchio's internal validation. No explicit decimals check in CToken instruction data format. If decimals validation is needed, it must be added to instruction data structure.
+
+#### 3. No NonTransferableTokens Extension Check
+
+**Token-2022**: Does NOT check `NonTransferableAccount` extension during burn (burning non-transferable tokens is allowed)
+```rust
+// Token-2022 allows burning non-transferable tokens
+// Only transfers are blocked for NonTransferableAccount
+if source_account.get_extension::<NonTransferableAccount>().is_ok() {
+    return Err(TokenError::NonTransferable.into());  // Only in transfer
+}
+```
+
+**CToken Burn**: No check for `NonTransferableAccount` extension (matches Token-2022 behavior)
+
+**Why allowed**: Burning reduces supply and eliminates tokens - doesn't violate non-transferable constraint since tokens aren't moving to another account.
+
+### Extension Handling
+
+CToken Burn only operates on CMints, which do not support restricted extensions:
+
+- **CMints only support TokenMetadata extension** - no Pausable, TransferFee, TransferHook, PermanentDelegate, or DefaultAccountState
+- **No extension checks needed** - CMints cannot have these extensions, so no validation is required
+- **For T22 mints with restricted extensions**: Use Transfer2 (decompress) to convert to SPL tokens, then burn via SPL Token-2022
+
+### Security Notes
+
+#### 1. Account Order Reversed from MintTo
+
+```
+CToken MintTo: [cmint, destination_ctoken, authority]
+CToken Burn:   [source_ctoken, cmint, authority]
+```
+
+**Reason**: SPL Token convention - source account first for burn, destination first for mint. CToken follows this pattern for pinocchio compatibility.
+
+#### 2. Top-Up Payer is Authority
+
+Unlike mint_to where payer is a separate account, burn uses the authority (signer) as payer for rent top-ups:
+
+```rust
+let payer = accounts.get(2).ok_or(ProgramError::NotEnoughAccountKeys)?;  // Same as authority
+```
+
+**Implication**: Burning tokens may require additional lamports from the authority's account if CMint/CToken are compressible and need top-up.
+
+#### 3. Pinocchio Error Conversion
+
+```rust
+process_burn(accounts, &instruction_data[..8])
+    .map_err(|e| ProgramError::Custom(u64::from(e) as u32))?;
+```
+
+Pinocchio errors are converted to `ProgramError::Custom`. Common TokenError codes:
+- `TokenError::OwnerMismatch` (4)
+- `TokenError::MintMismatch` (3)
+- `TokenError::AccountFrozen` (17)
+- `TokenError::InsufficientFunds` (1)
+
+#### 4. No Extension Validation Before Pinocchio Call
+
+CToken Burn does NOT call `check_mint_extensions()` before burning. Extension checks (PausableConfig, PermanentDelegate) are handled internally by pinocchio burn logic.
+
+**Contrast with Transfer2/CTokenTransfer**: Those instructions explicitly call `check_mint_extensions()` to validate TransferFeeConfig, TransferHook, PausableConfig, and extract PermanentDelegate.
+
+**Risk**: If future Token-2022 extensions require pre-burn validation, CToken Burn would need to add explicit extension checks before calling pinocchio.
diff --git a/programs/compressed-token/program/docs/instructions/CTOKEN_BURN_CHECKED.md b/programs/compressed-token/program/docs/instructions/CTOKEN_BURN_CHECKED.md
new file mode 100644
index 0000000000..3aa0cc0401
--- /dev/null
+++ b/programs/compressed-token/program/docs/instructions/CTOKEN_BURN_CHECKED.md
@@ -0,0 +1,178 @@
+## CToken BurnChecked
+
+**discriminator:** 15
+**enum:** `InstructionType::CTokenBurnChecked`
+**path:** programs/compressed-token/program/src/ctoken_burn.rs
+
+**description:**
+Burns tokens from a decompressed CToken account and decreases the CMint supply with decimals validation, fully compatible with SPL Token BurnChecked semantics. Account layout `CToken` is defined in `program-libs/ctoken-interface/src/state/ctoken/ctoken_struct.rs`. Account layout `CompressedMint` (CMint) is defined in `program-libs/ctoken-interface/src/state/mint/compressed_mint.rs`. Extension layout `CompressionInfo` is defined in `program-libs/compressible/src/compression_info.rs` and is embedded in both CToken and CMint structs. Uses pinocchio-token-program to process the burn_checked (handles balance/supply updates, authority check, frozen check, decimals validation). After the burn, automatically tops up compressible accounts with additional lamports if needed. Top-up prevents accounts from becoming compressible during normal operations. Enforces max_top_up limit if provided (transaction fails if exceeded). Account order is REVERSED from mint_to instruction: [source_ctoken, cmint, authority] vs mint_to's [cmint, destination_ctoken, authority].
+
+**Instruction data:**
+
+Format 1 (9 bytes, legacy):
+- Bytes 0-7: `amount` (u64, little-endian) - Number of tokens to burn
+- Byte 8: `decimals` (u8) - Expected token decimals
+- No max_top_up enforcement (effectively unlimited)
+
+Format 2 (11 bytes):
+- Bytes 0-7: `amount` (u64, little-endian) - Number of tokens to burn
+- Byte 8: `decimals` (u8) - Expected token decimals
+- Bytes 9-10: `max_top_up` (u16, little-endian) - Maximum lamports for combined CMint + CToken top-ups (0 = no limit)
+
+**Accounts:**
+1. source CToken
+   - (mutable)
+   - The CToken account to burn from
+   - Must have sufficient balance for the burn
+   - May receive rent top-up if compressible
+   - Must not be frozen
+
+2. CMint
+   - (mutable)
+   - The compressed mint account
+   - Validated: decimals field matches instruction data decimals
+   - Supply is decreased by burn amount
+   - May receive rent top-up if compressible
+
+3. authority
+   - (signer)
+   - Owner of the source CToken account
+   - Must sign the transaction
+   - Also serves as payer for rent top-ups if needed
+
+**Instruction Logic and Checks:**
+
+1. **Validate minimum accounts:**
+   - Require at least 3 accounts (source CToken, CMint, authority/payer)
+   - Return NotEnoughAccountKeys if insufficient
+
+2. **Parse instruction data:**
+   - Require at least 9 bytes (amount + decimals)
+   - Parse max_top_up:
+     - If instruction_data.len() == 9: max_top_up = 0 (no limit, legacy format)
+     - If instruction_data.len() == 11: parse u16 from bytes 9-10 as max_top_up
+     - Otherwise: return InvalidInstructionData
+
+3. **Process SPL burn_checked via pinocchio-token-program:**
+   - Call `process_burn_checked` with first 9 bytes (amount + decimals)
+   - Validates authority signature matches source CToken owner
+   - Validates decimals match CMint's decimals field
+   - Checks source CToken balance is sufficient for burn amount
+   - Checks source CToken is not frozen
+   - Decreases source CToken balance by amount
+   - Decreases CMint supply by amount
+   - Errors are converted from pinocchio errors to ProgramError::Custom
+
+4. **Calculate and execute top-up transfers:**
+   Called via `calculate_and_execute_compressible_top_ups(cmint, ctoken, payer, max_top_up)`:
+
+   a. **Initialize transfer array and budget:**
+      - Create Transfer array for [cmint, ctoken] with amounts initialized to 0
+      - Initialize lamports_budget to max_top_up + 1 (allowing exact match when total == max_top_up)
+
+   b. **Calculate CMint top-up:**
+      - Borrow CMint data and deserialize using `CompressedMint::zero_copy_at`
+      - Access compression info directly from mint.base.compression
+      - Lazy load Clock sysvar for current_slot and Rent sysvar if not yet loaded
+      - Call `compression.calculate_top_up_lamports(data_len, current_slot, lamports, rent_exemption)`
+      - Subtract calculated top-up from lamports_budget
+
+   c. **Calculate CToken top-up:**
+      - Borrow CToken data and deserialize using `CToken::zero_copy_at_checked`
+      - Access compression info directly from token.compression
+      - Calculate top-up lamports and subtract from budget
+
+   d. **Validate budget:**
+      - If both top-up amounts are 0, exit early
+      - If max_top_up != 0 and lamports_budget == 0, fail with MaxTopUpExceeded
+
+   e. **Execute transfers:**
+      - Call `multi_transfer_lamports(payer, &transfers)` to atomically transfer lamports
+      - Updates account balances for both CMint and CToken if needed
+
+**Errors:**
+
+- `ProgramError::NotEnoughAccountKeys` (error code: 11) - Less than 3 accounts provided
+- `ProgramError::InvalidInstructionData` (error code: 3) - Instruction data length is not 9 or 11 bytes
+- `ProgramError::InsufficientFunds` (error code: 6) - Source CToken balance less than burn amount (from pinocchio burn), or payer has insufficient funds for top-up transfers
+- `ProgramError::ArithmeticOverflow` (error code: 24) - Overflow when calculating total top-up amount
+- Pinocchio token errors (converted to ProgramError::Custom):
+  - `TokenError::OwnerMismatch` (error code: 4) - Authority is not owner or delegate
+  - `TokenError::MintMismatch` (error code: 3) - CToken mint doesn't match CMint
+  - `TokenError::MintDecimalsMismatch` (error code: 18) - Decimals don't match CMint's decimals
+  - `TokenError::AccountFrozen` (error code: 17) - CToken account is frozen
+- `CTokenError::CMintDeserializationFailed` (error code: 18047) - Failed to deserialize CMint account using zero-copy
+- `CTokenError::InvalidAccountData` (error code: 18002) - Account data length is too small, calculate top-up failed, or invalid account format
+- `CTokenError::InvalidAccountState` (error code: 18036) - CToken account is not initialized
+- `CTokenError::InvalidAccountType` (error code: 18053) - Account is not a CToken account type
+- `CTokenError::SysvarAccessError` (error code: 18020) - Failed to get Clock or Rent sysvar for top-up calculation
+- `CTokenError::MaxTopUpExceeded` (error code: 18043) - Total top-up amount (CMint + CToken) exceeds max_top_up limit
+
+## Comparison with Token-2022
+
+### Functional Parity
+
+CToken BurnChecked implements similar core functionality to SPL Token-2022's BurnChecked instruction:
+
+1. **Balance/Supply Updates**: Decrease token account balance and mint supply by burn amount
+2. **Authority Validation**: Verify owner signature or delegate authority
+3. **Account State Checks**:
+   - Frozen account check (fails if account is frozen)
+   - Mint mismatch validation (account must belong to specified mint)
+   - Insufficient funds check (account must have sufficient balance)
+4. **Decimals Validation**: Validate instruction decimals match mint decimals
+5. **Delegate Handling**: Support for burning via delegate with delegated amount tracking
+6. **Permanent Delegate**: Honor permanent delegate authority if configured on mint
+
+### CToken-Specific Features
+
+1. **Compressible Top-Up Logic**: After burning, automatically tops up compressible accounts with rent lamports
+2. **max_top_up Parameter**: Limits combined lamports spent on CMint + CToken top-ups
+3. **Backwards Compatible Instruction Data**: Supports 9-byte (legacy) and 11-byte (with max_top_up) formats
+
+### Missing Features
+
+1. **No Multisig Support**: Only supports single-signer authority
+2. **No PausableConfig Check**: Token-2022 fails if mint is paused
+3. **No CpiGuard Check**: Token-2022 blocks burn in CPI context if guard enabled and authority is owner
+
+### Instruction Data Comparison
+
+| Token-2022 BurnChecked | CToken BurnChecked |
+|------------------------|-------------------|
+| 10 bytes (discriminator + amount + decimals) | 9 or 11 bytes (amount + decimals + optional max_top_up) |
+
+### Account Layout Comparison
+
+| Token-2022 BurnChecked | CToken BurnChecked |
+|------------------------|-------------------|
+| [source, mint, authority, ...signers] | [source_ctoken, cmint, authority] |
+| 3+ accounts (for multisig) | Exactly 3 accounts |
+
+### Security Notes
+
+1. **Account Order Reversed from MintTo:**
+   - CToken MintTo: [cmint, destination_ctoken, authority]
+   - CToken BurnChecked: [source_ctoken, cmint, authority]
+
+2. **Top-Up Payer is Authority:**
+   - Authority (signer) serves as payer for rent top-ups
+   - Burning tokens may require additional lamports from the authority's account
+
+3. **Decimals Validation:**
+   - Pinocchio validates instruction decimals against CMint's decimals field
+   - Returns MintDecimalsMismatch (error code: 18) on mismatch
+
+### Security Properties
+
+**Shared:**
+- Authority signature validation before state changes
+- Account ownership by token program validation
+- Overflow prevention in balance/supply arithmetic
+- Frozen account protection
+- Decimals mismatch protection
+
+**CToken-Specific:**
+- Authority lamport drainage protection via max_top_up
+- Top-up atomicity: if top-up fails, entire instruction fails
+- Compressibility timing management
diff --git a/programs/compressed-token/program/docs/instructions/CTOKEN_FREEZE_ACCOUNT.md b/programs/compressed-token/program/docs/instructions/CTOKEN_FREEZE_ACCOUNT.md
new file mode 100644
index 0000000000..0129ad464e
--- /dev/null
+++ b/programs/compressed-token/program/docs/instructions/CTOKEN_FREEZE_ACCOUNT.md
@@ -0,0 +1,182 @@
+## CToken Freeze Account
+
+**discriminator:** 10
+**enum:** `CTokenInstruction::CTokenFreezeAccount`
+**path:** programs/compressed-token/program/src/ctoken_freeze_thaw.rs
+
+**description:**
+Freezes a decompressed ctoken account, preventing transfers and other operations while frozen. This is a pass-through instruction that validates mint ownership (must be owned by SPL Token, Token-2022, or CToken program) before delegating to pinocchio-token-program for standard SPL Token freeze validation. After freezing, the account's state field is set to AccountState::Frozen, and only the freeze_authority of the mint can freeze accounts (mint must have freeze_authority set). The account layout `CToken` is defined in program-libs/ctoken-interface/src/state/ctoken/ctoken_struct.rs.
+
+**Instruction data:**
+No instruction data required beyond the discriminator byte.
+
+**Accounts:**
+1. token_account
+   - (mutable)
+   - The ctoken account to freeze
+   - Must be initialized (AccountState::Initialized)
+   - Will have state field updated to AccountState::Frozen
+
+2. mint
+   - The mint account associated with the token account
+   - Must be owned by SPL Token, Token-2022, or CToken program
+   - Must have freeze_authority set (not None)
+
+3. freeze_authority
+   - (signer)
+   - Must match the mint's freeze_authority
+   - Must sign the transaction
+
+**Instruction Logic and Checks:**
+
+1. **Validate minimum accounts:**
+   - Require at least 2 accounts to get mint account (index 1)
+   - Return NotEnoughAccountKeys if insufficient
+
+2. **Validate mint ownership:**
+   - Get mint account (accounts[1])
+   - Call `check_token_program_owner(mint_info)` from programs/compressed-token/program/src/shared/owner_validation.rs
+   - Verify mint is owned by one of:
+     - SPL Token program (TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA)
+     - Token-2022 program (TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb)
+     - CToken program (cTokenmWW8bLPjZEBAUgYy3zKxQZW6VKi7bqNFEVv3m)
+   - Return IncorrectProgramId if mint owner doesn't match
+
+3. **Delegate to pinocchio-token-program:**
+   - Call `process_freeze_account(accounts)` from pinocchio-token-program
+   - This performs standard SPL Token freeze validation:
+     - Verifies token_account is mutable
+     - Verifies freeze_authority is signer
+     - Verifies token_account.mint == mint.key()
+     - Verifies mint.freeze_authority == Some(freeze_authority.key())
+     - Verifies token_account state is Initialized (not already Frozen)
+     - Updates token_account.state to AccountState::Frozen
+   - Map any errors from u64 to ProgramError::Custom(u32)
+
+**Errors:**
+- `ProgramError::NotEnoughAccountKeys` (error code: 11) - Less than 2 accounts provided (cannot get mint account)
+- `ProgramError::IncorrectProgramId` (error code: 7) - Mint is not owned by a valid token program (SPL Token, Token-2022, or CToken)
+- SPL Token errors from pinocchio-token-program (converted from u64 to ProgramError::Custom(u32)):
+  - `TokenError::MintCannotFreeze` (error code: 16) - Mint's freeze_authority is None
+  - `TokenError::OwnerMismatch` (error code: 4) - freeze_authority doesn't match mint's freeze_authority
+  - `TokenError::MintMismatch` (error code: 3) - token_account's mint doesn't match provided mint
+  - `TokenError::InvalidState` (error code: 13) - Account is already frozen or uninitialized
+  - `ProgramError::InvalidAccountData` (error code: 4) - Account data is malformed
+
+## Comparison with Token-2022
+
+### Functional Parity
+
+CToken's FreezeAccount instruction maintains complete functional parity with Token-2022 for core freeze operations:
+
+- **Same discriminator:** Both use discriminator 10 (0x0A)
+- **Same account requirements:** token_account (writable), mint (read-only), freeze_authority (signer)
+- **Same state transitions:** Initialized → Frozen (prevents reverse transition Frozen → Frozen)
+- **Same authority validation:** Verifies freeze_authority matches mint's freeze_authority
+- **Same error handling:** Returns identical TokenError codes (MintCannotFreeze, OwnerMismatch, MintMismatch, InvalidState)
+- **Extension support:** Both handle Token-2022 extensions through TLV unpacking (PodStateWithExtensionsMut)
+
+### CToken-Specific Features
+
+**Additional Mint Ownership Validation:**
+CToken adds an explicit mint ownership check before delegating to the standard freeze logic:
+
+```rust
+// programs/compressed-token/program/src/ctoken_freeze_thaw.rs:14-15
+let mint_info = accounts.get(1).ok_or(ProgramError::NotEnoughAccountKeys)?;
+check_token_program_owner(mint_info)?;
+```
+
+This validates that the mint is owned by one of:
+- SPL Token program (TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA)
+- Token-2022 program (TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb)
+- CToken program (cTokenmWW8bLPjZEBAUgYy3zKxQZW6VKi7bqNFEVv3m)
+
+**Security benefit:** This explicit check provides defense-in-depth by failing fast with `ProgramError::IncorrectProgramId` before attempting deserialization, preventing potential cross-program account confusion.
+
+**Comparison with Token-2022:** Token-2022 relies on implicit validation through `PodStateWithExtensions::unpack()` which would fail on invalid mint data, but does not perform explicit ownership validation (see Token-2022 analysis: "MISSING CHECK 2: Mint Program Ownership").
+
+### Missing Features
+
+**No Multisig Support:**
+CToken's freeze instruction does not support multisig freeze authorities. The instruction only accepts:
+- Single signer freeze authority (accounts[2] must be signer)
+
+Token-2022 supports both:
+- Single owner: 3 accounts (token_account, mint, freeze_authority)
+- Multisig owner: 3+M accounts (token_account, mint, multisig_account, ...M signers)
+
+**Impact:** Mints with multisig freeze authorities cannot use CToken freeze operations. Users must rely on the native Token-2022 freeze instruction for multisig-controlled mints.
+
+### Extension Handling Differences
+
+**Token-2022 Extensions:**
+Both CToken and Token-2022 handle extensions identically through the underlying `process_freeze_account` implementation:
+- Uses `PodStateWithExtensionsMut::<PodAccount>::unpack()` for token account
+- Uses `PodStateWithExtensions::<PodMint>::unpack()` for mint
+- No extension-specific validation required (freeze operates on base state only)
+
+**CToken-Specific Extensions:**
+CToken accounts may have a `Compressible` extension (not present in SPL/Token-2022). The freeze instruction operates on the base `CToken` state and does not interact with the compressible extension. Frozen accounts remain frozen after compression/decompression cycles.
+
+**Permanent Delegate Interaction:**
+- Token-2022: Permanent delegate cannot transfer/burn from frozen accounts (operations fail with AccountFrozen)
+- CToken: Same behavior - permanent delegate cannot compress frozen accounts (frozen check in `programs/compressed-token/program/src/transfer2/compression/ctoken/compress_or_decompress_ctokens.rs:173-178`)
+
+**Default Account State Extension:**
+- Token-2022: Supports `DefaultAccountState` extension to create accounts in frozen state by default
+- CToken: Supports this extension when creating CToken accounts from Token-2022 mints (extension data preserved during decompression)
+
+### Security Property Comparison
+
+Both implementations provide equivalent security properties:
+
+| Security Property | Token-2022 | CToken |
+|------------------|------------|---------|
+| Account initialization validation | Yes (unpack checks is_initialized) | Yes (via pinocchio-token-program) |
+| Account type validation | Yes (checks AccountType::Account) | Yes (via pinocchio-token-program) |
+| State transition guards | Yes (prevents Frozen→Frozen) | Yes (via pinocchio-token-program) |
+| Native account rejection | Yes (NativeNotSupported) | Yes (via pinocchio-token-program) |
+| Mint association validation | Yes (key comparison) | Yes (via pinocchio-token-program) |
+| Mint initialization validation | Yes (unpack checks is_initialized) | Yes (via pinocchio-token-program) |
+| Freeze authority existence check | Yes (checks PodCOption::SOME) | Yes (via pinocchio-token-program) |
+| Freeze authority key validation | Yes (validate_owner) | Yes (via pinocchio-token-program) |
+| Single signer validation | Yes | Yes (via pinocchio-token-program) |
+| Multisig support | Yes (M-of-N threshold) | No |
+| **Explicit mint ownership check** | **No** (implicit via unpack) | **Yes** (explicit check_token_program_owner) |
+| **Explicit account ownership check** | **No** (implicit via unpack) | **No** (implicit via unpack) |
+
+**Key Differences:**
+1. **CToken adds explicit mint ownership validation** - Provides defense-in-depth with clear error messages before data borrowing
+2. **Token-2022 supports multisig** - CToken only supports single signer freeze authorities
+3. **Both lack explicit account ownership validation** - Rely on implicit unpack failures for non-token-program accounts
+
+### Implementation Architecture
+
+**Token-2022:**
+```
+FreezeAccount instruction (discriminator: 10)
+  ↓
+process_toggle_freeze_account(freeze=true)
+  ↓
+- Unpack source account (PodStateWithExtensionsMut)
+- Unpack mint (PodStateWithExtensions)
+- Validate freeze authority (single or multisig)
+- Update account state to Frozen
+```
+
+**CToken:**
+```
+CTokenFreezeAccount instruction (discriminator: 10)
+  ↓
+process_ctoken_freeze_account()
+  ↓
+check_token_program_owner(mint) // Additional validation
+  ↓
+process_freeze_account() (from pinocchio-token-program)
+  ↓
+- Same validation logic as Token-2022 single-signer path
+- Update account state to Frozen
+```
+
+**Architecture benefit:** CToken reuses Token-2022's battle-tested freeze logic through pinocchio-token-program while adding an extra layer of mint ownership validation.
diff --git a/programs/compressed-token/program/docs/instructions/CTOKEN_MINT_TO.md b/programs/compressed-token/program/docs/instructions/CTOKEN_MINT_TO.md
new file mode 100644
index 0000000000..7d50aa3555
--- /dev/null
+++ b/programs/compressed-token/program/docs/instructions/CTOKEN_MINT_TO.md
@@ -0,0 +1,217 @@
+## CToken MintTo
+
+**discriminator:** 7
+**enum:** `InstructionType::CTokenMintTo`
+**path:** programs/compressed-token/program/src/ctoken_mint_to.rs
+
+**description:**
+Mints tokens from a decompressed CMint account to a destination CToken account, fully compatible with SPL Token mint_to semantics. Uses pinocchio-token-program to process the mint_to operation which handles balance/supply updates, authority validation, and frozen account checks. After minting, automatically tops up compressible accounts with additional lamports if needed to prevent accounts from becoming compressible during normal operations. Both CMint and destination CToken can receive top-ups based on their current slot and account balance. Supports max_top_up parameter to limit rent top-up costs where 0 means no limit. Instruction data is backwards-compatible with two formats: 8-byte format for legacy compatibility without max_top_up enforcement and 10-byte format with max_top_up. This instruction only works with CMints (compressed mints). CMints do not support restricted Token-2022 extensions (Pausable, TransferFee, TransferHook, PermanentDelegate, DefaultAccountState) - only TokenMetadata is allowed.
+
+Account layouts:
+- `CToken` defined in: program-libs/ctoken-interface/src/state/ctoken/ctoken_struct.rs
+- `CompressedMint` (CMint) defined in: program-libs/ctoken-interface/src/state/mint/compressed_mint.rs
+- `CompressionInfo` extension defined in: program-libs/compressible/src/compression_info.rs
+
+**Instruction data:**
+Path: programs/compressed-token/program/src/ctoken_mint_to.rs (lines 10-47)
+
+Byte layout:
+- Bytes 0-7: `amount` (u64, little-endian) - Number of tokens to mint
+- Bytes 8-9: `max_top_up` (u16, little-endian, optional) - Maximum lamports for top-ups combined, 0 = no limit
+
+Format variants:
+- 8-byte format: amount only, no max_top_up enforcement
+- 10-byte format: amount + max_top_up
+
+**Accounts:**
+1. CMint
+   - (writable)
+   - The compressed mint account to mint from
+   - Validated: mint authority matches authority account
+   - Supply is increased by mint amount
+   - May receive rent top-up if compressible
+
+2. destination CToken
+   - (writable)
+   - The destination CToken account to mint to
+   - Validated: mint field matches CMint pubkey, not frozen
+   - Balance is increased by mint amount
+   - May receive rent top-up if compressible
+
+3. authority
+   - (signer, writable when top-ups needed)
+   - Mint authority of the CMint account
+   - Validated: must sign the transaction
+   - Also serves as payer for rent top-ups if needed
+
+**Instruction Logic and Checks:**
+
+1. **Validate minimum accounts:**
+   - Require at least 3 accounts (cmint, destination, authority)
+   - Return NotEnoughAccountKeys if insufficient
+
+2. **Parse instruction data:**
+   - Require at least 8 bytes for amount
+   - Parse max_top_up from bytes 8-10 if present (10-byte format)
+   - Default to 0 (no limit) if only 8 bytes provided (legacy format)
+   - Return InvalidInstructionData if length is invalid (not 8 or 10 bytes)
+
+3. **Process SPL mint_to via pinocchio-token-program:**
+   - Call `process_mint_to` with first 8 bytes (amount only)
+   - Validates authority signature matches CMint mint authority
+   - Checks destination CToken mint matches CMint
+   - Checks destination CToken is not frozen
+   - Increases destination CToken balance by amount
+   - Increases CMint supply by amount
+   - Errors are converted from pinocchio errors to ProgramError::Custom
+
+4. **Calculate top-up requirements:**
+   For both CMint and destination CToken accounts:
+
+   a. **Deserialize account using zero-copy:**
+      - CMint: Use `CompressedMint::zero_copy_at`
+      - CToken: Use `CToken::zero_copy_at_checked`
+      - Access compression info directly from embedded field (all accounts now have compression embedded)
+
+   b. **Calculate top-up amount:**
+      - Get current slot from Clock sysvar (lazy loaded, only if needed)
+      - Get rent exemption from Rent sysvar
+      - Call `calculate_top_up_lamports` which:
+        - Checks if account is compressible
+        - Calculates rent deficit if any
+        - Adds configured lamports_per_write amount
+        - Returns 0 if account is well-funded
+
+   c. **Track lamports budget:**
+      - Initialize budget to max_top_up + 1 (allowing exact match)
+      - Subtract CMint top-up amount from budget
+      - Subtract CToken top-up amount from budget
+      - If budget reaches 0 and max_top_up is not 0, fail with MaxTopUpExceeded
+
+5. **Execute top-up transfers:**
+   - Skip if no accounts need top-up (both amounts are 0)
+   - Use authority account (third account) as funding source
+   - Execute multi_transfer_lamports to top up both accounts atomically
+   - Update account lamports balances
+
+**Errors:**
+
+- `ProgramError::NotEnoughAccountKeys` (error code: 11) - Less than 3 accounts provided
+- `ProgramError::InvalidInstructionData` (error code: 3) - Instruction data length is not 8 or 10 bytes
+- Pinocchio token errors (converted to ProgramError::Custom):
+  - `TokenError::MintMismatch` (error code: 3) - CToken mint doesn't match CMint
+  - `TokenError::OwnerMismatch` (error code: 4) - Authority doesn't match CMint mint_authority
+  - `TokenError::AccountFrozen` (error code: 17) - CToken account is frozen
+- `CTokenError::CMintDeserializationFailed` (error code: 18047) - Failed to deserialize CMint account using zero-copy
+- `CTokenError::InvalidAccountData` (error code: 18002) - Failed to deserialize CToken account or calculate top-up amount
+- `CTokenError::SysvarAccessError` (error code: 18020) - Failed to get Clock or Rent sysvar for top-up calculation
+- `CTokenError::MaxTopUpExceeded` (error code: 18043) - Total top-up amount (CMint + CToken) exceeds max_top_up limit
+
+---
+
+## Comparison with Token-2022
+
+This section compares CToken MintTo with Token-2022's MintTo and MintToChecked instructions.
+
+### Functional Parity
+
+CToken MintTo maintains core compatibility with Token-2022's MintTo instruction:
+
+- **Authority validation:** Both require mint authority signature and validate against the mint's configured mint_authority
+- **Balance updates:** Both increase destination account balance and mint supply by the specified amount
+- **Frozen account checks:** Both prevent minting to frozen accounts
+- **Mint matching:** Both validate that destination account's mint field matches the mint account
+- **Overflow protection:** Both check for arithmetic overflow when adding to balances and supply
+- **Fixed supply enforcement:** Both fail if mint_authority is set to None (supply is fixed)
+
+### CToken-Specific Features
+
+CToken MintTo extends Token-2022 functionality with compression-specific features:
+
+**1. Compressible Top-Up Logic**
+
+After minting, CToken MintTo automatically replenishes lamports for compressible accounts to prevent premature compression:
+
+- **Dual account top-up:** Both CMint and destination CToken may receive rent top-ups in a single transaction
+- **Compressibility checks:** Uses `calculate_top_up_lamports` to determine if accounts need funding based on:
+  - Current slot vs last_compressible_slot
+  - Account lamport balance vs rent exemption threshold
+  - Configured lamports_per_write amount
+- **Automatic funding:** Authority account serves as payer for all top-ups
+- **Zero-copy access:** Uses zero-copy deserialization to read compression info directly from embedded fields without full account deserialization
+
+**2. Max Top-Up Parameter**
+
+CToken MintTo includes a `max_top_up` parameter to control rent costs:
+
+- **Budget enforcement:** Limits combined lamports spent on CMint + CToken top-ups
+- **Value 0 = unlimited:** Setting max_top_up to 0 means no spending limit
+- **Backwards compatibility:** Supports 8-byte format (amount only, no limit) and 10-byte format (amount + max_top_up)
+- **Fails on overflow:** Returns MaxTopUpExceeded error if total top-up exceeds budget
+- **Prevents DoS:** Protects authority account from unexpected lamport drainage
+
+**3. Authority Account Mutability**
+
+- **Token-2022:** Authority account is read-only (signature verification only)
+- **CToken:** Authority account must be writable when top-ups are needed (serves as payer)
+
+### Missing Token-2022 Features
+
+**1. No Multisig Support**
+
+- **Token-2022:** Supports multisig authorities via additional signer accounts (accounts 3..3+M)
+- **CToken:** Does not support multisig authorities - only single signer supported
+- **Implication:** CToken MintTo expects exactly 3 accounts; Token-2022 accepts 3+ for multisig
+
+**2. No MintToChecked Variant**
+
+- **Token-2022:** Provides MintToChecked instruction that validates decimals parameter against mint
+- **CToken:** Does not implement decimals validation in CToken MintTo
+- **Token-2022 MintToChecked behavior:**
+  - Instruction data: 10 bytes (discriminator + amount + decimals)
+  - Validation: `expected_decimals != mint.base.decimals` returns MintDecimalsMismatch error
+  - Use case: Prevents minting with incorrect decimal assumptions in offline/hardware wallet scenarios
+- **CToken workaround:** Clients must validate decimals independently before calling CToken MintTo
+
+### Extension Handling
+
+CToken MintTo only operates on CMints, which do not support restricted extensions:
+
+- **CMints only support TokenMetadata extension** - no Pausable, TransferFee, TransferHook, PermanentDelegate, or DefaultAccountState
+- **No extension checks needed** - CMints cannot have these extensions, so no validation is required
+- **Compressible extension (CToken-specific):** Always present in CMint and CToken accounts as embedded field, accessed via zero-copy
+
+### Security Notes
+
+**Shared Security Properties:**
+
+- Both validate authority signature before state changes
+- Both check for account ownership by token program
+- Both prevent overflow in balance/supply arithmetic
+- Both prevent minting to frozen accounts
+
+**CToken-Specific Security Considerations:**
+
+1. **Authority lamport drainage:** Authority must have sufficient lamports for top-ups; use max_top_up to limit exposure
+2. **Top-up atomicity:** If top-up fails (insufficient authority balance), entire instruction fails - no partial minting
+3. **Compressibility timing:** Top-ups are calculated based on current slot and account state; accounts may still become compressible after minting if not topped up
+4. **No multisig protection:** Single authority compromise affects all minting; Token-2022 multisig provides defense in depth
+
+**Token-2022-Specific Security Considerations:**
+
+1. **Extension-based restrictions:** NonTransferable, PausableConfig, and ConfidentialMintBurn extensions add security controls not enforced in CToken MintTo
+2. **Decimals validation (MintToChecked):** Prevents decimal precision errors in offline transaction construction
+
+### Summary Table
+
+| Feature | Token-2022 MintTo | Token-2022 MintToChecked | CToken MintTo |
+|---------|-------------------|--------------------------|---------------|
+| Instruction data | 8 bytes (amount) | 10 bytes (amount + decimals) | 8 or 10 bytes (amount + optional max_top_up) |
+| Multisig support | Yes | Yes | No |
+| Decimals validation | No | Yes | No |
+| Automatic rent top-up | No | No | Yes (compressible accounts) |
+| Top-up budget control | N/A | N/A | Yes (max_top_up) |
+| Authority account | Read-only | Read-only | Writable (when top-ups needed) |
+| Extension checks | NonTransferable, PausableConfig, ConfidentialMintBurn | Same as MintTo | None (CMints don't support restricted extensions) |
+| Account count | 3+ (multisig) | 3+ (multisig) | Exactly 3 |
+| Backwards compatibility | N/A | N/A | 8-byte format (legacy) and 10-byte format (with max_top_up) |
diff --git a/programs/compressed-token/program/docs/instructions/CTOKEN_MINT_TO_CHECKED.md b/programs/compressed-token/program/docs/instructions/CTOKEN_MINT_TO_CHECKED.md
new file mode 100644
index 0000000000..91e5352790
--- /dev/null
+++ b/programs/compressed-token/program/docs/instructions/CTOKEN_MINT_TO_CHECKED.md
@@ -0,0 +1,143 @@
+## CToken MintToChecked
+
+**discriminator:** 14
+**enum:** `InstructionType::CTokenMintToChecked`
+**path:** programs/compressed-token/program/src/ctoken_mint_to.rs
+
+**description:**
+Mints tokens from a decompressed CMint account to a destination CToken account with decimals validation, fully compatible with SPL Token MintToChecked semantics. Uses pinocchio-token-program to process the mint_to_checked operation which handles balance/supply updates, authority validation, frozen account checks, and decimals validation. After minting, automatically tops up compressible accounts with additional lamports if needed to prevent accounts from becoming compressible during normal operations. Both CMint and destination CToken can receive top-ups based on their current slot and account balance. Supports max_top_up parameter to limit rent top-up costs where 0 means no limit.
+
+Account layouts:
+- `CToken` defined in: program-libs/ctoken-interface/src/state/ctoken/ctoken_struct.rs
+- `CompressedMint` (CMint) defined in: program-libs/ctoken-interface/src/state/mint/compressed_mint.rs
+- `CompressionInfo` extension defined in: program-libs/compressible/src/compression_info.rs
+
+**Instruction data:**
+Path: programs/compressed-token/program/src/ctoken_mint_to.rs (lines 62-112, function `process_ctoken_mint_to_checked`)
+
+Byte layout:
+- Bytes 0-7: `amount` (u64, little-endian) - Number of tokens to mint
+- Byte 8: `decimals` (u8) - Expected token decimals
+- Bytes 9-10: `max_top_up` (u16, little-endian, optional) - Maximum lamports for top-ups combined, 0 = no limit
+
+Format variants:
+- 9 bytes: amount + decimals (legacy, no max_top_up enforcement)
+- 11 bytes: amount + decimals + max_top_up
+
+**Accounts:**
+1. CMint
+   - (writable)
+   - The compressed mint account to mint from
+   - Validated: mint authority matches authority account
+   - Validated: decimals field matches instruction data decimals
+   - Supply is increased by mint amount
+   - May receive rent top-up if compressible
+
+2. destination CToken
+   - (writable)
+   - The destination CToken account to mint to
+   - Validated: mint field matches CMint pubkey, not frozen
+   - Balance is increased by mint amount
+   - May receive rent top-up if compressible
+
+3. authority
+   - (signer, writable when top-ups needed)
+   - Mint authority of the CMint account
+   - Validated: must sign the transaction
+   - Also serves as payer for rent top-ups if needed
+
+**Instruction Logic and Checks:**
+
+1. **Validate minimum accounts:**
+   - Require at least 3 accounts (cmint, destination, authority)
+   - Return NotEnoughAccountKeys if insufficient
+
+2. **Parse instruction data:**
+   - Require at least 9 bytes (amount + decimals)
+   - Parse max_top_up from bytes 9-11 if present (11-byte format)
+   - Default to 0 (no limit) if only 9 bytes provided (legacy format)
+   - Return InvalidInstructionData if length is invalid (not 9 or 11 bytes)
+
+3. **Process SPL mint_to_checked via pinocchio-token-program:**
+   - Call `process_mint_to_checked` with first 9 bytes (amount + decimals)
+   - Validates authority signature matches CMint mint authority
+   - Validates decimals match CMint's decimals field
+   - Checks destination CToken mint matches CMint
+   - Checks destination CToken is not frozen
+   - Increases destination CToken balance by amount
+   - Increases CMint supply by amount
+   - Errors are converted from pinocchio errors to ProgramError::Custom
+
+4. **Calculate and execute top-up transfers:**
+   - Calculate lamports needed for CMint based on compression state
+   - Calculate lamports needed for CToken based on compression state
+   - Validate total against max_top_up budget
+   - Transfer lamports from authority to both accounts if needed
+
+**Errors:**
+
+- `ProgramError::NotEnoughAccountKeys` (error code: 11) - Less than 3 accounts provided
+- `ProgramError::InvalidInstructionData` (error code: 3) - Instruction data length is not 9 or 11 bytes
+- Pinocchio token errors (converted to ProgramError::Custom):
+  - `TokenError::MintMismatch` (error code: 3) - CToken mint doesn't match CMint
+  - `TokenError::OwnerMismatch` (error code: 4) - Authority doesn't match CMint mint_authority
+  - `TokenError::MintDecimalsMismatch` (error code: 18) - Decimals don't match CMint's decimals
+  - `TokenError::AccountFrozen` (error code: 17) - CToken account is frozen
+- `CTokenError::CMintDeserializationFailed` (error code: 18047) - Failed to deserialize CMint account using zero-copy
+- `CTokenError::InvalidAccountData` (error code: 18002) - Failed to deserialize CToken account or calculate top-up amount
+- `CTokenError::SysvarAccessError` (error code: 18020) - Failed to get Clock or Rent sysvar for top-up calculation
+- `CTokenError::MaxTopUpExceeded` (error code: 18043) - Total top-up amount (CMint + CToken) exceeds max_top_up limit
+
+---
+
+## Comparison with Token-2022
+
+### Functional Parity
+
+CToken MintToChecked maintains core compatibility with Token-2022's MintToChecked instruction:
+
+- **Authority validation:** Both require mint authority signature and validate against the mint's configured mint_authority
+- **Balance updates:** Both increase destination account balance and mint supply by the specified amount
+- **Frozen account checks:** Both prevent minting to frozen accounts
+- **Mint matching:** Both validate that destination account's mint field matches the mint account
+- **Decimals validation:** Both validate that instruction decimals match mint decimals
+- **Overflow protection:** Both check for arithmetic overflow when adding to balances and supply
+- **Fixed supply enforcement:** Both fail if mint_authority is set to None (supply is fixed)
+
+### CToken-Specific Features
+
+1. **Compressible Top-Up Logic**: After minting, automatically replenishes lamports for compressible accounts
+2. **max_top_up Parameter**: Limits combined lamports spent on CMint + CToken top-ups
+3. **Authority Account Mutability**: Authority account must be writable when top-ups are needed
+
+### Missing Features
+
+1. **No Multisig Support**: Token-2022 supports multisig authorities via additional signer accounts
+2. **No Extension Checks**: Token-2022's MintToChecked validates NonTransferable, PausableConfig, and ConfidentialMintBurn extensions
+
+### Instruction Data Comparison
+
+| Token-2022 MintToChecked | CToken MintToChecked |
+|--------------------------|---------------------|
+| 10 bytes (discriminator + amount + decimals) | 9 or 11 bytes (amount + decimals + optional max_top_up) |
+
+### Account Layout Comparison
+
+| Token-2022 MintToChecked | CToken MintToChecked |
+|--------------------------|---------------------|
+| [mint, destination, authority, ...signers] | [cmint, destination, authority] |
+| 3+ accounts (for multisig) | Exactly 3 accounts |
+
+### Security Properties
+
+**Shared:**
+- Authority signature validation before state changes
+- Account ownership by token program validation
+- Overflow prevention in balance/supply arithmetic
+- Frozen account protection
+- Decimals mismatch protection
+
+**CToken-Specific:**
+- Authority lamport drainage protection via max_top_up
+- Top-up atomicity: if top-up fails, entire instruction fails
+- Compressibility timing management
diff --git a/programs/compressed-token/program/docs/instructions/CTOKEN_REVOKE.md b/programs/compressed-token/program/docs/instructions/CTOKEN_REVOKE.md
new file mode 100644
index 0000000000..0c1cd02991
--- /dev/null
+++ b/programs/compressed-token/program/docs/instructions/CTOKEN_REVOKE.md
@@ -0,0 +1,199 @@
+## CToken Revoke
+
+**discriminator:** 5
+**enum:** `InstructionType::CTokenRevoke`
+**path:** programs/compressed-token/program/src/ctoken_approve_revoke.rs
+
+### SPL Instruction Format Compatibility
+
+**Important:** This instruction is only compatible with the SPL Token instruction format (using `spl_token_2022::instruction::revoke` with changed program ID) when **no top-up is required**.
+
+If the CToken account has a compressible extension and requires a rent top-up, the instruction needs the **system program account** to perform the lamports transfer. Without the system program account, the top-up CPI will fail.
+
+**Compatibility scenarios:**
+- **SPL-compatible (no system program needed):** Non-compressible accounts, or compressible accounts with sufficient prepaid rent
+- **NOT SPL-compatible (system program required):** Compressible accounts that need rent top-up based on current slot
+
+**description:**
+Revokes any previously granted delegation on a decompressed ctoken account (account layout `CToken` defined in program-libs/ctoken-interface/src/state/ctoken/ctoken_struct.rs). Before the revoke operation, automatically tops up compressible accounts (extension layout `CompressionInfo` defined in program-libs/compressible/src/compression_info.rs) with additional lamports if needed to prevent accounts from becoming compressible during normal operations. The instruction supports a max_top_up parameter (0 = no limit) that enforces transaction failure if the calculated top-up exceeds this limit. Uses pinocchio-token-program for SPL-compatible revoke semantics. Supports backwards-compatible instruction data format (0 bytes legacy vs 2 bytes with max_top_up). The revoke operation follows SPL Token rules exactly (clears delegate and delegated_amount).
+
+**Instruction data:**
+Path: programs/compressed-token/program/src/ctoken_approve_revoke.rs (lines 70-94)
+
+- Empty (0 bytes): legacy format, no max_top_up enforcement (max_top_up = 0, no limit)
+- Bytes 0-1 (optional): `max_top_up` (u16, little-endian) - Maximum lamports for top-up (0 = no limit)
+
+**Accounts:**
+1. source
+   - (mutable)
+   - The source ctoken account to revoke delegation on
+   - May receive rent top-up if compressible
+
+2. owner
+   - (signer, mutable)
+   - Owner of the source account
+   - Must sign the transaction
+   - Acts as payer for rent top-up if compressible extension present
+
+**Instruction Logic and Checks:**
+
+1. **Parse instruction data:**
+   - If 0 bytes: legacy format, set max_top_up = 0 (no limit)
+   - If 2 bytes: parse max_top_up (u16, little-endian)
+   - Return InvalidInstructionData for any other length
+
+2. **Validate minimum accounts:**
+   - Require at least 2 accounts (source, owner)
+   - Return NotEnoughAccountKeys if insufficient
+
+3. **Process compressible top-up:**
+   - Borrow source account data mutably
+   - Deserialize CToken using zero-copy validation
+   - Initialize lamports_budget based on max_top_up:
+     - If max_top_up == 0: budget = u64::MAX (no limit)
+     - Otherwise: budget = max_top_up + 1 (allows exact match)
+   - Call process_compression_top_up with source account's compression info
+   - Drop borrow before CPI
+   - If transfer_amount > 0:
+     - Check that transfer_amount <= lamports_budget
+     - Return MaxTopUpExceeded if budget exceeded
+     - Transfer lamports from owner to source via CPI
+
+4. **Process SPL revoke:**
+   - Call process_revoke with accounts
+   - Clears the delegate field and delegated_amount on the source account
+
+**Errors:**
+
+- `ProgramError::InvalidInstructionData` (error code: 3) - Instruction data is not 0 or 2 bytes
+- `ProgramError::NotEnoughAccountKeys` (error code: 11) - Less than 2 accounts provided
+- `CTokenError::InvalidAccountData` (error code: 18002) - Failed to deserialize CToken account
+- `CTokenError::SysvarAccessError` (error code: 18020) - Failed to get Clock or Rent sysvar for top-up calculation
+- `CTokenError::MaxTopUpExceeded` (error code: 18043) - Calculated top-up exceeds max_top_up parameter
+- `ProgramError::MissingRequiredSignature` (error code: 8) - Owner did not sign the transaction (SPL Token error)
+- Pinocchio token errors (converted to ProgramError::Custom):
+  - `TokenError::OwnerMismatch` (error code: 4) - Authority doesn't match account owner
+  - `TokenError::AccountFrozen` (error code: 17) - Account is frozen
+
+## Comparison with Token-2022
+
+### Functional Parity
+
+CToken Revoke maintains functional parity with Token-2022 for the core revoke operation:
+
+1. **Delegate Clearing**: Both implementations atomically clear the `delegate` field and `delegated_amount` to zero
+2. **Owner Authority**: Both require the token account owner to sign the transaction
+3. **Account State Validation**: Both validate that the source account is properly initialized and owned by the token program
+4. **Frozen Account Handling**: Both prevent revoke operations on frozen accounts (enforced by pinocchio-token-program)
+5. **Signer Validation**: Both ensure the authority account is a transaction signer
+
+### CToken-Specific Features
+
+CToken Revoke adds compression-aware functionality not present in Token-2022:
+
+1. **Compressible Top-Up Logic**: Automatically tops up accounts with the Compressible extension to prevent them from becoming compressible during normal operations
+   - Calculates required lamports based on rent exemption and compression threshold
+   - Transfers lamports from owner (payer) to source account via CPI
+   - Uses Clock and Rent sysvars to determine compressibility
+
+2. **max_top_up Parameter**: Enforces transaction failure if the calculated top-up exceeds the specified limit
+   - `max_top_up = 0` means no limit (legacy behavior)
+   - Prevents unexpected lamport transfers during revoke operations
+   - Returns `CTokenError::MaxTopUpExceeded` if budget exceeded
+
+3. **Backwards-Compatible Instruction Data**:
+   - 0 bytes: Legacy format (no max_top_up enforcement)
+   - 2 bytes: New format with max_top_up parameter
+
+### Missing Features
+
+CToken Revoke does NOT implement the following Token-2022 features:
+
+1. **Multisignature Support**: Token-2022 supports M-of-N multisig accounts as the authority
+   - Token-2022 validates multisig signers and enforces threshold requirements
+   - CToken only supports single-signature owner authority
+   - Account requirements: Token-2022 requires additional signer accounts for multisig (2..2+M accounts)
+
+2. **Dual Authority Model**: Token-2022 allows BOTH the account owner AND the current delegate to revoke delegation
+   - Token-2022 implementation (lines 637-649 in processor.rs):
+     ```rust
+     Self::validate_owner(
+         program_id,
+         match &source_account.base.delegate {
+             PodCOption {
+                 option: PodCOption::<Pubkey>::SOME,
+                 value: delegate,
+             } if authority_info.key == delegate => delegate,
+             _ => &source_account.base.owner,
+         },
+         authority_info,
+         // ...
+     )
+     ```
+   - CToken only accepts the owner as authority (account index 1)
+   - Use case: In Token-2022, delegates can voluntarily relinquish their own authority
+
+3. **No CPI Guard Extension Check**: Token-2022 does not check CPI Guard for Revoke (intentional design)
+   - CToken similarly has no CPI Guard check (delegates to pinocchio-token-program)
+   - Note: Token-2022 Approve DOES check CPI Guard and blocks approve during CPI if enabled
+
+### Extension Handling Differences
+
+**Token-2022 Extension Interactions:**
+- No explicit extension checks in Revoke
+- CPI Guard: Not checked (Revoke can be called via CPI even with CpiGuard enabled)
+- Non-Transferable: Works on non-transferable accounts (no tokens moved)
+- Transfer Hooks: No interaction (no token transfer occurs)
+- Permanent Delegate: No conflict (permanent delegate is separate from regular delegate)
+
+**CToken Extension Handling:**
+- Compressible extension: Explicitly processed for rent top-up
+- No other extension-specific logic (delegates to pinocchio-token-program for base validation)
+
+### Security Property Comparison
+
+**Shared Security Properties:**
+1. **Program Ownership Validation**: Both validate source account is owned by token program
+2. **Initialization Check**: Both ensure account is initialized before processing
+3. **Frozen Account Protection**: Both block revoke on frozen accounts
+4. **Authority Key Matching**: Both verify authority signature matches expected owner
+5. **Atomic State Updates**: Both clear delegate and delegated_amount together
+6. **No Balance Checks**: Both are pure authority operations (no token balance validation)
+
+**CToken-Specific Security:**
+1. **Rent Protection**: max_top_up parameter prevents unexpected lamport transfers
+2. **Compressibility Prevention**: Ensures accounts remain above compression threshold after operation
+3. **Zero-Copy Validation**: Uses zero-copy deserialization for CToken account structure
+
+**Token-2022-Specific Security:**
+1. **Multisig Validation**: Enforces M-of-N signature requirements for multisig authorities
+2. **Duplicate Signer Prevention**: Prevents counting same signer multiple times in multisig
+3. **Delegate Self-Revocation**: Allows delegate to remove their own authority (not available in CToken)
+
+### Implementation Differences
+
+**Token-2022 (lines 624-654 in processor.rs):**
+- Direct processor implementation
+- Flexible authority selection (owner OR delegate)
+- No additional lamport transfers
+- No instruction data (unit variant)
+
+**CToken (programs/compressed-token/program/src/ctoken_approve_revoke.rs):**
+- Wrapper around pinocchio-token-program's process_revoke
+- Owner-only authority model
+- Pre-processes compressible top-up before delegating to SPL logic
+- Optional instruction data for max_top_up parameter (0 or 2 bytes)
+
+### Use Case Implications
+
+1. **Standard Token Operations**: CToken Revoke provides identical functionality for non-compressible accounts
+2. **Compression-Aware Applications**: CToken's top-up logic prevents surprise account compression
+3. **Multisig Wallets**: Not supported in CToken (use Token-2022 for multisig requirements)
+4. **Delegate Self-Revocation**: Not available in CToken (only owner can revoke)
+5. **Budget-Constrained Transactions**: max_top_up parameter enables precise lamport budget control
+
+### Overall Risk Assessment
+
+**CToken Revoke**: Low risk. Well-secured with comprehensive validation and compression-specific protections. Missing multisig support reduces attack surface but limits flexibility for advanced wallet architectures.
+
+**Token-2022 Revoke**: Low risk. Comprehensive validation with additional multisig support and dual authority model. CPI Guard intentionally not enforced to preserve revoke functionality in all contexts.
diff --git a/programs/compressed-token/program/docs/instructions/CTOKEN_THAW_ACCOUNT.md b/programs/compressed-token/program/docs/instructions/CTOKEN_THAW_ACCOUNT.md
new file mode 100644
index 0000000000..ce37fdf4fe
--- /dev/null
+++ b/programs/compressed-token/program/docs/instructions/CTOKEN_THAW_ACCOUNT.md
@@ -0,0 +1,189 @@
+## CToken Thaw Account
+
+**discriminator:** 11
+**enum:** `CTokenInstruction::CTokenThawAccount`
+**path:** programs/compressed-token/program/src/ctoken_freeze_thaw.rs
+
+**description:**
+Thaws a frozen decompressed ctoken account, restoring normal operation. This is a pass-through instruction that validates mint ownership (must be owned by SPL Token, Token-2022, or CToken program) before delegating to pinocchio-token-program for standard SPL Token thaw validation. After thawing, the account's state field is set to AccountState::Initialized, and only the freeze_authority of the mint can thaw accounts (mint must have freeze_authority set). The account layout `CToken` is defined in program-libs/ctoken-interface/src/state/ctoken/ctoken_struct.rs.
+
+**Instruction data:**
+No instruction data required beyond the discriminator byte.
+
+**Accounts:**
+1. token_account
+   - (mutable)
+   - The frozen ctoken account to thaw
+   - Must be frozen (AccountState::Frozen)
+   - Will have state field updated to AccountState::Initialized
+
+2. mint
+   - The mint account associated with the token account
+   - Must be owned by SPL Token, Token-2022, or CToken program
+   - Must have freeze_authority set (not None)
+
+3. freeze_authority
+   - (signer)
+   - Must match the mint's freeze_authority
+   - Must sign the transaction
+
+**Instruction Logic and Checks:**
+
+1. **Validate minimum accounts:**
+   - Require at least 2 accounts to get mint account (index 1)
+   - Return NotEnoughAccountKeys if insufficient
+
+2. **Validate mint ownership:**
+   - Get mint account (accounts[1])
+   - Call `check_token_program_owner(mint_info)` from programs/compressed-token/program/src/shared/owner_validation.rs
+   - Verify mint is owned by one of:
+     - SPL Token program (TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA)
+     - Token-2022 program (TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb)
+     - CToken program (cTokenmWW8bLPjZEBAUgYy3zKxQZW6VKi7bqNFEVv3m)
+   - Return IncorrectProgramId if mint owner doesn't match
+
+3. **Delegate to pinocchio-token-program:**
+   - Call `process_thaw_account(accounts)` from pinocchio-token-program
+   - This performs standard SPL Token thaw validation:
+     - Verifies token_account is mutable
+     - Verifies freeze_authority is signer
+     - Verifies token_account.mint == mint.key()
+     - Verifies mint.freeze_authority == Some(freeze_authority.key())
+     - Verifies token_account state is Frozen (not already Initialized)
+     - Updates token_account.state to AccountState::Initialized
+   - Map any errors from u64 to ProgramError::Custom(u32)
+
+**Errors:**
+- `ProgramError::NotEnoughAccountKeys` (error code: 11) - Less than 2 accounts provided (cannot get mint account)
+- `ProgramError::IncorrectProgramId` (error code: 7) - Mint is not owned by a valid token program (SPL Token, Token-2022, or CToken)
+- SPL Token errors from pinocchio-token-program (converted from u64 to ProgramError::Custom(u32)):
+  - `TokenError::MintCannotFreeze` (error code: 16) - Mint's freeze_authority is None
+  - `TokenError::OwnerMismatch` (error code: 4) - freeze_authority doesn't match mint's freeze_authority
+  - `TokenError::MintMismatch` (error code: 3) - token_account's mint doesn't match provided mint
+  - `TokenError::InvalidState` (error code: 13) - Account is not frozen or is uninitialized
+  - `ProgramError::InvalidAccountData` (error code: 4) - Account data is malformed
+
+## Comparison with Token-2022
+
+### Functional Parity
+
+CToken ThawAccount provides the same core functionality as Token-2022's ThawAccount instruction:
+
+**Shared Security Properties:**
+1. **State Transition Validation:** Both enforce that the account must be in Frozen state before thawing (transitions Frozen → Initialized)
+2. **Authority Validation Chain:** Both require the freeze_authority to sign and match the mint's freeze_authority
+3. **Mint Association Enforcement:** Both validate the token account's mint matches the provided mint account
+4. **Account Ownership Validation:** Both validate accounts through deserialization (CToken via pinocchio-token-program, Token-2022 via PodStateWithExtensions)
+5. **Native Token Protection:** Both reject native SOL wrapper accounts
+6. **Atomic State Update:** Both perform all validation before state changes
+7. **Freeze Authority Existence:** Both require mint.freeze_authority is not None
+
+**Shared Account Requirements:**
+- Account 0: Token account (writable, must be frozen)
+- Account 1: Mint (readable, must have freeze_authority set)
+- Account 2: Freeze authority (must be signer in non-multisig case)
+
+**Shared Instruction Format:**
+- Discriminator: `11` (byte value)
+- No additional instruction data beyond discriminator
+
+### CToken-Specific Features
+
+**Additional Mint Ownership Validation:**
+
+CToken performs an extra security check before delegating to pinocchio-token-program:
+
+```rust
+// From programs/compressed-token/program/src/ctoken_freeze_thaw.rs:24-25
+let mint_info = accounts.get(1).ok_or(ProgramError::NotEnoughAccountKeys)?;
+check_token_program_owner(mint_info)?;
+```
+
+This `check_token_program_owner` validation (defined in `programs/compressed-token/program/src/shared/owner_validation.rs`) verifies the mint is owned by one of three valid programs:
+- SPL Token program (TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA)
+- Token-2022 program (TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb)
+- CToken program (cTokenmWW8bLPjZEBAUgYy3zKxQZW6VKi7bqNFEVv3m)
+
+This prevents attempts to thaw accounts with mints from arbitrary programs, adding an extra layer of program isolation security.
+
+**Error Code Conversion:**
+
+CToken converts u64 error codes from pinocchio-token-program to u32 ProgramError::Custom codes:
+```rust
+process_thaw_account(accounts).map_err(|e| ProgramError::Custom(u64::from(e) as u32))
+```
+
+### Missing Features
+
+**No Multisignature Support:**
+
+CToken ThawAccount does NOT support multisignature freeze authorities. Token-2022 supports:
+- Account 2 can be a multisig account (readable, not signer)
+- Accounts 3..3+M: M signer accounts for multisig threshold validation
+
+Token-2022's multisig validation includes:
+- Deserializing multisig account data (PodMultisig)
+- Matching each signer to configured multisig signers (no duplicates)
+- Enforcing threshold requirements (num_signers >= multisig.m)
+
+**Impact:** CToken accounts with multisig freeze authorities cannot be thawed through CToken program. This is a deliberate limitation as CToken focuses on single-authority operations.
+
+### Extension Handling Differences
+
+**CToken Extensions:**
+
+CToken accounts may have the **Compressible extension** which is NOT present in Token-2022. However, this extension does not affect freeze/thaw operations:
+- Freeze/thaw operations work identically regardless of Compressible extension presence
+- Compression state (whether account has been compressed before) is irrelevant to freeze state
+- Rent management from Compressible extension is orthogonal to freeze/thaw
+
+**Token-2022 Extension Behavior:**
+
+Token-2022 freeze/thaw operations are extension-agnostic with specific behaviors:
+- **CPI Guard:** Does NOT block freeze/thaw (considered administrative operations by freeze authority, not owner operations)
+- **Default Account State:** If mint has Default Account State extension set to Frozen, newly created accounts start frozen but can still be thawed
+- **Immutable Owner:** No effect on freeze/thaw (operations don't change ownership)
+- **Non-Transferable:** Tokens can still be frozen/thawed regardless of transferability
+
+**Shared Extension Philosophy:** Both implementations treat freeze/thaw as fundamental token operations that work uniformly across all account types, with no extension-specific validation required.
+
+### Security Property Comparison
+
+**Token-2022 Validation (12 checks):**
+1. State transition validation (must be frozen to thaw)
+2. Account ownership validation (token account)
+3. Native token rejection
+4. Mint association validation
+5. Mint account ownership and deserialization
+6. Freeze authority existence validation
+7. Freeze authority signature validation (non-multisig)
+8. Freeze authority match validation
+9. Multisig account validation
+10. Multisig signer matching validation
+11. Multisig threshold validation
+12. Atomic state update
+
+**CToken Validation (8 checks):**
+1. Minimum account validation (at least 2 accounts)
+2. **Mint program ownership validation (CToken-specific)**
+3. State transition validation (delegated to pinocchio-token-program)
+4. Account ownership validation (delegated to pinocchio-token-program)
+5. Native token rejection (delegated to pinocchio-token-program)
+6. Mint association validation (delegated to pinocchio-token-program)
+7. Freeze authority validation (delegated to pinocchio-token-program)
+8. Atomic state update (delegated to pinocchio-token-program)
+
+**Key Differences:**
+- CToken adds upfront mint ownership validation not present in Token-2022
+- CToken omits multisig support (checks 9-11 from Token-2022)
+- CToken delegates most validation to pinocchio-token-program, which implements SPL Token-compatible logic
+- Both achieve the same security guarantees for single-authority freeze operations
+
+**Audit Alignment:**
+
+Both implementations avoid known Token-2022 vulnerabilities:
+- No supply inflation bugs (no balance modifications)
+- No transfer exploits (not a transfer operation)
+- No missing balance checks (no amounts involved)
+- No account ordering issues (deterministic positional indexing)
+- No authority bypass (complete authority validation chains)
diff --git a/programs/compressed-token/program/docs/instructions/CTOKEN_TRANSFER.md b/programs/compressed-token/program/docs/instructions/CTOKEN_TRANSFER.md
index e89fcb3b50..5e4f95fc93 100644
--- a/programs/compressed-token/program/docs/instructions/CTOKEN_TRANSFER.md
+++ b/programs/compressed-token/program/docs/instructions/CTOKEN_TRANSFER.md
@@ -2,25 +2,37 @@
 
 **discriminator:** 3
 **enum:** `InstructionType::CTokenTransfer`
-**path:** programs/compressed-token/program/src/ctoken_transfer.rs
+**path:** programs/compressed-token/program/src/transfer/default.rs
+
+### SPL Instruction Format Compatibility
+
+**Important:** This instruction uses the same account layout as SPL Token transfer (source, destination, authority) but has extended instruction data format.
+
+When accounts require rent top-up, lamports are transferred directly from the authority account to the token accounts. The authority must have sufficient lamports to cover the top-up amount.
+
+**Compatibility scenarios:**
+- **SPL-compatible:** When using 8-byte instruction data (amount only) with no top-up needed
+- **Extended format:** When using 10-byte instruction data (amount + max_top_up) for compressible accounts
 
 **description:**
 1. Transfers tokens between decompressed ctoken solana accounts, fully compatible with SPL Token semantics
-2. Account layout `CToken` is defined in path: program-libs/ctoken-types/src/state/ctoken/ctoken_struct.rs
-3. Extension layout `CompressionInfo` is defined in path: program-libs/ctoken-types/src/state/extensions/compressible.rs
-4. Uses light_token_22 fork to process the transfer (required because token_22 has hardcoded program ID checks)
+2. Account layout `CToken` is defined in path: program-libs/ctoken-interface/src/state/ctoken/ctoken_struct.rs
+3. Compression info for rent top-up is defined in: program-libs/compressible/src/compression_info.rs
+4. Uses pinocchio-token-program to process the transfer (lightweight SPL-compatible implementation)
 5. After the transfer, automatically tops up compressible accounts with additional lamports if needed:
    - Calculates top-up requirements based on current slot and account balance
-   - Only applies to accounts with compressible extension
+   - Only applies to accounts with compression info in their base state
    - Top-up prevents accounts from becoming compressible during normal operations
-6. Supports standard SPL Token transfer features including delegate authority (multisig not supported)
+6. Supports standard SPL Token transfer features including delegate authority and permanent delegate (multisig not supported)
 7. The transfer amount and authority validation follow SPL Token rules exactly
+8. Validates T22 extension markers match between source and destination (pausable, permanent_delegate, transfer_fee, transfer_hook)
 
 **Instruction data:**
-- First byte: instruction discriminator (3)
-- Second byte: 0 (padding)
-- Remaining bytes: SPL TokenInstruction::Transfer serialized
+After discriminator byte, the following formats are supported:
+- **8 bytes (legacy):** amount (u64) - No max_top_up enforcement
+- **10 bytes (extended):** amount (u64) + max_top_up (u16)
   - `amount`: u64 - Number of tokens to transfer
+  - `max_top_up`: u16 - Maximum lamports for top-up (0 = no limit)
 
 **Accounts:**
 1. source
@@ -40,52 +52,66 @@
    - Owner of the source account or delegate with sufficient allowance
    - Must sign the transaction
 
-4. payer (when accounts have compressible extension)
-   - (signer, mutable)
-   - Pays for rent top-ups if needed
-   - Must be the third account if any account needs top-up
+Note: The authority account (index 2) also serves as the payer for top-ups when accounts have compressible extension.
 
 **Instruction Logic and Checks:**
 
-1. **Parse instruction data:**
-
-2. **Validate minimum accounts:**
-   - Require at least 3 accounts (source, destination, authority/payer)
+1. **Validate minimum accounts:**
+   - Require at least 3 accounts (source, destination, authority)
    - Return NotEnoughAccountKeys if insufficient
 
-3. **Convert account formats:**
-   - Convert Pinocchio AccountInfos to Anchor AccountInfos
+2. **Validate instruction data:**
+   - Must be at least 8 bytes (amount)
+   - If 10 bytes, parse max_top_up from bytes [8..10]
+   - If 8 bytes, set max_top_up = 0 (legacy, no limit)
+   - Any other length returns InvalidInstructionData
+
+3. **Process transfer extensions:**
+   - Call `process_transfer_extensions` from shared.rs with source, destination, authority (no mint)
+
+   a. **Validate sender (source account):**
+      - Deserialize source account (CToken) using zero-copy
+      - Check for T22 restricted extensions (pausable, permanent_delegate, transfer_fee, transfer_hook, default_account_state)
+      - If source has restricted extensions, deserialize and validate mint extensions:
+        - Mint must not be paused
+        - Transfer fees must be zero
+        - Transfer hooks must have nil program_id
+        - Extract permanent delegate if present
+      - Validate permanent delegate authority if applicable
+      - Calculate top-up lamports from compression info
+
+   b. **Validate recipient (destination account):**
+      - Deserialize destination account and extract extension information
+      - Extract T22 extension markers
+      - Calculate top-up lamports from compression info
+
+   c. **Check T22 extension consistency:**
+      - Verify sender and destination have matching T22 extension markers
+      - Error if flags mismatch (InvalidInstructionData)
+
+   d. **Perform compressible top-up:**
+      - Check max_top_up budget if set (non-zero)
+      - Execute multi_transfer_lamports from authority to accounts
 
 4. **Process SPL transfer:**
-   - Call light_token_22::Processor::process_transfer
-
-5. **Calculate top-up requirements:**
-   For each of source and destination accounts:
-
-   a. **Check for compressible extension:**
-      - Skip if account size is base size (no extensions)
-      - Parse extensions if present
-      - Error if extensions exist but no Compressible found
-
-   b. **Calculate top-up amount:**
-      - Get current slot from Clock sysvar (lazy loaded)
-      - Call `calculate_top_up_lamports` which:
-        - Checks if account is compressible
-        - Calculates rent deficit if any
-        - Adds configured lamports_per_write amount
-        - Returns 0 if account is well-funded
-
-6. **Execute top-up transfers:**
-   - Skip if no accounts need top-up (current_slot == 0 indicates no compressible accounts)
-   - Use payer account (third account) as funding source
-   - Execute multi_transfer_lamports to top up both accounts atomically
-   - Update account lamports balances
+   - Call pinocchio_token_program::processor::transfer::process_transfer
+   - Pass signer_is_validated flag if permanent delegate was validated
 
 **Errors:**
 
 - `ProgramError::NotEnoughAccountKeys` (error code: 11) - Less than 3 accounts provided
-- `ProgramError::InvalidInstructionData` (error code: 3) - Instruction is not TokenInstruction::Transfer or failed to unpack instruction data
-- `ProgramError::InsufficientFunds` (error code: 6) - Source balance less than amount (SPL Token error)
-- `ProgramError::Custom` (SPL Token errors) - OwnerMismatch, MintMismatch, AccountFrozen, or InvalidDelegate from SPL token validation
-- `CTokenError::InvalidAccountData` (error code: 18002) - Account has extensions but no Compressible extension or failed to parse extensions
-- `CTokenError::SysvarAccessError` (error code: 18020) - Failed to get Clock sysvar for current slot
+- `ProgramError::InvalidInstructionData` (error code: 3) - Instruction data is not 8 or 10 bytes, or T22 extension flags mismatch between source and destination
+- `ProgramError::MissingRequiredSignature` (error code: 8) - Authority is permanent delegate but not a signer
+- `ProgramError::InsufficientFunds` (error code: 6) - Source balance less than amount (pinocchio error)
+- Pinocchio token errors (converted to ProgramError::Custom):
+  - `TokenError::OwnerMismatch` (error code: 4) - Authority is not owner or delegate
+  - `TokenError::MintMismatch` (error code: 3) - Source and destination have different mints
+  - `TokenError::AccountFrozen` (error code: 17) - Source or destination account is frozen
+  - `TokenError::InsufficientFunds` (error code: 1) - Delegate has insufficient allowance
+- `CTokenError::InvalidAccountData` (error code: 18002) - Failed to deserialize CToken account, mint mismatch, or invalid extension data
+- `CTokenError::SysvarAccessError` (error code: 18020) - Failed to get Clock or Rent sysvar for top-up calculation
+- `CTokenError::MaxTopUpExceeded` (error code: 18043) - Calculated top-up exceeds max_top_up limit
+- `ErrorCode::MintRequiredForTransfer` (error code: 6128) - Account has restricted extensions but mint account not provided
+- `ErrorCode::MintPaused` (error code: 6127) - Mint has pausable extension and is currently paused
+- `ErrorCode::NonZeroTransferFeeNotSupported` (error code: 6129) - Mint has non-zero transfer fee configured
+- `ErrorCode::TransferHookNotSupported` (error code: 6130) - Mint has transfer hook with non-nil program_id
diff --git a/programs/compressed-token/program/docs/instructions/CTOKEN_TRANSFER_CHECKED.md b/programs/compressed-token/program/docs/instructions/CTOKEN_TRANSFER_CHECKED.md
new file mode 100644
index 0000000000..4fef5bcd49
--- /dev/null
+++ b/programs/compressed-token/program/docs/instructions/CTOKEN_TRANSFER_CHECKED.md
@@ -0,0 +1,376 @@
+## CToken TransferChecked
+
+**discriminator:** 6
+**enum:** `InstructionType::CTokenTransferChecked`
+**path:** programs/compressed-token/program/src/transfer/checked.rs
+
+### SPL Instruction Format Compatibility
+
+**Important:** This instruction uses the same account layout as SPL Token TransferChecked (source, mint, destination, authority) but has extended instruction data format.
+
+When accounts require rent top-up, lamports are transferred directly from the authority account to the token accounts. The authority must have sufficient lamports to cover the top-up amount.
+
+**Compatibility scenarios:**
+- **SPL-compatible:** When using 9-byte instruction data (amount + decimals) with no top-up needed
+- **Extended format:** When using 11-byte instruction data (amount + decimals + max_top_up) for compressible accounts
+
+**description:**
+Transfers tokens between decompressed ctoken solana accounts with mint decimals validation, fully compatible with SPL Token TransferChecked semantics. Account layout `CToken` is defined in program-libs/ctoken-interface/src/state/ctoken/ctoken_struct.rs. Compression info for rent top-up is defined in program-libs/compressible/src/compression_info.rs. Uses pinocchio-token-program to process the transfer (lightweight SPL-compatible implementation). After the transfer, automatically tops up compressible accounts with additional lamports if needed based on current slot and account balance. Top-up prevents accounts from becoming compressible during normal operations. Supports standard SPL Token transfer features including delegate authority and permanent delegate (multisig not supported). The transfer amount, authority validation, and decimals validation follow SPL Token TransferChecked rules exactly. Validates that mint decimals match the provided decimals parameter. Difference from CTokenTransfer: Requires mint account (4 accounts vs 3) for decimals validation and T22 extension validation.
+
+**Instruction data:**
+- **9 bytes (legacy):** amount (u64) + decimals (u8)
+- **11 bytes (with max_top_up):** amount (u64) + decimals (u8) + max_top_up (u16)
+  - max_top_up: Maximum lamports for top-up operations (0 = no limit)
+
+**Accounts:**
+1. source
+   - (mutable)
+   - The source ctoken account
+   - Must have sufficient balance for the transfer
+   - Must have same mint as destination
+   - May receive rent top-up if compressible
+   - If has cached decimals in compressible extension, used for validation
+
+2. mint
+   - (immutable)
+   - The mint account for the token being transferred
+   - Must match source and destination account mints
+   - Decimals field must match instruction data decimals parameter
+   - Required for T22 extension validation when accounts have restricted extensions
+
+3. destination
+   - (mutable)
+   - The destination ctoken account
+   - Must have same mint as source
+   - Must have matching T22 extension markers (pausable, permanent_delegate, transfer_fee, transfer_hook)
+   - May receive rent top-up if compressible
+
+4. authority
+   - (signer)
+   - Owner of the source account or delegate with sufficient allowance
+   - Must sign the transaction
+   - If is permanent delegate, validated as signer and pinocchio validation is skipped
+   - Also serves as payer for top-ups when accounts have compressible extension
+
+**Instruction Logic and Checks:**
+
+1. **Validate minimum accounts:**
+   - Require exactly 4 accounts (source, mint, destination, authority)
+   - Return NotEnoughAccountKeys if insufficient
+
+2. **Validate instruction data:**
+   - Must be at least 9 bytes (amount + decimals)
+   - If 11 bytes, parse max_top_up from bytes [9..11]
+   - If 9 bytes, set max_top_up = 0 (legacy, no limit)
+   - Any other length returns InvalidInstructionData
+
+3. **Parse max_top_up parameter:**
+   - 0 = no limit on top-up lamports
+   - Non-zero = maximum combined lamports for source + destination top-up
+   - Transaction fails if calculated top-up exceeds max_top_up
+
+4. **Process transfer extensions:**
+   - Call process_transfer_extensions from shared.rs with source, destination, authority, mint, and max_top_up
+   - Validate sender (source account):
+     - Deserialize source account (CToken) and extract extension information
+     - Validate mint account matches source token's mint field
+     - Check for T22 restricted extensions (pausable, permanent_delegate, transfer_fee, transfer_hook, default_account_state)
+     - If source has restricted extensions, deserialize and validate mint extensions once:
+       - Mint must not be paused
+       - Transfer fees must be zero
+       - Transfer hooks must have nil program_id
+       - Extract permanent delegate if present
+     - Validate permanent delegate authority if applicable
+     - Cache decimals from compressible extension if has_decimals flag is set
+   - Validate recipient (destination account):
+     - Deserialize destination account and extract extension information
+     - No mint validation for recipient (only sender needs to match mint)
+     - Extract T22 extension markers
+   - Verify sender and destination have matching T22 extension markers
+   - Calculate top-up amounts for both accounts based on compression info:
+     - Get current slot from Clock sysvar (lazy loaded once)
+     - Get rent exemption from Rent sysvar
+     - Call calculate_top_up_lamports for each account
+   - Transfer lamports from authority to accounts if top-up needed:
+     - Check max_top_up budget if set (non-zero)
+     - Execute multi_transfer_lamports atomically
+   - Return (signer_is_validated, decimals) tuple
+
+5. **Extract decimals and execute transfer:**
+   - Parse amount and decimals from instruction data using unpack_amount_and_decimals
+   - If source account has cached decimals in compressible extension (extension_decimals is Some):
+     - Validate extension_decimals == instruction decimals parameter
+     - Create accounts slice without mint: [source, destination, authority]
+     - Call pinocchio process_transfer with expected_decimals = None
+     - signer_is_validated flag from permanent delegate check skips redundant owner/delegate validation
+   - If no cached decimals (extension_decimals is None):
+     - Validate mint account owner is token program
+     - Call pinocchio process_transfer with all 4 accounts [source, mint, destination, authority] and expected_decimals = Some(decimals)
+     - signer_is_validated flag from permanent delegate check skips redundant owner/delegate validation
+   - pinocchio-token-program validates:
+     - Source and destination have same mint
+     - Mint decimals match provided decimals parameter (when expected_decimals is Some)
+     - Authority is owner or delegate with sufficient allowance (unless signer_is_validated is true)
+     - Source has sufficient balance
+     - Accounts are not frozen
+     - Delegate amount is decremented if delegated transfer
+   - Transfers amount from source to destination
+
+**Errors:**
+
+- `ProgramError::NotEnoughAccountKeys` (error code: 11) - Less than 4 accounts provided
+- `ProgramError::InvalidInstructionData` (error code: 3) - Instruction data is not 9 or 11 bytes, or decimals validation failed
+- `ProgramError::MissingRequiredSignature` (error code: 8) - Authority is permanent delegate but not a signer
+- `CTokenError::InvalidAccountData` (error code: 18002) - Failed to deserialize CToken account, mint mismatch, or invalid extension data
+- `CTokenError::SysvarAccessError` (error code: 18020) - Failed to get Clock or Rent sysvar for top-up calculation
+- `CTokenError::MaxTopUpExceeded` (error code: 18043) - Calculated top-up exceeds max_top_up limit
+- `ProgramError::InsufficientFunds` (error code: 6) - Source balance less than amount (pinocchio error)
+- Pinocchio token errors (converted to ProgramError::Custom):
+  - `TokenError::OwnerMismatch` (error code: 4) - Authority is not owner or delegate
+  - `TokenError::MintMismatch` (error code: 3) - Source and destination have different mints or mint account mismatch
+  - `TokenError::AccountFrozen` (error code: 17) - Source or destination account is frozen
+  - `TokenError::InsufficientFunds` (error code: 1) - Delegate has insufficient allowance
+  - `TokenError::InvalidMint` (error code: 2) - Mint decimals do not match provided decimals parameter
+- `ErrorCode::MintRequiredForTransfer` (error code: 6128) - Account has restricted extensions but mint account not provided
+- `ErrorCode::MintPaused` (error code: 6127) - Mint has pausable extension and is currently paused
+- `ErrorCode::NonZeroTransferFeeNotSupported` (error code: 6129) - Mint has non-zero transfer fee configured
+- `ErrorCode::TransferHookNotSupported` (error code: 6130) - Mint has transfer hook with non-nil program_id
+
+## Comparison with Token-2022
+
+### Functional Parity
+
+CToken TransferChecked provides core compatibility with SPL Token-2022's TransferChecked instruction:
+
+- **Same core semantics**: Transfers tokens from source to destination with authority validation and decimals verification
+- **Same account ordering**: source (0), mint (1), destination (2), authority (3)
+- **Same instruction data**: amount (u64) + decimals (u8) for the first 9 bytes
+- **Same validations**: Mint decimals match, source/destination mints match, sufficient balance, frozen state checks
+- **Same authority model**: Supports owner, delegate, and permanent delegate as authority
+- **Extension awareness**: Both recognize and validate Token-2022 extensions (pausable, permanent delegate, transfer fee, transfer hook)
+
+### CToken-Specific Features
+
+#### 1. Compressible Top-Up Logic
+CToken TransferChecked includes automatic rent top-up for compressible accounts that Token-2022 does not have:
+
+- **Automatic lamport top-up**: Both source and destination accounts receive top-up lamports if they have the Compressible extension and are approaching compressibility
+- **Top-up calculation**: Uses `calculate_top_up_lamports()` based on current slot, account balance, and rent exemption threshold
+- **Payer**: Authority account pays for top-ups via `multi_transfer_lamports`
+- **Budget enforcement**: `max_top_up` parameter (bytes 9-11) limits total lamports for combined source + destination top-up (0 = no limit)
+- **Purpose**: Prevents accounts from becoming compressible during normal operations, ensuring continuous availability
+
+**Code Reference**: `programs/compressed-token/program/src/transfer/shared.rs:93-122`
+
+#### 2. Max Top-Up Parameter
+CToken supports an optional 11-byte instruction format with max_top_up budget:
+
+- **9 bytes (legacy)**: amount + decimals (max_top_up = 0, no limit)
+- **11 bytes (extended)**: amount + decimals + max_top_up (u16)
+- **Enforcement**: Transaction fails with `MaxTopUpExceeded` if calculated top-up exceeds budget
+- **Token-2022**: Has no equivalent budget parameter
+
+**Code Reference**: `programs/compressed-token/program/src/transfer/checked.rs:57-65`
+
+#### 3. Cached Decimals Optimization
+CToken can cache mint decimals in the Compressible extension to skip mint account validation:
+
+- **Cache location**: Stored in Compressible extension via `has_decimals` flag and `decimals()` method
+- **When cached**: Uses only 3 accounts [source, destination, authority] and validates decimals against instruction parameter
+- **When not cached**: Uses all 4 accounts (includes mint) and delegates decimals check to pinocchio-token-program
+- **Benefit**: Reduces account requirements and mint deserialization overhead for compressible accounts
+- **Token-2022**: Always requires mint account for decimals validation
+
+**Code Reference**: `programs/compressed-token/program/src/transfer/checked.rs:81-101`
+
+#### 4. Single Account Deserialization
+CToken deserializes each account (source, destination) exactly once to extract:
+
+- Token-2022 extension flags (pausable, permanent_delegate, transfer_fee, transfer_hook)
+- Compressible extension state for top-up calculation
+- Cached decimals if present
+
+Token-2022 deserializes accounts multiple times throughout validation.
+
+**Code Reference**: `programs/compressed-token/program/src/transfer/shared.rs:186-264`
+
+### Missing Features
+
+#### 1. No Multisig Support
+- **CToken**: Does not support multisignature authorities. Expects exactly 4 accounts.
+- **Token-2022**: Supports M-of-N multisig with additional signer accounts (accounts 4..4+M)
+- **Validation**: CToken has no multisig account validation or M-of-N signature checks
+- **Impact**: Programs requiring multisig must use Token-2022 accounts or implement custom authority logic
+
+**Token-2022 Reference**: `/home/ananas/dev/token-2022/program/src/processor.rs:1899-1914` (validate_owner function)
+
+#### 2. No TransferFee Handling
+- **CToken**: Rejects mints with non-zero transfer fees via `check_mint_extensions`
+- **Token-2022**: Calculates epoch-based transfer fees, withholds fees in destination's `TransferFeeAmount` extension
+- **Fee calculation**: Token-2022 uses `calculate_epoch_fee(epoch, amount)` with checked arithmetic
+- **Fee withholding**: Token-2022 updates `withheld_amount` in destination extension
+- **CToken behavior**: `has_transfer_fee` flag is detected but fees must be zero (error: `NonZeroTransferFeeNotSupported`)
+- **Credited amount**: CToken always credits full amount (no fee deduction), Token-2022 credits `amount - fee`
+
+**Token-2022 Reference**: `/home/ananas/dev/token-2022/analysis/transfer-checked.md:94-96, 211-222`
+**CToken Reference**: `programs/compressed-token/program/src/transfer/shared.rs:245-249` (extension flag detection)
+
+#### 3. No TransferHook Execution
+- **CToken**: Rejects mints with transfer hooks that have non-nil program_id
+- **Token-2022**: Invokes external hook programs via CPI with transferring flag protection
+- **Reentrancy protection**: Token-2022 sets `TransferHookAccount.transferring = true` before CPI, clears after
+- **CPI invocation**: Token-2022 calls `spl_transfer_hook_interface::onchain::invoke_execute()`
+- **CToken behavior**: `has_transfer_hook` flag is detected but hook program must be nil/zero (error: `TransferHookNotSupported`)
+- **Use case limitation**: CToken cannot support custom transfer logic hooks
+
+**Token-2022 Reference**: `/home/ananas/dev/token-2022/analysis/transfer-checked.md:236-270`
+**CToken Reference**: `programs/compressed-token/program/src/transfer/shared.rs:250-253` (extension flag detection)
+
+#### 4. No Self-Transfer Optimization
+- **CToken**: Processes source and destination independently even when identical
+- **Token-2022**: Detects `source_account_info.key == destination_account_info.key` and exits early after validation
+- **Token-2022 placement**: Self-transfer check occurs at line 469, AFTER all security validations but BEFORE state modifications
+- **Benefit**: Token-2022 saves computation for self-transfers while maintaining security
+- **CToken impact**: Self-transfers execute full logic including balance updates and top-ups
+
+**Token-2022 Reference**: `/home/ananas/dev/token-2022/analysis/transfer-checked.md:157-163, 296-304`
+
+#### 5. No Native SOL Support
+- **CToken**: Does not support wrapped SOL (native tokens)
+- **Token-2022**: Synchronizes SOL lamport balances with token amounts for `is_native()` accounts
+- **Token-2022 behavior**: Uses `checked_sub`/`checked_add` on lamports field to match token transfer
+- **CToken accounts**: Only support SPL-compatible token accounts, not native SOL wrapping
+
+**Token-2022 Reference**: `/home/ananas/dev/token-2022/analysis/transfer-checked.md:225-234`
+
+#### 6. No Confidential Transfer Support
+- **CToken**: Does not check `ConfidentialTransferAccount` extension
+- **Token-2022**: Validates `non_confidential_transfer_allowed()` for accounts with confidential extension
+- **Token-2022 error**: `NonConfidentialTransfersDisabled` when confidential account blocks non-confidential credits
+- **Use case**: Token-2022 supports privacy-preserving transfers with encrypted amounts
+
+**Token-2022 Reference**: `/home/ananas/dev/token-2022/analysis/transfer-checked.md:188-192`
+
+#### 7. No Memo Requirement Support
+- **CToken**: Does not validate MemoTransfer extension requirements
+- **Token-2022**: Checks `MemoTransfer` extension on both source and destination, ensures memo instruction precedes transfer
+- **Token-2022 validation**: Inspects previous sibling instruction for memo program invocation
+- **Token-2022 error**: `MissingMemoInPreviousInstruction` when memo required but not present
+- **Compliance**: Token-2022 supports regulatory requirements for transaction memos
+
+**Token-2022 Reference**: `/home/ananas/dev/token-2022/analysis/transfer-checked.md:182-186, 325-326`
+
+#### 8. No CPI Guard Support
+- **CToken**: Does not check CpiGuard extension
+- **Token-2022**: Blocks owner-signed transfers when `CpiGuard.lock_cpi` is enabled and execution is in CPI context
+- **Token-2022 validation**: Checks `cpi_guard.lock_cpi.into() && in_cpi() && authority == owner` (lines 402-412)
+- **Security**: Prevents CPI Guard bypass even when owner is permanent delegate
+- **Token-2022 error**: `CpiGuardTransferBlocked`
+
+**Token-2022 Reference**: `/home/ananas/dev/token-2022/analysis/transfer-checked.md:115-120, 306-307`
+
+#### 9. No NonTransferable Support
+- **CToken**: Does not check NonTransferableAccount extension
+- **Token-2022**: Prevents all transfers from accounts marked as non-transferable
+- **Token-2022 validation**: `source_account.get_extension::<NonTransferableAccount>().is_ok()` check (line 324)
+- **Token-2022 error**: `TokenError::NonTransferable`
+- **Use case**: Token-2022 supports soulbound/non-transferable tokens
+
+**Token-2022 Reference**: `/home/ananas/dev/token-2022/analysis/transfer-checked.md:62-65`
+
+### Extension Handling Differences
+
+#### Extensions CToken Validates (With Restrictions)
+
+1. **PausableAccount** (account extension)
+   - **Detection**: Extracts `has_pausable` flag from source and destination extensions
+   - **Validation**: Requires source/destination to have matching pausable flags
+   - **Mint check**: Validates mint is not paused via `check_mint_extensions`
+   - **Token-2022**: Same validation, checks `PausableConfig.paused.into() == false`
+   - **Reference**: `programs/compressed-token/program/src/transfer/shared.rs:239-241`
+
+2. **PermanentDelegateAccount** (account extension)
+   - **Detection**: Extracts `has_permanent_delegate` flag from extensions
+   - **Validation**: If authority matches permanent delegate pubkey from mint, validates is_signer
+   - **Difference**: CToken skips pinocchio validation when permanent delegate is validated (`signer_is_validated = true`)
+   - **Token-2022**: Validates permanent delegate via multisig-aware `validate_owner()`
+   - **Reference**: `programs/compressed-token/program/src/transfer/shared.rs:242-244, 164-178`
+
+3. **TransferFeeAccount** (account extension)
+   - **Detection**: Extracts `has_transfer_fee` flag from extensions
+   - **Validation**: Requires mint's `TransferFeeConfig` has zero fees for current epoch
+   - **Error**: `NonZeroTransferFeeNotSupported` if fees are configured
+   - **Token-2022**: Calculates and withholds fees in destination's `TransferFeeAmount` extension
+   - **Reference**: `programs/compressed-token/program/src/transfer/shared.rs:245-249`
+
+4. **TransferHookAccount** (account extension)
+   - **Detection**: Extracts `has_transfer_hook` flag from extensions
+   - **Validation**: Requires mint's `TransferHook` has nil (zero) program_id
+   - **Error**: `TransferHookNotSupported` if hook program is set
+   - **Token-2022**: Executes hook via CPI with transferring flag protection
+   - **Reference**: `programs/compressed-token/program/src/transfer/shared.rs:250-253`
+
+#### Extension Consistency Enforcement
+
+- **CToken**: Requires source and destination to have matching T22 extension flags (`has_pausable`, `has_permanent_delegate`, `has_transfer_fee`, `has_transfer_hook`)
+- **Validation**: Single check comparing all 4 flags via `check_t22_extensions()`
+- **Token-2022**: Validates extensions independently based on presence/absence
+- **Error**: `InvalidInstructionData` if flags mismatch
+- **Purpose**: Ensures both accounts are compatible for transfer operations
+
+**Reference**: `programs/compressed-token/program/src/transfer/shared.rs:32-42, 79`
+
+#### Extensions Not Supported by CToken
+
+- **NonTransferableAccount** - No validation, allows transfers from non-transferable accounts
+- **CpiGuard** - No validation, allows CPI transfers even with lock_cpi enabled
+- **MemoTransfer** - No validation, does not enforce memo requirements
+- **ConfidentialTransferAccount** - No validation, does not handle confidential accounts
+- **ImmutableOwner** - Not checked (not relevant to transfers)
+
+### Security Property Comparison
+
+#### Shared Security Properties
+
+1. **Account Ownership Validation**: Both validate source/destination are owned by token program
+2. **Frozen State Checks**: Both prevent transfers from/to frozen accounts
+3. **Balance Sufficiency**: Both validate source has sufficient balance before transfer
+4. **Mint Consistency**: Both validate source/destination have same mint
+5. **Decimals Validation**: Both ensure provided decimals match mint decimals
+6. **Checked Arithmetic**: Both use checked operations for balance updates to prevent overflow
+7. **Authority Validation**: Both support owner, delegate, and permanent delegate authorities
+
+#### CToken-Specific Security
+
+1. **Extension Flag Matching**: CToken enforces source/destination must have identical T22 extension flags
+2. **Top-Up Budget Enforcement**: `max_top_up` parameter prevents excessive lamport transfers
+3. **Zero-Fee Requirement**: CToken rejects any mint with non-zero transfer fees (fail-safe)
+4. **Nil Hook Requirement**: CToken rejects any mint with non-nil transfer hook program_id (fail-safe)
+5. **Single Deserialization**: Each account deserialized exactly once reduces attack surface
+
+#### Token-2022-Specific Security
+
+1. **Self-Transfer Validation Ordering**: Self-transfer check occurs AFTER all security validations but BEFORE state modifications (prevents bypass)
+2. **CPI Guard Bypass Prevention**: Explicitly blocks CPI transfers even when owner is permanent delegate
+3. **Reentrancy Protection**: Transferring flag prevents recursive calls during transfer hook execution
+4. **Multisig Validation**: M-of-N signature validation for multisig authorities
+5. **Non-Transferable Enforcement**: Blocks all transfers from soulbound tokens
+6. **Memo Compliance**: Ensures regulatory requirements via memo instruction validation
+7. **Native SOL Synchronization**: Prevents lamport/token desynchronization for wrapped SOL
+
+#### Known Vulnerability Mitigations
+
+Both CToken and Token-2022 mitigate:
+
+- **Supply Inflation Bugs**: Balance checks before state changes + checked arithmetic
+- **Mint Mismatch**: Triple validation (source-mint, source-dest, decimals)
+- **Account Ordering Issues**: Explicit account extraction with typed unpacking
+- **Overflow Vulnerabilities**: All arithmetic uses checked variants
+
+Token-2022 additionally mitigates:
+
+- **CPI Guard Bypass**: Explicit check for `authority == owner && lock_cpi && in_cpi()` (Certora-2024 audit finding)
+- **Transfer Fee Overflow**: Fee calculation returns Option with explicit overflow handling
+- **Reentrancy Attacks**: Transferring flag prevents hook reentrancy
+
+**Token-2022 Reference**: `/home/ananas/dev/token-2022/analysis/transfer-checked.md:348-370`
diff --git a/programs/compressed-token/program/docs/instructions/TRANSFER2.md b/programs/compressed-token/program/docs/instructions/TRANSFER2.md
index 1cc1d30166..085627dfc2 100644
--- a/programs/compressed-token/program/docs/instructions/TRANSFER2.md
+++ b/programs/compressed-token/program/docs/instructions/TRANSFER2.md
@@ -20,8 +20,8 @@
 1. Batch transfer instruction supporting multiple token operations in a single transaction with up to 5 different mints (cmints or spl)
 
 2. Account types and data layouts:
-   - Compressed accounts: `TokenData` (program-libs/ctoken-types/src/state/token_data.rs)
-   - Decompressed Solana accounts: `CToken` for ctokens (program-libs/ctoken-types/src/state/ctoken/ctoken_struct.rs) or standard SPL token accounts
+   - Compressed accounts: `TokenData` (program-libs/ctoken-interface/src/state/compressed_token/token_data.rs)
+   - Decompressed Solana accounts: `CToken` for ctokens (program-libs/ctoken-interface/src/state/ctoken/ctoken_struct.rs) or standard SPL token accounts
    - SPL tokens when compressed are backed by tokens stored in ctoken pool PDAs
 
 3. Compression modes:
@@ -40,7 +40,7 @@
    - Execute mode: All operations supported including compress/decompress
 
 **Instruction data:**
-1. instruction data is defined in path: program-libs/ctoken-types/src/instructions/transfer2.rs
+1. instruction data is defined in path: program-libs/ctoken-interface/src/instructions/transfer2/instruction_data.rs
    - `with_transaction_hash`: Compute transaction hash for the complete transaction and include in compressed account data, enables ZK proofs over how compressed accounts are spent
    - `with_lamports_change_account_merkle_tree_index`: Track lamport changes in specified tree
    - `proof`: Optional CompressedProof - Required for ZK validation of compressed inputs; not needed for proof by index or when no compressed inputs exist
@@ -48,12 +48,12 @@
    - `out_token_data`: Vec<MultiTokenTransferOutputData> - Output compressed token accounts (packed: owner/delegate/mint/merkle_tree are indices to packed accounts)
    - `in_lamports`: Optional lamport amounts for input accounts (unimplemented)
    - `out_lamports`: Optional lamport amounts for output accounts (unimplemented)
-   - `in_tlv`: Optional TLV data for input accounts (unimplemented)
-   - `out_tlv`: Optional TLV data for output accounts (unimplemented)
+   - `in_tlv`: Optional TLV data for input accounts (used for CompressedOnly extension during decompress)
+   - `out_tlv`: Optional TLV data for output accounts (used for CompressedOnly extension during CompressAndClose)
    - `compressions`: Optional Vec<Compression> - Compress/decompress operations
    - `cpi_context`: Optional CompressedCpiContext - Required for CPI operations; write mode: set either first_set_context or set_context (not both); execute mode: provide with all flags false
 
-2. Compression struct fields (path: program-libs/ctoken-types/src/instructions/transfer2.rs):
+2. Compression struct fields (path: program-libs/ctoken-interface/src/instructions/transfer2/compression.rs):
    - `mode`: CompressionMode enum (Compress, Decompress, CompressAndClose)
    - `amount`: u64 - Amount to compress/decompress
    - `mint`: u8 - Index of mint account in packed accounts
@@ -130,7 +130,10 @@ Packed accounts (dynamic indexing):
    - Deserialize `CompressedTokenInstructionDataTransfer2` using zero-copy
    - Validate CPI context via `check_cpi_context`: Ensures `set_context || first_set_context` is false when `cpi_context` is Some
    - Validate instruction data via `validate_instruction_data`:
-     - Check unimplemented features (`in_lamports`, `out_lamports`, `in_tlv`, `out_tlv`) are None
+     - Check unimplemented features (`in_lamports`, `out_lamports`) are None
+     - Validate `in_tlv` length matches `in_token_data` length if provided
+     - Validate `out_tlv` length matches `out_token_data` length if provided
+     - Block CompressedOnly inputs from having compressed outputs (error: CompressedOnlyBlocksTransfer)
      - Ensure CPI context write mode (`set_context || first_set_context`) has no compressions
    - Determine required optional accounts via `Transfer2Config::from_instruction_data`:
      - Analyzes instruction data to identify which optional accounts must be present
@@ -140,6 +143,10 @@ Packed accounts (dynamic indexing):
      - Sets `no_compressed_accounts` when no compressed accounts involved (in_token_data and out_token_data both empty)
      - Uses checked arithmetic to prevent lamport calculation overflow
    - Validate and parse accounts via `Transfer2Accounts::validate_and_parse`
+   - Build mint extension cache via `build_mint_extension_cache`:
+     - Caches extension state for unique mints (max 5)
+     - **Mode-dependent enforcement:** Compress enforces restrictions; Decompress and CompressAndClose bypass
+     - For CompressAndClose with restricted extensions: requires CompressedOnly extension in output TLV
 
 2. **Branch based on compressed account involvement:**
 
@@ -252,6 +259,14 @@ When compression processing occurs (in both Path A and Path B):
      - Subtracts compression amount from the source ctoken account balance (with overflow protection)
    - **For Decompress:**
      - Adds decompression amount to the recipient ctoken account balance (with overflow protection)
+     - **Extension state transfer (with CompressedOnly in input TLV):**
+       - Validates destination CToken is fresh (zero amount, no delegate, no close_authority)
+       - Transfers delegate and delegated_amount from CompressedOnly extension to CToken
+       - Transfers withheld_transfer_fee to CToken's TransferFeeAccount extension
+       - Restores frozen state (sets CToken.state = 2 if extension.is_frozen)
+       - Error: `DecompressDestinationNotFresh` if destination has non-zero state
+     - **CompressedOnly inputs must decompress to CToken, not SPL token accounts:**
+       - Error: `CompressedOnlyRequiresCTokenDecompress` if decompressing to SPL token account
    - **For CompressAndClose:**
      - **Authority validation:**
        - Authority must be signer
@@ -264,9 +279,11 @@ When compression processing occurs (in both Path A and Path B):
        - Account becomes compressible when it lacks sufficient rent for current epoch + 1
        - This prevents compression_authority from arbitrarily compressing accounts before rent expires
        - Error: `ProgramError::InvalidAccountData` with message "account not compressible" if check fails
-     - **Frozen account check:**
-       - Frozen ctoken accounts (state == 2) cannot be compressed
-       - Error: `ErrorCode::AccountFrozen` if account is frozen
+     - **Frozen account handling:**
+       - Frozen ctoken accounts (state == 2) CAN be CompressAndClose'd
+       - Frozen state is preserved via CompressedOnly extension in output TLV
+       - The account is temporarily unfrozen (set to initialized) to pass close validation
+       - Error: `ErrorCode::AccountFrozen` if trying to Compress (not CompressAndClose) a frozen account
      - **Design principle: Compression authority control** (see `program-libs/compressible/docs/RENT.md` for detailed rent calculations)
        - Tokens: Belong to the owner, but compression is controlled by compression_authority
        - Rent exemption + completed epoch rent: Belong to rent_sponsor (who funded them)
@@ -281,9 +298,19 @@ When compression processing occurs (in both Path A and Path B):
        - Owner: If `compress_to_pubkey` flag is true, owner must be the token account's pubkey (allows closing accounts owned by PDAs)
        - **Note:** `compress_to_pubkey` is stored in the compressible extension and set during account creation, not per-instruction
        - Mint: Must match the ctoken account's mint field
-       - Delegate: Must be None (has_delegate=false and delegate=0) - delegates cannot be carried over
        - Version: Must be ShaFlat (version=3) for security
        - Version: Must match the version specified in the token account's compressible extension
+     - **Delegate/Frozen state handling (with CompressedOnly extension):**
+       - If account has `compression_only` flag set (restricted mint), CompressedOnly extension is REQUIRED in output TLV
+       - CompressedOnly extension preserves: `is_frozen`, `delegated_amount`, `delegate` (in token_data), `withheld_transfer_fee`
+       - Delegate: Must match between ctoken.delegate and compressed output delegate
+       - Delegated amount: Must match between ctoken.delegated_amount and extension.delegated_amount
+       - Frozen state: Must match between ctoken.state==2 and extension.is_frozen
+       - Withheld fee: Must match between ctoken TransferFeeAccount.withheld_amount and extension.withheld_transfer_fee
+       - Error: `CompressAndCloseDelegatedAmountMismatch`, `CompressAndCloseInvalidDelegate`, `CompressAndCloseFrozenMismatch`, `CompressAndCloseWithheldFeeMismatch`
+     - **Delegate handling (without CompressedOnly extension):**
+       - Delegate: Must be None (has_delegate=false and delegate=0) - delegates cannot be carried over without extension
+       - Error: `CompressAndCloseDelegateNotAllowed` if source has delegate or output has delegate
      - **Account state updates:**
        - Token account balance is set to 0
        - Account is marked for closing after the transaction
@@ -302,8 +329,12 @@ When compression processing occurs (in both Path A and Path B):
 - `ProgramError::InvalidInstructionData` (error code: 3) - Invalid instruction data or authority index for decompress mode
 - `ProgramError::InvalidAccountData` (error code: 4) - Account data deserialization fails
 - `ProgramError::ArithmeticOverflow` (error code: 24) - Overflow in lamport calculations
-- `CTokenError::TokenDataTlvUnimplemented` (error code: 18035) - TLV data not yet supported
-- `CTokenError::CompressedTokenAccountTlvUnimplemented` (error code: 18021) - Compressed account TLV not supported
+- `CTokenError::InLamportsUnimplemented` (error code: 18050) - in_lamports field not yet implemented
+- `CTokenError::OutLamportsUnimplemented` (error code: 18051) - out_lamports field not yet implemented
+- `CTokenError::CompressedTokenAccountTlvUnimplemented` (error code: 18021) - out_tlv provided but not all compressions are CompressAndClose mode
+- `CTokenError::CompressedOnlyBlocksTransfer` (error code: 18048) - CompressedOnly inputs cannot have compressed outputs (must decompress only)
+- `CTokenError::OutTlvOutputCountMismatch` (error code: 18049) - out_tlv length does not match out_token_data length
+- `CTokenError::DecompressDestinationNotFresh` (error code: 18055) - Decompress destination CToken has non-zero state (amount, delegate, etc)
 - `CTokenError::InvalidInstructionData` (error code: 18001) - Compressions not allowed when writing to CPI context
 - `CTokenError::InvalidCompressionMode` (error code: 18018) - Invalid compression mode value
 - `CTokenError::CompressInsufficientFunds` (error code: 18019) - Insufficient balance for compression
@@ -330,6 +361,14 @@ When compression processing occurs (in both Path A and Path B):
 - `ErrorCode::CompressAndCloseBalanceMismatch` (error code: 6091) - Token account balance must match compressed output amount
 - `ErrorCode::CompressAndCloseDelegateNotAllowed` (error code: 6092) - Source token account has delegate OR compressed output has delegate (delegates not supported)
 - `ErrorCode::CompressAndCloseInvalidVersion` (error code: 6093) - Compressed token version must be 3 (ShaFlat) and must match compressible extension's account_version
+- `ErrorCode::CompressAndCloseInvalidMint` (error code: 6108) - Compressed token mint does not match source token account mint
+- `ErrorCode::CompressAndCloseMissingCompressedOnlyExtension` (error code: 6109) - Missing required CompressedOnly extension for restricted mint or frozen account
+- `ErrorCode::CompressAndCloseDelegatedAmountMismatch` (error code: 6116) - Delegated amount mismatch between ctoken and CompressedOnly extension
+- `ErrorCode::CompressAndCloseInvalidDelegate` (error code: 6118) - Delegate mismatch between ctoken and compressed token output
+- `ErrorCode::CompressAndCloseWithheldFeeMismatch` (error code: 6120) - Withheld transfer fee mismatch
+- `ErrorCode::CompressAndCloseFrozenMismatch` (error code: 6122) - Frozen state mismatch between ctoken and CompressedOnly extension
+- `ErrorCode::CompressedOnlyRequiresCTokenDecompress` (error code: 6144) - CompressedOnly inputs must decompress to CToken account, not SPL token account
+- `ErrorCode::TlvRequiresVersion3` (error code: 6123) - TLV extensions only supported with version 3 (ShaFlat)
 - `ErrorCode::CompressAndCloseDuplicateOutput` (error code: 6420) - Cannot use the same compressed output account for multiple CompressAndClose operations (security protection against fund theft)
 - `ErrorCode::CompressAndCloseOutputMissing` (error code: 6421) - Compressed token account output required but not provided
 - `AccountError::InvalidSigner` (error code: 12015) - Required signer account is not signing
diff --git a/programs/compressed-token/program/src/claim.rs b/programs/compressed-token/program/src/claim.rs
index 0be65a02d4..19e7de8c31 100644
--- a/programs/compressed-token/program/src/claim.rs
+++ b/programs/compressed-token/program/src/claim.rs
@@ -2,7 +2,9 @@ use anchor_compressed_token::ErrorCode;
 use anchor_lang::prelude::ProgramError;
 use light_account_checks::{checks::check_owner, AccountInfoTrait, AccountIterator};
 use light_compressible::{compression_info::ClaimAndUpdate, config::CompressibleConfig};
-use light_ctoken_interface::state::{CToken, ZExtensionStructMut};
+use light_ctoken_interface::state::{
+    CToken, CompressedMint, ACCOUNT_TYPE_MINT, ACCOUNT_TYPE_TOKEN_ACCOUNT,
+};
 use light_program_profiler::profile;
 use pinocchio::{account_info::AccountInfo, sysvars::Sysvar};
 use spl_pod::solana_msg::msg;
@@ -89,42 +91,71 @@ pub fn process_claim(
     Ok(())
 }
 
+/// Determines account type from account data.
+/// - If account is exactly 165 bytes: CToken (legacy size without extensions)
+/// - If account is > 165 bytes: read byte 165 for discriminator
+/// - If account is < 165 bytes: invalid
+#[inline(always)]
+fn determine_account_type(data: &[u8]) -> Result<u8, ProgramError> {
+    const ACCOUNT_TYPE_OFFSET: usize = 165;
+
+    match data.len().cmp(&ACCOUNT_TYPE_OFFSET) {
+        core::cmp::Ordering::Less => Err(ProgramError::InvalidAccountData),
+        core::cmp::Ordering::Equal => Ok(ACCOUNT_TYPE_TOKEN_ACCOUNT), // 165 bytes = CToken
+        core::cmp::Ordering::Greater => Ok(data[ACCOUNT_TYPE_OFFSET]),
+    }
+}
+
 fn validate_and_claim(
     accounts: &ClaimAccounts,
     config_account: &CompressibleConfig,
-    token_account: &AccountInfo,
+    account: &AccountInfo,
     current_slot: u64,
 ) -> Result<Option<u64>, ProgramError> {
-    // Verify the token account is owned by the compressed token program
-    check_owner(&crate::LIGHT_CPI_SIGNER.program_id, token_account)?;
+    // Verify the account is owned by the compressed token program
+    check_owner(&crate::LIGHT_CPI_SIGNER.program_id, account)?;
 
     // Get current lamports balance
-    let current_lamports = AccountInfoTrait::lamports(token_account);
+    let current_lamports = AccountInfoTrait::lamports(account);
     // Claim rent for completed epochs
-    let bytes = token_account.data_len() as u64;
-    // Parse and process the token account
-    let mut token_account_data = AccountInfoTrait::try_borrow_mut_data(token_account)?;
-    let (mut compressed_token, _) = CToken::zero_copy_at_mut_checked(&mut token_account_data)?;
-
-    // Find compressible extension
-    if let Some(extensions) = compressed_token.extensions.as_mut() {
-        for extension in extensions {
-            if let ZExtensionStructMut::Compressible(compressible_ext) = extension {
-                return compressible_ext
-                    .info
-                    .claim_and_update(ClaimAndUpdate {
-                        compression_authority: accounts.compression_authority.key(),
-                        rent_sponsor: accounts.rent_sponsor.key(),
-                        config_account,
-                        bytes,
-                        current_slot,
-                        current_lamports,
-                    })
-                    .map_err(ProgramError::from);
-            }
+    let bytes = account.data_len() as u64;
+    // Parse and process the account
+    let mut account_data = AccountInfoTrait::try_borrow_mut_data(account)?;
+
+    // Determine account type and process accordingly
+    let account_type = determine_account_type(&account_data)?;
+
+    let claim_and_update = ClaimAndUpdate {
+        compression_authority: accounts.compression_authority.key(),
+        rent_sponsor: accounts.rent_sponsor.key(),
+        config_account,
+        bytes,
+        current_slot,
+        current_lamports,
+    };
+
+    match account_type {
+        ACCOUNT_TYPE_TOKEN_ACCOUNT => {
+            // CToken account
+            let (mut ctoken, _) = CToken::zero_copy_at_mut_checked(&mut account_data)?;
+            ctoken
+                .base
+                .compression
+                .claim_and_update(claim_and_update)
+                .map_err(ProgramError::from)
+        }
+        ACCOUNT_TYPE_MINT => {
+            // CMint account
+            let (mut cmint, _) = CompressedMint::zero_copy_at_mut_checked(&mut account_data)?;
+            cmint
+                .base
+                .compression
+                .claim_and_update(claim_and_update)
+                .map_err(ProgramError::from)
+        }
+        _ => {
+            msg!("Invalid account type: {}", account_type);
+            Err(ProgramError::InvalidAccountData)
         }
     }
-
-    msg!("No compressible extension found");
-    Ok(None)
 }
diff --git a/programs/compressed-token/program/src/close_token_account/accounts.rs b/programs/compressed-token/program/src/close_token_account/accounts.rs
index 24036308f9..90151b173a 100644
--- a/programs/compressed-token/program/src/close_token_account/accounts.rs
+++ b/programs/compressed-token/program/src/close_token_account/accounts.rs
@@ -1,6 +1,5 @@
 use anchor_lang::solana_program::program_error::ProgramError;
 use light_account_checks::checks::check_owner;
-use light_ctoken_interface::COMPRESSIBLE_TOKEN_ACCOUNT_SIZE;
 use light_program_profiler::profile;
 use pinocchio::account_info::AccountInfo;
 
@@ -20,11 +19,6 @@ impl<'info> CloseTokenAccountAccounts<'info> {
         let mut iter = AccountIterator::new(accounts);
         let token_account = iter.next_mut("token_account")?;
         check_owner(&LIGHT_CPI_SIGNER.program_id, token_account)?;
-        if token_account.data_len() != 165
-            && token_account.data_len() != COMPRESSIBLE_TOKEN_ACCOUNT_SIZE as usize
-        {
-            return Err(ProgramError::InvalidAccountData);
-        }
         Ok(CloseTokenAccountAccounts {
             token_account,
             destination: iter.next_mut("destination")?,
diff --git a/programs/compressed-token/program/src/close_token_account/processor.rs b/programs/compressed-token/program/src/close_token_account/processor.rs
index 511ad7715d..38a05a34c0 100644
--- a/programs/compressed-token/program/src/close_token_account/processor.rs
+++ b/programs/compressed-token/program/src/close_token_account/processor.rs
@@ -2,13 +2,12 @@ use anchor_compressed_token::ErrorCode;
 use anchor_lang::prelude::ProgramError;
 use light_account_checks::{checks::check_signer, AccountInfoTrait};
 use light_compressible::rent::{get_rent_exemption_lamports, AccountRentState};
-use light_ctoken_interface::state::{CToken, ZCompressedTokenMut, ZExtensionStructMut};
+use light_ctoken_interface::state::{AccountState, CToken, ZCTokenMut};
 use light_program_profiler::profile;
 #[cfg(target_os = "solana")]
 use pinocchio::sysvars::Sysvar;
 use pinocchio::{account_info::AccountInfo, pubkey::pubkey_eq};
 use spl_pod::solana_msg::msg;
-use spl_token_2022::state::AccountState;
 
 use super::accounts::CloseTokenAccountAccounts;
 use crate::shared::{convert_program_error, transfer_lamports};
@@ -37,7 +36,7 @@ pub fn process_close_token_account(
 #[profile]
 pub fn validate_token_account_close_instruction(
     accounts: &CloseTokenAccountAccounts,
-    ctoken: &ZCompressedTokenMut<'_>,
+    ctoken: &ZCTokenMut<'_>,
 ) -> Result<(), ProgramError> {
     validate_token_account::<false>(accounts, ctoken)?;
     Ok(())
@@ -48,7 +47,7 @@ pub fn validate_token_account_close_instruction(
 #[profile]
 pub fn validate_token_account_for_close_transfer2(
     accounts: &CloseTokenAccountAccounts,
-    ctoken: &ZCompressedTokenMut<'_>,
+    ctoken: &ZCTokenMut<'_>,
 ) -> Result<bool, ProgramError> {
     validate_token_account::<true>(accounts, ctoken)
 }
@@ -56,85 +55,81 @@ pub fn validate_token_account_for_close_transfer2(
 #[inline(always)]
 fn validate_token_account<const COMPRESS_AND_CLOSE: bool>(
     accounts: &CloseTokenAccountAccounts,
-    ctoken: &ZCompressedTokenMut<'_>,
+    ctoken: &ZCTokenMut<'_>,
 ) -> Result<bool, ProgramError> {
     if accounts.token_account.key() == accounts.destination.key() {
         return Err(ProgramError::InvalidAccountData);
     }
 
-    // Check account state - reject frozen and uninitialized
-    match *ctoken.state {
-        state if state == AccountState::Initialized as u8 => {} // OK to proceed
-        state if state == AccountState::Frozen as u8 => return Err(ErrorCode::AccountFrozen.into()),
-        _ => return Err(ProgramError::UninitializedAccount),
-    }
     // For compress and close we compress the balance and close.
     if !COMPRESS_AND_CLOSE {
         // Check that the account has zero balance
-        if u64::from(*ctoken.amount) != 0 {
+        if u64::from(ctoken.amount) != 0 {
             return Err(ErrorCode::NonNativeHasBalance.into());
         }
+        // TODO: Non-zero transfer fees not yet supported. If fees != 0 support is added:
+        // - Check TransferFeeAccount.withheld_amount == 0 before allowing close
+        // - Implement harvest_withheld_fees instruction to extract fees first
+        // - T22 blocks close when withheld_amount > 0 to prevent fee loss
+    }
+    // All ctoken accounts are now compressible - CompressionInfo is embedded directly in the struct
+    let compression = &ctoken.base.compression;
+
+    // Validate rent_sponsor matches
+    let rent_sponsor = accounts
+        .rent_sponsor
+        .ok_or(ProgramError::NotEnoughAccountKeys)?;
+    if compression.rent_sponsor != *rent_sponsor.key() {
+        msg!("rent recipient mismatch");
+        return Err(ProgramError::InvalidAccountData);
     }
-    // For COMPRESS_AND_CLOSE: Only compressible accounts (with Compressible extension) are allowed
-    // For regular close: Owner must match
-    if let Some(extensions) = ctoken.extensions.as_ref() {
-        for extension in extensions {
-            if let ZExtensionStructMut::Compressible(compressible_ext) = extension {
-                let rent_sponsor = accounts
-                    .rent_sponsor
-                    .ok_or(ProgramError::NotEnoughAccountKeys)?;
-                if compressible_ext.info.rent_sponsor != *rent_sponsor.key() {
-                    msg!("rent recipient mismatch");
-                    return Err(ProgramError::InvalidAccountData);
-                }
-
-                if COMPRESS_AND_CLOSE {
-                    // For CompressAndClose: ONLY compression_authority can compress and close
-                    if compressible_ext.info.compression_authority != *accounts.authority.key() {
-                        msg!("compress and close requires compression authority");
-                        return Err(ProgramError::InvalidAccountData);
-                    }
-
-                    #[cfg(target_os = "solana")]
-                    let current_slot = pinocchio::sysvars::clock::Clock::get()
-                        .map_err(convert_program_error)?
-                        .slot;
-
-                    #[cfg(target_os = "solana")]
-                    {
-                        let is_compressible = compressible_ext
-                            .info
-                            .is_compressible(
-                                accounts.token_account.data_len() as u64,
-                                current_slot,
-                                accounts.token_account.lamports(),
-                            )
-                            .map_err(|_| ProgramError::InvalidAccountData)?;
 
-                        if is_compressible.is_none() {
-                            msg!("account not compressible");
-                            return Err(ProgramError::InvalidAccountData);
-                        }
-                    }
+    if COMPRESS_AND_CLOSE {
+        // For CompressAndClose: ONLY compression_authority can compress and close
+        if compression.compression_authority != *accounts.authority.key() {
+            msg!("compress and close requires compression authority");
+            return Err(ProgramError::InvalidAccountData);
+        }
 
-                    return Ok(compressible_ext.info.compress_to_pubkey());
-                }
-                // For regular close (!COMPRESS_AND_CLOSE): fall through to owner check
+        #[cfg(target_os = "solana")]
+        let current_slot = pinocchio::sysvars::clock::Clock::get()
+            .map_err(convert_program_error)?
+            .slot;
+
+        #[cfg(target_os = "solana")]
+        {
+            let is_compressible = compression
+                .is_compressible(
+                    accounts.token_account.data_len() as u64,
+                    current_slot,
+                    accounts.token_account.lamports(),
+                )
+                .map_err(|_| ProgramError::InvalidAccountData)?;
+
+            if is_compressible.is_none() {
+                msg!("account not compressible");
+                return Err(ProgramError::InvalidAccountData);
             }
         }
-    }
 
-    // CompressAndClose requires Compressible extension - if we reach here without returning, reject
-    if COMPRESS_AND_CLOSE {
-        msg!("compress and close requires compressible extension");
-        return Err(ProgramError::InvalidAccountData);
+        return Ok(compression.compress_to_pubkey());
+    }
+    // For regular close (!COMPRESS_AND_CLOSE): fall through to owner check
+
+    // Check account state - reject frozen and uninitialized (only for regular close)
+    let account_state =
+        AccountState::try_from(ctoken.state).map_err(|_| ProgramError::UninitializedAccount)?;
+    match account_state {
+        AccountState::Initialized => {} // OK to proceed
+        AccountState::Frozen => return Err(ErrorCode::AccountFrozen.into()),
+        AccountState::Uninitialized => return Err(ProgramError::UninitializedAccount),
     }
 
     // For regular close: check close_authority first, then fall back to owner
     // This matches SPL Token behavior where close_authority takes precedence over owner
-    if let Some(close_authority) = ctoken.close_authority.as_ref() {
+    if let Some(close_authority) = ctoken.close_authority() {
         // close_authority is set - only close_authority can close
-        if !pubkey_eq(close_authority.array_ref(), accounts.authority.key()) {
+        if !pubkey_eq(ctoken.close_authority.array_ref(), accounts.authority.key()) {
             msg!(
                 "close authority mismatch: close_authority {:?} != {:?} authority",
                 solana_pubkey::Pubkey::from(close_authority.to_bytes()),
@@ -174,85 +169,65 @@ pub fn distribute_lamports(accounts: &CloseTokenAccountAccounts<'_>) -> Result<(
     let token_account_data = AccountInfoTrait::try_borrow_data(accounts.token_account)?;
     let (ctoken, _) = CToken::zero_copy_at_checked(&token_account_data)?;
 
-    if let Some(extensions) = ctoken.extensions.as_ref() {
-        for extension in extensions {
-            if let light_ctoken_interface::state::ZExtensionStruct::Compressible(compressible_ext) =
-                extension
-            {
-                // Calculate distribution based on rent and write_top_up
-                #[cfg(target_os = "solana")]
-                let current_slot = pinocchio::sysvars::clock::Clock::get()
-                    .map_err(convert_program_error)?
-                    .slot;
-                #[cfg(not(target_os = "solana"))]
-                let current_slot = 0;
-                let compression_cost: u64 =
-                    compressible_ext.info.rent_config.compression_cost.into();
-
-                let (mut lamports_to_rent_sponsor, mut lamports_to_destination) = {
-                    let base_lamports =
-                        get_rent_exemption_lamports(accounts.token_account.data_len() as u64)
-                            .map_err(|_| ProgramError::InvalidAccountData)?;
-
-                    let state = AccountRentState {
-                        num_bytes: accounts.token_account.data_len() as u64,
-                        current_slot,
-                        current_lamports: token_account_lamports,
-                        last_claimed_slot: compressible_ext.info.last_claimed_slot.into(),
-                    };
-
-                    let distribution = state.calculate_close_distribution(
-                        &compressible_ext.info.rent_config,
-                        base_lamports,
-                    );
-                    (distribution.to_rent_sponsor, distribution.to_user)
-                };
-
-                let rent_sponsor = accounts
-                    .rent_sponsor
-                    .ok_or(ProgramError::NotEnoughAccountKeys)?;
-
-                if accounts.authority.key() == &compressible_ext.info.compression_authority {
-                    // When compressing via compression_authority:
-                    // Extract compression incentive from rent_sponsor portion to give to forester
-                    // The compression incentive is included in lamports_to_rent_sponsor
-                    lamports_to_rent_sponsor = lamports_to_rent_sponsor
-                        .checked_sub(compression_cost)
-                        .ok_or(ProgramError::InsufficientFunds)?;
-
-                    // Unused funds also go to rent_sponsor.
-                    lamports_to_rent_sponsor += lamports_to_destination;
-                    lamports_to_destination = compression_cost; // This will go to fee_payer (forester)
-                }
-
-                // Transfer lamports to rent sponsor.
-                if lamports_to_rent_sponsor > 0 {
-                    transfer_lamports(
-                        lamports_to_rent_sponsor,
-                        accounts.token_account,
-                        rent_sponsor,
-                    )
-                    .map_err(convert_program_error)?;
-                }
+    // All ctoken accounts are now compressible - CompressionInfo is embedded directly in the struct
+    let compression = &ctoken.base.compression;
+
+    // Calculate distribution based on rent and write_top_up
+    #[cfg(target_os = "solana")]
+    let current_slot = pinocchio::sysvars::clock::Clock::get()
+        .map_err(convert_program_error)?
+        .slot;
+    #[cfg(not(target_os = "solana"))]
+    let current_slot = 0;
+    let compression_cost: u64 = compression.rent_config.compression_cost.into();
+
+    let (mut lamports_to_rent_sponsor, mut lamports_to_destination) = {
+        let base_lamports = get_rent_exemption_lamports(accounts.token_account.data_len() as u64)
+            .map_err(|_| ProgramError::InvalidAccountData)?;
+
+        let state = AccountRentState {
+            num_bytes: accounts.token_account.data_len() as u64,
+            current_slot,
+            current_lamports: token_account_lamports,
+            last_claimed_slot: compression.last_claimed_slot.into(),
+        };
+
+        let distribution =
+            state.calculate_close_distribution(&compression.rent_config, base_lamports);
+        (distribution.to_rent_sponsor, distribution.to_user)
+    };
+
+    let rent_sponsor = accounts
+        .rent_sponsor
+        .ok_or(ProgramError::NotEnoughAccountKeys)?;
+
+    if accounts.authority.key() == &compression.compression_authority {
+        // When compressing via compression_authority:
+        // Extract compression incentive from rent_sponsor portion to give to forester
+        // The compression incentive is included in lamports_to_rent_sponsor
+        lamports_to_rent_sponsor = lamports_to_rent_sponsor
+            .checked_sub(compression_cost)
+            .ok_or(ProgramError::InsufficientFunds)?;
+
+        // Unused funds also go to rent_sponsor.
+        lamports_to_rent_sponsor += lamports_to_destination;
+        lamports_to_destination = compression_cost; // This will go to fee_payer (forester)
+    }
 
-                // Transfer lamports to destination (user or forester).
-                if lamports_to_destination > 0 {
-                    transfer_lamports(
-                        lamports_to_destination,
-                        accounts.token_account,
-                        accounts.destination,
-                    )
-                    .map_err(convert_program_error)?;
-                }
-                return Ok(());
-            }
-        }
+    // Transfer lamports to rent sponsor.
+    if lamports_to_rent_sponsor > 0 {
+        transfer_lamports(
+            lamports_to_rent_sponsor,
+            accounts.token_account,
+            rent_sponsor,
+        )
+        .map_err(convert_program_error)?;
     }
 
-    // Non-compressible account: transfer all lamports to destination
-    if token_account_lamports > 0 {
+    // Transfer lamports to destination (user or forester).
+    if lamports_to_destination > 0 {
         transfer_lamports(
-            token_account_lamports,
+            lamports_to_destination,
             accounts.token_account,
             accounts.destination,
         )
diff --git a/programs/compressed-token/program/src/create_associated_token_account.rs b/programs/compressed-token/program/src/create_associated_token_account.rs
index 50eb19893f..25a43ed5dc 100644
--- a/programs/compressed-token/program/src/create_associated_token_account.rs
+++ b/programs/compressed-token/program/src/create_associated_token_account.rs
@@ -1,26 +1,24 @@
 use anchor_lang::prelude::ProgramError;
 use borsh::BorshDeserialize;
 use light_account_checks::AccountIterator;
-use light_compressible::config::CompressibleConfig;
-use light_ctoken_interface::instructions::{
-    create_associated_token_account::CreateAssociatedTokenAccountInstructionData,
-    extensions::compressible::CompressibleExtensionInstructionData,
-};
+use light_ctoken_interface::instructions::create_associated_token_account::CreateAssociatedTokenAccountInstructionData;
 use light_program_profiler::profile;
-use pinocchio::{account_info::AccountInfo, instruction::Seed, pubkey::Pubkey};
+use pinocchio::{account_info::AccountInfo, instruction::Seed};
 use spl_pod::solana_msg::msg;
 
 use crate::{
     create_token_account::next_config_account,
+    extensions::has_mint_extensions,
     shared::{
         convert_program_error, create_pda_account,
-        initialize_ctoken_account::initialize_ctoken_account, transfer_lamports_via_cpi,
-        validate_ata_derivation,
+        initialize_ctoken_account::{
+            initialize_ctoken_account, CTokenInitConfig, CompressionInstructionData,
+        },
+        transfer_lamports_via_cpi, validate_ata_derivation,
     },
 };
 
 /// Process the create associated token account instruction (non-idempotent)
-/// Owner and mint are passed as accounts instead of instruction data
 #[inline(always)]
 pub fn process_create_associated_token_account(
     account_infos: &[AccountInfo],
@@ -30,7 +28,6 @@ pub fn process_create_associated_token_account(
 }
 
 /// Process the create associated token account instruction (idempotent)
-/// Owner and mint are passed as accounts instead of instruction data
 #[inline(always)]
 pub fn process_create_associated_token_account_idempotent(
     account_infos: &[AccountInfo],
@@ -39,68 +36,39 @@ pub fn process_create_associated_token_account_idempotent(
     process_create_associated_token_account_with_mode::<true>(account_infos, instruction_data)
 }
 
-/// Convert create_associated_token_account instruction format to create_ata format by extracting
-/// owner and mint from accounts and calling the inner function directly
-///
-/// Note:
-/// - we don't validate the mint because it would be very expensive with compressed mints
-/// - it is possible to create an associated token account for non existing mints
-/// - accounts with non existing mints can never have a balance
-///
 /// Account order:
 /// 0. owner (non-mut, non-signer)
 /// 1. mint (non-mut, non-signer)
 /// 2. fee_payer (signer, mut)
 /// 3. associated_token_account (mut)
 /// 4. system_program
-/// 5. optional accounts (config, rent_payer, etc.)
+/// 5. compressible_config
+/// 6. rent_payer
+#[profile]
 #[inline(always)]
 fn process_create_associated_token_account_with_mode<const IDEMPOTENT: bool>(
     account_infos: &[AccountInfo],
     mut instruction_data: &[u8],
 ) -> Result<(), ProgramError> {
-    if account_infos.len() < 2 {
-        return Err(ProgramError::NotEnoughAccountKeys);
-    }
-
-    let instruction_inputs =
-        CreateAssociatedTokenAccountInstructionData::deserialize(&mut instruction_data)
-            .map_err(ProgramError::from)?;
-
-    let (owner_and_mint, remaining_accounts) = account_infos.split_at(2);
-    let owner = &owner_and_mint[0];
-    let mint = &owner_and_mint[1];
-
-    process_create_associated_token_account_inner::<IDEMPOTENT>(
-        remaining_accounts,
-        owner.key(),
-        mint.key(),
-        instruction_inputs.bump,
-        instruction_inputs.compressible_config,
-    )
-}
+    let inputs = CreateAssociatedTokenAccountInstructionData::deserialize(&mut instruction_data)
+        .map_err(ProgramError::from)?;
 
-/// Core logic for creating associated token account with owner and mint as pubkeys
-#[inline(always)]
-#[profile]
-pub(crate) fn process_create_associated_token_account_inner<const IDEMPOTENT: bool>(
-    account_infos: &[AccountInfo],
-    owner_bytes: &[u8; 32],
-    mint_bytes: &[u8; 32],
-    bump: u8,
-    compressible_config: Option<CompressibleExtensionInstructionData>,
-) -> Result<(), ProgramError> {
     let mut iter = AccountIterator::new(account_infos);
-
+    let owner = iter.next_account("owner")?;
+    let mint = iter.next_account("mint")?;
     let fee_payer = iter.next_signer_mut("fee_payer")?;
     let associated_token_account = iter.next_mut("associated_token_account")?;
     let _system_program = iter.next_non_mut("system_program")?;
+    let config_account = next_config_account(&mut iter)?;
+    let rent_payer = iter.next_mut("rent_payer")?;
+
+    let owner_bytes = owner.key();
+    let mint_bytes = mint.key();
+    let bump = inputs.bump;
 
     // If idempotent mode, check if account already exists
     if IDEMPOTENT {
-        // Verify the PDA derivation is correct
         validate_ata_derivation(associated_token_account, owner_bytes, mint_bytes, bump)?;
-        // If account is already owned by our program, it exists - return success
         if associated_token_account.is_owned_by(&crate::LIGHT_CPI_SIGNER.program_id) {
             return Ok(());
         }
@@ -111,89 +79,30 @@ pub(crate) fn process_create_associated_token_account_inner<const IDEMPOTENT: bo
         return Err(ProgramError::IllegalOwner);
     }
 
-    let token_account_size = if compressible_config.is_some() {
-        light_ctoken_interface::COMPRESSIBLE_TOKEN_ACCOUNT_SIZE as usize
-    } else {
-        light_ctoken_interface::BASE_TOKEN_ACCOUNT_SIZE as usize
-    };
-
-    let (compressible_config_account, custom_rent_payer) =
-        if let Some(compressible_config_ix_data) = compressible_config.as_ref() {
-            let (compressible_config_account, custom_rent_payer) = process_compressible_config(
-                compressible_config_ix_data,
-                &mut iter,
-                token_account_size,
-                fee_payer,
-                associated_token_account,
-                bump,
-                owner_bytes,
-                mint_bytes,
-            )?;
-            (Some(compressible_config_account), custom_rent_payer)
-        } else {
-            // Create the PDA account (with rent-exempt balance only)
-            let bump_seed = [bump];
-            let ata_seeds = [
-                Seed::from(owner_bytes.as_ref()),
-                Seed::from(crate::LIGHT_CPI_SIGNER.program_id.as_ref()),
-                Seed::from(mint_bytes.as_ref()),
-                Seed::from(bump_seed.as_ref()),
-            ];
-
-            create_pda_account(
-                fee_payer,
-                associated_token_account,
-                token_account_size,
-                None,                       // fee_payer is keypair
-                Some(ata_seeds.as_slice()), // ATA is PDA
-                None,
-            )?;
-            (None, None)
-        };
-
-    initialize_ctoken_account(
-        associated_token_account,
-        mint_bytes,
-        owner_bytes,
-        compressible_config,
-        compressible_config_account,
-        custom_rent_payer,
-    )?;
-    Ok(())
-}
-
-#[profile]
-#[allow(clippy::too_many_arguments)]
-fn process_compressible_config<'info>(
-    compressible_config_ix_data: &CompressibleExtensionInstructionData,
-    iter: &mut AccountIterator<'info, AccountInfo>,
-    token_account_size: usize,
-    fee_payer: &'info AccountInfo,
-    associated_token_account: &'info AccountInfo,
-    ata_bump: u8,
-    owner_bytes: &[u8; 32],
-    mint_bytes: &[u8; 32],
-) -> Result<(&'info CompressibleConfig, Option<Pubkey>), ProgramError> {
     // Validate that rent_payment is not exactly 1 epoch (footgun prevention)
-    if compressible_config_ix_data.rent_payment == 1 {
+    if inputs.rent_payment == 1 {
         msg!("Prefunding for exactly 1 epoch is not allowed. If the account is created near an epoch boundary, it could become immediately compressible. Use 0 or 2+ epochs.");
         return Err(anchor_compressed_token::ErrorCode::OneEpochPrefundingNotAllowed.into());
     }
 
-    if compressible_config_ix_data
-        .compress_to_account_pubkey
-        .is_some()
-    {
+    // Associated token accounts must not compress to pubkey
+    if inputs.compressible_config.is_some() {
         msg!("Associated token accounts must not compress to pubkey");
         return Err(ProgramError::InvalidInstructionData);
     }
 
-    let compressible_config_account = next_config_account(iter)?;
+    // Check which extensions the mint has
+    let mint_extensions = has_mint_extensions(mint)?;
 
-    let rent_payer = iter.next_account("rent payer")?;
+    // Calculate account size based on extensions
+    let account_size = mint_extensions.calculate_account_size()?;
 
-    let custom_rent_payer =
-        *rent_payer.key() != compressible_config_account.rent_sponsor.to_bytes();
+    let rent = config_account
+        .rent_config
+        .get_rent_with_compression_cost(account_size, inputs.rent_payment as u64);
+    let account_size = account_size as usize;
+
+    let custom_rent_payer = *rent_payer.key() != config_account.rent_sponsor.to_bytes();
 
     // Prevents setting executable accounts as rent_sponsor
     if custom_rent_payer && !rent_payer.is_signer() {
@@ -201,25 +110,18 @@ fn process_compressible_config<'info>(
         return Err(ProgramError::MissingRequiredSignature);
     }
 
-    let rent = compressible_config_account
-        .rent_config
-        .get_rent_with_compression_cost(
-            token_account_size as u64,
-            compressible_config_ix_data.rent_payment as u64,
-        );
-
-    // Build ATA seeds (new_account is always a PDA)
-    let ata_bump_seed = [ata_bump];
+    // Build ATA seeds (token account is always a PDA)
+    let bump_seed = [bump];
     let ata_seeds = [
         Seed::from(owner_bytes.as_ref()),
         Seed::from(crate::LIGHT_CPI_SIGNER.program_id.as_ref()),
         Seed::from(mint_bytes.as_ref()),
-        Seed::from(ata_bump_seed.as_ref()),
+        Seed::from(bump_seed.as_ref()),
     ];
 
     // Build rent sponsor seeds if using rent sponsor PDA as fee_payer
-    let rent_sponsor_bump = [compressible_config_account.rent_sponsor_bump];
-    let version_bytes = compressible_config_account.version.to_le_bytes();
+    let version_bytes = config_account.version.to_le_bytes();
+    let rent_sponsor_bump = [config_account.rent_sponsor_bump];
     let rent_sponsor_seeds = [
         Seed::from(b"rent_sponsor".as_ref()),
         Seed::from(version_bytes.as_ref()),
@@ -233,28 +135,47 @@ fn process_compressible_config<'info>(
     } else {
         Some(rent_sponsor_seeds.as_slice())
     };
+
+    // Custom rent payer pays both account creation and compression incentive
+    // Protocol rent sponsor only pays account creation, fee_payer pays compression incentive
     let additional_lamports = if custom_rent_payer { Some(rent) } else { None };
 
+    // Create ATA account
     create_pda_account(
         rent_payer,
         associated_token_account,
-        token_account_size,
+        account_size,
         fee_payer_seeds,
         Some(ata_seeds.as_slice()),
         additional_lamports,
     )?;
 
+    // When using protocol rent sponsor, fee_payer pays the compression incentive
     if !custom_rent_payer {
-        // Payer transfers the additional rent (compression incentive)
         transfer_lamports_via_cpi(rent, fee_payer, associated_token_account)
             .map_err(convert_program_error)?;
     }
-    Ok((
-        compressible_config_account,
-        if custom_rent_payer {
-            Some(*rent_payer.key())
-        } else {
-            None
+
+    // Initialize the token account
+    initialize_ctoken_account(
+        associated_token_account,
+        CTokenInitConfig {
+            mint: mint_bytes,
+            owner: owner_bytes,
+            compress_to_pubkey: None, // ATAs must not compress to pubkey
+            compression_ix_data: CompressionInstructionData {
+                compression_only: inputs.compression_only,
+                token_account_version: inputs.token_account_version,
+                write_top_up: inputs.write_top_up,
+            },
+            compressible_config_account: config_account,
+            custom_rent_payer: if custom_rent_payer {
+                Some(*rent_payer.key())
+            } else {
+                None
+            },
+            mint_extensions,
+            mint_account: mint,
         },
-    ))
+    )
 }
diff --git a/programs/compressed-token/program/src/create_token_account.rs b/programs/compressed-token/program/src/create_token_account.rs
index 681756e62c..a6b702f5f1 100644
--- a/programs/compressed-token/program/src/create_token_account.rs
+++ b/programs/compressed-token/program/src/create_token_account.rs
@@ -4,19 +4,21 @@ use light_account_checks::{
     checks::{check_discriminator, check_owner},
     AccountIterator,
 };
-use light_compressed_account::Pubkey;
 use light_compressible::config::CompressibleConfig;
-use light_ctoken_interface::{
-    instructions::create_ctoken_account::CreateTokenAccountInstructionData,
-    COMPRESSIBLE_TOKEN_ACCOUNT_SIZE,
-};
+use light_ctoken_interface::instructions::create_ctoken_account::CreateTokenAccountInstructionData;
 use light_program_profiler::profile;
 use pinocchio::{account_info::AccountInfo, instruction::Seed};
 use spl_pod::{bytemuck, solana_msg::msg};
 
-use crate::shared::{
-    convert_program_error, create_pda_account,
-    initialize_ctoken_account::initialize_ctoken_account, transfer_lamports_via_cpi,
+use crate::{
+    extensions::has_mint_extensions,
+    shared::{
+        convert_program_error, create_pda_account,
+        initialize_ctoken_account::{
+            initialize_ctoken_account, CTokenInitConfig, CompressionInstructionData,
+        },
+        transfer_lamports_via_cpi,
+    },
 };
 
 /// Validated accounts for the create token account instruction
@@ -26,7 +28,7 @@ pub struct CreateCTokenAccounts<'info> {
     /// The mint for the token account (only used for pubkey not checked)
     pub mint: &'info AccountInfo,
     /// Optional compressible configuration accounts
-    pub compressible: Option<CompressibleAccounts<'info>>,
+    pub compressible: CompressibleAccounts<'info>,
 }
 
 /// Accounts required when creating a compressible token account
@@ -45,47 +47,19 @@ impl<'info> CreateCTokenAccounts<'info> {
     /// Parse and validate accounts from the provided account infos
     #[profile]
     #[inline(always)]
-    pub fn parse(
-        account_infos: &'info [AccountInfo],
-        inputs: &CreateTokenAccountInstructionData,
-    ) -> Result<Self, ProgramError> {
+    pub fn new(account_infos: &'info [AccountInfo]) -> Result<Self, ProgramError> {
         let mut iter = AccountIterator::new(account_infos);
-
-        // Required accounts
-        // For compressible accounts: token_account must be signer (account created via CPI)
-        // For non-compressible accounts: token_account doesn't need to be signer (SPL compatibility - initialize_account3)
-        let token_account = if inputs.compressible_config.is_some() {
-            iter.next_signer_mut("token_account")?
-        } else {
-            iter.next_mut("token_account")?
-        };
-        let mint = iter.next_non_mut("mint")?;
-
-        // Parse optional compressible accounts
-        let compressible = if inputs.compressible_config.is_some() {
-            let payer = iter.next_signer_mut("payer")?;
-
-            let parsed_config = next_config_account(&mut iter)?;
-
-            let system_program = iter.next_non_mut("system program")?;
-            // Must be signer if custom rent payer.
-            // Rent sponsor is not signer.
-            let rent_payer = iter.next_mut("rent payer")?;
-
-            Some(CompressibleAccounts {
-                payer,
-                parsed_config,
-                system_program,
-                rent_payer,
-            })
-        } else {
-            None
-        };
-
         Ok(Self {
-            token_account,
-            mint,
-            compressible,
+            token_account: iter.next_signer_mut("token_account")?,
+            mint: iter.next_non_mut("mint")?,
+            compressible: CompressibleAccounts {
+                payer: iter.next_signer_mut("payer")?,
+                parsed_config: next_config_account(&mut iter)?,
+                system_program: iter.next_non_mut("system program")?,
+                // Must be signer if custom rent payer.
+                // Rent sponsor is not signer.
+                rent_payer: iter.next_mut("rent payer")?,
+            },
         })
     }
 }
@@ -131,112 +105,111 @@ pub fn process_create_token_account(
     account_infos: &[AccountInfo],
     mut instruction_data: &[u8],
 ) -> Result<(), ProgramError> {
-    let inputs = if instruction_data.len() == 32 {
-        // Backward compatibility with spl token program instruction data.
-        let mut instruction_data_array = [0u8; 32];
-        instruction_data_array.copy_from_slice(instruction_data);
-        CreateTokenAccountInstructionData {
-            owner: Pubkey::from(instruction_data_array),
-            compressible_config: None,
-        }
-    } else {
-        CreateTokenAccountInstructionData::deserialize(&mut instruction_data)
-            .map_err(ProgramError::from)?
-    };
+    let inputs = CreateTokenAccountInstructionData::deserialize(&mut instruction_data)
+        .map_err(ProgramError::from)?;
 
     // Parse and validate accounts
-    let accounts = CreateCTokenAccounts::parse(account_infos, &inputs)?;
-
-    // Create account via cpi
-    let (compressible_config_account, custom_rent_payer) = if let Some(compressible) =
-        accounts.compressible.as_ref()
-    {
-        let compressible_config = inputs
-            .compressible_config
-            .as_ref()
-            .ok_or(ProgramError::InvalidInstructionData)?;
-
-        // Validate that rent_payment is not exactly 1 epoch (footgun prevention)
-        if compressible_config.rent_payment == 1 {
-            msg!("Prefunding for exactly 1 epoch is not allowed. If the account is created near an epoch boundary, it could become immediately compressible. Use 0 or 2+ epochs.");
-            return Err(anchor_compressed_token::ErrorCode::OneEpochPrefundingNotAllowed.into());
-        }
-
-        if let Some(compress_to_pubkey) = compressible_config.compress_to_account_pubkey.as_ref() {
-            // Compress to pubkey specifies compression to account pubkey instead of the owner.
-            // This is useful for pda token accounts that rely on pubkey derivation but have a program wide
-            // authority pda as owner.
-            // To prevent compressing ctokens to owners that cannot sign, prevent misconfiguration,
-            // we check that the account is a pda and can be signer with known seeds.
-            compress_to_pubkey.check_seeds(accounts.token_account.key())?;
-        }
-
-        let config_account = &compressible.parsed_config;
-        let rent = compressible
-            .parsed_config
-            .rent_config
-            .get_rent_with_compression_cost(
-                COMPRESSIBLE_TOKEN_ACCOUNT_SIZE,
-                compressible_config.rent_payment as u64,
-            );
-        let account_size = COMPRESSIBLE_TOKEN_ACCOUNT_SIZE as usize;
-
-        let custom_rent_payer =
-            *compressible.rent_payer.key() != config_account.rent_sponsor.to_bytes();
-
-        // Prevents setting executable accounts as rent_sponsor
-        if custom_rent_payer && !compressible.rent_payer.is_signer() {
-            msg!("Custom rent payer must be a signer");
-            return Err(ProgramError::MissingRequiredSignature);
-        }
-
-        // Build fee_payer seeds (rent_sponsor PDA or None for custom keypair)
-        let version_bytes = config_account.version.to_le_bytes();
-        let bump_seed = [config_account.rent_sponsor_bump];
-        let rent_sponsor_seeds = [
-            Seed::from(b"rent_sponsor".as_ref()),
-            Seed::from(version_bytes.as_ref()),
-            Seed::from(bump_seed.as_ref()),
-        ];
-
-        // fee_payer_seeds: Some for rent_sponsor PDA, None for custom keypair
-        // new_account_seeds: None (token_account is always a keypair signer)
-        let fee_payer_seeds = if custom_rent_payer {
-            None
-        } else {
-            Some(rent_sponsor_seeds.as_slice())
-        };
-
-        // Create token account (handles DoS prevention internally)
-        create_pda_account(
-            compressible.rent_payer,
-            accounts.token_account,
-            account_size,
-            fee_payer_seeds,
-            None, // token_account is keypair signer
-            None, // no additional lamports here
-        )?;
-
-        // Payer transfers the additional rent (compression incentive)
-        transfer_lamports_via_cpi(rent, compressible.payer, accounts.token_account)
-            .map_err(convert_program_error)?;
+    let accounts = CreateCTokenAccounts::new(account_infos)?;
+
+    // Validate that rent_payment is not exactly 1 epoch (footgun prevention)
+    if inputs.rent_payment == 1 {
+        msg!("Prefunding for exactly 1 epoch is not allowed. If the account is created near an epoch boundary, it could become immediately compressible. Use 0 or 2+ epochs.");
+        return Err(anchor_compressed_token::ErrorCode::OneEpochPrefundingNotAllowed.into());
+    }
+
+    if let Some(compress_to_pubkey) = inputs.compressible_config.as_ref() {
+        // Compress to pubkey specifies compression to account pubkey instead of the owner.
+        // This is useful for pda token accounts that rely on pubkey derivation but have a program wide
+        // authority pda as owner.
+        // To prevent compressing ctokens to owners that cannot sign, prevent misconfiguration,
+        // we check that the account is a pda and can be signer with known seeds.
+        compress_to_pubkey.check_seeds(accounts.token_account.key())?;
+    }
+
+    // Check which extensions the mint has (single deserialization)
+    let mint_extensions = has_mint_extensions(accounts.mint)?;
+
+    // If restricted extensions exist, compression_only must be set
+    if mint_extensions.has_restricted_extensions() && inputs.compression_only == 0 {
+        msg!("Mint has restricted extensions - compression_only must be set");
+        return Err(anchor_compressed_token::ErrorCode::CompressionOnlyRequired.into());
+    }
 
-        if custom_rent_payer {
-            (Some(*config_account), Some(*compressible.rent_payer.key()))
-        } else {
-            (Some(*config_account), None)
-        }
+    // Calculate account size based on extensions
+    let account_size = mint_extensions.calculate_account_size()?;
+
+    let config_account = &accounts.compressible.parsed_config;
+    let rent = config_account
+        .rent_config
+        .get_rent_with_compression_cost(account_size, inputs.rent_payment as u64);
+    let account_size = account_size as usize;
+
+    let custom_rent_payer =
+        *accounts.compressible.rent_payer.key() != config_account.rent_sponsor.to_bytes();
+
+    // Prevents setting executable accounts as rent_sponsor
+    if custom_rent_payer && !accounts.compressible.rent_payer.is_signer() {
+        msg!("Custom rent payer must be a signer");
+        return Err(ProgramError::MissingRequiredSignature);
+    }
+
+    // Build fee_payer seeds (rent_sponsor PDA or None for custom keypair)
+    let version_bytes = config_account.version.to_le_bytes();
+    let bump_seed = [config_account.rent_sponsor_bump];
+    let rent_sponsor_seeds = [
+        Seed::from(b"rent_sponsor".as_ref()),
+        Seed::from(version_bytes.as_ref()),
+        Seed::from(bump_seed.as_ref()),
+    ];
+
+    // fee_payer_seeds: Some for rent_sponsor PDA, None for custom keypair
+    // new_account_seeds: None (token_account is always a keypair signer)
+    let fee_payer_seeds = if custom_rent_payer {
+        None
     } else {
-        (None, None)
+        Some(rent_sponsor_seeds.as_slice())
     };
 
+    // Custom rent payer pays both account creation and compression incentive
+    // Protocol rent sponsor only pays account creation, payer pays compression incentive
+    let additional_lamports = if custom_rent_payer { Some(rent) } else { None };
+
+    // Create token account (handles DoS prevention internally)
+    create_pda_account(
+        accounts.compressible.rent_payer,
+        accounts.token_account,
+        account_size,
+        fee_payer_seeds,
+        None, // token_account is keypair signer
+        additional_lamports,
+    )?;
+
+    // When using protocol rent sponsor, payer pays the compression incentive
+    if !custom_rent_payer {
+        transfer_lamports_via_cpi(rent, accounts.compressible.payer, accounts.token_account)
+            .map_err(convert_program_error)?;
+    }
+
     // Initialize the token account (assumes account already exists and is owned by our program)
     initialize_ctoken_account(
         accounts.token_account,
-        accounts.mint.key(),
-        &inputs.owner.to_bytes(),
-        inputs.compressible_config,
-        compressible_config_account,
-        custom_rent_payer,
+        CTokenInitConfig {
+            mint: accounts.mint.key(),
+            owner: &inputs.owner.to_bytes(),
+            compress_to_pubkey: inputs.compressible_config.as_ref(),
+            compression_ix_data: CompressionInstructionData {
+                compression_only: inputs.compression_only,
+                token_account_version: inputs.token_account_version,
+                write_top_up: inputs.write_top_up,
+            },
+            compressible_config_account: accounts.compressible.parsed_config,
+            custom_rent_payer: if custom_rent_payer {
+                Some(*accounts.compressible.rent_payer.key())
+            } else {
+                None
+            },
+            mint_extensions,
+            mint_account: accounts.mint,
+        },
     )
 }
diff --git a/programs/compressed-token/program/src/ctoken_approve_revoke.rs b/programs/compressed-token/program/src/ctoken_approve_revoke.rs
new file mode 100644
index 0000000000..0dcc6734d8
--- /dev/null
+++ b/programs/compressed-token/program/src/ctoken_approve_revoke.rs
@@ -0,0 +1,264 @@
+use anchor_lang::solana_program::{msg, program_error::ProgramError};
+use light_ctoken_interface::{state::CToken, CTokenError};
+use pinocchio::account_info::AccountInfo;
+use pinocchio_token_program::processor::{
+    approve::process_approve, revoke::process_revoke,
+    shared::approve::process_approve as shared_process_approve, unpack_amount_and_decimals,
+};
+
+use crate::{
+    shared::{
+        convert_program_error, owner_validation::check_token_program_owner,
+        transfer_lamports_via_cpi,
+    },
+    transfer2::compression::ctoken::process_compression_top_up,
+};
+
+/// Account indices for approve instruction
+const APPROVE_ACCOUNT_SOURCE: usize = 0;
+const APPROVE_ACCOUNT_OWNER: usize = 2; // owner is payer for top-up
+
+/// Account indices for approve_checked instruction (static 4-account layout)
+const APPROVE_CHECKED_ACCOUNT_SOURCE: usize = 0;
+const APPROVE_CHECKED_ACCOUNT_MINT: usize = 1;
+const APPROVE_CHECKED_ACCOUNT_DELEGATE: usize = 2;
+const APPROVE_CHECKED_ACCOUNT_OWNER: usize = 3;
+
+/// Account indices for revoke instruction
+const REVOKE_ACCOUNT_SOURCE: usize = 0;
+const REVOKE_ACCOUNT_OWNER: usize = 1; // owner is payer for top-up
+
+/// Process CToken approve instruction.
+/// Handles compressible extension top-up before delegating to pinocchio.
+///
+/// Instruction data format (backwards compatible):
+/// - 8 bytes: amount (legacy, no max_top_up enforcement)
+/// - 10 bytes: amount + max_top_up (u16, 0 = no limit)
+#[inline(always)]
+pub fn process_ctoken_approve(
+    accounts: &[AccountInfo],
+    instruction_data: &[u8],
+) -> Result<(), ProgramError> {
+    let source = accounts
+        .get(APPROVE_ACCOUNT_SOURCE)
+        .ok_or(ProgramError::NotEnoughAccountKeys)?;
+    let payer = accounts
+        .get(APPROVE_ACCOUNT_OWNER)
+        .ok_or(ProgramError::NotEnoughAccountKeys)?;
+
+    // Parse max_top_up based on instruction data length (0 = no limit)
+    let max_top_up = match instruction_data.len() {
+        8 => 0u16, // Legacy: no max_top_up
+        10 => u16::from_le_bytes(
+            instruction_data[8..10]
+                .try_into()
+                .map_err(|_| ProgramError::InvalidInstructionData)?,
+        ),
+        _ => return Err(ProgramError::InvalidInstructionData),
+    };
+
+    // Handle compressible top-up before pinocchio call
+    process_compressible_top_up(source, payer, max_top_up)?;
+
+    // Only pass the first 8 bytes (amount) to the SPL approve processor
+    process_approve(accounts, &instruction_data[..8]).map_err(convert_program_error)
+}
+
+/// Process CToken revoke instruction.
+/// Handles compressible extension top-up before delegating to pinocchio.
+///
+/// Instruction data format (backwards compatible):
+/// - 0 bytes: legacy, no max_top_up enforcement
+/// - 2 bytes: max_top_up (u16, 0 = no limit)
+#[inline(always)]
+pub fn process_ctoken_revoke(
+    accounts: &[AccountInfo],
+    instruction_data: &[u8],
+) -> Result<(), ProgramError> {
+    let source = accounts
+        .get(REVOKE_ACCOUNT_SOURCE)
+        .ok_or(ProgramError::NotEnoughAccountKeys)?;
+    let payer = accounts
+        .get(REVOKE_ACCOUNT_OWNER)
+        .ok_or(ProgramError::NotEnoughAccountKeys)?;
+
+    // Parse max_top_up based on instruction data length (0 = no limit)
+    let max_top_up = match instruction_data.len() {
+        0 => 0u16, // Legacy: no max_top_up
+        2 => u16::from_le_bytes(
+            instruction_data[0..2]
+                .try_into()
+                .map_err(|_| ProgramError::InvalidInstructionData)?,
+        ),
+        _ => return Err(ProgramError::InvalidInstructionData),
+    };
+
+    // Handle compressible top-up before pinocchio call
+    process_compressible_top_up(source, payer, max_top_up)?;
+
+    process_revoke(accounts).map_err(convert_program_error)
+}
+
+/// Calculate and transfer compressible top-up for a single account.
+///
+/// # Arguments
+/// * `max_top_up` - Maximum lamports for top-up. Transaction fails if exceeded. (0 = no limit)
+#[inline(always)]
+fn process_compressible_top_up(
+    account: &AccountInfo,
+    payer: &AccountInfo,
+    max_top_up: u16,
+) -> Result<(), ProgramError> {
+    // Borrow account data to get extensions
+    let mut account_data = account
+        .try_borrow_mut_data()
+        .map_err(convert_program_error)?;
+    let (ctoken, _) = CToken::zero_copy_at_mut_checked(&mut account_data)?;
+
+    let mut transfer_amount = 0u64;
+    let mut lamports_budget = if max_top_up == 0 {
+        u64::MAX
+    } else {
+        (max_top_up as u64).saturating_add(1)
+    };
+
+    process_compression_top_up(
+        &ctoken.base.compression,
+        account,
+        &mut 0,
+        &mut transfer_amount,
+        &mut lamports_budget,
+    )?;
+
+    // Drop borrow before CPI
+    drop(account_data);
+
+    if transfer_amount > 0 {
+        if lamports_budget == 0 {
+            return Err(CTokenError::MaxTopUpExceeded.into());
+        }
+        transfer_lamports_via_cpi(transfer_amount, payer, account)
+            .map_err(convert_program_error)?;
+    }
+
+    Ok(())
+}
+
+/// Process CToken approve_checked instruction.
+/// Static 4-account layout with cached decimals optimization.
+///
+/// Instruction data format:
+/// - 9 bytes: amount (8) + decimals (1) - legacy, no max_top_up enforcement
+/// - 11 bytes: amount (8) + decimals (1) + max_top_up (2, u16, 0 = no limit)
+///
+/// Account layout (always 4 accounts):
+/// 0: source CToken account (writable) - may have cached decimals
+/// 1: mint account (immutable) - used for validation if no cached decimals
+/// 2: delegate (immutable) - the delegate authority
+/// 3: owner (signer, writable) - owner of source, payer for top-ups
+#[inline(always)]
+pub fn process_ctoken_approve_checked(
+    accounts: &[AccountInfo],
+    instruction_data: &[u8],
+) -> Result<(), ProgramError> {
+    if accounts.len() < 4 {
+        msg!(
+            "CToken approve_checked: expected at least 4 accounts received {}",
+            accounts.len()
+        );
+        return Err(ProgramError::NotEnoughAccountKeys);
+    }
+
+    if instruction_data.len() < 9 {
+        return Err(ProgramError::InvalidInstructionData);
+    }
+
+    // Parse amount and decimals from instruction data
+    let (amount, decimals) =
+        unpack_amount_and_decimals(instruction_data).map_err(|e| ProgramError::Custom(e as u32))?;
+
+    // Parse max_top_up from bytes 9-10 if present (0 = no limit)
+    let max_top_up = match instruction_data.len() {
+        9 => 0u16, // Legacy: no max_top_up
+        11 => u16::from_le_bytes(
+            instruction_data[9..11]
+                .try_into()
+                .map_err(|_| ProgramError::InvalidInstructionData)?,
+        ),
+        _ => return Err(ProgramError::InvalidInstructionData),
+    };
+
+    let source = accounts
+        .get(APPROVE_CHECKED_ACCOUNT_SOURCE)
+        .ok_or(ProgramError::NotEnoughAccountKeys)?;
+    let mint = accounts
+        .get(APPROVE_CHECKED_ACCOUNT_MINT)
+        .ok_or(ProgramError::NotEnoughAccountKeys)?;
+    let delegate = accounts
+        .get(APPROVE_CHECKED_ACCOUNT_DELEGATE)
+        .ok_or(ProgramError::NotEnoughAccountKeys)?;
+    let owner = accounts
+        .get(APPROVE_CHECKED_ACCOUNT_OWNER)
+        .ok_or(ProgramError::NotEnoughAccountKeys)?;
+
+    // Borrow source account to check for cached decimals
+    let cached_decimals = {
+        let mut account_data = source
+            .try_borrow_mut_data()
+            .map_err(convert_program_error)?;
+        let (ctoken, _) = CToken::zero_copy_at_mut_checked(&mut account_data)?;
+
+        // Get cached decimals if present
+        let cached = ctoken.base.decimals();
+
+        // Also handle compressible top-up while we have the borrow
+        let mut transfer_amount = 0u64;
+        let mut lamports_budget = if max_top_up == 0 {
+            u64::MAX
+        } else {
+            (max_top_up as u64).saturating_add(1)
+        };
+
+        process_compression_top_up(
+            &ctoken.base.compression,
+            source,
+            &mut 0,
+            &mut transfer_amount,
+            &mut lamports_budget,
+        )?;
+
+        // Drop borrow before CPI
+        drop(account_data);
+
+        if transfer_amount > 0 {
+            if lamports_budget == 0 {
+                return Err(CTokenError::MaxTopUpExceeded.into());
+            }
+            transfer_lamports_via_cpi(transfer_amount, owner, source)
+                .map_err(convert_program_error)?;
+        }
+
+        cached
+    };
+
+    // Call pinocchio approve based on cached decimals presence
+    if let Some(cached_decimals) = cached_decimals {
+        // Validate cached decimals match instruction decimals
+        if cached_decimals != decimals {
+            msg!(
+                "CToken approve_checked: cached decimals {} != instruction decimals {}",
+                cached_decimals,
+                decimals
+            );
+            return Err(ProgramError::InvalidInstructionData);
+        }
+        // Create 3-account slice [source, delegate, owner] - skip mint
+        let approve_accounts = [*source, *delegate, *owner];
+        shared_process_approve(&approve_accounts, amount, None).map_err(convert_program_error)
+    } else {
+        // No cached decimals - validate via mint account
+        check_token_program_owner(mint)?;
+        // Use full 4-account layout [source, mint, delegate, owner]
+        shared_process_approve(accounts, amount, Some(decimals)).map_err(convert_program_error)
+    }
+}
diff --git a/programs/compressed-token/program/src/ctoken_burn.rs b/programs/compressed-token/program/src/ctoken_burn.rs
index e3251b15a2..0b6a25b113 100644
--- a/programs/compressed-token/program/src/ctoken_burn.rs
+++ b/programs/compressed-token/program/src/ctoken_burn.rs
@@ -1,7 +1,7 @@
 use anchor_lang::solana_program::{msg, program_error::ProgramError};
 use light_program_profiler::profile;
 use pinocchio::account_info::AccountInfo;
-use pinocchio_token_program::processor::burn::process_burn;
+use pinocchio_token_program::processor::{burn::process_burn, burn_checked::process_burn_checked};
 
 use crate::shared::compressible_top_up::calculate_and_execute_compressible_top_ups;
 
@@ -56,3 +56,55 @@ pub fn process_ctoken_burn(
 
     calculate_and_execute_compressible_top_ups(cmint, ctoken, payer, max_top_up)
 }
+
+/// Process ctoken burn_checked instruction
+///
+/// Instruction data format:
+/// - 9 bytes: amount (8) + decimals (1) - legacy, no max_top_up enforcement
+/// - 11 bytes: amount (8) + decimals (1) + max_top_up (2, u16, 0 = no limit)
+///
+/// Account layout (same as burn):
+/// 0: source CToken account (writable)
+/// 1: CMint account (writable)
+/// 2: authority (signer, also payer for top-ups)
+#[profile]
+#[inline(always)]
+pub fn process_ctoken_burn_checked(
+    accounts: &[AccountInfo],
+    instruction_data: &[u8],
+) -> Result<(), ProgramError> {
+    if accounts.len() < 3 {
+        msg!(
+            "CToken burn_checked: expected at least 3 accounts received {}",
+            accounts.len()
+        );
+        return Err(ProgramError::NotEnoughAccountKeys);
+    }
+
+    if instruction_data.len() < 9 {
+        return Err(ProgramError::InvalidInstructionData);
+    }
+
+    // Parse max_top_up from bytes 9-10 if present
+    let max_top_up = match instruction_data.len() {
+        9 => 0u16, // Legacy: no max_top_up
+        11 => u16::from_le_bytes(
+            instruction_data[9..11]
+                .try_into()
+                .map_err(|_| ProgramError::InvalidInstructionData)?,
+        ),
+        _ => return Err(ProgramError::InvalidInstructionData),
+    };
+
+    // Call pinocchio burn_checked - validates decimals against CMint, handles balance/supply updates
+    process_burn_checked(accounts, &instruction_data[..9])
+        .map_err(|e| ProgramError::Custom(u64::from(e) as u32))?;
+
+    // Calculate and execute top-ups for both CMint and CToken
+    // burn account order: [ctoken, cmint, authority] - reverse of mint_to
+    let ctoken = accounts.first().ok_or(ProgramError::NotEnoughAccountKeys)?;
+    let cmint = accounts.get(1).ok_or(ProgramError::NotEnoughAccountKeys)?;
+    let payer = accounts.get(2).ok_or(ProgramError::NotEnoughAccountKeys)?;
+
+    calculate_and_execute_compressible_top_ups(cmint, ctoken, payer, max_top_up)
+}
diff --git a/programs/compressed-token/program/src/ctoken_freeze_thaw.rs b/programs/compressed-token/program/src/ctoken_freeze_thaw.rs
new file mode 100644
index 0000000000..e9fd15ee71
--- /dev/null
+++ b/programs/compressed-token/program/src/ctoken_freeze_thaw.rs
@@ -0,0 +1,27 @@
+use anchor_lang::solana_program::program_error::ProgramError;
+use pinocchio::account_info::AccountInfo;
+use pinocchio_token_program::processor::{
+    freeze_account::process_freeze_account, thaw_account::process_thaw_account,
+};
+
+use crate::shared::owner_validation::check_token_program_owner;
+
+/// Process CToken freeze account instruction.
+/// Validates mint ownership before calling pinocchio-token-program.
+#[inline(always)]
+pub fn process_ctoken_freeze_account(accounts: &[AccountInfo]) -> Result<(), ProgramError> {
+    // accounts[1] is the mint
+    let mint_info = accounts.get(1).ok_or(ProgramError::NotEnoughAccountKeys)?;
+    check_token_program_owner(mint_info)?;
+    process_freeze_account(accounts).map_err(|e| ProgramError::Custom(u64::from(e) as u32))
+}
+
+/// Process CToken thaw account instruction.
+/// Validates mint ownership before calling pinocchio-token-program.
+#[inline(always)]
+pub fn process_ctoken_thaw_account(accounts: &[AccountInfo]) -> Result<(), ProgramError> {
+    // accounts[1] is the mint
+    let mint_info = accounts.get(1).ok_or(ProgramError::NotEnoughAccountKeys)?;
+    check_token_program_owner(mint_info)?;
+    process_thaw_account(accounts).map_err(|e| ProgramError::Custom(u64::from(e) as u32))
+}
diff --git a/programs/compressed-token/program/src/ctoken_mint_to.rs b/programs/compressed-token/program/src/ctoken_mint_to.rs
index 453bf0e9b6..215525987e 100644
--- a/programs/compressed-token/program/src/ctoken_mint_to.rs
+++ b/programs/compressed-token/program/src/ctoken_mint_to.rs
@@ -1,7 +1,9 @@
 use anchor_lang::solana_program::{msg, program_error::ProgramError};
 use light_program_profiler::profile;
 use pinocchio::account_info::AccountInfo;
-use pinocchio_token_program::processor::mint_to::process_mint_to;
+use pinocchio_token_program::processor::{
+    mint_to::process_mint_to, mint_to_checked::process_mint_to_checked,
+};
 
 use crate::shared::compressible_top_up::calculate_and_execute_compressible_top_ups;
 
@@ -56,3 +58,55 @@ pub fn process_ctoken_mint_to(
 
     calculate_and_execute_compressible_top_ups(cmint, ctoken, payer, max_top_up)
 }
+
+/// Process ctoken mint_to_checked instruction
+///
+/// Instruction data format:
+/// - 9 bytes: amount (8) + decimals (1) - legacy, no max_top_up enforcement
+/// - 11 bytes: amount (8) + decimals (1) + max_top_up (2, u16, 0 = no limit)
+///
+/// Account layout (same as mint_to):
+/// 0: CMint account (writable)
+/// 1: destination CToken account (writable)
+/// 2: authority (signer, also payer for top-ups)
+#[profile]
+#[inline(always)]
+pub fn process_ctoken_mint_to_checked(
+    accounts: &[AccountInfo],
+    instruction_data: &[u8],
+) -> Result<(), ProgramError> {
+    if accounts.len() < 3 {
+        msg!(
+            "CToken mint_to_checked: expected at least 3 accounts received {}",
+            accounts.len()
+        );
+        return Err(ProgramError::NotEnoughAccountKeys);
+    }
+
+    if instruction_data.len() < 9 {
+        return Err(ProgramError::InvalidInstructionData);
+    }
+
+    // Parse max_top_up from bytes 9-10 if present
+    let max_top_up = match instruction_data.len() {
+        9 => 0u16, // Legacy: no max_top_up
+        11 => u16::from_le_bytes(
+            instruction_data[9..11]
+                .try_into()
+                .map_err(|_| ProgramError::InvalidInstructionData)?,
+        ),
+        _ => return Err(ProgramError::InvalidInstructionData),
+    };
+
+    // Call pinocchio mint_to_checked - validates decimals against CMint, handles supply/balance updates
+    process_mint_to_checked(accounts, &instruction_data[..9])
+        .map_err(|e| ProgramError::Custom(u64::from(e) as u32))?;
+
+    // Calculate and execute top-ups for both CMint and CToken
+    // mint_to account order: [cmint, ctoken, authority]
+    let cmint = accounts.first().ok_or(ProgramError::NotEnoughAccountKeys)?;
+    let ctoken = accounts.get(1).ok_or(ProgramError::NotEnoughAccountKeys)?;
+    let payer = accounts.get(2).ok_or(ProgramError::NotEnoughAccountKeys)?;
+
+    calculate_and_execute_compressible_top_ups(cmint, ctoken, payer, max_top_up)
+}
diff --git a/programs/compressed-token/program/src/ctoken_transfer.rs b/programs/compressed-token/program/src/ctoken_transfer.rs
deleted file mode 100644
index 3a12629eb0..0000000000
--- a/programs/compressed-token/program/src/ctoken_transfer.rs
+++ /dev/null
@@ -1,139 +0,0 @@
-use anchor_lang::solana_program::{msg, program_error::ProgramError};
-use light_ctoken_interface::{
-    state::{CToken, ZExtensionStruct},
-    CTokenError,
-};
-use light_program_profiler::profile;
-use pinocchio::account_info::AccountInfo;
-use pinocchio_token_program::processor::transfer::process_transfer;
-
-use crate::shared::{
-    convert_program_error,
-    transfer_lamports::{multi_transfer_lamports, Transfer},
-};
-
-/// Process ctoken transfer instruction
-///
-/// Instruction data format (backwards compatible):
-/// - 8 bytes: amount (legacy, no max_top_up enforcement)
-/// - 10 bytes: amount + max_top_up (u16, 0 = no limit)
-#[profile]
-#[inline(always)]
-pub fn process_ctoken_transfer(
-    accounts: &[AccountInfo],
-    instruction_data: &[u8],
-) -> Result<(), ProgramError> {
-    if accounts.len() < 3 {
-        msg!(
-            "CToken transfer: expected at least 3 accounts received {}",
-            accounts.len()
-        );
-        return Err(ProgramError::NotEnoughAccountKeys);
-    }
-
-    // Validate minimum instruction data length
-    if instruction_data.len() < 8 {
-        return Err(ProgramError::InvalidInstructionData);
-    }
-
-    // Parse max_top_up based on instruction data length
-    // 0 means no limit
-    let max_top_up = match instruction_data.len() {
-        8 => 0u16, // Legacy: no max_top_up
-        10 => u16::from_le_bytes(
-            instruction_data[8..10]
-                .try_into()
-                .map_err(|_| ProgramError::InvalidInstructionData)?,
-        ),
-        _ => return Err(ProgramError::InvalidInstructionData),
-    };
-
-    // Only pass the first 8 bytes (amount) to the SPL transfer processor
-    process_transfer(accounts, &instruction_data[..8], false)
-        .map_err(|e| ProgramError::Custom(u64::from(e) as u32))?;
-    calculate_and_execute_top_up_transfers(accounts, max_top_up)
-}
-
-/// Calculate and execute top-up transfers for compressible accounts
-///
-/// # Arguments
-/// * `accounts` - The account infos (source, dest, authority/payer)
-/// * `max_top_up` - Maximum lamports for rent and top-up combined. Transaction fails if exceeded. (0 = no limit)
-#[inline(always)]
-#[profile]
-fn calculate_and_execute_top_up_transfers(
-    accounts: &[pinocchio::account_info::AccountInfo],
-    max_top_up: u16,
-) -> Result<(), ProgramError> {
-    // Initialize transfers array with account references, amounts will be updated
-    let account0 = accounts.first().ok_or(ProgramError::NotEnoughAccountKeys)?;
-    let account1 = accounts.get(1).ok_or(ProgramError::NotEnoughAccountKeys)?;
-    let mut transfers = [
-        Transfer {
-            account: account0,
-            amount: 0,
-        },
-        Transfer {
-            account: account1,
-            amount: 0,
-        },
-    ];
-    let mut current_slot = 0;
-    // Initialize budget: +1 allows exact match (total == max_top_up)
-    let mut lamports_budget = (max_top_up as u64).saturating_add(1);
-
-    // Calculate transfer amounts for accounts with compressible extensions
-    for transfer in transfers.iter_mut() {
-        if transfer.account.data_len() > light_ctoken_interface::BASE_TOKEN_ACCOUNT_SIZE as usize {
-            let account_data = transfer
-                .account
-                .try_borrow_data()
-                .map_err(convert_program_error)?;
-            let (token, _) = CToken::zero_copy_at_checked(&account_data)?;
-            if let Some(extensions) = token.extensions.as_ref() {
-                for extension in extensions.iter() {
-                    if let ZExtensionStruct::Compressible(compressible_extension) = extension {
-                        if current_slot == 0 {
-                            use pinocchio::sysvars::{clock::Clock, Sysvar};
-                            current_slot = Clock::get()
-                                .map_err(|_| CTokenError::SysvarAccessError)?
-                                .slot;
-                        }
-
-                        transfer.amount = compressible_extension
-                            .info
-                            .calculate_top_up_lamports(
-                                transfer.account.data_len() as u64,
-                                current_slot,
-                                transfer.account.lamports(),
-                                light_ctoken_interface::COMPRESSIBLE_TOKEN_RENT_EXEMPTION,
-                            )
-                            .map_err(|_| CTokenError::InvalidAccountData)?;
-
-                        lamports_budget = lamports_budget.saturating_sub(transfer.amount);
-                    }
-                }
-            } else {
-                // Only Compressible extensions are implemented for ctoken accounts.
-                return Err(CTokenError::InvalidAccountData.into());
-            }
-        }
-    }
-    // Exit early in case none of the accounts is compressible.
-    if current_slot == 0 {
-        return Ok(());
-    }
-
-    if transfers[0].amount == 0 && transfers[1].amount == 0 {
-        return Ok(());
-    }
-
-    // Check budget wasn't exhausted (0 means exceeded max_top_up)
-    if max_top_up != 0 && lamports_budget == 0 {
-        return Err(CTokenError::MaxTopUpExceeded.into());
-    }
-
-    let payer = accounts.get(2).ok_or(ProgramError::NotEnoughAccountKeys)?;
-    multi_transfer_lamports(payer, &transfers).map_err(convert_program_error)?;
-    Ok(())
-}
diff --git a/programs/compressed-token/program/src/extensions/check_mint_extensions.rs b/programs/compressed-token/program/src/extensions/check_mint_extensions.rs
new file mode 100644
index 0000000000..15c2e6cd24
--- /dev/null
+++ b/programs/compressed-token/program/src/extensions/check_mint_extensions.rs
@@ -0,0 +1,230 @@
+use anchor_compressed_token::ErrorCode;
+use anchor_lang::prelude::ProgramError;
+use light_account_checks::AccountInfoTrait;
+use light_ctoken_interface::{
+    is_restricted_extension, MintExtensionFlags, ALLOWED_EXTENSION_TYPES,
+};
+use pinocchio::{account_info::AccountInfo, msg, pubkey::Pubkey};
+use spl_token_2022::{
+    extension::{
+        default_account_state::DefaultAccountState, pausable::PausableConfig,
+        permanent_delegate::PermanentDelegate, transfer_fee::TransferFeeConfig,
+        transfer_hook::TransferHook, BaseStateWithExtensions, ExtensionType,
+        PodStateWithExtensions,
+    },
+    pod::PodMint,
+    state::AccountState,
+};
+
+const SPL_TOKEN_2022_ID: [u8; 32] = spl_token_2022::ID.to_bytes();
+
+/// Result of checking mint extensions (runtime validation)
+#[derive(Debug, Clone, PartialEq, Eq, Default)]
+pub struct MintExtensionChecks {
+    /// The permanent delegate pubkey if the mint has the PermanentDelegate extension and it's set
+    pub permanent_delegate: Option<Pubkey>,
+    /// Whether the mint has the TransferFeeConfig extension (non-zero fees are rejected)
+    pub has_transfer_fee: bool,
+    /// Whether the mint has restricted extensions (Pausable, PermanentDelegate, TransferFee, TransferHook, DefaultAccountState)
+    /// Used to require CompressedOnly output when compressing tokens from restricted mints
+    pub has_restricted_extensions: bool,
+    /// Whether the mint is paused (PausableConfig.paused == true)
+    /// CompressAndClose bypasses this check
+    pub is_paused: bool,
+    /// Whether the mint has non-zero transfer fees
+    /// CompressAndClose bypasses this check
+    pub has_non_zero_transfer_fee: bool,
+    /// Whether the mint has a non-nil transfer hook program_id
+    /// CompressAndClose bypasses this check
+    pub has_non_nil_transfer_hook: bool,
+}
+
+/// Parse mint extensions in a single pass with zero-copy deserialization.
+/// This function deserializes the mint once and extracts extension information.
+/// It does NOT throw errors for invalid extension states (paused, non-zero fees, non-nil hook).
+/// Use `check_mint_extensions` wrapper to enforce state validation.
+///
+/// # Arguments
+/// * `mint_account` - The SPL Token 2022 mint account to check
+///
+/// # Returns
+/// * `Ok(MintExtensionChecks)` - Extension check results including `has_invalid_extension_state`
+/// * `Err(ProgramError)` - If there's an error parsing the mint account
+pub fn parse_mint_extensions(
+    mint_account: &AccountInfo,
+) -> Result<MintExtensionChecks, ProgramError> {
+    // Only Token-2022 mints can have extensions
+    if !mint_account.is_owned_by(&SPL_TOKEN_2022_ID) {
+        return Ok(MintExtensionChecks::default());
+    }
+
+    let mint_data = AccountInfoTrait::try_borrow_data(mint_account)?;
+
+    // Zero-copy parse mint with extensions using PodStateWithExtensions
+    let mint_state = PodStateWithExtensions::<PodMint>::unpack(&mint_data)?;
+
+    // Always compute has_restricted_extensions (needed for CompressAndClose validation)
+    let extension_types = mint_state.get_extension_types()?;
+    let has_restricted_extensions = extension_types.iter().any(is_restricted_extension);
+
+    // Check pausable extension
+    let is_paused = mint_state
+        .get_extension::<PausableConfig>()
+        .map(|pausable_config| bool::from(pausable_config.paused))
+        .unwrap_or(false);
+
+    // Check permanent delegate extension
+    let permanent_delegate =
+        if let Ok(permanent_delegate_ext) = mint_state.get_extension::<PermanentDelegate>() {
+            // Convert OptionalNonZeroPubkey to Option<Pubkey>
+            Option::<solana_pubkey::Pubkey>::from(permanent_delegate_ext.delegate)
+                .map(|delegate| Pubkey::from(delegate.to_bytes()))
+        } else {
+            None
+        };
+
+    // Check transfer fee extension
+    let (has_transfer_fee, has_non_zero_transfer_fee) =
+        if let Ok(transfer_fee_config) = mint_state.get_extension::<TransferFeeConfig>() {
+            // Check both older and newer fee configs for non-zero values
+            let older_fee = &transfer_fee_config.older_transfer_fee;
+            let newer_fee = &transfer_fee_config.newer_transfer_fee;
+            let has_non_zero = u16::from(older_fee.transfer_fee_basis_points) != 0
+                || u64::from(older_fee.maximum_fee) != 0
+                || u16::from(newer_fee.transfer_fee_basis_points) != 0
+                || u64::from(newer_fee.maximum_fee) != 0;
+            (true, has_non_zero)
+        } else {
+            (false, false)
+        };
+
+    // Check transfer hook extension - only nil program_id supported
+    let has_non_nil_transfer_hook = mint_state
+        .get_extension::<TransferHook>()
+        .map(|transfer_hook| {
+            Option::<solana_pubkey::Pubkey>::from(transfer_hook.program_id).is_some()
+        })
+        .unwrap_or(false);
+
+    Ok(MintExtensionChecks {
+        permanent_delegate,
+        has_transfer_fee,
+        has_restricted_extensions,
+        is_paused,
+        has_non_zero_transfer_fee,
+        has_non_nil_transfer_hook,
+    })
+}
+
+/// Check mint extensions and enforce state validation.
+/// Wrapper around `parse_mint_extensions` that throws errors for invalid states.
+///
+/// # Arguments
+/// * `mint_account` - The SPL Token 2022 mint account to check
+/// * `deny_restricted_extensions` - If true, fail if mint has restricted extensions
+///
+/// # Returns
+/// * `Ok(MintExtensionChecks)` - Extension check results
+/// * `Err(ErrorCode::MintPaused)` - If the mint is paused
+/// * `Err(ErrorCode::NonZeroTransferFeeNotSupported)` - If transfer fees are non-zero
+/// * `Err(ErrorCode::TransferHookNotSupported)` - If transfer hook program_id is non-nil
+/// * `Err(ErrorCode::MintHasRestrictedExtensions)` - If deny_restricted_extensions and has restricted
+/// * `Err(ProgramError)` - If there's an error parsing the mint account
+#[inline(always)]
+pub fn check_mint_extensions(
+    mint_account: &AccountInfo,
+    deny_restricted_extensions: bool,
+) -> Result<MintExtensionChecks, ProgramError> {
+    let checks = parse_mint_extensions(mint_account)?;
+
+    // When there are output compressed accounts, mint must not contain restricted extensions.
+    // Restricted extensions require compression_only mode (no compressed outputs).
+    if deny_restricted_extensions && checks.has_restricted_extensions {
+        msg!("Mint has restricted extensions - compression_only mode required");
+        return Err(ErrorCode::MintHasRestrictedExtensions.into());
+    }
+
+    // Check for invalid extension states - throw specific errors for each
+    if checks.is_paused {
+        return Err(ErrorCode::MintPaused.into());
+    }
+    if checks.has_non_zero_transfer_fee {
+        return Err(ErrorCode::NonZeroTransferFeeNotSupported.into());
+    }
+    if checks.has_non_nil_transfer_hook {
+        return Err(ErrorCode::TransferHookNotSupported.into());
+    }
+
+    Ok(checks)
+}
+
+/// Hash which extensions a mint has in a single zero-copy deserialization.
+/// This function is used during account creation to determine which marker extensions
+/// should be added to the ctoken account.
+///
+/// Note: This function only checks which extensions exist, not their values.
+/// For runtime validation (checking if paused, getting delegate pubkey), use `check_mint_extensions` instead.
+///
+/// # Arguments
+/// * `mint_account` - The SPL Token 2022 mint account to check
+///
+/// # Returns
+/// * `Ok(MintExtensionFlags)` - Flags indicating which extensions the mint has
+/// * `Err(ProgramError)` - If there's an error parsing the mint account
+#[inline(always)]
+pub fn has_mint_extensions(mint_account: &AccountInfo) -> Result<MintExtensionFlags, ProgramError> {
+    // Only Token-2022 mints can have extensions
+    if !mint_account.is_owned_by(&SPL_TOKEN_2022_ID) {
+        return Ok(MintExtensionFlags::default());
+    }
+
+    let mint_data = AccountInfoTrait::try_borrow_data(mint_account)?;
+
+    // Zero-copy parse mint with extensions using PodStateWithExtensions
+    let mint_state = PodStateWithExtensions::<PodMint>::unpack(&mint_data)?;
+
+    // Get all extension types in a single call
+    let extension_types = mint_state.get_extension_types()?;
+
+    // Check for unsupported extensions and collect flags in a single pass
+    let mut has_pausable = false;
+    let mut has_permanent_delegate = false;
+    let mut has_transfer_fee = false;
+    let mut has_transfer_hook = false;
+    let mut has_default_account_state = false;
+
+    for ext in &extension_types {
+        if !ALLOWED_EXTENSION_TYPES.contains(ext) {
+            msg!("Unsupported mint extension: {:?}", ext);
+            return Err(ErrorCode::MintWithInvalidExtension.into());
+        }
+        match ext {
+            ExtensionType::Pausable => has_pausable = true,
+            ExtensionType::PermanentDelegate => has_permanent_delegate = true,
+            ExtensionType::TransferFeeConfig => has_transfer_fee = true,
+            ExtensionType::TransferHook => has_transfer_hook = true,
+            ExtensionType::DefaultAccountState => has_default_account_state = true,
+            _ => {}
+        }
+    }
+
+    // Check if DefaultAccountState is set to Frozen
+    // AccountState::Frozen as u8 = 2, ext.state is PodAccountState (u8)
+    let default_account_state_frozen = if has_default_account_state {
+        mint_state
+            .get_extension::<DefaultAccountState>()
+            .map(|ext| ext.state == AccountState::Frozen as u8)
+            .unwrap_or(false)
+    } else {
+        false
+    };
+
+    Ok(MintExtensionFlags {
+        has_pausable,
+        has_permanent_delegate,
+        has_default_account_state,
+        default_state_frozen: default_account_state_frozen,
+        has_transfer_fee,
+        has_transfer_hook,
+    })
+}
diff --git a/programs/compressed-token/program/src/extensions/mod.rs b/programs/compressed-token/program/src/extensions/mod.rs
index 487222df77..c6cdcd6c3b 100644
--- a/programs/compressed-token/program/src/extensions/mod.rs
+++ b/programs/compressed-token/program/src/extensions/mod.rs
@@ -1,6 +1,11 @@
+pub mod check_mint_extensions;
 pub mod processor;
 pub mod token_metadata;
 
+// Re-export extension checking functions
+pub use check_mint_extensions::{
+    check_mint_extensions, has_mint_extensions, parse_mint_extensions, MintExtensionChecks,
+};
 // Import from ctoken-types instead of local modules
 use light_ctoken_interface::{
     instructions::mint_action::ZAction,
@@ -10,6 +15,11 @@ use light_ctoken_interface::{
     },
     CTokenError,
 };
+// Re-export from ctoken-interface (consolidated types)
+pub use light_ctoken_interface::{
+    is_restricted_extension, MintExtensionFlags, ALLOWED_EXTENSION_TYPES,
+    RESTRICTED_EXTENSION_TYPES,
+};
 use light_program_profiler::profile;
 use light_zero_copy::ZeroCopyNew;
 use spl_pod::solana_msg::msg;
diff --git a/programs/compressed-token/program/src/lib.rs b/programs/compressed-token/program/src/lib.rs
index fc0950fc0e..c891bd74c1 100644
--- a/programs/compressed-token/program/src/lib.rs
+++ b/programs/compressed-token/program/src/lib.rs
@@ -10,12 +10,14 @@ pub mod close_token_account;
 pub mod convert_account_infos;
 pub mod create_associated_token_account;
 pub mod create_token_account;
+pub mod ctoken_approve_revoke;
 pub mod ctoken_burn;
+pub mod ctoken_freeze_thaw;
 pub mod ctoken_mint_to;
-pub mod ctoken_transfer;
 pub mod extensions;
 pub mod mint_action;
 pub mod shared;
+pub mod transfer;
 pub mod transfer2;
 pub mod withdraw_funding_pool;
 
@@ -27,13 +29,17 @@ use create_associated_token_account::{
     process_create_associated_token_account, process_create_associated_token_account_idempotent,
 };
 use create_token_account::process_create_token_account;
-use ctoken_mint_to::process_ctoken_mint_to;
-use ctoken_transfer::process_ctoken_transfer;
+use ctoken_approve_revoke::{
+    process_ctoken_approve, process_ctoken_approve_checked, process_ctoken_revoke,
+};
+use ctoken_burn::{process_ctoken_burn, process_ctoken_burn_checked};
+use ctoken_freeze_thaw::{process_ctoken_freeze_account, process_ctoken_thaw_account};
+use ctoken_mint_to::{process_ctoken_mint_to, process_ctoken_mint_to_checked};
+use transfer::{process_ctoken_transfer, process_ctoken_transfer_checked};
 use withdraw_funding_pool::process_withdraw_funding_pool;
 
 use crate::{
-    convert_account_infos::convert_account_infos, ctoken_burn::process_ctoken_burn,
-    mint_action::processor::process_mint_action,
+    convert_account_infos::convert_account_infos, mint_action::processor::process_mint_action,
 };
 
 pub const LIGHT_CPI_SIGNER: CpiSigner =
@@ -48,12 +54,28 @@ pub(crate) const MAX_PACKED_ACCOUNTS: usize = 40;
 pub enum InstructionType {
     /// CToken transfer
     CTokenTransfer = 3,
+    /// CToken Approve
+    CTokenApprove = 4,
+    /// CToken Revoke
+    CTokenRevoke = 5,
+    /// CToken TransferChecked - transfer with decimals validation
+    CTokenTransferChecked = 6,
     /// CToken mint_to - mint from decompressed CMint to CToken with top-ups
     CTokenMintTo = 7,
     /// CToken burn - burn from CToken, update CMint supply, with top-ups
     CTokenBurn = 8,
     /// CToken CloseAccount
     CloseTokenAccount = 9,
+    /// CToken FreezeAccount
+    CTokenFreezeAccount = 10,
+    /// CToken ThawAccount
+    CTokenThawAccount = 11,
+    /// CToken ApproveChecked - approve with decimals validation
+    CTokenApproveChecked = 12,
+    /// CToken MintToChecked - mint with decimals validation
+    CTokenMintToChecked = 14,
+    /// CToken BurnChecked - burn with decimals validation
+    CTokenBurnChecked = 15,
     /// Create CToken, equivalent to SPL Token InitializeAccount3
     CreateTokenAccount = 18,
     CreateAssociatedCTokenAccount = 100,
@@ -87,9 +109,17 @@ impl From<u8> for InstructionType {
     fn from(value: u8) -> Self {
         match value {
             3 => InstructionType::CTokenTransfer,
+            4 => InstructionType::CTokenApprove,
+            5 => InstructionType::CTokenRevoke,
+            6 => InstructionType::CTokenTransferChecked,
             7 => InstructionType::CTokenMintTo,
             8 => InstructionType::CTokenBurn,
             9 => InstructionType::CloseTokenAccount,
+            10 => InstructionType::CTokenFreezeAccount,
+            11 => InstructionType::CTokenThawAccount,
+            12 => InstructionType::CTokenApproveChecked,
+            14 => InstructionType::CTokenMintToChecked,
+            15 => InstructionType::CTokenBurnChecked,
             18 => InstructionType::CreateTokenAccount,
             100 => InstructionType::CreateAssociatedCTokenAccount,
             101 => InstructionType::Transfer2,
@@ -124,6 +154,18 @@ pub fn process_instruction(
             // msg!("CTokenTransfer");
             process_ctoken_transfer(accounts, &instruction_data[1..])?;
         }
+        InstructionType::CTokenApprove => {
+            msg!("CTokenApprove");
+            process_ctoken_approve(accounts, &instruction_data[1..])?;
+        }
+        InstructionType::CTokenRevoke => {
+            msg!("CTokenRevoke");
+            process_ctoken_revoke(accounts, &instruction_data[1..])?;
+        }
+        InstructionType::CTokenTransferChecked => {
+            msg!("CTokenTransferChecked");
+            process_ctoken_transfer_checked(accounts, &instruction_data[1..])?;
+        }
         InstructionType::CTokenMintTo => {
             msg!("CTokenMintTo");
             process_ctoken_mint_to(accounts, &instruction_data[1..])?;
@@ -132,10 +174,30 @@ pub fn process_instruction(
             msg!("CTokenBurn");
             process_ctoken_burn(accounts, &instruction_data[1..])?;
         }
+        InstructionType::CTokenApproveChecked => {
+            msg!("CTokenApproveChecked");
+            process_ctoken_approve_checked(accounts, &instruction_data[1..])?;
+        }
+        InstructionType::CTokenMintToChecked => {
+            msg!("CTokenMintToChecked");
+            process_ctoken_mint_to_checked(accounts, &instruction_data[1..])?;
+        }
+        InstructionType::CTokenBurnChecked => {
+            msg!("CTokenBurnChecked");
+            process_ctoken_burn_checked(accounts, &instruction_data[1..])?;
+        }
         InstructionType::CloseTokenAccount => {
             msg!("CloseTokenAccount");
             process_close_token_account(accounts, &instruction_data[1..])?;
         }
+        InstructionType::CTokenFreezeAccount => {
+            msg!("CTokenFreezeAccount");
+            process_ctoken_freeze_account(accounts)?;
+        }
+        InstructionType::CTokenThawAccount => {
+            msg!("CTokenThawAccount");
+            process_ctoken_thaw_account(accounts)?;
+        }
         InstructionType::CreateTokenAccount => {
             msg!("CreateTokenAccount");
             process_create_token_account(accounts, &instruction_data[1..])?;
diff --git a/programs/compressed-token/program/src/mint_action/actions/compress_and_close_cmint.rs b/programs/compressed-token/program/src/mint_action/actions/compress_and_close_cmint.rs
index 9d198c4d2e..4434953a1c 100644
--- a/programs/compressed-token/program/src/mint_action/actions/compress_and_close_cmint.rs
+++ b/programs/compressed-token/program/src/mint_action/actions/compress_and_close_cmint.rs
@@ -1,12 +1,13 @@
 use anchor_compressed_token::ErrorCode;
 use anchor_lang::prelude::ProgramError;
 use light_ctoken_interface::{
-    instructions::mint_action::ZCompressAndCloseCMintAction,
-    state::{CompressedMint, ExtensionStruct},
+    instructions::mint_action::ZCompressAndCloseCMintAction, state::CompressedMint,
 };
 use light_program_profiler::profile;
-#[cfg(target_os = "solana")]
-use pinocchio::sysvars::{clock::Clock, Sysvar};
+use pinocchio::{
+    pubkey::pubkey_eq,
+    sysvars::{clock::Clock, Sysvar},
+};
 use spl_pod::solana_msg::msg;
 
 use crate::{
@@ -21,12 +22,12 @@ use crate::{
 /// 1. **Idempotent Check**: If idempotent flag is set and CMint doesn't exist, succeed silently
 /// 2. **State Validation**: Ensure CMint exists (cmint_decompressed = true)
 /// 3. **CMint Verification**: Verify CMint account matches compressed_mint.metadata.mint
-/// 4. **Extension Validation**: Ensure CMint has Compressible extension
-/// 5. **Compressibility Check**: Verify is_compressible() returns true
+/// 4. **Rent Sponsor Validation**: Verify rent_sponsor matches compression info
+/// 5. **Compressibility Check**: Verify is_compressible() returns true (rent expired)
 /// 6. **Lamport Distribution**: ALL lamports -> rent_sponsor
 /// 7. **Account Closure**: Assign to system program, resize to 0
 /// 8. **Flag Update**: Set cmint_decompressed = false
-/// 9. **Remove Compressible Extension**: Remove from compressed mint extensions
+/// 9. **Clear Compression Info**: Zero out embedded compression info
 ///
 /// ## Note
 /// CompressAndCloseCMint is **permissionless** - anyone can compress and close a CMint
@@ -37,9 +38,11 @@ pub fn process_compress_and_close_cmint_action(
     compressed_mint: &mut CompressedMint,
     validated_accounts: &MintActionAccounts,
 ) -> Result<(), ProgramError> {
-    // 1. Check idempotent flag - if CMint doesn't exist and idempotent is set, succeed silently
-    if action.idempotent != 0 && !compressed_mint.metadata.cmint_decompressed {
-        // CMint doesn't exist, but idempotent flag is set - succeed silently
+    // NOTE: CompressAndCloseCMint is permissionless - anyone can compress if is_compressible() returns true
+    // All lamports returned to rent_sponsor
+
+    // 1. Idempotent check - if CMint doesn't exist and idempotent is set, succeed silently
+    if action.is_idempotent() && !compressed_mint.metadata.cmint_decompressed {
         return Ok(());
     }
 
@@ -63,87 +66,56 @@ pub fn process_compress_and_close_cmint_action(
         .ok_or(ErrorCode::MissingRentSponsor)?;
 
     // 3. Verify CMint account matches compressed_mint.metadata.mint
-    if cmint.key() != &compressed_mint.metadata.mint.to_bytes() {
+    if !pubkey_eq(cmint.key(), &compressed_mint.metadata.mint.to_bytes()) {
         msg!("CMint account does not match compressed_mint.metadata.mint");
         return Err(ErrorCode::InvalidCMintAccount.into());
     }
 
-    // 4. Get Compressible extension (required)
-    let compression_info = compressed_mint
-        .extensions
-        .as_ref()
-        .and_then(|exts| {
-            exts.iter().find_map(|e| match e {
-                ExtensionStruct::Compressible(info) => Some(info),
-                _ => None,
-            })
-        })
-        .ok_or_else(|| {
-            msg!("CMint does not have Compressible extension");
-            ErrorCode::CMintMissingCompressibleExtension
-        })?;
+    // 4. Access compression info directly (all cmints now have embedded compression)
+    let compression_info = &compressed_mint.compression;
 
-    // 5. Verify rent_sponsor matches extension
-    if rent_sponsor.key() != &compression_info.info.rent_sponsor {
-        msg!("Rent sponsor does not match extension");
+    // 5. Verify rent_sponsor matches compression info
+    if !pubkey_eq(rent_sponsor.key(), &compression_info.rent_sponsor) {
+        msg!("Rent sponsor does not match compression info");
         return Err(ErrorCode::InvalidRentSponsor.into());
     }
 
-    // 7. Check is_compressible (rent has expired)
-    #[cfg(target_os = "solana")]
+    // 5. Check is_compressible (rent has expired)
     let current_slot = Clock::get()
         .map_err(|_| ProgramError::UnsupportedSysvar)?
         .slot;
-    #[cfg(not(target_os = "solana"))]
-    let _current_slot = 1u64;
 
-    #[cfg(target_os = "solana")]
-    {
-        let is_compressible = compression_info
-            .info
-            .is_compressible(cmint.data_len() as u64, current_slot, cmint.lamports())
-            .map_err(|_| ProgramError::InvalidAccountData)?;
+    let is_compressible = compression_info
+        .is_compressible(cmint.data_len() as u64, current_slot, cmint.lamports())
+        .ok()
+        .flatten();
 
-        if is_compressible.is_none() {
-            msg!("CMint is not compressible (rent not expired)");
-            return Err(ErrorCode::CMintNotCompressible.into());
+    if is_compressible.is_none() {
+        if action.is_idempotent() {
+            return Ok(());
         }
+        msg!("CMint is not compressible (rent not expired)");
+        return Err(ErrorCode::CMintNotCompressible.into());
     }
-
-    // 6. Transfer all lamports to rent_sponsor
-    let cmint_lamports = cmint.lamports();
-    if cmint_lamports > 0 {
+    // Close cmint account.
+    {
+        // 6. Transfer all lamports to rent_sponsor
+        let cmint_lamports = cmint.lamports();
         transfer_lamports(cmint_lamports, cmint, rent_sponsor).map_err(convert_program_error)?;
-    }
 
-    // 7. Close account (assign to system program, resize to 0)
-    unsafe {
-        cmint.assign(&[0u8; 32]);
+        // 7. Close account (assign to system program, resize to 0)
+        unsafe {
+            cmint.assign(&[0u8; 32]);
+        }
+        cmint
+            .resize(0)
+            .map_err(|e| ProgramError::Custom(u64::from(e) as u32 + 6000))?;
     }
-    cmint
-        .resize(0)
-        .map_err(|e| ProgramError::Custom(u64::from(e) as u32 + 6000))?;
-
     // 8. Set cmint_decompressed = false
     compressed_mint.metadata.cmint_decompressed = false;
 
-    // 9. Remove Compressible extension from compressed mint
-    let extensions = compressed_mint
-        .extensions
-        .as_mut()
-        .ok_or(ErrorCode::CMintMissingCompressibleExtension)?;
-
-    if extensions.len() == 1 {
-        // Only Compressible extension exists, just set to None
-        compressed_mint.extensions = None;
-    } else {
-        // Find and remove Compressible extension
-        let pos = extensions
-            .iter()
-            .position(|e| matches!(e, ExtensionStruct::Compressible(_)))
-            .ok_or(ErrorCode::CMintMissingCompressibleExtension)?;
-        extensions.remove(pos);
-    }
-
+    // 9. Zero out compression info - only relevant when account is decompressed
+    // When compressed back to a compressed account, this info should be cleared
+    compressed_mint.compression = light_compressible::compression_info::CompressionInfo::default();
     Ok(())
 }
diff --git a/programs/compressed-token/program/src/mint_action/actions/decompress_mint.rs b/programs/compressed-token/program/src/mint_action/actions/decompress_mint.rs
index 84d87e22c5..b84bd1c955 100644
--- a/programs/compressed-token/program/src/mint_action/actions/decompress_mint.rs
+++ b/programs/compressed-token/program/src/mint_action/actions/decompress_mint.rs
@@ -2,14 +2,14 @@ use anchor_compressed_token::ErrorCode;
 use anchor_lang::prelude::ProgramError;
 use light_compressible::{compression_info::CompressionInfo, rent::RentConfig};
 use light_ctoken_interface::{
-    instructions::mint_action::ZDecompressMintAction,
-    state::{CompressedMint, CompressibleExtension, ExtensionStruct},
-    COMPRESSED_MINT_SEED,
+    instructions::mint_action::ZDecompressMintAction, state::CompressedMint, COMPRESSED_MINT_SEED,
 };
 use light_program_profiler::profile;
-#[cfg(target_os = "solana")]
-use pinocchio::sysvars::{clock::Clock, Sysvar};
-use pinocchio::{account_info::AccountInfo, instruction::Seed};
+use pinocchio::{
+    account_info::AccountInfo,
+    instruction::Seed,
+    sysvars::{clock::Clock, Sysvar},
+};
 use pinocchio_system::instructions::Transfer;
 use spl_pod::solana_msg::msg;
 
@@ -27,7 +27,7 @@ use crate::{
 ///
 /// ## Process Steps
 /// 1. **State Validation**: Ensure mint is not already decompressed
-/// 2. **Rent Payment Validation**: rent_payment must be >= 2 (CMint is always compressible)
+/// 2. **Rent Payment Validation**: rent_payment must be 0 or >= 2
 /// 3. **Config Validation**: Validate CompressibleConfig account
 /// 4. **Write Top-Up Validation**: write_top_up must not exceed max_top_up
 /// 5. **Add Compressible Extension**: Add CompressionInfo to the compressed mint extensions
@@ -60,15 +60,9 @@ pub fn process_decompress_mint_action(
         return Err(ErrorCode::CMintAlreadyExists.into());
     }
 
-    // 2. Validate rent_payment (CMint is ALWAYS compressible)
-    // rent_payment == 0 is rejected - CMint must be compressible
-    if action.rent_payment == 0 {
-        msg!("rent_payment must be >= 2 (CMint is always compressible)");
-        return Err(ErrorCode::InvalidRentPayment.into());
-    }
     // rent_payment == 1 is rejected - epoch boundary edge case
     if action.rent_payment == 1 {
-        msg!("Prefunding for exactly 1 epoch is not allowed. Use 2+ epochs.");
+        msg!("Prefunding for exactly 1 epoch is not allowed. Use 0 or 2+ epochs.");
         return Err(ErrorCode::OneEpochPrefundingNotAllowed.into());
     }
 
@@ -88,16 +82,6 @@ pub fn process_decompress_mint_action(
 
     let config = parse_config_account(config_account)?;
 
-    // 4. Validate rent_payment doesn't exceed max_funded_epochs
-    if action.rent_payment > config.rent_config.max_funded_epochs {
-        msg!(
-            "rent_payment {} exceeds max_funded_epochs {}",
-            action.rent_payment,
-            config.rent_config.max_funded_epochs
-        );
-        return Err(ErrorCode::RentPaymentExceedsMax.into());
-    }
-
     // 5. Validate write_top_up doesn't exceed max_top_up
     if action.write_top_up > config.rent_config.max_top_up as u32 {
         msg!(
@@ -119,17 +103,12 @@ pub fn process_decompress_mint_action(
     }
 
     // 7. Get current slot for last_claimed_slot
-    #[cfg(target_os = "solana")]
     let current_slot = Clock::get()
         .map_err(|_| ProgramError::UnsupportedSysvar)?
         .slot;
-    #[cfg(not(target_os = "solana"))]
-    let current_slot = 1u64;
 
-    // 8. Build Compressible extension and add to compressed_mint
-    // NOTE: Compressible will be stripped when writing to compressed account,
-    // but kept when writing to CMint (sync in mint_output.rs)
-    let compression_info = CompressionInfo {
+    // 8. Set compression info directly on compressed_mint (all cmints now have embedded compression)
+    compressed_mint.compression = CompressionInfo {
         config_account_version: config.version,
         compress_to_pubkey: 0, // Not applicable for CMint
         account_version: 3,    // ShaFlat version
@@ -146,17 +125,6 @@ pub fn process_decompress_mint_action(
         },
     };
 
-    // Add Compressible extension to compressed_mint
-    let extension = ExtensionStruct::Compressible(CompressibleExtension {
-        compression_only: false,
-        info: compression_info,
-    });
-    if let Some(ref mut extensions) = compressed_mint.extensions {
-        extensions.push(extension);
-    } else {
-        compressed_mint.extensions = Some(vec![extension]);
-    }
-
     // 9. Verify PDA derivation
     let seeds: [&[u8]; 2] = [COMPRESSED_MINT_SEED, mint_signer.key()];
     verify_pda(
@@ -214,11 +182,8 @@ pub fn process_decompress_mint_action(
     .invoke()
     .map_err(convert_program_error)?;
 
-    // 16. Set the cmint_decompressed flag (will be persisted in sync)
+    // 16. Set the cmint_decompressed flag
     compressed_mint.metadata.cmint_decompressed = true;
 
-    // NOTE: Don't serialize here - the sync logic at the end of MintAction
-    // processor will write the output compressed mint to CMint account
-
     Ok(())
 }
diff --git a/programs/compressed-token/program/src/mint_action/actions/mint_to.rs b/programs/compressed-token/program/src/mint_action/actions/mint_to.rs
index ab0629926f..dc538f4f9b 100644
--- a/programs/compressed-token/program/src/mint_action/actions/mint_to.rs
+++ b/programs/compressed-token/program/src/mint_action/actions/mint_to.rs
@@ -97,6 +97,8 @@ fn create_output_compressed_token_accounts<'a>(
             mint,
             queue_pubkey_index,
             parsed_instruction_data.token_account_version,
+            None,  // No TLV for mint_to
+            false, // Minted tokens are always initialized (not frozen)
         )?;
         processed_count += 1;
     }
diff --git a/programs/compressed-token/program/src/mint_action/actions/process_actions.rs b/programs/compressed-token/program/src/mint_action/actions/process_actions.rs
index 3110270cd9..38a9bd0b72 100644
--- a/programs/compressed-token/program/src/mint_action/actions/process_actions.rs
+++ b/programs/compressed-token/program/src/mint_action/actions/process_actions.rs
@@ -86,8 +86,8 @@ pub fn process_actions<'a>(
                 compressed_mint.base.freeze_authority =
                     update_action.new_authority.as_ref().map(|a| **a);
             }
+            // TODO: Remove CreateSplMint - dead code, never activated
             ZAction::CreateSplMint(_create_spl_action) => {
-                // The creation of an associated spl mint is not activated.
                 return Err(ErrorCode::MintActionUnsupportedOperation.into());
                 // process_create_spl_mint_action(
                 //     create_spl_action,
diff --git a/programs/compressed-token/program/src/mint_action/mint_input.rs b/programs/compressed-token/program/src/mint_action/mint_input.rs
index df32d7d8ea..ef4c8ff306 100644
--- a/programs/compressed-token/program/src/mint_action/mint_input.rs
+++ b/programs/compressed-token/program/src/mint_action/mint_input.rs
@@ -37,6 +37,7 @@ pub fn create_input_compressed_mint_account(
             .mint
             .as_ref()
             .ok_or(ProgramError::InvalidInstructionData)?;
+        // Return it so that we dont deserialize it twice.
         let compressed_mint = CompressedMint::try_from(mint_data)?;
         let bytes = compressed_mint
             .try_to_vec()
diff --git a/programs/compressed-token/program/src/mint_action/mint_output.rs b/programs/compressed-token/program/src/mint_action/mint_output.rs
index ac2902104d..d8cb7656d2 100644
--- a/programs/compressed-token/program/src/mint_action/mint_output.rs
+++ b/programs/compressed-token/program/src/mint_action/mint_output.rs
@@ -4,9 +4,8 @@ use borsh::BorshSerialize;
 use light_compressed_account::instruction_data::data::ZOutputCompressedAccountWithPackedContextMut;
 use light_compressible::rent::get_rent_exemption_lamports;
 use light_ctoken_interface::{
-    hash_cache::HashCache,
-    instructions::mint_action::ZMintActionCompressedInstructionData,
-    state::{CompressedMint, ExtensionStruct},
+    hash_cache::HashCache, instructions::mint_action::ZMintActionCompressedInstructionData,
+    state::CompressedMint,
 };
 use light_hasher::{sha256::Sha256BE, Hasher};
 use light_program_profiler::profile;
@@ -45,50 +44,47 @@ pub fn process_output_compressed_account<'a>(
         &validated_accounts.packed_accounts,
         &mut compressed_mint,
     )?;
-
-    // AUTO-SYNC OUTPUT: If CMint account was passed, update it with new state
-    // SKIP if CompressAndCloseCMint action is present (CMint is being closed, not synced)
-    if let Some(cmint_account) = validated_accounts.get_cmint() {
+    // When decompressed (CMint is source of truth), use zero values
+    let cmint_is_source_of_truth = accounts_config.cmint_is_source_of_truth();
+    // Serialize state into CMint solana account
+    // SKIP if CompressAndCloseCMint action is present (CMint is being closed)
+    // SKIP if DecompressMint action is present (CMint is being closed)
+    if cmint_is_source_of_truth {
+        let cmint_account = validated_accounts
+            .get_cmint()
+            .ok_or(ErrorCode::CMintNotFound)?;
         if !accounts_config.has_compress_and_close_cmint_action {
-            // Check if CMint has Compressible extension and handle top-up
-            if let Some(ref mut extensions) = compressed_mint.extensions {
-                if let Some(ExtensionStruct::Compressible(ref mut compression_info)) = extensions
-                    .iter_mut()
-                    .find(|e| matches!(e, ExtensionStruct::Compressible(_)))
-                {
-                    // Get current slot for top-up calculation
-                    let current_slot = Clock::get()
-                        .map_err(|_| ProgramError::UnsupportedSysvar)?
-                        .slot;
-
-                    let num_bytes = cmint_account.data_len() as u64;
-                    let current_lamports = cmint_account.lamports();
-                    let rent_exemption = get_rent_exemption_lamports(num_bytes)
-                        .map_err(|_| ErrorCode::CMintTopUpCalculationFailed)?;
-
-                    // Calculate top-up amount
-                    let top_up = compression_info
-                        .info
-                        .calculate_top_up_lamports(
-                            num_bytes,
-                            current_slot,
-                            current_lamports,
-                            rent_exemption,
-                        )
-                        .map_err(|_| ErrorCode::CMintTopUpCalculationFailed)?;
-
-                    if top_up > 0 {
-                        let fee_payer = validated_accounts
-                            .executing
-                            .as_ref()
-                            .map(|exec| exec.system.fee_payer)
-                            .ok_or(ProgramError::NotEnoughAccountKeys)?;
-                        transfer_lamports(top_up, fee_payer, cmint_account)
-                            .map_err(convert_program_error)?;
-                    }
+            let num_bytes = cmint_account.data_len() as u64;
+            let current_lamports = cmint_account.lamports();
+            let rent_exemption = get_rent_exemption_lamports(num_bytes)
+                .map_err(|_| ErrorCode::CMintTopUpCalculationFailed)?;
+
+            // Skip top-up calculation if decompress mint action is present.
+            if !accounts_config.has_decompress_mint_action {
+                // Handle top-up for compressed mint (compression info is now embedded directly)
+                // Get current slot for top-up calculation
+                let current_slot = Clock::get()
+                    .map_err(|_| ProgramError::UnsupportedSysvar)?
+                    .slot;
+                // Calculate top-up amount using embedded compression info
+                let top_up = compressed_mint
+                    .compression
+                    .calculate_top_up_lamports(
+                        num_bytes,
+                        current_slot,
+                        current_lamports,
+                        rent_exemption,
+                    )
+                    .map_err(|_| ErrorCode::CMintTopUpCalculationFailed)?;
 
-                    // Update last_claimed_slot to current slot
-                    compression_info.info.last_claimed_slot = current_slot;
+                if top_up > 0 {
+                    let fee_payer = validated_accounts
+                        .executing
+                        .as_ref()
+                        .map(|exec| exec.system.fee_payer)
+                        .ok_or(ProgramError::NotEnoughAccountKeys)?;
+                    transfer_lamports(top_up, fee_payer, cmint_account)
+                        .map_err(convert_program_error)?;
                 }
             }
 
@@ -136,8 +132,6 @@ pub fn process_output_compressed_account<'a>(
         }
     }
 
-    // When decompressed (CMint is source of truth), use zero values
-    let cmint_is_source_of_truth = accounts_config.cmint_is_source_of_truth();
     let compressed_account_data = mint_account
         .compressed_account
         .data
diff --git a/programs/compressed-token/program/src/mint_action/zero_copy_config.rs b/programs/compressed-token/program/src/mint_action/zero_copy_config.rs
index 933c20536f..6bd87282af 100644
--- a/programs/compressed-token/program/src/mint_action/zero_copy_config.rs
+++ b/programs/compressed-token/program/src/mint_action/zero_copy_config.rs
@@ -65,12 +65,11 @@ pub fn get_zero_copy_configs(
 
     // Output mint config (always present) with final authority states
     let output_mint_config = CompressedMintConfig {
-        base: (),
-        metadata: (),
-        extensions: (
-            !output_extensions_config.is_empty(),
-            output_extensions_config,
-        ),
+        extensions: if output_extensions_config.is_empty() {
+            None
+        } else {
+            Some(output_extensions_config)
+        },
     };
 
     // Count recipients from MintTo actions
diff --git a/programs/compressed-token/program/src/shared/compressible_top_up.rs b/programs/compressed-token/program/src/shared/compressible_top_up.rs
index e43021919b..99c6479d9f 100644
--- a/programs/compressed-token/program/src/shared/compressible_top_up.rs
+++ b/programs/compressed-token/program/src/shared/compressible_top_up.rs
@@ -1,12 +1,14 @@
 use anchor_lang::solana_program::program_error::ProgramError;
-use light_compressible::rent::get_rent_exemption_lamports;
 use light_ctoken_interface::{
-    state::{CToken, CompressedMint, ZExtensionStruct},
-    CTokenError, BASE_TOKEN_ACCOUNT_SIZE, COMPRESSIBLE_TOKEN_RENT_EXEMPTION,
+    state::{CToken, CompressedMint},
+    CTokenError,
 };
 use light_program_profiler::profile;
 use light_zero_copy::traits::ZeroCopyAt;
-use pinocchio::account_info::AccountInfo;
+use pinocchio::{
+    account_info::AccountInfo,
+    sysvars::{clock::Clock, rent::Rent, Sysvar},
+};
 
 use super::{
     convert_program_error,
@@ -41,6 +43,7 @@ pub fn calculate_and_execute_compressible_top_ups<'a>(
     ];
 
     let mut current_slot = 0;
+    let mut rent: Option<Rent> = None;
     // Initialize budget: +1 allows exact match (total == max_top_up)
     let mut lamports_budget = (max_top_up as u64).saturating_add(1);
 
@@ -49,63 +52,49 @@ pub fn calculate_and_execute_compressible_top_ups<'a>(
         let cmint_data = cmint.try_borrow_data().map_err(convert_program_error)?;
         let (mint, _) = CompressedMint::zero_copy_at(&cmint_data)
             .map_err(|_| CTokenError::CMintDeserializationFailed)?;
-        if let Some(ref extensions) = mint.extensions {
-            for extension in extensions.iter() {
-                if let ZExtensionStruct::Compressible(ref compression_info) = extension {
-                    if current_slot == 0 {
-                        use pinocchio::sysvars::{clock::Clock, Sysvar};
-                        current_slot = Clock::get()
-                            .map_err(|_| CTokenError::SysvarAccessError)?
-                            .slot;
-                    }
-                    let rent_exemption = get_rent_exemption_lamports(cmint.data_len() as u64)
-                        .map_err(|_| CTokenError::InvalidAccountData)?;
-                    transfers[0].amount = compression_info
-                        .info
-                        .calculate_top_up_lamports(
-                            cmint.data_len() as u64,
-                            current_slot,
-                            cmint.lamports(),
-                            rent_exemption,
-                        )
-                        .map_err(|_| CTokenError::InvalidAccountData)?;
-                    lamports_budget = lamports_budget.saturating_sub(transfers[0].amount);
-                    break;
-                }
-            }
+        // Access compression info directly from meta (all cmints now have compression embedded)
+        if current_slot == 0 {
+            current_slot = Clock::get()
+                .map_err(|_| CTokenError::SysvarAccessError)?
+                .slot;
+            rent = Some(Rent::get().map_err(|_| CTokenError::SysvarAccessError)?);
         }
+        let rent_exemption = rent.as_ref().unwrap().minimum_balance(cmint.data_len());
+        transfers[0].amount = mint
+            .base
+            .compression
+            .calculate_top_up_lamports(
+                cmint.data_len() as u64,
+                current_slot,
+                cmint.lamports(),
+                rent_exemption,
+            )
+            .map_err(|_| CTokenError::InvalidAccountData)?;
+        lamports_budget = lamports_budget.saturating_sub(transfers[0].amount);
     }
 
-    // Calculate CToken top-up (CToken uses zero-copy extensions)
-    if ctoken.data_len() > BASE_TOKEN_ACCOUNT_SIZE as usize {
+    // Calculate CToken top-up
+    {
         let account_data = ctoken.try_borrow_data().map_err(convert_program_error)?;
         let (token, _) = CToken::zero_copy_at_checked(&account_data)?;
-        if let Some(ref extensions) = token.extensions {
-            for extension in extensions.iter() {
-                if let ZExtensionStruct::Compressible(compressible_ext) = extension {
-                    if current_slot == 0 {
-                        use pinocchio::sysvars::{clock::Clock, Sysvar};
-                        current_slot = Clock::get()
-                            .map_err(|_| CTokenError::SysvarAccessError)?
-                            .slot;
-                    }
-                    transfers[1].amount = compressible_ext
-                        .info
-                        .calculate_top_up_lamports(
-                            ctoken.data_len() as u64,
-                            current_slot,
-                            ctoken.lamports(),
-                            COMPRESSIBLE_TOKEN_RENT_EXEMPTION,
-                        )
-                        .map_err(|_| CTokenError::InvalidAccountData)?;
-                    lamports_budget = lamports_budget.saturating_sub(transfers[1].amount);
-                    break;
-                }
-            }
-        } else {
-            // Only Compressible extensions are implemented for ctoken accounts.
-            return Err(CTokenError::InvalidAccountData.into());
+        // Access compression info directly from meta (all ctokens now have compression embedded)
+        if current_slot == 0 {
+            current_slot = Clock::get()
+                .map_err(|_| CTokenError::SysvarAccessError)?
+                .slot;
+            rent = Some(Rent::get().map_err(|_| CTokenError::SysvarAccessError)?);
         }
+        let rent_exemption = rent.as_ref().unwrap().minimum_balance(ctoken.data_len());
+        transfers[1].amount = token
+            .compression
+            .calculate_top_up_lamports(
+                ctoken.data_len() as u64,
+                current_slot,
+                ctoken.lamports(),
+                rent_exemption,
+            )
+            .map_err(|_| CTokenError::InvalidAccountData)?;
+        lamports_budget = lamports_budget.saturating_sub(transfers[1].amount);
     }
 
     // Exit early if no compressible accounts
diff --git a/programs/compressed-token/program/src/shared/initialize_ctoken_account.rs b/programs/compressed-token/program/src/shared/initialize_ctoken_account.rs
index 5b25dce1af..29dac88155 100644
--- a/programs/compressed-token/program/src/shared/initialize_ctoken_account.rs
+++ b/programs/compressed-token/program/src/shared/initialize_ctoken_account.rs
@@ -1,125 +1,147 @@
 use anchor_lang::prelude::ProgramError;
 use light_account_checks::AccountInfoTrait;
-use light_compressible::{compression_info::ZCompressionInfoMut, config::CompressibleConfig};
+use light_compressible::config::CompressibleConfig;
 use light_ctoken_interface::{
-    instructions::extensions::compressible::CompressibleExtensionInstructionData,
-    state::extensions::CompressibleExtension, CTokenError, COMPRESSIBLE_TOKEN_ACCOUNT_SIZE,
+    instructions::create_ctoken_account::CompressToPubkey,
+    state::{ctoken::CompressedTokenConfig, AccountState, CToken, ExtensionStructConfig},
+    CTokenError, CTOKEN_PROGRAM_ID,
 };
 use light_program_profiler::profile;
-use light_zero_copy::traits::ZeroCopyAtMut;
+use light_zero_copy::traits::ZeroCopyNew;
 #[cfg(target_os = "solana")]
 use pinocchio::sysvars::{clock::Clock, Sysvar};
 use pinocchio::{account_info::AccountInfo, msg, pubkey::Pubkey};
 
-use crate::ErrorCode;
+use crate::extensions::MintExtensionFlags;
+
+const SPL_TOKEN_ID: [u8; 32] = spl_token::ID.to_bytes();
+const SPL_TOKEN_2022_ID: [u8; 32] = spl_token_2022::ID.to_bytes();
+
+/// SPL Token Mint account length (82 bytes)
+const SPL_MINT_LEN: usize = 82;
+/// Token-2022 AccountType byte position
+/// Token-2022 pads mints to BASE_ACCOUNT_LENGTH (165 bytes) before AccountType
+/// Layout: 82 bytes mint data + 83 bytes padding + 1 byte AccountType
+const T22_ACCOUNT_TYPE_OFFSET: usize = 165;
+/// AccountType::Mint discriminator value
+const ACCOUNT_TYPE_MINT: u8 = 1;
+
+/// Compression-related instruction data for initializing a CToken account
+#[derive(Debug, Clone, Copy)]
+pub struct CompressionInstructionData {
+    /// Version of the compressed token account when compressed
+    pub token_account_version: u8,
+    /// If true, the compressed token account cannot be transferred
+    pub compression_only: u8,
+    /// Write top-up in lamports per write
+    pub write_top_up: u32,
+}
+
+/// Configuration for initializing a CToken account
+pub struct CTokenInitConfig<'a> {
+    /// The mint pubkey (32 bytes)
+    pub mint: &'a [u8; 32],
+    /// The owner pubkey (32 bytes)
+    pub owner: &'a [u8; 32],
+    /// Compression instruction data (all accounts now have compression fields embedded)
+    pub compression_ix_data: CompressionInstructionData,
+    /// Optional compress-to-pubkey configuration
+    pub compress_to_pubkey: Option<&'a CompressToPubkey>,
+    /// Compressible config account (if provided, compression is enabled)
+    pub compressible_config_account: &'a CompressibleConfig,
+    /// Custom rent payer pubkey (if not using default rent sponsor)
+    pub custom_rent_payer: Option<Pubkey>,
+    /// Mint extension flags
+    pub mint_extensions: MintExtensionFlags,
+    /// Mint account for caching decimals
+    pub mint_account: &'a AccountInfo,
+}
 
-/// Initialize a token account using spl-pod with zero balance and default settings
+/// Initialize a token account using zero-copy with embedded CompressionInfo
 #[profile]
 pub fn initialize_ctoken_account(
     token_account_info: &AccountInfo,
-    mint_pubkey: &[u8; 32],
-    owner_pubkey: &[u8; 32],
-    compressible_config: Option<CompressibleExtensionInstructionData>,
-    compressible_config_account: Option<&CompressibleConfig>,
-    // account is compressible but with custom fee payer -> rent recipient is fee payer
-    custom_rent_payer: Option<Pubkey>,
+    config: CTokenInitConfig<'_>,
 ) -> Result<(), ProgramError> {
-    let required_size = if compressible_config.is_none() {
-        165
-    } else {
-        COMPRESSIBLE_TOKEN_ACCOUNT_SIZE as usize
-    };
-    // Access the token account data as mutable bytes
-    let mut token_account_data = AccountInfoTrait::try_borrow_mut_data(token_account_info)?;
-    let actual_size = token_account_data.len();
-
-    // Check account size before attempting to initialize
-    if actual_size != required_size {
-        msg!(
-            "Account too small: required {} bytes, got {} bytes",
-            required_size,
-            actual_size
-        );
-        return Err(ErrorCode::InsufficientAccountSize.into());
+    let CTokenInitConfig {
+        mint,
+        owner,
+        compression_ix_data,
+        compress_to_pubkey,
+        compressible_config_account,
+        custom_rent_payer,
+        mint_extensions,
+        mint_account,
+    } = config;
+
+    // Build extensions Vec from boolean flags
+    let mut extensions = Vec::with_capacity(mint_extensions.num_extensions());
+    if mint_extensions.has_pausable {
+        extensions.push(ExtensionStructConfig::PausableAccount(()));
+    }
+    if mint_extensions.has_permanent_delegate {
+        extensions.push(ExtensionStructConfig::PermanentDelegateAccount(()));
+    }
+    if mint_extensions.has_transfer_fee {
+        extensions.push(ExtensionStructConfig::TransferFeeAccount(()));
+    }
+    if mint_extensions.has_transfer_hook {
+        extensions.push(ExtensionStructConfig::TransferHookAccount(()));
     }
 
-    // Manually initialize the token account at the correct offsets
-    // SPL Token Account Layout (165 bytes total):
-    // mint: 32 bytes (offset 0-31)
-    // owner: 32 bytes (offset 32-63)
-    // state: 1 byte (offset 108)
-    // Account is already zeroed, only need to set these 3 fields
-
-    let (base_token_bytes, extension_bytes) = token_account_data.split_at_mut(165);
+    // Build the config for new_zero_copy
+    let zc_config = CompressedTokenConfig {
+        mint: light_compressed_account::Pubkey::from(*mint),
+        owner: light_compressed_account::Pubkey::from(*owner),
+        state: if mint_extensions.default_state_frozen {
+            AccountState::Frozen as u8
+        } else {
+            AccountState::Initialized as u8
+        },
+        compression_only: compression_ix_data.compression_only != 0,
+        extensions: if extensions.is_empty() {
+            None
+        } else {
+            Some(extensions)
+        },
+    };
 
-    if base_token_bytes[108] != 0 {
-        msg!("Token account already initialized");
-        return Err(ErrorCode::AlreadyInitialized.into());
-    }
+    // Access the token account data as mutable bytes
+    let mut token_account_data = AccountInfoTrait::try_borrow_mut_data(token_account_info)?;
 
-    // Copy mint (32 bytes at offset 0)
-    base_token_bytes[0..32].copy_from_slice(mint_pubkey);
-
-    // Copy owner (32 bytes at offset 32)
-    base_token_bytes[32..64].copy_from_slice(owner_pubkey);
-
-    // Set state to Initialized (1 byte at offset 108)
-    base_token_bytes[108] = 1;
-
-    // Configure compressible extension if present
-    if let Some(compressible_config) = compressible_config {
-        let compressible_config_account =
-            compressible_config_account.ok_or(ErrorCode::InvalidCompressAuthority)?;
-        // Split to get the actual CompressionInfo data starting at byte 7
-        let (extension_bytes, compressible_data) = extension_bytes.split_at_mut(7);
-
-        // Manually set extension metadata
-        // Byte 0: AccountType::Account = 2
-        extension_bytes[0] = 2;
-
-        // Byte 1: Option::Some = 1 (for Option<Vec<ExtensionStruct>>)
-        extension_bytes[1] = 1;
-
-        // Bytes 2-5: Vec length = 1 (little-endian u32)
-        extension_bytes[2..6].copy_from_slice(&[1, 0, 0, 0]);
-
-        // Byte 6: Compressible enum discriminator = 32 (avoids Token-2022 overlap)
-        extension_bytes[6] = 32;
-
-        // Create zero-copy mutable reference to CompressibleExtension
-        let (mut compressible_extension, _) =
-            CompressibleExtension::zero_copy_at_mut(compressible_data).map_err(|e| {
-                msg!(
-                    "Failed to create CompressibleExtension zero-copy reference: {:?}",
-                    e
-                );
-                ProgramError::InvalidAccountData
-            })?;
-
-        // Set compression_only field (false = 0 by default, accounts are compressible)
-        compressible_extension.compression_only = 0;
-
-        configure_compressible_extension(
-            &mut compressible_extension.info,
-            compressible_config,
-            compressible_config_account,
-            custom_rent_payer,
-        )?;
-    }
+    // Use new_zero_copy to initialize the token account
+    // This sets mint, owner, state, compression_only, account_type, and extensions
+    let (mut ctoken, _remaining) = CToken::new_zero_copy(&mut token_account_data, zc_config)
+        .map_err(|e| {
+            msg!("Failed to initialize CToken: {:?}", e);
+            ProgramError::InvalidAccountData
+        })?;
+
+    // Configure compression info fields and decimals
+    configure_compression_info(
+        &mut ctoken.base,
+        compression_ix_data,
+        compress_to_pubkey,
+        compressible_config_account,
+        custom_rent_payer,
+        mint_account,
+    )?;
 
     Ok(())
 }
 
 #[profile]
 #[inline(always)]
-fn configure_compressible_extension(
-    compressible_extension: &mut ZCompressionInfoMut<'_>,
-    compressible_config: CompressibleExtensionInstructionData,
+fn configure_compression_info(
+    meta: &mut light_ctoken_interface::state::ZCTokenZeroCopyMetaMut<'_>,
+    compression_ix_data: CompressionInstructionData,
+    compress_to_pubkey: Option<&CompressToPubkey>,
     compressible_config_account: &CompressibleConfig,
     custom_rent_payer: Option<Pubkey>,
+    mint_account: &AccountInfo,
 ) -> Result<(), ProgramError> {
     // Set config_account_version
-    compressible_extension.config_account_version = compressible_config_account.version.into();
+    meta.compression.config_account_version = compressible_config_account.version.into();
 
     #[cfg(target_os = "solana")]
     let current_slot = Clock::get()
@@ -127,60 +149,89 @@ fn configure_compressible_extension(
         .slot;
     #[cfg(not(target_os = "solana"))]
     let current_slot = 1;
-    compressible_extension.last_claimed_slot = current_slot.into();
-    // Initialize RentConfig with default values
-    compressible_extension.rent_config.base_rent =
+    meta.compression.last_claimed_slot = current_slot.into();
+
+    // Initialize RentConfig from compressible config account
+    meta.compression.rent_config.base_rent =
         compressible_config_account.rent_config.base_rent.into();
-    compressible_extension.rent_config.compression_cost = compressible_config_account
+    meta.compression.rent_config.compression_cost = compressible_config_account
         .rent_config
         .compression_cost
         .into();
-    compressible_extension
-        .rent_config
-        .lamports_per_byte_per_epoch = compressible_config_account
+    meta.compression.rent_config.lamports_per_byte_per_epoch = compressible_config_account
         .rent_config
         .lamports_per_byte_per_epoch;
-    compressible_extension.rent_config.max_funded_epochs =
+    meta.compression.rent_config.max_funded_epochs =
         compressible_config_account.rent_config.max_funded_epochs;
-    compressible_extension.rent_config.max_top_up =
+    meta.compression.rent_config.max_top_up =
         compressible_config_account.rent_config.max_top_up.into();
 
     // Set the compression_authority, rent_sponsor and lamports_per_write
-    compressible_extension.compression_authority =
+    meta.compression.compression_authority =
         compressible_config_account.compression_authority.to_bytes();
     if let Some(custom_rent_payer) = custom_rent_payer {
         // The custom rent payer is the rent recipient.
-        // In this case the rent mechanism stay the same,
-        // the account can be compressed and closed by a forester,
-        // rent rewards cannot be claimed by the forester.
-        compressible_extension.rent_sponsor = custom_rent_payer;
+        meta.compression.rent_sponsor = custom_rent_payer;
     } else {
-        compressible_extension.rent_sponsor = compressible_config_account.rent_sponsor.to_bytes();
+        meta.compression.rent_sponsor = compressible_config_account.rent_sponsor.to_bytes();
     }
 
     // Validate write_top_up doesn't exceed max_top_up
-    if compressible_config.write_top_up > compressible_config_account.rent_config.max_top_up as u32
+    if compression_ix_data.write_top_up > compressible_config_account.rent_config.max_top_up as u32
     {
         msg!(
             "write_top_up {} exceeds max_top_up {}",
-            compressible_config.write_top_up,
+            compression_ix_data.write_top_up,
             compressible_config_account.rent_config.max_top_up
         );
         return Err(CTokenError::WriteTopUpExceedsMaximum.into());
     }
-    compressible_extension
+    meta.compression
         .lamports_per_write
-        .set(compressible_config.write_top_up);
-    compressible_extension.compress_to_pubkey =
-        compressible_config.compress_to_account_pubkey.is_some() as u8;
+        .set(compression_ix_data.write_top_up);
+    meta.compression.compress_to_pubkey = compress_to_pubkey.is_some() as u8;
+
     // Validate token_account_version is ShaFlat (3)
-    if compressible_config.token_account_version != 3 {
+    if compression_ix_data.token_account_version != 3 {
         msg!(
             "Invalid token_account_version: {}. Only version 3 (ShaFlat) is supported",
-            compressible_config.token_account_version
+            compression_ix_data.token_account_version
         );
         return Err(ProgramError::InvalidInstructionData);
     }
-    compressible_extension.account_version = compressible_config.token_account_version;
+    meta.compression.account_version = compression_ix_data.token_account_version;
+
+    // Read decimals from mint account
+    let mint_data = AccountInfoTrait::try_borrow_data(mint_account)?;
+    // Only try to read decimals if mint has data (is initialized)
+    if !mint_data.is_empty() {
+        let owner = mint_account.owner();
+
+        // Validate mint account based on owner program
+        let is_valid_mint = if *owner == SPL_TOKEN_ID {
+            // SPL Token: mint must be exactly 82 bytes
+            mint_data.len() == SPL_MINT_LEN
+        } else if *owner == SPL_TOKEN_2022_ID || *owner == CTOKEN_PROGRAM_ID {
+            // Token-2022/CToken: Either exactly 82 bytes (no extensions) or
+            // check AccountType marker at offset 165 (with extensions)
+            // Layout with extensions: 82 bytes mint + 83 bytes padding + AccountType
+            mint_data.len() == SPL_MINT_LEN
+                || (mint_data.len() > T22_ACCOUNT_TYPE_OFFSET
+                    && mint_data[T22_ACCOUNT_TYPE_OFFSET] == ACCOUNT_TYPE_MINT)
+        } else {
+            msg!("Invalid mint owner");
+            return Err(ProgramError::IncorrectProgramId);
+        };
+
+        if !is_valid_mint {
+            msg!("Invalid mint account: not a valid mint");
+            return Err(ProgramError::InvalidAccountData);
+        }
+
+        // Mint layout: decimals at byte 44 for all token programs
+        // (mint_authority option: 36, supply: 8) = 44
+        meta.set_decimals(mint_data[44]);
+    }
+
     Ok(())
 }
diff --git a/programs/compressed-token/program/src/shared/mod.rs b/programs/compressed-token/program/src/shared/mod.rs
index e3a02859d7..99368379a9 100644
--- a/programs/compressed-token/program/src/shared/mod.rs
+++ b/programs/compressed-token/program/src/shared/mod.rs
@@ -12,7 +12,6 @@ pub mod token_output;
 pub mod transfer_lamports;
 pub mod validate_ata_derivation;
 
-// Re-export AccountIterator from light-account-checks
 pub use convert_program_error::convert_program_error;
 pub use create_pda_account::{create_pda_account, verify_pda};
 pub use light_account_checks::AccountIterator;
diff --git a/programs/compressed-token/program/src/shared/owner_validation.rs b/programs/compressed-token/program/src/shared/owner_validation.rs
index bee27117f6..e983743187 100644
--- a/programs/compressed-token/program/src/shared/owner_validation.rs
+++ b/programs/compressed-token/program/src/shared/owner_validation.rs
@@ -1,60 +1,89 @@
 use anchor_compressed_token::ErrorCode;
 use anchor_lang::solana_program::program_error::ProgramError;
 use light_account_checks::checks::check_signer;
-use light_ctoken_interface::state::ZCompressedTokenMut;
+use light_ctoken_interface::{state::ZCTokenMut, CTOKEN_PROGRAM_ID};
 use light_program_profiler::profile;
-use pinocchio::account_info::AccountInfo;
+use pinocchio::{account_info::AccountInfo, pubkey::pubkey_eq};
 
-/// Verify owner or delegate signer authorization for token operations
-/// Returns the delegate account info if delegate is used, None otherwise
+use crate::extensions::MintExtensionChecks;
+
+const SPL_TOKEN_ID: [u8; 32] = spl_token::ID.to_bytes();
+const SPL_TOKEN_2022_ID: [u8; 32] = spl_token_2022::ID.to_bytes();
+
+/// Check that an account is owned by a valid token program (SPL Token, Token-2022, or cToken).
+#[inline(always)]
+pub fn check_token_program_owner(account: &AccountInfo) -> Result<(), ProgramError> {
+    let owner = account.owner();
+    if pubkey_eq(owner, &SPL_TOKEN_ID)
+        || pubkey_eq(owner, &SPL_TOKEN_2022_ID)
+        || pubkey_eq(owner, &CTOKEN_PROGRAM_ID)
+    {
+        Ok(())
+    } else {
+        Err(ProgramError::IncorrectProgramId)
+    }
+}
+
+/// Verify owner, delegate, or permanent delegate signer authorization for token operations.
+/// Accepts optional permanent delegate pubkey from mint extension for additional authorization.
 #[profile]
 pub fn verify_owner_or_delegate_signer<'a>(
     owner_account: &'a AccountInfo,
     delegate_account: Option<&'a AccountInfo>,
+    permanent_delegate: Option<&pinocchio::pubkey::Pubkey>,
+    accounts: &[AccountInfo],
 ) -> Result<(), ProgramError> {
+    // Check if owner is signer
+    if check_signer(owner_account).is_ok() {
+        return Ok(());
+    }
+
+    // Check if delegate is signer
     if let Some(delegate_account) = delegate_account {
-        // If delegate is used, delegate or owner must be signer
-        match check_signer(delegate_account) {
-            Ok(()) => {}
-            Err(delegate_error) => {
-                check_signer(owner_account).map_err(|e| {
-                    anchor_lang::solana_program::msg!(
-                        "Checking owner signer: {:?}",
-                        solana_pubkey::Pubkey::new_from_array(*owner_account.key())
-                    );
-                    anchor_lang::solana_program::msg!("Owner signer check failed: {:?}", e);
-                    anchor_lang::solana_program::msg!(
-                        "Delegate signer: {:?}",
-                        solana_pubkey::Pubkey::new_from_array(*delegate_account.key())
-                    );
-                    anchor_lang::solana_program::msg!(
-                        "Delegate signer check failed: {:?}",
-                        delegate_error
-                    );
-                    ProgramError::from(e)
-                })?;
+        if check_signer(delegate_account).is_ok() {
+            return Ok(());
+        }
+    }
+
+    // Check if permanent delegate is signer (search through all accounts)
+    if let Some(perm_delegate) = permanent_delegate {
+        for account in accounts {
+            if pubkey_eq(account.key(), perm_delegate) && account.is_signer() {
+                return Ok(());
             }
         }
-        Ok(())
-    } else {
-        // If no delegate, owner must be signer
-        check_signer(owner_account).map_err(|e| {
-            anchor_lang::solana_program::msg!(
-                "Checking owner signer: {:?}",
-                solana_pubkey::Pubkey::new_from_array(*owner_account.key())
-            );
-            anchor_lang::solana_program::msg!("Owner signer check failed: {:?}", e);
-            ProgramError::from(e)
-        })?;
-        Ok(())
     }
+
+    // No valid signer found
+    anchor_lang::solana_program::msg!(
+        "Checking owner signer: {:?}",
+        solana_pubkey::Pubkey::new_from_array(*owner_account.key())
+    );
+    anchor_lang::solana_program::msg!("Owner signer check failed: InvalidSigner");
+    if let Some(delegate_account) = delegate_account {
+        anchor_lang::solana_program::msg!(
+            "Delegate signer: {:?}",
+            solana_pubkey::Pubkey::new_from_array(*delegate_account.key())
+        );
+        anchor_lang::solana_program::msg!("Delegate signer check failed: InvalidSigner");
+    }
+    if let Some(perm_delegate) = permanent_delegate {
+        anchor_lang::solana_program::msg!(
+            "Permanent delegate: {:?}",
+            solana_pubkey::Pubkey::new_from_array(*perm_delegate)
+        );
+        anchor_lang::solana_program::msg!("Permanent delegate signer check failed: InvalidSigner");
+    }
+    Err(ErrorCode::OwnerMismatch.into())
 }
 
-/// Verify and update token account authority using zero-copy compressed token format
+/// Verify and update token account authority using zero-copy compressed token format.
+/// Allows owner, account delegate, or permanent delegate (from mint) to authorize compression operations.
 #[profile]
 pub fn check_ctoken_owner(
-    compressed_token: &mut ZCompressedTokenMut,
+    compressed_token: &mut ZCTokenMut,
     authority_account: &AccountInfo,
+    mint_checks: Option<&MintExtensionChecks>,
 ) -> Result<(), ProgramError> {
     // Verify authority is signer
     check_signer(authority_account).map_err(|e| {
@@ -63,37 +92,22 @@ pub fn check_ctoken_owner(
     })?;
 
     let authority_key = authority_account.key();
-    let owner_key = compressed_token.owner.to_bytes();
+    let owner_key = compressed_token.owner.array_ref();
 
     // Check if authority is the owner
-    if *authority_key == owner_key {
-        Ok(()) // Owner can always compress, no delegation update needed
-    } else {
-        Err(ErrorCode::OwnerMismatch.into())
+    if pubkey_eq(authority_key, owner_key) {
+        return Ok(()); // Owner can always compress
+    }
+
+    // Check if authority is the permanent delegate from the mint
+    if let Some(checks) = mint_checks {
+        if let Some(permanent_delegate) = &checks.permanent_delegate {
+            if pubkey_eq(authority_key, permanent_delegate) {
+                return Ok(()); // Permanent delegate can compress any account of this mint
+            }
+        }
     }
-    // delegation is unimplemented.
-    // // Check if authority is a valid delegate
-    // if let Some(delegate) = &compressed_token.delegate {
-    //     let delegate_key = delegate.to_bytes();
-    //     if *authority_key == delegate_key {
-    //         // Verify delegated amount is sufficient
-    //         let delegated_amount: u64 = u64::from(*compressed_token.delegated_amount);
-    //         if delegated_amount >= compression_amount {
-    //             // Decrease delegated amount by compression amount
-    //             let new_delegated_amount = delegated_amount
-    //                 .checked_sub(compression_amount)
-    //                 .ok_or(ProgramError::ArithmeticOverflow)?;
-    //             *compressed_token.delegated_amount = new_delegated_amount.into();
-    //             return Ok(());
-    //         } else {
-    //             anchor_lang::solana_program::msg!(
-    //                 "Insufficient delegated amount: {} < {}",
-    //                 delegated_amount,
-    //                 compression_amount
-    //             );
-    //             return Err(ProgramError::InsufficientFunds);
-    //         }
-    //     }
-    // }
-    // Authority is neither owner, valid delegate, nor rent authority
+
+    // Authority is neither owner, account delegate, nor permanent delegate
+    Err(ErrorCode::OwnerMismatch.into())
 }
diff --git a/programs/compressed-token/program/src/shared/token_input.rs b/programs/compressed-token/program/src/shared/token_input.rs
index 9471243260..670689f218 100644
--- a/programs/compressed-token/program/src/shared/token_input.rs
+++ b/programs/compressed-token/program/src/shared/token_input.rs
@@ -1,65 +1,44 @@
 use std::panic::Location;
 
-use anchor_compressed_token::TokenData;
+use anchor_compressed_token::{ErrorCode, TokenData};
 use anchor_lang::solana_program::program_error::ProgramError;
 use light_account_checks::AccountError;
 use light_compressed_account::instruction_data::with_readonly::ZInAccountMut;
 use light_ctoken_interface::{
     hash_cache::HashCache,
-    instructions::transfer2::ZMultiInputTokenDataWithContext,
-    state::{CompressedTokenAccountState, TokenDataVersion},
+    instructions::{
+        extensions::ZExtensionInstructionData, transfer2::ZMultiInputTokenDataWithContext,
+    },
+    state::{
+        CompressedOnlyExtension, CompressedTokenAccountState, ExtensionStruct, TokenDataVersion,
+    },
 };
 use pinocchio::account_info::AccountInfo;
 
-use crate::shared::owner_validation::verify_owner_or_delegate_signer;
-
-#[inline(always)]
-pub fn set_input_compressed_account(
-    input_compressed_account: &mut ZInAccountMut,
-    hash_cache: &mut HashCache,
-    input_token_data: &ZMultiInputTokenDataWithContext,
-    accounts: &[AccountInfo],
-    lamports: u64,
-) -> std::result::Result<(), ProgramError> {
-    set_input_compressed_account_inner::<false>(
-        input_compressed_account,
-        hash_cache,
-        input_token_data,
-        accounts,
-        lamports,
-    )
-}
-
-#[inline(always)]
-pub fn set_input_compressed_account_frozen(
-    input_compressed_account: &mut ZInAccountMut,
-    hash_cache: &mut HashCache,
-    input_token_data: &ZMultiInputTokenDataWithContext,
-    accounts: &[AccountInfo],
-    lamports: u64,
-) -> std::result::Result<(), ProgramError> {
-    set_input_compressed_account_inner::<true>(
-        input_compressed_account,
-        hash_cache,
-        input_token_data,
-        accounts,
-        lamports,
-    )
-}
+use crate::{
+    shared::owner_validation::verify_owner_or_delegate_signer,
+    transfer2::check_extensions::MintExtensionCache,
+};
 
 /// Creates an input compressed account using zero-copy patterns and index-based account lookup.
 ///
-/// Validates signer authorization (owner or delegate), populates the zero-copy account structure,
-/// and computes the appropriate token data hash based on frozen state.
-fn set_input_compressed_account_inner<const IS_FROZEN: bool>(
+/// Validates signer authorization (owner, delegate, or permanent delegate), populates the
+/// zero-copy account structure, and computes the appropriate token data hash based on frozen state.
+#[allow(clippy::too_many_arguments)]
+#[inline(always)]
+pub fn set_input_compressed_account<'a>(
     input_compressed_account: &mut ZInAccountMut,
     hash_cache: &mut HashCache,
     input_token_data: &ZMultiInputTokenDataWithContext,
-    accounts: &[AccountInfo],
+    packed_accounts: &[AccountInfo],
+    all_accounts: &[AccountInfo],
     lamports: u64,
+    tlv_data: Option<&'a [ZExtensionInstructionData<'a>]>,
+    mint_cache: &MintExtensionCache,
+    is_frozen: bool,
 ) -> std::result::Result<(), ProgramError> {
-    // Get owner from remaining accounts using the owner index
-    let owner_account = accounts
+    // Get owner from packed accounts using the owner index
+    let owner_account = packed_accounts
         .get(input_token_data.owner as usize)
         .ok_or_else(|| {
             print_on_error_pubkey(input_token_data.owner, "owner", Location::caller());
@@ -69,7 +48,7 @@ fn set_input_compressed_account_inner<const IS_FROZEN: bool>(
     // Verify signer authorization using shared function
     let delegate_account = if input_token_data.has_delegate() {
         Some(
-            accounts
+            packed_accounts
                 .get(input_token_data.delegate as usize)
                 .ok_or_else(|| {
                     print_on_error_pubkey(
@@ -84,30 +63,67 @@ fn set_input_compressed_account_inner<const IS_FROZEN: bool>(
         None
     };
 
-    verify_owner_or_delegate_signer(owner_account, delegate_account)?;
-    let token_version = TokenDataVersion::try_from(input_token_data.version)?;
-    let mint_account = &accounts
+    // Get mint account early for hashing
+    let mint_account = &packed_accounts
         .get(input_token_data.mint as usize)
         .ok_or_else(|| {
             print_on_error_pubkey(input_token_data.mint, "mint", Location::caller());
             ProgramError::Custom(AccountError::NotEnoughAccountKeys.into())
         })?;
 
+    // Lookup permanent delegate for mint account.
+    let permanent_delegate = mint_cache
+        .get_by_key(&input_token_data.mint)
+        .and_then(|c| c.permanent_delegate.as_ref());
+
+    verify_owner_or_delegate_signer(
+        owner_account,
+        delegate_account,
+        permanent_delegate,
+        all_accounts,
+    )?;
+    let token_version = TokenDataVersion::try_from(input_token_data.version)?;
+
     let data_hash = {
         match token_version {
             TokenDataVersion::ShaFlat => {
-                let state = if IS_FROZEN {
+                let state = if is_frozen {
                     CompressedTokenAccountState::Frozen as u8
                 } else {
                     CompressedTokenAccountState::Initialized as u8
                 };
+                // Convert instruction TLV data to state TLV
+                let tlv: Option<Vec<ExtensionStruct>> = match tlv_data {
+                    Some(exts) => {
+                        let mut result = Vec::with_capacity(exts.len());
+                        for ext in exts.iter() {
+                            match ext {
+                                ZExtensionInstructionData::CompressedOnly(data) => {
+                                    result.push(ExtensionStruct::CompressedOnly(
+                                        CompressedOnlyExtension {
+                                            delegated_amount: data.delegated_amount.into(),
+                                            withheld_transfer_fee: data
+                                                .withheld_transfer_fee
+                                                .into(),
+                                        },
+                                    ));
+                                }
+                                _ => {
+                                    return Err(ErrorCode::UnsupportedTlvExtensionType.into());
+                                }
+                            }
+                        }
+                        Some(result)
+                    }
+                    None => None,
+                };
                 let token_data = TokenData {
                     mint: mint_account.key().into(),
                     owner: owner_account.key().into(),
                     amount: input_token_data.amount.into(),
                     delegate: delegate_account.map(|x| (*x.key()).into()),
                     state,
-                    tlv: None,
+                    tlv,
                 };
                 token_data.hash_sha_flat()?
             }
@@ -121,7 +137,7 @@ fn set_input_compressed_account_inner<const IS_FROZEN: bool>(
                 let hashed_delegate =
                     delegate_account.map(|delegate| hash_cache.get_or_hash_pubkey(delegate.key()));
 
-                if !IS_FROZEN {
+                if !is_frozen {
                     TokenData::hash_with_hashed_values(
                         &hashed_mint,
                         &hashed_owner,
diff --git a/programs/compressed-token/program/src/shared/token_output.rs b/programs/compressed-token/program/src/shared/token_output.rs
index a4da130dea..275431c760 100644
--- a/programs/compressed-token/program/src/shared/token_output.rs
+++ b/programs/compressed-token/program/src/shared/token_output.rs
@@ -5,7 +5,11 @@ use light_compressed_account::{
 };
 use light_ctoken_interface::{
     hash_cache::HashCache,
-    state::{CompressedTokenAccountState, TokenData, TokenDataConfig, TokenDataVersion},
+    instructions::extensions::ZExtensionInstructionData,
+    state::{
+        CompressedTokenAccountState, ExtensionStructConfig, TokenData, TokenDataConfig,
+        TokenDataVersion,
+    },
 };
 use light_hasher::{sha256::Sha256BE, Hasher};
 use light_program_profiler::profile;
@@ -14,61 +18,10 @@ use light_zero_copy::{num_trait::ZeroCopyNumTrait, ZeroCopyNew};
 /// 1. Set token account data
 /// 2. Create token account data hash
 /// 3. Set output compressed account
-#[inline(always)]
 #[allow(clippy::too_many_arguments)]
 #[profile]
-pub fn set_output_compressed_account(
-    output_compressed_account: &mut ZOutputCompressedAccountWithPackedContextMut<'_>,
-    hash_cache: &mut HashCache,
-    owner: Pubkey,
-    delegate: Option<Pubkey>,
-    amount: impl ZeroCopyNumTrait,
-    lamports: Option<impl ZeroCopyNumTrait>,
-    mint_pubkey: Pubkey,
-    merkle_tree_index: u8,
-    version: u8,
-) -> Result<(), ProgramError> {
-    set_output_compressed_account_inner::<false>(
-        output_compressed_account,
-        hash_cache,
-        owner,
-        delegate,
-        amount,
-        lamports,
-        mint_pubkey,
-        merkle_tree_index,
-        version,
-    )
-}
-
 #[inline(always)]
-#[allow(clippy::too_many_arguments)]
-pub fn set_output_compressed_account_frozen(
-    output_compressed_account: &mut ZOutputCompressedAccountWithPackedContextMut<'_>,
-    hash_cache: &mut HashCache,
-    owner: Pubkey,
-    delegate: Option<Pubkey>,
-    amount: impl ZeroCopyNumTrait,
-    lamports: Option<impl ZeroCopyNumTrait>,
-    mint_pubkey: Pubkey,
-    merkle_tree_index: u8,
-    version: u8,
-) -> Result<(), ProgramError> {
-    set_output_compressed_account_inner::<true>(
-        output_compressed_account,
-        hash_cache,
-        owner,
-        delegate,
-        amount,
-        lamports,
-        mint_pubkey,
-        merkle_tree_index,
-        version,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn set_output_compressed_account_inner<const IS_FROZEN: bool>(
+pub fn set_output_compressed_account<'a>(
     output_compressed_account: &mut ZOutputCompressedAccountWithPackedContextMut<'_>,
     hash_cache: &mut HashCache,
     owner: Pubkey,
@@ -78,6 +31,8 @@ fn set_output_compressed_account_inner<const IS_FROZEN: bool>(
     mint_pubkey: Pubkey,
     merkle_tree_index: u8,
     version: u8,
+    tlv_data: Option<&'a [ZExtensionInstructionData<'a>]>,
+    is_frozen: bool,
 ) -> Result<(), ProgramError> {
     // Get compressed account data from CPI struct to temporarily create TokenData
     let compressed_account_data = output_compressed_account
@@ -85,24 +40,39 @@ fn set_output_compressed_account_inner<const IS_FROZEN: bool>(
         .data
         .as_mut()
         .ok_or(ProgramError::InvalidAccountData)?;
+
+    // Extract config from tlv_data for allocation
+    let tlv_config: Option<Vec<ExtensionStructConfig>> = tlv_data.map(|exts| {
+        exts.iter()
+            .filter_map(|ext| match ext {
+                ZExtensionInstructionData::CompressedOnly(_) => {
+                    Some(ExtensionStructConfig::CompressedOnly(()))
+                }
+                _ => None,
+            })
+            .collect()
+    });
+
     // 1. Set token account data
     {
-        // Create token data config based on delegate presence
+        // Create token data config based on delegate presence and TLV
         let token_config = TokenDataConfig {
             delegate: (delegate.is_some(), ()),
-            tlv: (false, vec![]),
+            tlv: match &tlv_config {
+                Some(configs) if !configs.is_empty() => (true, configs.clone()),
+                _ => (false, vec![]),
+            },
         };
         let (mut token_data, _) =
             TokenData::new_zero_copy(compressed_account_data.data, token_config)
                 .map_err(ProgramError::from)?;
 
-        token_data.set(
-            mint_pubkey,
-            owner,
-            amount,
-            delegate,
-            CompressedTokenAccountState::Initialized,
-        )?;
+        let state = if is_frozen {
+            CompressedTokenAccountState::Frozen
+        } else {
+            CompressedTokenAccountState::Initialized
+        };
+        token_data.set(mint_pubkey, owner, amount, delegate, state, tlv_data)?;
     }
     let token_version = TokenDataVersion::try_from(version)?;
     // 2. Create TokenData using zero-copy to compute the data hash
@@ -118,7 +88,7 @@ fn set_output_compressed_account_inner<const IS_FROZEN: bool>(
                 let hashed_delegate = delegate
                     .map(|delegate_pubkey| hash_cache.get_or_hash_pubkey(&delegate_pubkey.into()));
 
-                if !IS_FROZEN {
+                if !is_frozen {
                     TokenData::hash_with_hashed_values(
                         &hashed_mint,
                         &hashed_owner,
diff --git a/programs/compressed-token/program/src/transfer/checked.rs b/programs/compressed-token/program/src/transfer/checked.rs
new file mode 100644
index 0000000000..8c18b03bf5
--- /dev/null
+++ b/programs/compressed-token/program/src/transfer/checked.rs
@@ -0,0 +1,101 @@
+use anchor_lang::solana_program::{msg, program_error::ProgramError};
+use light_program_profiler::profile;
+use pinocchio::account_info::AccountInfo;
+use pinocchio_token_program::processor::{
+    shared::transfer::process_transfer, unpack_amount_and_decimals,
+};
+
+use super::shared::{process_transfer_extensions, TransferAccounts};
+use crate::shared::owner_validation::check_token_program_owner;
+/// Account indices for CToken transfer_checked instruction
+/// Note: Different from ctoken_transfer - mint is at index 1
+const ACCOUNT_SOURCE: usize = 0;
+const ACCOUNT_MINT: usize = 1;
+const ACCOUNT_DESTINATION: usize = 2;
+const ACCOUNT_AUTHORITY: usize = 3;
+
+/// Process ctoken transfer_checked instruction
+///
+/// Instruction data format (backwards compatible):
+/// - 9 bytes: amount + decimals (legacy, no max_top_up enforcement)
+/// - 11 bytes: amount + decimals + max_top_up (u16, 0 = no limit)
+#[profile]
+#[inline(always)]
+pub fn process_ctoken_transfer_checked(
+    accounts: &[AccountInfo],
+    instruction_data: &[u8],
+) -> Result<(), ProgramError> {
+    if accounts.len() < 4 {
+        msg!(
+            "CToken transfer_checked: expected at least 4 accounts received {}",
+            accounts.len()
+        );
+        return Err(ProgramError::NotEnoughAccountKeys);
+    }
+
+    // Validate minimum instruction data length (amount + decimals)
+    if instruction_data.len() < 9 {
+        return Err(ProgramError::InvalidInstructionData);
+    }
+
+    // Get account references
+    let source = accounts
+        .get(ACCOUNT_SOURCE)
+        .ok_or(ProgramError::NotEnoughAccountKeys)?;
+    let mint = accounts
+        .get(ACCOUNT_MINT)
+        .ok_or(ProgramError::NotEnoughAccountKeys)?;
+    let destination = accounts
+        .get(ACCOUNT_DESTINATION)
+        .ok_or(ProgramError::NotEnoughAccountKeys)?;
+    let authority = accounts
+        .get(ACCOUNT_AUTHORITY)
+        .ok_or(ProgramError::NotEnoughAccountKeys)?;
+
+    // Parse max_top_up based on instruction data length
+    // 0 means no limit
+    let max_top_up = match instruction_data.len() {
+        9 => 0u16, // Legacy: no max_top_up
+        11 => u16::from_le_bytes(
+            instruction_data[9..11]
+                .try_into()
+                .map_err(|_| ProgramError::InvalidInstructionData)?,
+        ),
+        _ => return Err(ProgramError::InvalidInstructionData),
+    };
+
+    let (signer_is_validated, extension_decimals) = process_transfer_extensions(
+        TransferAccounts {
+            source,
+            destination,
+            authority,
+            mint: Some(mint),
+        },
+        max_top_up,
+    )?;
+
+    // Pass the first 9 bytes (amount + decimals) to the SPL transfer_checked processor
+    let (amount, decimals) =
+        unpack_amount_and_decimals(instruction_data).map_err(|e| ProgramError::Custom(e as u32))?;
+
+    if let Some(extension_decimals) = extension_decimals {
+        if extension_decimals != decimals {
+            msg!("extension_decimals != decimals");
+            return Err(ProgramError::InvalidInstructionData);
+        }
+        // Create accounts slice without mint: [source, destination, authority]
+        // pinocchio expects 3 accounts when expected_decimals is None
+        let transfer_accounts = [*source, *destination, *authority];
+        process_transfer(
+            transfer_accounts.as_slice(),
+            amount,
+            None,
+            signer_is_validated,
+        )
+        .map_err(|e| ProgramError::Custom(u64::from(e) as u32))
+    } else {
+        check_token_program_owner(mint)?;
+        process_transfer(accounts, amount, Some(decimals), signer_is_validated)
+            .map_err(|e| ProgramError::Custom(u64::from(e) as u32))
+    }
+}
diff --git a/programs/compressed-token/program/src/transfer/default.rs b/programs/compressed-token/program/src/transfer/default.rs
new file mode 100644
index 0000000000..b6a818da03
--- /dev/null
+++ b/programs/compressed-token/program/src/transfer/default.rs
@@ -0,0 +1,81 @@
+use anchor_lang::solana_program::{msg, program_error::ProgramError};
+use light_program_profiler::profile;
+use pinocchio::account_info::AccountInfo;
+use pinocchio_token_program::processor::transfer::process_transfer;
+
+use crate::transfer::shared::{process_transfer_extensions, TransferAccounts};
+
+/// Account indices for CToken transfer instruction
+const ACCOUNT_SOURCE: usize = 0;
+const ACCOUNT_DESTINATION: usize = 1;
+const ACCOUNT_AUTHORITY: usize = 2;
+
+/// Process ctoken transfer instruction
+///
+/// Instruction data format (backwards compatible):
+/// - 8 bytes: amount (legacy, no max_top_up enforcement)
+/// - 10 bytes: amount + max_top_up (u16, 0 = no limit)
+#[profile]
+#[inline(always)]
+pub fn process_ctoken_transfer(
+    accounts: &[AccountInfo],
+    instruction_data: &[u8],
+) -> Result<(), ProgramError> {
+    if accounts.len() < 3 {
+        msg!(
+            "CToken transfer: expected at least 3 accounts received {}",
+            accounts.len()
+        );
+        return Err(ProgramError::NotEnoughAccountKeys);
+    }
+
+    // Validate minimum instruction data length
+    if instruction_data.len() < 8 {
+        return Err(ProgramError::InvalidInstructionData);
+    }
+
+    // Parse max_top_up based on instruction data length
+    // 0 means no limit
+    let max_top_up = match instruction_data.len() {
+        8 => 0u16, // Legacy: no max_top_up
+        10 => u16::from_le_bytes(
+            instruction_data[8..10]
+                .try_into()
+                .map_err(|_| ProgramError::InvalidInstructionData)?,
+        ),
+        _ => return Err(ProgramError::InvalidInstructionData),
+    };
+
+    let signer_is_validated = process_extensions(accounts, max_top_up)?;
+
+    // Only pass the first 8 bytes (amount) to the SPL transfer processor
+    process_transfer(accounts, &instruction_data[..8], signer_is_validated)
+        .map_err(|e| ProgramError::Custom(u64::from(e) as u32))
+}
+
+fn process_extensions(
+    accounts: &[pinocchio::account_info::AccountInfo],
+    max_top_up: u16,
+) -> Result<bool, ProgramError> {
+    let source = accounts
+        .get(ACCOUNT_SOURCE)
+        .ok_or(ProgramError::NotEnoughAccountKeys)?;
+    let destination = accounts
+        .get(ACCOUNT_DESTINATION)
+        .ok_or(ProgramError::NotEnoughAccountKeys)?;
+    let authority = accounts
+        .get(ACCOUNT_AUTHORITY)
+        .ok_or(ProgramError::NotEnoughAccountKeys)?;
+
+    // Ignore decimals - only used for transfer_checked
+    let (signer_is_validated, _decimals) = process_transfer_extensions(
+        TransferAccounts {
+            source,
+            destination,
+            authority,
+            mint: None,
+        },
+        max_top_up,
+    )?;
+    Ok(signer_is_validated)
+}
diff --git a/programs/compressed-token/program/src/transfer/mod.rs b/programs/compressed-token/program/src/transfer/mod.rs
new file mode 100644
index 0000000000..b6ae073c09
--- /dev/null
+++ b/programs/compressed-token/program/src/transfer/mod.rs
@@ -0,0 +1,6 @@
+mod checked;
+mod default;
+mod shared;
+
+pub use checked::*;
+pub use default::*;
diff --git a/programs/compressed-token/program/src/transfer/shared.rs b/programs/compressed-token/program/src/transfer/shared.rs
new file mode 100644
index 0000000000..371a587f4a
--- /dev/null
+++ b/programs/compressed-token/program/src/transfer/shared.rs
@@ -0,0 +1,263 @@
+use anchor_compressed_token::ErrorCode;
+use anchor_lang::solana_program::program_error::ProgramError;
+use light_ctoken_interface::{
+    state::{CToken, ZExtensionStructMut},
+    CTokenError, MintExtensionFlags,
+};
+use light_program_profiler::profile;
+use pinocchio::{account_info::AccountInfo, pubkey::pubkey_eq};
+
+use crate::{
+    extensions::{check_mint_extensions, MintExtensionChecks},
+    shared::{
+        convert_program_error,
+        transfer_lamports::{multi_transfer_lamports, Transfer},
+    },
+};
+
+/// Extension information detected from a single account deserialization.
+/// Uses `MintExtensionFlags` for T22 extension flags to avoid duplication.
+#[derive(Debug, Default)]
+struct AccountExtensionInfo {
+    /// T22 extension flags (pausable, permanent_delegate, transfer_fee, transfer_hook)
+    flags: MintExtensionFlags,
+    /// Top-up amount calculated from compression info
+    top_up_amount: u64,
+    /// Cached decimals from compressible extension (if has_decimals was set)
+    decimals: Option<u8>,
+}
+
+impl AccountExtensionInfo {
+    #[inline(always)]
+    fn check_t22_extensions(&self, other: &Self) -> Result<(), ProgramError> {
+        if self.flags.has_pausable != other.flags.has_pausable
+            || self.flags.has_permanent_delegate != other.flags.has_permanent_delegate
+            || self.flags.has_transfer_fee != other.flags.has_transfer_fee
+            || self.flags.has_transfer_hook != other.flags.has_transfer_hook
+        {
+            Err(ProgramError::InvalidInstructionData)
+        } else {
+            Ok(())
+        }
+    }
+}
+
+/// Account references for transfer operations
+pub struct TransferAccounts<'a> {
+    pub source: &'a AccountInfo,
+    pub destination: &'a AccountInfo,
+    pub authority: &'a AccountInfo,
+    pub mint: Option<&'a AccountInfo>,
+}
+
+/// Process extensions (pausable check, permanent delegate validation, transfer fee withholding)
+/// and calculate/execute top-up transfers.
+/// Each account is deserialized exactly once. Mint is checked once if any account has extensions.
+///
+/// # Arguments
+/// * `transfer_accounts` - Account references for source, destination, authority, and optional mint
+/// * `max_top_up` - Maximum lamports for rent and top-up combined. Transaction fails if exceeded. (0 = no limit)
+///
+/// Returns:
+/// - `Ok((true, decimals))` - Permanent delegate is validated as authority/signer, skip pinocchio validation
+/// - `Ok((false, decimals))` - Use normal pinocchio owner/delegate validation
+/// - `decimals` is Some(u8) if source account has cached decimals in compressible extension
+#[inline(always)]
+#[profile]
+pub fn process_transfer_extensions(
+    transfer_accounts: TransferAccounts,
+    max_top_up: u16,
+) -> Result<(bool, Option<u8>), ProgramError> {
+    let mut current_slot = 0;
+
+    let (sender_info, signer_is_validated) =
+        validate_sender(&transfer_accounts, &mut current_slot)?;
+
+    // Process recipient
+    let recipient_info = validate_recipient(transfer_accounts.destination, &mut current_slot)?;
+    // Sender and recipient must have matching T22 extension markers
+    sender_info.check_t22_extensions(&recipient_info)?;
+
+    // Perform compressible top-up if needed
+    transfer_top_up(
+        &transfer_accounts,
+        sender_info.top_up_amount,
+        recipient_info.top_up_amount,
+        max_top_up,
+    )?;
+
+    // Return decimals from sender (source account has the cached decimals)
+    Ok((signer_is_validated, sender_info.decimals))
+}
+
+#[inline(always)]
+fn transfer_top_up(
+    transfer_accounts: &TransferAccounts,
+    sender_top_up: u64,
+    recipient_top_up: u64,
+    max_top_up: u16,
+) -> Result<(), ProgramError> {
+    if sender_top_up > 0 || recipient_top_up > 0 {
+        // Check budget if max_top_up is set (non-zero)
+        let total_top_up = sender_top_up.saturating_add(recipient_top_up);
+        if max_top_up != 0 && total_top_up > max_top_up as u64 {
+            return Err(CTokenError::MaxTopUpExceeded.into());
+        }
+
+        let transfers = [
+            Transfer {
+                account: transfer_accounts.source,
+                amount: sender_top_up,
+            },
+            Transfer {
+                account: transfer_accounts.destination,
+                amount: recipient_top_up,
+            },
+        ];
+        multi_transfer_lamports(transfer_accounts.authority, &transfers)
+            .map_err(convert_program_error)
+    } else {
+        Ok(())
+    }
+}
+
+fn validate_sender(
+    transfer_accounts: &TransferAccounts,
+    current_slot: &mut u64,
+) -> Result<(AccountExtensionInfo, bool), ProgramError> {
+    // Process sender once
+    let sender_info = process_account_extensions(
+        transfer_accounts.source,
+        current_slot,
+        transfer_accounts.mint,
+    )?;
+
+    // Get mint checks if any account has extensions (single mint deserialization)
+    let mint_checks = if sender_info.flags.has_restricted_extensions() {
+        let mint_account = transfer_accounts
+            .mint
+            .ok_or(ErrorCode::MintRequiredForTransfer)?;
+        Some(check_mint_extensions(mint_account, false)?)
+    } else {
+        None
+    };
+
+    // Validate permanent delegate for sender
+    let signer_is_validated =
+        validate_permanent_delegate(mint_checks.as_ref(), transfer_accounts.authority)?;
+
+    Ok((sender_info, signer_is_validated))
+}
+
+#[inline(always)]
+fn validate_recipient(
+    account: &AccountInfo,
+    current_slot: &mut u64,
+) -> Result<AccountExtensionInfo, ProgramError> {
+    // No mint validation for recipient - only sender needs to match mint
+    process_account_extensions(account, current_slot, None)
+}
+
+/// Validate permanent delegate authority.
+/// Returns true if authority is the permanent delegate and is a signer.
+#[inline(always)]
+fn validate_permanent_delegate(
+    mint_checks: Option<&MintExtensionChecks>,
+    authority: &AccountInfo,
+) -> Result<bool, ProgramError> {
+    if let Some(checks) = mint_checks {
+        if let Some(permanent_delegate_pubkey) = checks.permanent_delegate {
+            if pubkey_eq(authority.key(), &permanent_delegate_pubkey) {
+                if !authority.is_signer() {
+                    return Err(ProgramError::MissingRequiredSignature);
+                }
+                return Ok(true);
+            }
+        }
+    }
+    Ok(false)
+}
+
+/// Process account extensions with mutable access.
+/// Performs extension detection and compressible top-up calculation.
+/// If mint account is provided, validates it matches the token's mint field.
+#[inline(always)]
+#[profile]
+fn process_account_extensions(
+    account: &AccountInfo,
+    current_slot: &mut u64,
+    mint: Option<&AccountInfo>,
+) -> Result<AccountExtensionInfo, ProgramError> {
+    let mut account_data = account
+        .try_borrow_mut_data()
+        .map_err(convert_program_error)?;
+    let (token, remaining) = CToken::zero_copy_at_mut_checked(&mut account_data)?;
+    if !remaining.is_empty() {
+        return Err(ProgramError::InvalidAccountData);
+    }
+
+    // Validate mint account matches token's mint field
+    if let Some(mint_account) = mint {
+        if !pubkey_eq(mint_account.key(), token.mint.array_ref()) {
+            return Err(CTokenError::InvalidAccountData.into());
+        }
+    }
+
+    let mut info = AccountExtensionInfo::default();
+
+    {
+        // Get current slot for compressible top-up calculation
+        use pinocchio::sysvars::{clock::Clock, rent::Rent, Sysvar};
+        if *current_slot == 0 {
+            *current_slot = Clock::get()
+                .map_err(|_| CTokenError::SysvarAccessError)?
+                .slot;
+        }
+
+        let rent_exemption = Rent::get()
+            .map_err(|_| CTokenError::SysvarAccessError)?
+            .minimum_balance(account.data_len());
+
+        info.top_up_amount = token
+            .compression
+            .calculate_top_up_lamports(
+                account.data_len() as u64,
+                *current_slot,
+                account.lamports(),
+                rent_exemption,
+            )
+            .map_err(|_| CTokenError::InvalidAccountData)?;
+
+        // Extract cached decimals if set
+        info.decimals = token.base.decimals();
+    }
+
+    // Process other extensions if present
+    if let Some(extensions) = token.extensions {
+        for extension in extensions {
+            match extension {
+                ZExtensionStructMut::PausableAccount(_) => {
+                    info.flags.has_pausable = true;
+                }
+                ZExtensionStructMut::PermanentDelegateAccount(_) => {
+                    info.flags.has_permanent_delegate = true;
+                }
+                ZExtensionStructMut::TransferFeeAccount(_transfer_fee_ext) => {
+                    info.flags.has_transfer_fee = true;
+                    // Note: Non-zero transfer fees are rejected by check_mint_extensions,
+                    // so no fee withholding is needed here.
+                }
+                ZExtensionStructMut::TransferHookAccount(_) => {
+                    info.flags.has_transfer_hook = true;
+                    // No runtime logic needed - we only support nil program_id
+                }
+                // Placeholder and TokenMetadata variants are not valid for CToken accounts
+                _ => {
+                    return Err(CTokenError::InvalidAccountData.into());
+                }
+            }
+        }
+    }
+
+    Ok(info)
+}
diff --git a/programs/compressed-token/program/src/transfer2/check_extensions.rs b/programs/compressed-token/program/src/transfer2/check_extensions.rs
new file mode 100644
index 0000000000..f60aa48607
--- /dev/null
+++ b/programs/compressed-token/program/src/transfer2/check_extensions.rs
@@ -0,0 +1,145 @@
+use anchor_compressed_token::ErrorCode;
+use anchor_lang::prelude::ProgramError;
+use light_account_checks::packed_accounts::ProgramPackedAccounts;
+use light_array_map::ArrayMap;
+use light_ctoken_interface::instructions::{
+    extensions::ZExtensionInstructionData, transfer2::ZCompressedTokenInstructionDataTransfer2,
+};
+use light_program_profiler::profile;
+use pinocchio::account_info::AccountInfo;
+use spl_pod::solana_msg::msg;
+
+use crate::extensions::{check_mint_extensions, parse_mint_extensions, MintExtensionChecks};
+
+/// Validate TLV data and extract is_frozen flag from CompressedOnly extension.
+///
+/// Returns error if TLV data is present but version is not 3 (ShaFlat).
+/// Returns the is_frozen flag from CompressedOnly extension, or false if not present.
+#[inline(always)]
+pub fn validate_tlv_and_get_frozen(
+    tlv_data: Option<&[ZExtensionInstructionData]>,
+    version: u8,
+) -> Result<bool, ProgramError> {
+    // Validate TLV is only used with version 3 (ShaFlat)
+    if tlv_data.is_some_and(|v| !v.is_empty() && version != 3) {
+        msg!("TLV extensions only supported with version 3 (ShaFlat)");
+        return Err(ErrorCode::TlvRequiresVersion3.into());
+    }
+
+    // Extract is_frozen from CompressedOnly extension (0 = false, non-zero = true)
+    let is_frozen = tlv_data
+        .and_then(|exts| {
+            exts.iter().find_map(|ext| {
+                if let ZExtensionInstructionData::CompressedOnly(data) = ext {
+                    Some(data.is_frozen != 0)
+                } else {
+                    None
+                }
+            })
+        })
+        .unwrap_or(false);
+
+    Ok(is_frozen)
+}
+
+/// Cache for mint extension checks to avoid deserializing the same mint multiple times.
+pub type MintExtensionCache = ArrayMap<u8, MintExtensionChecks, 5>;
+
+/// Build mint extension cache for all unique mints in the instruction.
+///
+/// # Extension State Enforcement Strategy
+///
+/// Restrictions (paused, non-zero fees, non-nil hook) are enforced when **entering** compressed
+/// state, not when **exiting** it. This protects users who compressed tokens before restrictions
+/// were added - they can always recover their tokens.
+///
+/// - **Compress** (from ctoken or SPL): Enforces restrictions. Creating new compressed state
+///   requires valid extension state.
+/// - **Decompress**: Bypasses restrictions. Restoring existing compressed state to on-chain.
+///   If mint state changed after compression, user should still recover their tokens.
+/// - **CompressAndClose**: Bypasses restrictions. Preserving state in CompressedOnly extension.
+///   Foresters should be able to close accounts to recover rent exemption even if mint state changed.
+///
+/// # Errors (Compress mode only):
+/// - `MintPaused` - Mint is paused
+/// - `NonZeroTransferFeeNotSupported` - Transfer fees are non-zero
+/// - `TransferHookNotSupported` - Transfer hook program_id is non-nil
+/// - `MintHasRestrictedExtensions` - When `deny_restricted_extensions=true` and mint has
+///   Pausable, PermanentDelegate, TransferFeeConfig, TransferHook, or DefaultAccountState extensions
+///
+/// # Cached data:
+/// - `permanent_delegate`: Pubkey if PermanentDelegate extension exists and is set
+/// - `has_transfer_fee`: Whether TransferFeeConfig extension exists
+/// - `has_restricted_extensions`: Whether mint has restricted extensions
+/// - `is_paused`, `has_non_zero_transfer_fee`, `has_non_nil_transfer_hook`: Individual state flags
+#[profile]
+#[inline(always)]
+pub fn build_mint_extension_cache<'a>(
+    inputs: &ZCompressedTokenInstructionDataTransfer2,
+    packed_accounts: &'a ProgramPackedAccounts<'a, AccountInfo>,
+) -> Result<MintExtensionCache, ProgramError> {
+    let mut cache: MintExtensionCache = ArrayMap::new();
+    let deny_restricted_extensions = !inputs.out_token_data.is_empty();
+
+    // Collect mints from input token data
+    for input in inputs.in_token_data.iter() {
+        let mint_index = input.mint;
+        if cache.get_by_key(&mint_index).is_none() {
+            let mint_account = packed_accounts.get_u8(mint_index, "mint cache: input")?;
+            let checks = if inputs.out_token_data.is_empty() {
+                // No outputs - bypass state checks (full decompress or transfer-only)
+                parse_mint_extensions(mint_account)?
+            } else {
+                check_mint_extensions(mint_account, deny_restricted_extensions)?
+            };
+            cache.insert(mint_index, checks, ErrorCode::MintCacheCapacityExceeded)?;
+        }
+    }
+
+    // Collect mints from compressions
+    if let Some(compressions) = inputs.compressions.as_ref() {
+        for compression in compressions.iter() {
+            let mint_index = compression.mint;
+
+            if cache.get_by_key(&mint_index).is_none() {
+                let mint_account = packed_accounts.get_u8(mint_index, "mint cache: compression")?;
+                let is_full_decompress =
+                    compression.mode.is_decompress() && inputs.out_token_data.is_empty();
+                let checks = if compression.mode.is_compress_and_close() || is_full_decompress {
+                    // CompressAndClose and Decompress bypass extension state checks
+                    // (paused, non-zero fees, non-nil transfer hook)
+                    parse_mint_extensions(mint_account)?
+                } else {
+                    check_mint_extensions(mint_account, deny_restricted_extensions)?
+                };
+
+                // CompressAndClose with restricted extensions requires CompressedOnly output.
+                // Compress/Decompress don't need additional validation here:
+                // - Compress: blocked by check_mint_extensions when outputs exist
+                // - Decompress: bypassed (restoring existing state)
+                if checks.has_restricted_extensions && compression.mode.is_compress_and_close() {
+                    let output_idx = compression.get_compressed_token_account_index()?;
+                    let has_compressed_only = inputs
+                        .out_tlv
+                        .as_ref()
+                        .and_then(|tlvs| tlvs.get(output_idx as usize))
+                        .map(|tlv| {
+                            tlv.iter()
+                                .any(|e| matches!(e, ZExtensionInstructionData::CompressedOnly(_)))
+                        })
+                        .unwrap_or(false);
+                    if !has_compressed_only {
+                        msg!("Mint has restricted extensions - CompressedOnly output required");
+                        return Err(
+                            ErrorCode::CompressAndCloseMissingCompressedOnlyExtension.into()
+                        );
+                    }
+                }
+
+                cache.insert(mint_index, checks, ErrorCode::MintCacheCapacityExceeded)?;
+            }
+        }
+    }
+
+    Ok(cache)
+}
diff --git a/programs/compressed-token/program/src/transfer2/compression/ctoken/compress_and_close.rs b/programs/compressed-token/program/src/transfer2/compression/ctoken/compress_and_close.rs
index cf24372afb..4f8c334a34 100644
--- a/programs/compressed-token/program/src/transfer2/compression/ctoken/compress_and_close.rs
+++ b/programs/compressed-token/program/src/transfer2/compression/ctoken/compress_and_close.rs
@@ -3,8 +3,11 @@ use anchor_lang::prelude::ProgramError;
 use bitvec::prelude::*;
 use light_account_checks::{checks::check_signer, packed_accounts::ProgramPackedAccounts};
 use light_ctoken_interface::{
-    instructions::transfer2::{ZCompression, ZCompressionMode, ZMultiTokenTransferOutputData},
-    state::{ZCompressedTokenMut, ZExtensionStructMut},
+    instructions::{
+        extensions::ZExtensionInstructionData,
+        transfer2::{ZCompression, ZCompressionMode, ZMultiTokenTransferOutputData},
+    },
+    state::{ZCTokenMut, ZExtensionStructMut},
 };
 use light_program_profiler::profile;
 use pinocchio::{
@@ -28,7 +31,7 @@ pub fn process_compress_and_close(
     compress_and_close_inputs: Option<CompressAndCloseInputs>,
     amount: u64,
     token_account_info: &AccountInfo,
-    ctoken: &mut ZCompressedTokenMut,
+    ctoken: &mut ZCTokenMut,
     packed_accounts: &ProgramPackedAccounts<'_, AccountInfo>,
 ) -> Result<(), ProgramError> {
     let authority = authority.ok_or(ErrorCode::CompressAndCloseAuthorityMissing)?;
@@ -62,9 +65,13 @@ pub fn process_compress_and_close(
         ctoken,
         compress_to_pubkey,
         token_account_info.key(),
+        close_inputs.tlv,
     )?;
 
-    *ctoken.amount = 0.into();
+    ctoken.base.amount.set(0);
+    // Unfreeze the account if frozen (frozen state is preserved in compressed token TLV)
+    // This allows the close_token_account validation to pass for frozen accounts
+    ctoken.base.set_initialized();
     Ok(())
 }
 
@@ -73,27 +80,11 @@ fn validate_compressed_token_account(
     packed_accounts: &ProgramPackedAccounts<'_, AccountInfo>,
     compression_amount: u64,
     compressed_token_account: &ZMultiTokenTransferOutputData<'_>,
-    ctoken: &ZCompressedTokenMut,
+    ctoken: &ZCTokenMut,
     compress_to_pubkey: bool,
     token_account_pubkey: &Pubkey,
+    out_tlv: Option<&[ZExtensionInstructionData<'_>]>,
 ) -> Result<(), ProgramError> {
-    // Source token account must not have a delegate
-    // Compressed tokens don't support delegation, so we reject accounts with delegates
-    if ctoken.delegate.is_some() {
-        msg!("Source token account has delegate, cannot compress and close");
-        return Err(ErrorCode::CompressAndCloseDelegateNotAllowed.into());
-    }
-
-    if !pubkey_eq(
-        ctoken.mint.array_ref(),
-        packed_accounts
-            .get_u8(compressed_token_account.mint, "CompressAndClose: mint")?
-            .key(),
-    ) {
-        msg!("Invalid mint PDA derivation");
-        return Err(ErrorCode::MintActionInvalidMintPda.into());
-    }
-
     // Owners should match if not compressing to pubkey
     if compress_to_pubkey {
         // Owner should match token account pubkey if compressing to pubkey
@@ -113,7 +104,7 @@ fn validate_compressed_token_account(
             );
             return Err(ErrorCode::CompressAndCloseInvalidOwner.into());
         }
-    } else if *ctoken.owner
+    } else if ctoken.owner.to_bytes()
         != *packed_accounts
             .get_u8(compressed_token_account.owner, "CompressAndClose: owner")?
             .key()
@@ -140,42 +131,149 @@ fn validate_compressed_token_account(
         return Err(ErrorCode::CompressAndCloseAmountMismatch.into());
     }
     // Token balance must match the compressed output amount
-    if *ctoken.amount != compressed_token_account.amount {
+    if ctoken.amount.get() != compressed_token_account.amount.get() {
         msg!(
             "output ctoken.amount {} != compressed token account amount {}",
-            ctoken.amount,
+            ctoken.amount.get(),
             compressed_token_account.amount.get()
         );
         return Err(ErrorCode::CompressAndCloseBalanceMismatch.into());
     }
-    // Delegate should be None
-    if compressed_token_account.has_delegate() {
-        return Err(ErrorCode::CompressAndCloseDelegateNotAllowed.into());
-    }
-    if compressed_token_account.delegate != 0 {
-        return Err(ErrorCode::CompressAndCloseDelegateNotAllowed.into());
+
+    // Mint must match
+    let output_mint = packed_accounts
+        .get_u8(compressed_token_account.mint, "CompressAndClose: mint")?
+        .key();
+    if *output_mint != ctoken.mint.to_bytes() {
+        msg!(
+            "mint mismatch: ctoken {:?} != output {:?}",
+            solana_pubkey::Pubkey::new_from_array(ctoken.mint.to_bytes()),
+            solana_pubkey::Pubkey::new_from_array(*output_mint)
+        );
+        return Err(ErrorCode::CompressAndCloseInvalidMint.into());
     }
+
     // Version should be ShaFlat
     if compressed_token_account.version != 3 {
         return Err(ErrorCode::CompressAndCloseInvalidVersion.into());
     }
 
-    // Version should also match what's specified in the compressible extension
-    let expected_version = ctoken
-        .extensions
-        .as_ref()
-        .and_then(|ext| {
-            if let Some(ZExtensionStructMut::Compressible(ext)) = ext.first() {
-                Some(ext.info.account_version)
-            } else {
-                None
-            }
-        })
-        .ok_or(ErrorCode::CompressAndCloseInvalidVersion)?;
+    // Version should also match what's specified in the embedded compression info
+    let expected_version = ctoken.compression.account_version;
+    let compression_only = ctoken.compression_only != 0;
 
     if compressed_token_account.version != expected_version {
         return Err(ErrorCode::CompressAndCloseInvalidVersion.into());
     }
+    let compression_only_extension = out_tlv.as_ref().and_then(|ext| {
+        ext.iter()
+            .find(|e| matches!(e, ZExtensionInstructionData::CompressedOnly(_)))
+    });
+
+    if compression_only && compression_only_extension.is_none() {
+        return Err(ErrorCode::CompressAndCloseMissingCompressedOnlyExtension.into());
+    }
+
+    if let Some(ZExtensionInstructionData::CompressedOnly(compression_only_extension)) =
+        compression_only_extension
+    {
+        // Delegated amounts must match
+        if u64::from(compression_only_extension.delegated_amount) != ctoken.delegated_amount.get() {
+            msg!(
+                "delegated_amount mismatch: ctoken {} != extension {}",
+                ctoken.delegated_amount.get(),
+                u64::from(compression_only_extension.delegated_amount)
+            );
+            return Err(ErrorCode::CompressAndCloseDelegatedAmountMismatch.into());
+        }
+        // Delegate must be preserved for exact state restoration during decompress
+        if ctoken.delegate().is_some() || compression_only_extension.delegated_amount != 0 {
+            let delegate = ctoken
+                .delegate()
+                .ok_or(ErrorCode::CompressAndCloseInvalidDelegate)?;
+            if !compressed_token_account.has_delegate() {
+                msg!("ctoken has delegate but compressed token output does not");
+                return Err(ErrorCode::CompressAndCloseInvalidDelegate.into());
+            }
+            let token_data_delegate = packed_accounts.get_u8(
+                compressed_token_account.delegate,
+                "compressed_token_account delegate",
+            )?;
+            if !pubkey_eq(token_data_delegate.key(), &delegate.to_bytes()) {
+                msg!(
+                    "delegate mismatch: ctoken {:?} != output {:?}",
+                    solana_pubkey::Pubkey::new_from_array(delegate.to_bytes()),
+                    solana_pubkey::Pubkey::new_from_array(*token_data_delegate.key())
+                );
+                return Err(ErrorCode::CompressAndCloseInvalidDelegate.into());
+            }
+        }
+        // if ctoken has fee extension withheld amount must match
+        let ctoken_withheld_fee = ctoken.extensions.as_ref().and_then(|exts| {
+            exts.iter().find_map(|ext| {
+                if let ZExtensionStructMut::TransferFeeAccount(fee_ext) = ext {
+                    Some(fee_ext.withheld_amount)
+                } else {
+                    None
+                }
+            })
+        });
+
+        if let Some(withheld_fee) = ctoken_withheld_fee {
+            if compression_only_extension.withheld_transfer_fee != withheld_fee {
+                msg!(
+                    "withheld_transfer_fee mismatch: ctoken {} != extension {}",
+                    withheld_fee,
+                    u64::from(compression_only_extension.withheld_transfer_fee)
+                );
+                return Err(ErrorCode::CompressAndCloseWithheldFeeMismatch.into());
+            }
+        } else if u64::from(compression_only_extension.withheld_transfer_fee) != 0 {
+            msg!(
+                "withheld_transfer_fee must be 0 when ctoken has no fee extension, got {}",
+                u64::from(compression_only_extension.withheld_transfer_fee)
+            );
+            return Err(ErrorCode::CompressAndCloseWithheldFeeMismatch.into());
+        }
+
+        // Frozen state must match between CToken and extension data
+        // AccountState::Frozen = 2 in CToken
+        // ZeroCopy converts bool to u8: 0 = false, non-zero = true
+        let ctoken_is_frozen = ctoken.state == 2;
+        let extension_is_frozen = compression_only_extension.is_frozen != 0;
+        if extension_is_frozen != ctoken_is_frozen {
+            msg!(
+                "is_frozen mismatch: ctoken {} != extension {}",
+                ctoken_is_frozen,
+                compression_only_extension.is_frozen
+            );
+            return Err(ErrorCode::CompressAndCloseFrozenMismatch.into());
+        }
+    } else {
+        // Frozen accounts require CompressedOnly extension to preserve frozen state
+        // AccountState::Frozen = 2 in CToken
+        let ctoken_is_frozen = ctoken.state == 2;
+        if ctoken_is_frozen {
+            msg!("Frozen account requires CompressedOnly extension with is_frozen=true");
+            return Err(ErrorCode::CompressAndCloseMissingCompressedOnlyExtension.into());
+        }
+
+        // Source token account must not have a delegate
+        // Compressed tokens don't support delegation, so we reject accounts with delegates
+        if ctoken.delegate().is_some() {
+            msg!("Source token account has delegate, cannot compress and close");
+            return Err(ErrorCode::CompressAndCloseDelegateNotAllowed.into());
+        }
+
+        // Delegate should be None
+        if compressed_token_account.has_delegate() {
+            return Err(ErrorCode::CompressAndCloseDelegateNotAllowed.into());
+        }
+        if compressed_token_account.delegate != 0 {
+            return Err(ErrorCode::CompressAndCloseDelegateNotAllowed.into());
+        }
+    }
+
     Ok(())
 }
 
diff --git a/programs/compressed-token/program/src/transfer2/compression/ctoken/compress_or_decompress_ctokens.rs b/programs/compressed-token/program/src/transfer2/compression/ctoken/compress_or_decompress_ctokens.rs
index 54de5bf7b3..291b4b4564 100644
--- a/programs/compressed-token/program/src/transfer2/compression/ctoken/compress_or_decompress_ctokens.rs
+++ b/programs/compressed-token/program/src/transfer2/compression/ctoken/compress_or_decompress_ctokens.rs
@@ -3,18 +3,22 @@ use anchor_lang::prelude::ProgramError;
 use light_account_checks::checks::check_owner;
 use light_ctoken_interface::{
     instructions::transfer2::ZCompressionMode,
-    state::{CToken, ZExtensionStructMut},
+    state::{CToken, ZCTokenMut},
     CTokenError,
 };
 use light_program_profiler::profile;
+use light_zero_copy::traits::ZeroCopyAtMut;
 use pinocchio::{
     account_info::AccountInfo,
     pubkey::pubkey_eq,
-    sysvars::{clock::Clock, Sysvar},
+    sysvars::{clock::Clock, rent::Rent, Sysvar},
 };
 use spl_pod::solana_msg::msg;
 
-use super::{compress_and_close::process_compress_and_close, inputs::CTokenCompressionInputs};
+use super::{
+    compress_and_close::process_compress_and_close, decompress::apply_decompress_extension_state,
+    inputs::CTokenCompressionInputs,
+};
 use crate::shared::owner_validation::check_ctoken_owner;
 
 /// Perform compression/decompression on a ctoken account.
@@ -35,6 +39,8 @@ pub fn compress_or_decompress_ctokens(
         token_account_info,
         mode,
         packed_accounts,
+        mint_checks,
+        decompress_inputs,
     } = inputs;
 
     check_owner(&crate::LIGHT_CPI_SIGNER.program_id, token_account_info)?;
@@ -42,46 +48,29 @@ pub fn compress_or_decompress_ctokens(
         .try_borrow_mut_data()
         .map_err(|_| ProgramError::AccountBorrowFailed)?;
 
-    let (mut ctoken, _) = CToken::zero_copy_at_mut_checked(&mut token_account_data)?;
-
-    if !pubkey_eq(ctoken.mint.array_ref(), &mint) {
-        msg!(
-            "mint mismatch account: ctoken.mint {:?}, mint {:?}",
-            solana_pubkey::Pubkey::new_from_array(ctoken.mint.to_bytes()),
-            solana_pubkey::Pubkey::new_from_array(mint)
-        );
-        return Err(ProgramError::InvalidAccountData);
-    }
-
-    // Check if account is frozen (SPL Token-2022 compatibility)
-    // Frozen accounts cannot have their balance modified in any way
-    // TODO: Once freezing ctoken accounts is implemented, we need to allow
-    // CompressAndClose with rent authority for frozen accounts (similar to
-    // how rent authority can compress expired accounts)
-    if *ctoken.state == 2 {
-        msg!("Cannot modify frozen account");
-        return Err(ErrorCode::AccountFrozen.into());
-    }
+    let (mut ctoken, _) = CToken::zero_copy_at_mut(&mut token_account_data)?;
+    validate_ctoken(&ctoken, &mint, &mode)?;
 
     // Get current balance
-    let current_balance: u64 = u64::from(*ctoken.amount);
+    let current_balance: u64 = ctoken.base.amount.get();
     let mut current_slot = 0;
     // Calculate new balance using effective amount
     match mode {
         ZCompressionMode::Compress => {
-            // Verify authority for compression operations and update delegated amount if needed
+            // Verify authority for compression operations
             let authority_account = authority.ok_or(ErrorCode::InvalidCompressAuthority)?;
-            check_ctoken_owner(&mut ctoken, authority_account)?;
+            check_ctoken_owner(&mut ctoken, authority_account, mint_checks.as_ref())?;
 
             // Compress: subtract from solana account
             // Update the balance in the ctoken solana account
-            *ctoken.amount = current_balance
-                .checked_sub(amount)
-                .ok_or(ProgramError::ArithmeticOverflow)?
-                .into();
+            ctoken.base.amount.set(
+                current_balance
+                    .checked_sub(amount)
+                    .ok_or(ProgramError::ArithmeticOverflow)?,
+            );
 
-            process_compressible_extension(
-                ctoken.extensions.as_deref(),
+            process_compression_top_up(
+                &ctoken.base.compression,
                 token_account_info,
                 &mut current_slot,
                 transfer_amount,
@@ -89,15 +78,20 @@ pub fn compress_or_decompress_ctokens(
             )
         }
         ZCompressionMode::Decompress => {
+            // Handle extension state transfer from input compressed account
+            // Must be done BEFORE updating amount since validation checks for fresh (zero) amount
+            apply_decompress_extension_state(&mut ctoken, decompress_inputs)?;
+
             // Decompress: add to solana account
             // Update the balance in the compressed token account
-            *ctoken.amount = current_balance
-                .checked_add(amount)
-                .ok_or(ProgramError::ArithmeticOverflow)?
-                .into();
+            ctoken.base.amount.set(
+                current_balance
+                    .checked_add(amount)
+                    .ok_or(ProgramError::ArithmeticOverflow)?,
+            );
 
-            process_compressible_extension(
-                ctoken.extensions.as_deref(),
+            process_compression_top_up(
+                &ctoken.base.compression,
                 token_account_info,
                 &mut current_slot,
                 transfer_amount,
@@ -115,9 +109,11 @@ pub fn compress_or_decompress_ctokens(
     }
 }
 
+/// Process compression top-up using embedded compression info.
+/// All ctoken accounts now have compression info embedded directly in meta.
 #[inline(always)]
-fn process_compressible_extension(
-    extensions: Option<&[ZExtensionStructMut]>,
+pub fn process_compression_top_up(
+    compression: &light_compressible::compression_info::ZCompressionInfoMut<'_>,
     token_account_info: &AccountInfo,
     current_slot: &mut u64,
     transfer_amount: &mut u64,
@@ -127,29 +123,69 @@ fn process_compressible_extension(
         return Ok(());
     }
 
-    if let Some(extensions) = extensions {
-        for extension in extensions.iter() {
-            if let ZExtensionStructMut::Compressible(compressible_extension) = extension {
-                if *current_slot == 0 {
-                    *current_slot = Clock::get()
-                        .map_err(|_| CTokenError::SysvarAccessError)?
-                        .slot;
-                }
-                *transfer_amount = compressible_extension
-                    .info
-                    .calculate_top_up_lamports(
-                        token_account_info.data_len() as u64,
-                        *current_slot,
-                        token_account_info.lamports(),
-                        light_ctoken_interface::COMPRESSIBLE_TOKEN_RENT_EXEMPTION,
-                    )
-                    .map_err(|_| CTokenError::InvalidAccountData)?;
-
-                *lamports_budget = lamports_budget.saturating_sub(*transfer_amount);
-
-                return Ok(());
-            }
-        }
+    if *current_slot == 0 {
+        *current_slot = Clock::get()
+            .map_err(|_| CTokenError::SysvarAccessError)?
+            .slot;
     }
+    let rent_exemption = Rent::get()
+        .map_err(|_| CTokenError::SysvarAccessError)?
+        .minimum_balance(token_account_info.data_len());
+
+    *transfer_amount = compression
+        .calculate_top_up_lamports(
+            token_account_info.data_len() as u64,
+            *current_slot,
+            token_account_info.lamports(),
+            rent_exemption,
+        )
+        .map_err(|_| CTokenError::InvalidAccountData)?;
+
+    *lamports_budget = lamports_budget.saturating_sub(*transfer_amount);
+
+    Ok(())
+}
+
+/// Validate a CToken account for compression/decompression operations.
+///
+/// Checks:
+/// - Account type is CToken (not SPL token)
+/// - Account is initialized
+/// - Account is not frozen (unless CompressAndClose mode)
+/// - Mint matches expected mint
+#[inline(always)]
+fn validate_ctoken(
+    ctoken: &ZCTokenMut,
+    mint: &[u8; 32],
+    mode: &ZCompressionMode,
+) -> Result<(), ProgramError> {
+    // Account type check: must be CToken account (byte 165 == 2)
+    if !ctoken.is_ctoken_account() {
+        msg!("Invalid account type");
+        return Err(CTokenError::InvalidAccountType.into());
+    }
+
+    // Reject uninitialized accounts (state == 0)
+    if ctoken.base.state == 0 {
+        msg!("Account is uninitialized");
+        return Err(CTokenError::InvalidAccountState.into());
+    }
+    // Check if account is frozen (SPL Token-2022 compatibility)
+    // Frozen accounts cannot have their balance modified except for CompressAndClose
+    else if ctoken.base.state == 2 && !mode.is_compress_and_close() {
+        msg!("Cannot modify frozen account");
+        return Err(ErrorCode::AccountFrozen.into());
+    }
+
+    // Validate mint matches
+    if !pubkey_eq(ctoken.mint.array_ref(), mint) {
+        msg!(
+            "mint mismatch: ctoken.mint {:?}, expected {:?}",
+            solana_pubkey::Pubkey::new_from_array(ctoken.mint.to_bytes()),
+            solana_pubkey::Pubkey::new_from_array(*mint)
+        );
+        return Err(ProgramError::InvalidAccountData);
+    }
+
     Ok(())
 }
diff --git a/programs/compressed-token/program/src/transfer2/compression/ctoken/decompress.rs b/programs/compressed-token/program/src/transfer2/compression/ctoken/decompress.rs
new file mode 100644
index 0000000000..16fa845464
--- /dev/null
+++ b/programs/compressed-token/program/src/transfer2/compression/ctoken/decompress.rs
@@ -0,0 +1,128 @@
+use anchor_lang::prelude::ProgramError;
+use light_compressed_account::Pubkey;
+use light_ctoken_interface::{
+    instructions::extensions::ZExtensionInstructionData,
+    state::{ZCTokenMut, ZExtensionStructMut},
+    CTokenError,
+};
+use spl_pod::solana_msg::msg;
+
+use super::inputs::DecompressCompressOnlyInputs;
+
+/// Validates that the destination CToken is a fresh/zeroed account with matching owner.
+/// This ensures we can recreate the exact account state from the CompressedOnly extension.
+#[inline(always)]
+fn validate_decompression_destination(
+    ctoken: &ZCTokenMut,
+    input_owner: &Pubkey,
+) -> Result<(), ProgramError> {
+    // Owner must match
+    if ctoken.base.owner.to_bytes() != input_owner.to_bytes() {
+        msg!("Decompress destination owner mismatch");
+        return Err(CTokenError::DecompressDestinationNotFresh.into());
+    }
+
+    // Amount must be 0
+    if ctoken.base.amount.get() != 0 {
+        msg!("Decompress destination has non-zero amount");
+        return Err(CTokenError::DecompressDestinationNotFresh.into());
+    }
+
+    // Must not have delegate
+    if ctoken.delegate().is_some() {
+        msg!("Decompress destination has delegate set");
+        return Err(CTokenError::DecompressDestinationNotFresh.into());
+    }
+
+    // Delegated amount must be 0
+    if ctoken.base.delegated_amount.get() != 0 {
+        msg!("Decompress destination has non-zero delegated_amount");
+        return Err(CTokenError::DecompressDestinationNotFresh.into());
+    }
+
+    // Must not have close authority
+    if ctoken.close_authority().is_some() {
+        msg!("Decompress destination has close_authority set");
+        return Err(CTokenError::DecompressDestinationNotFresh.into());
+    }
+
+    Ok(())
+}
+
+/// Apply extension state from the input compressed account during decompress.
+/// This transfers delegate, delegated_amount, and withheld_transfer_fee from
+/// the compressed account's CompressedOnly extension to the CToken account.
+#[inline(always)]
+pub fn apply_decompress_extension_state(
+    ctoken: &mut ZCTokenMut,
+    decompress_inputs: Option<DecompressCompressOnlyInputs>,
+) -> Result<(), ProgramError> {
+    // If no decompress inputs, nothing to transfer
+    let Some(inputs) = decompress_inputs else {
+        return Ok(());
+    };
+
+    // Extract CompressedOnly extension data from input TLV
+    let compressed_only_data = inputs.tlv.iter().find_map(|ext| {
+        if let ZExtensionInstructionData::CompressedOnly(data) = ext {
+            Some(data)
+        } else {
+            None
+        }
+    });
+
+    // If no CompressedOnly extension, nothing to transfer
+    let Some(ext_data) = compressed_only_data else {
+        return Ok(());
+    };
+
+    // Validate destination is a fresh account with matching owner
+    validate_decompression_destination(ctoken, &Pubkey::from(*inputs.owner.key()))?;
+
+    let delegated_amount: u64 = ext_data.delegated_amount.into();
+    let withheld_transfer_fee: u64 = ext_data.withheld_transfer_fee.into();
+
+    // Handle delegate and delegated_amount
+    if delegated_amount > 0 || inputs.delegate.is_some() {
+        let input_delegate_pubkey = inputs.delegate.map(|acc| Pubkey::from(*acc.key()));
+
+        if let Some(input_del) = input_delegate_pubkey {
+            // Set delegate from the input (destination is guaranteed fresh with no delegate)
+            ctoken.base.set_delegate(Some(input_del))?;
+        } else if delegated_amount > 0 {
+            // Has delegated_amount but no delegate pubkey - invalid state
+            msg!("Decompress: delegated_amount > 0 but no delegate pubkey provided");
+            return Err(CTokenError::InvalidAccountData.into());
+        }
+
+        // Set delegated_amount (destination is guaranteed to have 0)
+        if delegated_amount > 0 {
+            ctoken.base.delegated_amount.set(delegated_amount);
+        }
+    }
+
+    // Handle withheld_transfer_fee
+    if withheld_transfer_fee > 0 {
+        let mut fee_applied = false;
+        if let Some(extensions) = ctoken.extensions.as_deref_mut() {
+            for extension in extensions.iter_mut() {
+                if let ZExtensionStructMut::TransferFeeAccount(ref mut fee_ext) = extension {
+                    fee_ext.add_withheld_amount(withheld_transfer_fee)?;
+                    fee_applied = true;
+                    break;
+                }
+            }
+        }
+        if !fee_applied {
+            msg!("Decompress: withheld_transfer_fee > 0 but no TransferFeeAccount extension found");
+            return Err(CTokenError::InvalidAccountData.into());
+        }
+    }
+
+    // Handle is_frozen - restore frozen state from compressed token
+    if ext_data.is_frozen != 0 {
+        ctoken.base.set_frozen();
+    }
+
+    Ok(())
+}
diff --git a/programs/compressed-token/program/src/transfer2/compression/ctoken/inputs.rs b/programs/compressed-token/program/src/transfer2/compression/ctoken/inputs.rs
index 305555c75c..0cf1ed3904 100644
--- a/programs/compressed-token/program/src/transfer2/compression/ctoken/inputs.rs
+++ b/programs/compressed-token/program/src/transfer2/compression/ctoken/inputs.rs
@@ -1,15 +1,100 @@
+use anchor_lang::prelude::ProgramError;
 use light_account_checks::packed_accounts::ProgramPackedAccounts;
-use light_ctoken_interface::instructions::transfer2::{
-    ZCompressedTokenInstructionDataTransfer2, ZCompression, ZCompressionMode,
-    ZMultiTokenTransferOutputData,
+use light_ctoken_interface::instructions::{
+    extensions::ZExtensionInstructionData,
+    transfer2::{
+        ZCompressedTokenInstructionDataTransfer2, ZCompression, ZCompressionMode,
+        ZMultiTokenTransferOutputData,
+    },
 };
 use pinocchio::{account_info::AccountInfo, pubkey::Pubkey};
+use spl_pod::solana_msg::msg;
+
+use crate::extensions::MintExtensionChecks;
+
+/// Decompress-specific inputs from the input compressed account.
+/// Only required for decompression with CompressedOnly extension.
+pub struct DecompressCompressOnlyInputs<'a> {
+    /// Input TLV for decompress operations (from the input compressed account being consumed).
+    pub tlv: &'a [ZExtensionInstructionData<'a>],
+    /// Delegate pubkey from input compressed account (for decompress extension state transfer).
+    pub delegate: Option<&'a AccountInfo>,
+    /// Owner pubkey from input compressed account (for decompress destination validation).
+    pub owner: &'a AccountInfo,
+}
+
+impl<'a> DecompressCompressOnlyInputs<'a> {
+    /// Extract decompress inputs for CompressedOnly extension state transfer.
+    ///
+    /// Extracts TLV, delegate, and owner from the input compressed account for decompress
+    /// operations. Also validates compression-input consistency (mode and mint match).
+    #[inline(always)]
+    pub fn try_extract(
+        compression: &ZCompression,
+        compression_index: usize,
+        compression_to_input: &[Option<u8>; 32],
+        inputs: &'a ZCompressedTokenInstructionDataTransfer2<'a>,
+        packed_accounts: &'a ProgramPackedAccounts<'a, AccountInfo>,
+    ) -> Result<Option<Self>, ProgramError> {
+        let Some(input_idx) = compression_to_input[compression_index] else {
+            return Ok(None);
+        };
+        let idx = input_idx as usize;
+
+        // Compression must be Decompress mode to consume an input
+        if compression.mode != ZCompressionMode::Decompress {
+            msg!(
+                "Input linked to non-decompress compression at index {}",
+                compression_index
+            );
+            return Err(ProgramError::InvalidInstructionData);
+        }
+
+        // Validate mint matches between compression and input
+        let input_data = inputs
+            .in_token_data
+            .get(idx)
+            .ok_or(ProgramError::InvalidInstructionData)?;
+        if compression.mint != input_data.mint {
+            msg!(
+                "Mint mismatch between compression and input at index {}",
+                compression_index
+            );
+            return Err(ProgramError::InvalidInstructionData);
+        }
+
+        // Get TLV slice (use empty slice if not present)
+        let tlv = inputs
+            .in_tlv
+            .as_ref()
+            .and_then(|tlvs| tlvs.get(idx))
+            .map(|v| v.as_slice())
+            .unwrap_or(&[]);
+
+        // Get delegate (optional, only if input has delegate)
+        let delegate = if input_data.has_delegate() {
+            Some(packed_accounts.get_u8(input_data.delegate, "input delegate")?)
+        } else {
+            None
+        };
+
+        // Get owner (required for DecompressCompressOnlyInputs)
+        let owner = packed_accounts.get_u8(input_data.owner, "input owner")?;
+
+        Ok(Some(DecompressCompressOnlyInputs {
+            tlv,
+            delegate,
+            owner,
+        }))
+    }
+}
 
 /// Compress and close specific inputs
 pub struct CompressAndCloseInputs<'a> {
     pub destination: &'a AccountInfo,
     pub rent_sponsor: &'a AccountInfo,
     pub compressed_token_account: Option<&'a ZMultiTokenTransferOutputData<'a>>,
+    pub tlv: Option<&'a [ZExtensionInstructionData<'a>]>,
 }
 
 /// Input struct for ctoken compression/decompression operations
@@ -21,6 +106,11 @@ pub struct CTokenCompressionInputs<'a> {
     pub token_account_info: &'a AccountInfo,
     pub mode: ZCompressionMode,
     pub packed_accounts: &'a ProgramPackedAccounts<'a, AccountInfo>,
+    /// Mint extension checks result (permanent delegate, transfer fee info).
+    /// Used to validate permanent delegate authority for compression operations.
+    pub mint_checks: Option<MintExtensionChecks>,
+    /// Decompress-specific inputs (TLV, delegate, owner from input compressed account).
+    pub decompress_inputs: Option<DecompressCompressOnlyInputs<'a>>,
 }
 
 impl<'a> CTokenCompressionInputs<'a> {
@@ -28,8 +118,10 @@ impl<'a> CTokenCompressionInputs<'a> {
     pub fn from_compression(
         compression: &ZCompression,
         token_account_info: &'a AccountInfo,
-        inputs: &'a ZCompressedTokenInstructionDataTransfer2,
+        inputs: &'a ZCompressedTokenInstructionDataTransfer2<'a>,
         packed_accounts: &'a ProgramPackedAccounts<'a, AccountInfo>,
+        mint_checks: Option<MintExtensionChecks>,
+        decompress_inputs: Option<DecompressCompressOnlyInputs<'a>>,
     ) -> Result<Self, anchor_lang::prelude::ProgramError> {
         let authority_account = if compression.mode != ZCompressionMode::Decompress {
             Some(packed_accounts.get_u8(
@@ -58,6 +150,13 @@ impl<'a> CTokenCompressionInputs<'a> {
                 compressed_token_account: inputs
                     .out_token_data
                     .get(compression.get_compressed_token_account_index()? as usize),
+                tlv: inputs
+                    .out_tlv
+                    .as_ref()
+                    .and_then(|v| {
+                        v.get(compression.get_compressed_token_account_index().ok()? as usize)
+                    })
+                    .map(|data| data.as_slice()),
             })
         } else {
             None
@@ -71,6 +170,8 @@ impl<'a> CTokenCompressionInputs<'a> {
             token_account_info,
             mode: compression.mode.clone(),
             packed_accounts,
+            mint_checks,
+            decompress_inputs,
         })
     }
 
@@ -88,6 +189,8 @@ impl<'a> CTokenCompressionInputs<'a> {
             token_account_info,
             mode: ZCompressionMode::Decompress,
             packed_accounts,
+            mint_checks: None,
+            decompress_inputs: None,
         }
     }
 }
diff --git a/programs/compressed-token/program/src/transfer2/compression/ctoken/mod.rs b/programs/compressed-token/program/src/transfer2/compression/ctoken/mod.rs
index 92dd3bdf17..b52ba4a2d6 100644
--- a/programs/compressed-token/program/src/transfer2/compression/ctoken/mod.rs
+++ b/programs/compressed-token/program/src/transfer2/compression/ctoken/mod.rs
@@ -6,24 +6,31 @@ use light_program_profiler::profile;
 use pinocchio::account_info::AccountInfo;
 
 use super::validate_compression_mode_fields;
+use crate::extensions::MintExtensionChecks;
 
 mod compress_and_close;
 mod compress_or_decompress_ctokens;
+mod decompress;
 mod inputs;
 
 pub use compress_and_close::close_for_compress_and_close;
-pub use compress_or_decompress_ctokens::compress_or_decompress_ctokens;
-pub use inputs::{CTokenCompressionInputs, CompressAndCloseInputs};
+pub use compress_or_decompress_ctokens::{
+    compress_or_decompress_ctokens, process_compression_top_up,
+};
+pub use inputs::{CTokenCompressionInputs, CompressAndCloseInputs, DecompressCompressOnlyInputs};
 
 /// Process compression/decompression for ctoken accounts.
 #[profile]
-pub(super) fn process_ctoken_compressions(
-    inputs: &ZCompressedTokenInstructionDataTransfer2,
+#[allow(clippy::too_many_arguments)]
+pub(super) fn process_ctoken_compressions<'a>(
+    inputs: &'a ZCompressedTokenInstructionDataTransfer2<'a>,
     compression: &ZCompression,
-    token_account_info: &AccountInfo,
-    packed_accounts: &ProgramPackedAccounts<'_, AccountInfo>,
+    token_account_info: &'a AccountInfo,
+    packed_accounts: &'a ProgramPackedAccounts<'a, AccountInfo>,
+    mint_checks: Option<MintExtensionChecks>,
     transfer_amount: &mut u64,
     lamports_budget: &mut u64,
+    decompress_inputs: Option<DecompressCompressOnlyInputs<'a>>,
 ) -> Result<(), anchor_lang::prelude::ProgramError> {
     // Validate compression fields for the given mode
     validate_compression_mode_fields(compression)?;
@@ -34,6 +41,8 @@ pub(super) fn process_ctoken_compressions(
         token_account_info,
         inputs,
         packed_accounts,
+        mint_checks,
+        decompress_inputs,
     )?;
 
     compress_or_decompress_ctokens(compression_inputs, transfer_amount, lamports_budget)
diff --git a/programs/compressed-token/program/src/transfer2/compression/mod.rs b/programs/compressed-token/program/src/transfer2/compression/mod.rs
index 4e67aaaeb8..e01db37136 100644
--- a/programs/compressed-token/program/src/transfer2/compression/mod.rs
+++ b/programs/compressed-token/program/src/transfer2/compression/mod.rs
@@ -13,6 +13,7 @@ use light_program_profiler::profile;
 use pinocchio::account_info::AccountInfo;
 use spl_pod::solana_msg::msg;
 
+use super::check_extensions::MintExtensionCache;
 use crate::{
     shared::{
         convert_program_error,
@@ -26,6 +27,7 @@ pub mod spl;
 
 pub use ctoken::{
     close_for_compress_and_close, compress_or_decompress_ctokens, CTokenCompressionInputs,
+    DecompressCompressOnlyInputs,
 };
 
 const SPL_TOKEN_ID: &[u8; 32] = &spl_token::ID.to_bytes();
@@ -36,20 +38,28 @@ const ID: &[u8; 32] = &LIGHT_CPI_SIGNER.program_id;
 ///
 /// # Arguments
 /// * `max_top_up` - Maximum lamports for rent and top-up combined. Transaction fails if exceeded. (0 = no limit)
+/// * `compression_to_input` - Lookup array mapping compression index to input index for decompress operations
 #[profile]
-pub fn process_token_compression(
+pub fn process_token_compression<'a>(
     fee_payer: &AccountInfo,
-    inputs: &ZCompressedTokenInstructionDataTransfer2,
-    packed_accounts: &ProgramPackedAccounts<'_, AccountInfo>,
+    inputs: &'a ZCompressedTokenInstructionDataTransfer2<'a>,
+    packed_accounts: &'a ProgramPackedAccounts<'a, AccountInfo>,
     cpi_authority: &AccountInfo,
     max_top_up: u16,
+    mint_cache: &'a MintExtensionCache,
+    compression_to_input: &[Option<u8>; 32],
 ) -> Result<(), ProgramError> {
     if let Some(compressions) = inputs.compressions.as_ref() {
+        if compressions.len() >= 32 {
+            // TODO: add meaningful error message
+            // TODO: use constant instead of 32.
+            return Err(ProgramError::InvalidInstructionData);
+        }
         let mut transfer_map = [0u64; MAX_PACKED_ACCOUNTS];
         // Initialize budget: +1 allows exact match (total == max_top_up)
         let mut lamports_budget = (max_top_up as u64).saturating_add(1);
 
-        for compression in compressions {
+        for (compression_index, compression) in compressions.iter().enumerate() {
             let account_index = compression.source_or_recipient as usize;
             if account_index >= MAX_PACKED_ACCOUNTS {
                 msg!(
@@ -65,31 +75,65 @@ pub fn process_token_compression(
                 "compression source or recipient",
             )?;
 
+            // Lookup cached mint extension checks (cache was built with skip logic already applied)
+            let mint_checks = mint_cache.get_by_key(&compression.mint).cloned();
+
             match source_or_recipient.owner() {
-                ID => ctoken::process_ctoken_compressions(
-                    inputs,
-                    compression,
-                    source_or_recipient,
-                    packed_accounts,
-                    &mut transfer_map[account_index],
-                    &mut lamports_budget,
-                )?,
+                ID => {
+                    let decompress_with_compress_only_inputs =
+                        DecompressCompressOnlyInputs::try_extract(
+                            compression,
+                            compression_index,
+                            compression_to_input,
+                            inputs,
+                            packed_accounts,
+                        )?;
+
+                    ctoken::process_ctoken_compressions(
+                        inputs,
+                        compression,
+                        source_or_recipient,
+                        packed_accounts,
+                        mint_checks,
+                        &mut transfer_map[account_index],
+                        &mut lamports_budget,
+                        decompress_with_compress_only_inputs,
+                    )?;
+                }
                 SPL_TOKEN_ID => {
+                    // SPL Token (not Token-2022) never has restricted extensions.
+                    // Delegation is disregarded for decompression to SPL token accounts.
                     spl::process_spl_compressions(
                         compression,
                         &SPL_TOKEN_ID.to_pubkey_bytes(),
                         source_or_recipient,
                         packed_accounts,
                         cpi_authority,
+                        false, // SPL Token has no extensions
                     )?;
                 }
                 SPL_TOKEN_2022_ID => {
+                    // CompressedOnly inputs must decompress to CToken accounts to preserve
+                    // extension state (frozen, delegated, withheld fees).
+                    if compression.mode.is_decompress()
+                        && compression_to_input[compression_index].is_some()
+                    {
+                        msg!("CompressedOnly inputs must decompress to CToken account");
+                        return Err(ErrorCode::CompressedOnlyRequiresCTokenDecompress.into());
+                    }
+
+                    // Check if mint has restricted extensions from the cache.
+                    // Delegation is disregarded for decompression to SPL token accounts.
+                    let is_restricted = mint_checks
+                        .map(|checks| checks.has_restricted_extensions)
+                        .unwrap_or(false);
                     spl::process_spl_compressions(
                         compression,
                         &SPL_TOKEN_2022_ID.to_pubkey_bytes(),
                         source_or_recipient,
                         packed_accounts,
                         cpi_authority,
+                        is_restricted,
                     )?;
                 }
                 _ => {
diff --git a/programs/compressed-token/program/src/transfer2/compression/spl.rs b/programs/compressed-token/program/src/transfer2/compression/spl.rs
index 2ac126f752..3d17754694 100644
--- a/programs/compressed-token/program/src/transfer2/compression/spl.rs
+++ b/programs/compressed-token/program/src/transfer2/compression/spl.rs
@@ -1,7 +1,10 @@
-use anchor_compressed_token::check_spl_token_pool_derivation_with_index;
+use anchor_compressed_token::ErrorCode;
 use anchor_lang::prelude::ProgramError;
 use light_account_checks::packed_accounts::ProgramPackedAccounts;
-use light_ctoken_interface::instructions::transfer2::{ZCompression, ZCompressionMode};
+use light_ctoken_interface::{
+    instructions::transfer2::{ZCompression, ZCompressionMode},
+    is_valid_spl_interface_pda,
+};
 use light_program_profiler::profile;
 use light_sdk_types::CPI_AUTHORITY_PDA_SEED;
 use pinocchio::{
@@ -21,44 +24,55 @@ pub(super) fn process_spl_compressions(
     token_account_info: &AccountInfo,
     packed_accounts: &ProgramPackedAccounts<'_, AccountInfo>,
     cpi_authority: &AccountInfo,
+    is_restricted: bool,
 ) -> Result<(), ProgramError> {
     let mode = &compression.mode;
 
     validate_compression_mode_fields(compression)?;
 
-    let mint_account = *packed_accounts
-        .get_u8(compression.mint, "process_spl_compression: token mint")?
-        .key();
+    let mint_account_info =
+        packed_accounts.get_u8(compression.mint, "process_spl_compression: token mint")?;
+    let mint_account = *mint_account_info.key();
+
+    let decimals = compression.decimals;
+
     let token_pool_account_info = packed_accounts.get_u8(
         compression.pool_account_index,
         "process_spl_compression: token pool account",
     )?;
-    check_spl_token_pool_derivation_with_index(
+    if !is_valid_spl_interface_pda(
+        &mint_account,
         &solana_pubkey::Pubkey::new_from_array(*token_pool_account_info.key()),
-        &solana_pubkey::Pubkey::new_from_array(mint_account),
         compression.pool_index,
         Some(compression.bump),
-    )?;
+        is_restricted,
+    ) {
+        return Err(ErrorCode::InvalidTokenPoolPda.into());
+    }
     match mode {
         ZCompressionMode::Compress => {
             let authority = packed_accounts.get_u8(
                 compression.authority,
                 "process_spl_compression: authority account",
             )?;
-            spl_token_transfer_invoke(
+            spl_token_transfer_checked_invoke(
                 token_program,
                 token_account_info,
+                mint_account_info,
                 token_pool_account_info,
                 authority,
                 u64::from(*compression.amount),
+                decimals,
             )?;
         }
-        ZCompressionMode::Decompress => spl_token_transfer_invoke_cpi(
+        ZCompressionMode::Decompress => spl_token_transfer_checked_invoke_cpi(
             token_program,
             token_pool_account_info,
+            mint_account_info,
             token_account_info,
             cpi_authority,
             u64::from(*compression.amount),
+            decimals,
         )?,
         ZCompressionMode::CompressAndClose => {
             msg!("CompressAndClose is unimplemented for spl token accounts");
@@ -70,12 +84,14 @@ pub(super) fn process_spl_compressions(
 
 #[profile]
 #[inline(always)]
-fn spl_token_transfer_invoke_cpi(
+fn spl_token_transfer_checked_invoke_cpi(
     token_program: &[u8; 32],
     from: &AccountInfo,
+    mint: &AccountInfo,
     to: &AccountInfo,
     cpi_authority: &AccountInfo,
     amount: u64,
+    decimals: u8,
 ) -> Result<(), ProgramError> {
     let bump_seed = [BUMP_CPI_AUTHORITY];
     let seed_array = [
@@ -84,43 +100,59 @@ fn spl_token_transfer_invoke_cpi(
     ];
     let signer = Signer::from(&seed_array);
 
-    spl_token_transfer_common(
+    spl_token_transfer_checked_common(
         token_program,
         from,
+        mint,
         to,
         cpi_authority,
         amount,
+        decimals,
         Some(&[signer]),
     )
 }
 
 #[profile]
 #[inline(always)]
-fn spl_token_transfer_invoke(
+fn spl_token_transfer_checked_invoke(
     program_id: &[u8; 32],
     from: &AccountInfo,
+    mint: &AccountInfo,
     to: &AccountInfo,
     authority: &AccountInfo,
     amount: u64,
+    decimals: u8,
 ) -> Result<(), ProgramError> {
-    spl_token_transfer_common(program_id, from, to, authority, amount, None)
+    spl_token_transfer_checked_common(
+        program_id, from, mint, to, authority, amount, decimals, None,
+    )
 }
 
+/// Performs a transfer_checked CPI to the token program.
+/// transfer_checked is required for Token 2022 mints with TransferFeeConfig extension.
+/// Account order: source, mint, destination, authority
 #[inline(always)]
-fn spl_token_transfer_common(
+#[allow(clippy::too_many_arguments)]
+fn spl_token_transfer_checked_common(
     token_program: &[u8; 32],
     from: &AccountInfo,
+    mint: &AccountInfo,
     to: &AccountInfo,
     authority: &AccountInfo,
     amount: u64,
+    decimals: u8,
     signers: Option<&[pinocchio::instruction::Signer]>,
 ) -> Result<(), ProgramError> {
-    let mut instruction_data = [0u8; 9];
-    instruction_data[0] = 3u8; // Transfer instruction discriminator
+    // TransferChecked instruction data: discriminator (1) + amount (8) + decimals (1) = 10 bytes
+    let mut instruction_data = [0u8; 10];
+    instruction_data[0] = 12u8; // TransferChecked instruction discriminator
     instruction_data[1..9].copy_from_slice(&amount.to_le_bytes());
+    instruction_data[9] = decimals;
 
+    // Account order for TransferChecked: source, mint, destination, authority
     let account_metas = [
         AccountMeta::new(from.key(), true, false),
+        AccountMeta::new(mint.key(), false, false), // mint is not writable
         AccountMeta::new(to.key(), true, false),
         AccountMeta::new(authority.key(), false, true),
     ];
@@ -131,7 +163,7 @@ fn spl_token_transfer_common(
         data: &instruction_data,
     };
 
-    let account_infos = &[from, to, authority];
+    let account_infos = &[from, mint, to, authority];
 
     match signers {
         Some(signers) => {
diff --git a/programs/compressed-token/program/src/transfer2/config.rs b/programs/compressed-token/program/src/transfer2/config.rs
index ed8c594bca..9a8ad16266 100644
--- a/programs/compressed-token/program/src/transfer2/config.rs
+++ b/programs/compressed-token/program/src/transfer2/config.rs
@@ -18,7 +18,10 @@ pub struct Transfer2Config {
     pub total_input_lamports: u64,
     /// Total output lamports (checked arithmetic).
     pub total_output_lamports: u64,
+    /// No compressed accounts (neither input nor output) - determines system CPI path
     pub no_compressed_accounts: bool,
+    /// No output compressed accounts - determines mint extension hotpath
+    pub no_output_compressed_accounts: bool, // TODO: remove dead code
 }
 
 impl Transfer2Config {
@@ -29,6 +32,7 @@ impl Transfer2Config {
     ) -> Result<Self, ProgramError> {
         let no_compressed_accounts =
             inputs.in_token_data.is_empty() && inputs.out_token_data.is_empty();
+        let no_output_compressed_accounts = inputs.out_token_data.is_empty();
         Ok(Self {
             sol_pool_required: false,
             sol_decompression_required: false,
@@ -41,6 +45,7 @@ impl Transfer2Config {
             total_input_lamports: 0,
             total_output_lamports: 0,
             no_compressed_accounts,
+            no_output_compressed_accounts,
         })
     }
 }
diff --git a/programs/compressed-token/program/src/transfer2/cpi.rs b/programs/compressed-token/program/src/transfer2/cpi.rs
index 1ec0736b58..aa06a1671d 100644
--- a/programs/compressed-token/program/src/transfer2/cpi.rs
+++ b/programs/compressed-token/program/src/transfer2/cpi.rs
@@ -1,6 +1,12 @@
 use light_compressed_account::instruction_data::with_readonly::InstructionDataInvokeCpiWithReadOnlyConfig;
-use light_ctoken_interface::instructions::transfer2::ZCompressedTokenInstructionDataTransfer2;
+use light_ctoken_interface::{
+    instructions::{
+        extensions::ZExtensionInstructionData, transfer2::ZCompressedTokenInstructionDataTransfer2,
+    },
+    state::{ExtensionStructConfig, TokenData, TokenDataConfig},
+};
 use light_program_profiler::profile;
+use light_zero_copy::ZeroCopyNew;
 use pinocchio::program_error::ProgramError;
 use tinyvec::ArrayVec;
 
@@ -23,9 +29,42 @@ pub fn allocate_cpi_bytes(
     }
 
     let mut output_accounts = ArrayVec::new();
-    for output_data in inputs.out_token_data.iter() {
+    for (i, output_data) in inputs.out_token_data.iter().enumerate() {
         let has_delegate = output_data.has_delegate();
-        output_accounts.push((false, compressed_token_data_len(has_delegate))); // Token accounts don't have addresses
+
+        // Check if there's TLV data for this output
+        let tlv_data: Option<&[ZExtensionInstructionData]> = inputs
+            .out_tlv
+            .as_ref()
+            .and_then(|tlvs| tlvs.get(i).map(|ext_vec| ext_vec.as_slice()));
+
+        let data_len = if let Some(tlv) = tlv_data {
+            if !tlv.is_empty() {
+                // Build TLV config for byte length calculation
+                let tlv_config: Vec<ExtensionStructConfig> = tlv
+                    .iter()
+                    .filter_map(|ext| match ext {
+                        ZExtensionInstructionData::CompressedOnly(_) => {
+                            Some(ExtensionStructConfig::CompressedOnly(()))
+                        }
+                        _ => None,
+                    })
+                    .collect();
+
+                let token_config = TokenDataConfig {
+                    delegate: (has_delegate, ()),
+                    tlv: (true, tlv_config),
+                };
+                TokenData::byte_len(&token_config).map_err(|_| ProgramError::InvalidAccountData)?
+                    as u32
+            } else {
+                compressed_token_data_len(has_delegate)
+            }
+        } else {
+            compressed_token_data_len(has_delegate)
+        };
+
+        output_accounts.push((false, data_len)); // Token accounts don't have addresses
     }
 
     // Add extra output account for change account if needed (no delegate, no token data)
diff --git a/programs/compressed-token/program/src/transfer2/mod.rs b/programs/compressed-token/program/src/transfer2/mod.rs
index a61a5859ba..b28155e73d 100644
--- a/programs/compressed-token/program/src/transfer2/mod.rs
+++ b/programs/compressed-token/program/src/transfer2/mod.rs
@@ -1,4 +1,5 @@
 pub mod accounts;
+pub mod check_extensions;
 pub mod compression;
 pub mod config;
 pub mod cpi;
diff --git a/programs/compressed-token/program/src/transfer2/processor.rs b/programs/compressed-token/program/src/transfer2/processor.rs
index 72e9c5f265..18f49e9fe7 100644
--- a/programs/compressed-token/program/src/transfer2/processor.rs
+++ b/programs/compressed-token/program/src/transfer2/processor.rs
@@ -4,8 +4,12 @@ use light_array_map::ArrayMap;
 use light_compressed_account::instruction_data::with_readonly::InstructionDataInvokeCpiWithReadOnly;
 use light_ctoken_interface::{
     hash_cache::HashCache,
-    instructions::transfer2::{
-        CompressedTokenInstructionDataTransfer2, ZCompressedTokenInstructionDataTransfer2,
+    instructions::{
+        extensions::ZExtensionInstructionData,
+        transfer2::{
+            CompressedTokenInstructionDataTransfer2, ZCompressedTokenInstructionDataTransfer2,
+            ZCompressionMode,
+        },
     },
     CTokenError,
 };
@@ -14,6 +18,7 @@ use light_zero_copy::{traits::ZeroCopyAt, ZeroCopyNew};
 use pinocchio::account_info::AccountInfo;
 use spl_pod::solana_msg::msg;
 
+use super::check_extensions::{build_mint_extension_cache, MintExtensionCache};
 use crate::{
     shared::{convert_program_error, cpi::execute_cpi_invoke},
     transfer2::{
@@ -53,12 +58,20 @@ pub fn process_transfer2(
 
     let validated_accounts = Transfer2Accounts::validate_and_parse(accounts, &transfer_config)?;
 
+    let mint_cache = build_mint_extension_cache(&inputs, &validated_accounts.packed_accounts)?;
+
     if transfer_config.no_compressed_accounts {
         // No compressed accounts are invalidated or created in this transaction
         //  -> no need to invoke the light system program.
-        process_no_system_program_cpi(&inputs, &validated_accounts)
+        process_no_system_program_cpi(&inputs, &validated_accounts, &mint_cache)
     } else {
-        process_with_system_program_cpi(accounts, &inputs, &validated_accounts, transfer_config)
+        process_with_system_program_cpi(
+            accounts,
+            &inputs,
+            &validated_accounts,
+            transfer_config,
+            &mint_cache,
+        )
     }
 }
 
@@ -79,18 +92,62 @@ pub fn validate_instruction_data(
     }
 
     if inputs.in_lamports.is_some() {
-        msg!("in_lamports are unimplemented",);
-        return Err(CTokenError::TokenDataTlvUnimplemented);
+        return Err(CTokenError::InLamportsUnimplemented);
     }
     if inputs.out_lamports.is_some() {
-        msg!("outlamports are unimplemented",);
-        return Err(CTokenError::TokenDataTlvUnimplemented);
+        return Err(CTokenError::OutLamportsUnimplemented);
     }
-    if inputs.in_tlv.is_some() {
-        return Err(CTokenError::CompressedTokenAccountTlvUnimplemented);
+    // Validate in_tlv length matches in_token_data if provided
+    if let Some(in_tlv) = inputs.in_tlv.as_ref() {
+        if in_tlv.len() != inputs.in_token_data.len() {
+            msg!(
+                "in_tlv length {} does not match in_token_data length {}",
+                in_tlv.len(),
+                inputs.in_token_data.len()
+            );
+            return Err(CTokenError::InvalidInstructionData);
+        }
+
+        // CompressedOnly inputs can only decompress - no compressed outputs allowed
+        let has_compressed_only = in_tlv.iter().any(|tlv_vec| {
+            tlv_vec
+                .iter()
+                .any(|ext| matches!(ext, ZExtensionInstructionData::CompressedOnly(_)))
+        });
+        if has_compressed_only && !inputs.out_token_data.is_empty() {
+            msg!("CompressedOnly inputs cannot have compressed outputs");
+            return Err(CTokenError::CompressedOnlyBlocksTransfer);
+        }
     }
-    if inputs.out_tlv.is_some() {
-        return Err(CTokenError::CompressedTokenAccountTlvUnimplemented);
+    // out_tlv is only allowed for CompressAndClose when rent authority is signer
+    // (forester compressing accounts with marker extensions)
+    if let Some(out_tlv) = inputs.out_tlv.as_ref() {
+        // Length check (mirrors in_tlv check above)
+        if out_tlv.len() != inputs.out_token_data.len() {
+            msg!(
+                "out_tlv length {} does not match out_token_data length {}",
+                out_tlv.len(),
+                inputs.out_token_data.len()
+            );
+            return Err(CTokenError::InvalidInstructionData);
+        }
+
+        // All compressions must be CompressAndClose
+        let allowed = inputs.compressions.as_ref().is_some_and(|compressions| {
+            compressions
+                .iter()
+                .all(|c| c.mode == ZCompressionMode::CompressAndClose)
+        });
+        if !allowed {
+            return Err(CTokenError::CompressedTokenAccountTlvUnimplemented);
+        }
+
+        // Output count must match compressions count (no extra outputs)
+        let compressions_len = inputs.compressions.as_ref().map(|c| c.len()).unwrap_or(0);
+        if inputs.out_token_data.len() != compressions_len {
+            msg!("out_tlv requires out_token_data.len() == compressions.len()");
+            return Err(CTokenError::OutTlvOutputCountMismatch);
+        }
     }
 
     // Check CPI context write mode doesn't have compressions.
@@ -110,9 +167,10 @@ pub fn validate_instruction_data(
 
 #[profile]
 #[inline(always)]
-fn process_no_system_program_cpi(
-    inputs: &ZCompressedTokenInstructionDataTransfer2,
-    validated_accounts: &Transfer2Accounts,
+fn process_no_system_program_cpi<'a>(
+    inputs: &'a ZCompressedTokenInstructionDataTransfer2<'a>,
+    validated_accounts: &'a Transfer2Accounts<'a>,
+    mint_cache: &'a MintExtensionCache,
 ) -> Result<(), ProgramError> {
     let fee_payer = validated_accounts
         .compressions_only_fee_payer
@@ -134,12 +192,18 @@ fn process_no_system_program_cpi(
     validate_mint_uniqueness(&mint_map, &validated_accounts.packed_accounts)
         .map_err(|e| ProgramError::Custom(e as u32 + 6000))?;
 
+    // This is the compression-only hot path (no compressed inputs/outputs).
+    // Extension checks are skipped because balance must be restored immediately
+    // (compress + decompress in same tx) or sum check will fail.
+    // No compressed inputs, so compression_to_input lookup is empty.
     process_token_compression(
         fee_payer,
         inputs,
         &validated_accounts.packed_accounts,
         cpi_authority_pda,
         inputs.max_top_up.get(),
+        mint_cache,
+        &[None; 32],
     )?;
 
     close_for_compress_and_close(compressions.as_slice(), validated_accounts)?;
@@ -149,11 +213,12 @@ fn process_no_system_program_cpi(
 
 #[profile]
 #[inline(always)]
-fn process_with_system_program_cpi(
+fn process_with_system_program_cpi<'a>(
     accounts: &[AccountInfo],
-    inputs: &ZCompressedTokenInstructionDataTransfer2,
-    validated_accounts: &Transfer2Accounts,
+    inputs: &'a ZCompressedTokenInstructionDataTransfer2<'a>,
+    validated_accounts: &'a Transfer2Accounts<'a>,
     transfer_config: Transfer2Config,
+    mint_cache: &'a MintExtensionCache,
 ) -> Result<(), ProgramError> {
     // Allocate CPI bytes for zero-copy structure
     let (mut cpi_bytes, config) = allocate_cpi_bytes(inputs).map_err(convert_program_error)?;
@@ -174,12 +239,14 @@ fn process_with_system_program_cpi(
     // Create HashCache to cache hashed pubkeys.
     let mut hash_cache = HashCache::new();
 
-    // Process input compressed accounts.
-    set_input_compressed_accounts(
+    // Process input compressed accounts and build compression-to-input lookup.
+    let compression_to_input = set_input_compressed_accounts(
         &mut cpi_instruction_struct,
         &mut hash_cache,
         inputs,
         &validated_accounts.packed_accounts,
+        accounts,
+        mint_cache,
     )?;
 
     // Process output compressed accounts.
@@ -204,12 +271,15 @@ fn process_with_system_program_cpi(
 
     if let Some(system_accounts) = validated_accounts.system.as_ref() {
         // Process token compressions/decompressions/close_and_compress
+        // Mint extension checks are already cached, so we pass the cache.
         process_token_compression(
             system_accounts.fee_payer,
             inputs,
             &validated_accounts.packed_accounts,
             system_accounts.cpi_authority_pda,
             inputs.max_top_up.get(),
+            mint_cache,
+            &compression_to_input,
         )?;
 
         // Get CPI accounts slice and tree accounts for light-system-program invocation
diff --git a/programs/compressed-token/program/src/transfer2/token_inputs.rs b/programs/compressed-token/program/src/transfer2/token_inputs.rs
index 3a29999341..fa85da81e2 100644
--- a/programs/compressed-token/program/src/transfer2/token_inputs.rs
+++ b/programs/compressed-token/program/src/transfer2/token_inputs.rs
@@ -2,22 +2,33 @@ use anchor_lang::prelude::ProgramError;
 use light_account_checks::packed_accounts::ProgramPackedAccounts;
 use light_compressed_account::instruction_data::with_readonly::ZInstructionDataInvokeCpiWithReadOnlyMut;
 use light_ctoken_interface::{
-    hash_cache::HashCache, instructions::transfer2::ZCompressedTokenInstructionDataTransfer2,
+    hash_cache::HashCache,
+    instructions::{
+        extensions::ZExtensionInstructionData, transfer2::ZCompressedTokenInstructionDataTransfer2,
+    },
+    CTokenError,
 };
 use light_program_profiler::profile;
 use pinocchio::account_info::AccountInfo;
 
+use super::check_extensions::{validate_tlv_and_get_frozen, MintExtensionCache};
 use crate::shared::token_input::set_input_compressed_account;
 
-/// Process input compressed accounts and return total input lamports
+/// Process input compressed accounts and return compression-to-input lookup.
+/// Returns `[Option<u8>; 32]` where `compression_to_input[compression_idx] = Some(input_idx)`.
 #[profile]
 #[inline(always)]
-pub fn set_input_compressed_accounts(
+pub fn set_input_compressed_accounts<'a>(
     cpi_instruction_struct: &mut ZInstructionDataInvokeCpiWithReadOnlyMut,
     hash_cache: &mut HashCache,
-    inputs: &ZCompressedTokenInstructionDataTransfer2,
+    inputs: &'a ZCompressedTokenInstructionDataTransfer2<'a>,
     packed_accounts: &ProgramPackedAccounts<'_, AccountInfo>,
-) -> Result<(), ProgramError> {
+    all_accounts: &[AccountInfo],
+    mint_cache: &'a MintExtensionCache,
+) -> Result<[Option<u8>; 32], ProgramError> {
+    // compression_to_input[compression_index] = Some(input_index), None means unset
+    let mut compression_to_input: [Option<u8>; 32] = [None; 32];
+
     for (i, input_data) in inputs.in_token_data.iter().enumerate() {
         let input_lamports = if let Some(lamports) = inputs.in_lamports.as_ref() {
             if let Some(input_lamports) = lamports.get(i) {
@@ -29,6 +40,28 @@ pub fn set_input_compressed_accounts(
             0
         };
 
+        // Get TLV data for this input
+        let tlv_data: Option<&[ZExtensionInstructionData]> = inputs
+            .in_tlv
+            .as_ref()
+            .and_then(|tlvs| tlvs.get(i).map(|ext_vec| ext_vec.as_slice()));
+
+        let is_frozen = validate_tlv_and_get_frozen(tlv_data, input_data.version)?;
+
+        // Extract compression_index from CompressedOnly TLV if present
+        if let Some(tlv) = tlv_data {
+            for ext in tlv {
+                if let ZExtensionInstructionData::CompressedOnly(co) = ext {
+                    let idx = co.compression_index as usize;
+                    // Check uniqueness - error if compression_index already used
+                    if compression_to_input[idx].is_some() {
+                        return Err(CTokenError::DuplicateCompressionIndex.into());
+                    }
+                    compression_to_input[idx] = Some(i as u8);
+                }
+            }
+        }
+
         set_input_compressed_account(
             cpi_instruction_struct
                 .input_compressed_accounts
@@ -37,9 +70,13 @@ pub fn set_input_compressed_accounts(
             hash_cache,
             input_data,
             packed_accounts.accounts,
+            all_accounts,
             input_lamports,
+            tlv_data,
+            mint_cache,
+            is_frozen,
         )?;
     }
 
-    Ok(())
+    Ok(compression_to_input)
 }
diff --git a/programs/compressed-token/program/src/transfer2/token_outputs.rs b/programs/compressed-token/program/src/transfer2/token_outputs.rs
index f4f04cff24..17d65942bf 100644
--- a/programs/compressed-token/program/src/transfer2/token_outputs.rs
+++ b/programs/compressed-token/program/src/transfer2/token_outputs.rs
@@ -2,20 +2,24 @@ use anchor_lang::prelude::ProgramError;
 use light_account_checks::packed_accounts::ProgramPackedAccounts;
 use light_compressed_account::instruction_data::with_readonly::ZInstructionDataInvokeCpiWithReadOnlyMut;
 use light_ctoken_interface::{
-    hash_cache::HashCache, instructions::transfer2::ZCompressedTokenInstructionDataTransfer2,
+    hash_cache::HashCache,
+    instructions::{
+        extensions::ZExtensionInstructionData, transfer2::ZCompressedTokenInstructionDataTransfer2,
+    },
 };
 use light_program_profiler::profile;
 use pinocchio::account_info::AccountInfo;
 
+use super::check_extensions::validate_tlv_and_get_frozen;
 use crate::shared::token_output::set_output_compressed_account;
 
 /// Process output compressed accounts and return total output lamports
 #[profile]
 #[inline(always)]
-pub fn set_output_compressed_accounts(
+pub fn set_output_compressed_accounts<'a>(
     cpi_instruction_struct: &mut ZInstructionDataInvokeCpiWithReadOnlyMut,
     hash_cache: &mut HashCache,
-    inputs: &ZCompressedTokenInstructionDataTransfer2,
+    inputs: &'a ZCompressedTokenInstructionDataTransfer2<'a>,
     packed_accounts: &ProgramPackedAccounts<'_, AccountInfo>,
 ) -> Result<(), ProgramError> {
     for (i, output_data) in inputs.out_token_data.iter().enumerate() {
@@ -39,7 +43,7 @@ pub fn set_output_compressed_accounts(
         // Get delegate if present
         let delegate_pubkey = if output_data.has_delegate() {
             let delegate_account =
-                packed_accounts.get_u8(output_data.delegate, "out token delegete")?;
+                packed_accounts.get_u8(output_data.delegate, "out token delegate")?;
             Some(*delegate_account.key())
         } else {
             None
@@ -49,6 +53,15 @@ pub fn set_output_compressed_accounts(
         } else {
             None
         };
+
+        // Get TLV data for this output
+        let tlv_data: Option<&[ZExtensionInstructionData]> = inputs
+            .out_tlv
+            .as_ref()
+            .and_then(|tlvs| tlvs.get(i).map(|ext_vec| ext_vec.as_slice()));
+
+        let is_frozen = validate_tlv_and_get_frozen(tlv_data, output_data.version)?;
+
         set_output_compressed_account(
             cpi_instruction_struct
                 .output_compressed_accounts
@@ -62,6 +75,8 @@ pub fn set_output_compressed_accounts(
             mint_account.key().into(),
             inputs.output_queue,
             output_data.version,
+            tlv_data,
+            is_frozen,
         )?;
     }
 
diff --git a/programs/compressed-token/program/tests/allocation_test.rs b/programs/compressed-token/program/tests/allocation_test.rs
index 9d9700fd5c..1338638193 100644
--- a/programs/compressed-token/program/tests/allocation_test.rs
+++ b/programs/compressed-token/program/tests/allocation_test.rs
@@ -11,11 +11,7 @@ use light_zero_copy::{traits::ZeroCopyAt, ZeroCopyNew};
 #[test]
 fn test_extension_allocation_only() {
     // Test 1: No extensions - should work
-    let mint_config_no_ext = CompressedMintConfig {
-        base: (),
-        metadata: (),
-        extensions: (false, vec![]),
-    };
+    let mint_config_no_ext = CompressedMintConfig { extensions: None };
     let expected_mint_size_no_ext = CompressedMint::byte_len(&mint_config_no_ext).unwrap();
 
     let mut outputs_no_ext = tinyvec::ArrayVec::<[(bool, u32); 35]>::new();
@@ -45,9 +41,7 @@ fn test_extension_allocation_only() {
     })];
 
     let mint_config_with_ext = CompressedMintConfig {
-        base: (),
-        metadata: (),
-        extensions: (true, extensions_config.clone()),
+        extensions: Some(extensions_config.clone()),
     };
     let expected_mint_size_with_ext = CompressedMint::byte_len(&mint_config_with_ext).unwrap();
 
@@ -156,9 +150,7 @@ fn test_progressive_extension_sizes() {
         })];
 
         let mint_config = CompressedMintConfig {
-            base: (),
-            metadata: (),
-            extensions: (true, extensions_config),
+            extensions: Some(extensions_config),
         };
 
         let expected_mint_size = CompressedMint::byte_len(&mint_config).unwrap();
diff --git a/programs/compressed-token/program/tests/check_authority.rs b/programs/compressed-token/program/tests/check_authority.rs
index 0459157343..31e850eeb6 100644
--- a/programs/compressed-token/program/tests/check_authority.rs
+++ b/programs/compressed-token/program/tests/check_authority.rs
@@ -3,6 +3,9 @@ use light_account_checks::account_info::test_account_info::pinocchio::get_accoun
 use light_compressed_token::mint_action::check_authority;
 use pinocchio::pubkey::Pubkey;
 
+// Anchor custom error codes start at offset 6000
+const ANCHOR_ERROR_OFFSET: u32 = 6000;
+
 // Helper function to create test account info
 fn create_test_account_info(
     pubkey: Pubkey,
@@ -43,7 +46,7 @@ fn test_check_authority_essential_cases() {
             anchor_lang::prelude::ProgramError::Custom(code) => {
                 assert_eq!(
                     code,
-                    ErrorCode::InvalidAuthorityMint as u32,
+                    ANCHOR_ERROR_OFFSET + ErrorCode::InvalidAuthorityMint as u32,
                     "Should return InvalidAuthorityMint for None authority"
                 );
             }
@@ -75,7 +78,7 @@ fn test_check_authority_essential_cases() {
             anchor_lang::prelude::ProgramError::Custom(code) => {
                 assert_eq!(
                     code,
-                    ErrorCode::InvalidAuthorityMint as u32,
+                    ANCHOR_ERROR_OFFSET + ErrorCode::InvalidAuthorityMint as u32,
                     "Should return InvalidAuthorityMint for wrong signer"
                 );
             }
@@ -95,7 +98,7 @@ fn test_check_authority_essential_cases() {
             anchor_lang::prelude::ProgramError::Custom(code) => {
                 assert_eq!(
                     code,
-                    ErrorCode::InvalidAuthorityMint as u32,
+                    ANCHOR_ERROR_OFFSET + ErrorCode::InvalidAuthorityMint as u32,
                     "Should return InvalidAuthorityMint for revoked authority"
                 );
             }
@@ -126,7 +129,7 @@ fn test_check_authority_revoked_edge_case() {
         anchor_lang::prelude::ProgramError::Custom(code) => {
             assert_eq!(
                 code,
-                ErrorCode::InvalidAuthorityMint as u32,
+                ANCHOR_ERROR_OFFSET + ErrorCode::InvalidAuthorityMint as u32,
                 "Should return InvalidAuthorityMint for revoked authority"
             );
         }
diff --git a/programs/compressed-token/program/tests/compress_and_close.rs b/programs/compressed-token/program/tests/compress_and_close.rs
index e3b5b885ec..dd9f276199 100644
--- a/programs/compressed-token/program/tests/compress_and_close.rs
+++ b/programs/compressed-token/program/tests/compress_and_close.rs
@@ -14,13 +14,22 @@ use light_ctoken_interface::{
 use light_zero_copy::traits::{ZeroCopyAt, ZeroCopyNew};
 use pinocchio::pubkey::Pubkey;
 
+// Anchor custom error codes start at offset 6000
+const ANCHOR_ERROR_OFFSET: u32 = 6000;
+
 /// Helper to create valid compressible CToken account data
 fn create_compressible_ctoken_data(
     owner_pubkey: &[u8; 32],
     rent_sponsor_pubkey: &[u8; 32],
 ) -> Vec<u8> {
-    // Create config for compressible CToken (no delegate, not native, no close_authority)
-    let config = CompressedTokenConfig::new_compressible(false, false, false);
+    // Create config for compressible CToken - CompressionInfo is now embedded in base struct
+    let config = CompressedTokenConfig {
+        mint: light_compressed_account::Pubkey::from([0u8; 32]),
+        owner: light_compressed_account::Pubkey::from(*owner_pubkey),
+        state: 1, // AccountState::Initialized
+        compression_only: false,
+        extensions: None,
+    };
 
     // Calculate required size
     let size = CToken::byte_len(&config).unwrap();
@@ -29,29 +38,18 @@ fn create_compressible_ctoken_data(
     // Initialize using zero-copy new
     let (mut ctoken, _) = CToken::new_zero_copy(&mut data, config).unwrap();
 
-    // Set required fields using to_bytes/to_bytes_mut methods
-    *ctoken.mint = light_compressed_account::Pubkey::from([0u8; 32]);
-    *ctoken.owner = light_compressed_account::Pubkey::from(*owner_pubkey);
-    *ctoken.state = 1; // AccountState::Initialized
-
-    // Set compressible extension fields
-    if let Some(extensions) = ctoken.extensions.as_mut() {
-        if let Some(light_ctoken_interface::state::ZExtensionStructMut::Compressible(comp_ext)) =
-            extensions.first_mut()
-        {
-            comp_ext.info.config_account_version.set(1);
-            comp_ext.info.account_version = 3; // ShaFlat
-            comp_ext
-                .info
-                .compression_authority
-                .copy_from_slice(owner_pubkey);
-            comp_ext
-                .info
-                .rent_sponsor
-                .copy_from_slice(rent_sponsor_pubkey);
-            comp_ext.info.last_claimed_slot.set(0);
-        }
-    }
+    // Set compression info fields (now embedded in meta, not an extension)
+    ctoken.compression.config_account_version.set(1);
+    ctoken.compression.account_version = 3; // ShaFlat
+    ctoken
+        .compression
+        .compression_authority
+        .copy_from_slice(owner_pubkey);
+    ctoken
+        .compression
+        .rent_sponsor
+        .copy_from_slice(rent_sponsor_pubkey);
+    ctoken.compression.last_claimed_slot.set(0);
 
     data
 }
@@ -70,7 +68,7 @@ fn test_close_for_compress_and_close_duplicate_detection() {
             pool_account_index: 2, // rent_sponsor index
             pool_index: 0,         // DUPLICATE: compressed_account_index = 0
             bump: 3,               // destination index
-            decimals: 0,
+            decimals: 9,
         },
         Compression {
             mode: CompressionMode::CompressAndClose,
@@ -81,7 +79,7 @@ fn test_close_for_compress_and_close_duplicate_detection() {
             pool_account_index: 2, // rent_sponsor index
             pool_index: 0,         // DUPLICATE: compressed_account_index = 0 (SAME AS FIRST!)
             bump: 3,               // destination index
-            decimals: 0,
+            decimals: 9,
         },
     ];
 
@@ -145,7 +143,7 @@ fn test_close_for_compress_and_close_duplicate_detection() {
         Err(anchor_lang::prelude::ProgramError::Custom(code)) => {
             assert_eq!(
                 code,
-                ErrorCode::CompressAndCloseDuplicateOutput as u32,
+                ANCHOR_ERROR_OFFSET + ErrorCode::CompressAndCloseDuplicateOutput as u32,
                 "Expected CompressAndCloseDuplicateOutput error, got error code: {}",
                 code
             );
diff --git a/programs/compressed-token/program/tests/exact_allocation_test.rs b/programs/compressed-token/program/tests/exact_allocation_test.rs
index ec2dd414d0..294c1cec99 100644
--- a/programs/compressed-token/program/tests/exact_allocation_test.rs
+++ b/programs/compressed-token/program/tests/exact_allocation_test.rs
@@ -35,9 +35,7 @@ fn test_exact_allocation_assertion() {
 
     // Step 1: Calculate expected mint size
     let mint_config = CompressedMintConfig {
-        base: (),
-        metadata: (),
-        extensions: (true, extensions_config.clone()),
+        extensions: Some(extensions_config.clone()),
     };
 
     let expected_mint_size = CompressedMint::byte_len(&mint_config).unwrap();
@@ -85,11 +83,7 @@ fn test_exact_allocation_assertion() {
 
     // Step 5: Calculate exact space needed
     let base_mint_size_no_ext = {
-        let no_ext_config = CompressedMintConfig {
-            base: (),
-            metadata: (),
-            extensions: (false, vec![]),
-        };
+        let no_ext_config = CompressedMintConfig { extensions: None };
         CompressedMint::byte_len(&no_ext_config).unwrap()
     };
 
@@ -292,9 +286,7 @@ fn test_allocation_with_various_metadata_sizes() {
         })];
 
         let mint_config = CompressedMintConfig {
-            base: (),
-            metadata: (),
-            extensions: (true, extensions_config.clone()),
+            extensions: Some(extensions_config.clone()),
         };
 
         let expected_mint_size = CompressedMint::byte_len(&mint_config).unwrap();
diff --git a/programs/compressed-token/program/tests/mint.rs b/programs/compressed-token/program/tests/mint.rs
index 8b62286ca3..7ed1a09028 100644
--- a/programs/compressed-token/program/tests/mint.rs
+++ b/programs/compressed-token/program/tests/mint.rs
@@ -17,7 +17,8 @@ use light_ctoken_interface::{
     },
     state::{
         AdditionalMetadata, AdditionalMetadataConfig, BaseMint, CompressedMint,
-        CompressedMintMetadata, ExtensionStruct, TokenMetadata, ZCompressedMint, ZExtensionStruct,
+        CompressedMintMetadata, CompressionInfo, ExtensionStruct, TokenMetadata, ZCompressedMint,
+        ZExtensionStruct, ACCOUNT_TYPE_MINT,
     },
 };
 use light_zero_copy::{traits::ZeroCopyAt, ZeroCopyNew};
@@ -367,6 +368,7 @@ fn test_compressed_mint_borsh_zero_copy_compatibility() {
     };
 
     let compressed_mint = CompressedMint {
+        compression: CompressionInfo::default(),
         base: BaseMint {
             mint_authority: Some(Pubkey::new_from_array([4; 32])),
             supply: 1000u64,
@@ -379,6 +381,8 @@ fn test_compressed_mint_borsh_zero_copy_compatibility() {
             mint: Pubkey::new_from_array([3; 32]),
             cmint_decompressed: false,
         },
+        reserved: [0u8; 49],
+        account_type: ACCOUNT_TYPE_MINT,
         extensions: Some(vec![ExtensionStruct::TokenMetadata(token_metadata)]),
     };
 
@@ -394,19 +398,43 @@ fn test_compressed_mint_borsh_zero_copy_compatibility() {
     // Re-serialize the zero-copy mint back to borsh and compare with original
     let zc_reserialized = {
         // Convert zero-copy fields back to regular types
+        // Reconstruct CompressionInfo from zero-copy fields
+        let compression = {
+            let zc = &zc_mint.base.compression;
+            CompressionInfo {
+                config_account_version: u16::from(zc.config_account_version),
+                compress_to_pubkey: zc.compress_to_pubkey,
+                account_version: zc.account_version,
+                lamports_per_write: u32::from(zc.lamports_per_write),
+                compression_authority: zc.compression_authority,
+                rent_sponsor: zc.rent_sponsor,
+                last_claimed_slot: u64::from(zc.last_claimed_slot),
+                rent_config: light_compressible::rent::RentConfig {
+                    base_rent: u16::from(zc.rent_config.base_rent),
+                    compression_cost: u16::from(zc.rent_config.compression_cost),
+                    lamports_per_byte_per_epoch: zc.rent_config.lamports_per_byte_per_epoch,
+                    max_funded_epochs: zc.rent_config.max_funded_epochs,
+                    max_top_up: u16::from(zc.rent_config.max_top_up),
+                },
+            }
+        };
+
         let reconstructed_mint = CompressedMint {
+            compression,
             base: BaseMint {
-                mint_authority: zc_mint.base.mint_authority.map(|x| *x),
-                supply: u64::from(*zc_mint.base.supply),
+                mint_authority: zc_mint.base.mint_authority().cloned(),
+                supply: u64::from(zc_mint.base.supply),
                 decimals: zc_mint.base.decimals,
                 is_initialized: zc_mint.base.is_initialized != 0,
-                freeze_authority: zc_mint.base.freeze_authority.map(|x| *x),
+                freeze_authority: zc_mint.base.freeze_authority().cloned(),
             },
             metadata: CompressedMintMetadata {
-                version: zc_mint.metadata.version,
-                mint: zc_mint.metadata.mint,
-                cmint_decompressed: zc_mint.metadata.cmint_decompressed != 0,
+                version: zc_mint.base.metadata.version,
+                mint: zc_mint.base.metadata.mint,
+                cmint_decompressed: zc_mint.base.metadata.cmint_decompressed != 0,
             },
+            reserved: *zc_mint.base.reserved,
+            account_type: zc_mint.base.account_type,
             extensions: zc_mint.extensions.as_ref().map(|zc_exts| {
                 zc_exts
                     .iter()
diff --git a/programs/compressed-token/program/tests/mint_action.rs b/programs/compressed-token/program/tests/mint_action.rs
index d7feae6706..90d9736fb7 100644
--- a/programs/compressed-token/program/tests/mint_action.rs
+++ b/programs/compressed-token/program/tests/mint_action.rs
@@ -224,7 +224,8 @@ fn compute_expected_config(data: &MintActionCompressedInstructionData) -> Accoun
         .map(|ctx| ctx.first_set_context || ctx.set_context)
         .unwrap_or(false);
 
-    // 3. has_mint_to_actions (only MintToCompressed needs tokens_out_queue, not MintToCToken)
+    // 3. has_mint_to_actions
+    // Only MintToCompressed counts - MintToCToken mints to existing decompressed accounts
     let has_mint_to_actions = data
         .actions
         .iter()
diff --git a/programs/compressed-token/program/tests/multi_sum_check.rs b/programs/compressed-token/program/tests/multi_sum_check.rs
index e3763017b6..d33091d221 100644
--- a/programs/compressed-token/program/tests/multi_sum_check.rs
+++ b/programs/compressed-token/program/tests/multi_sum_check.rs
@@ -89,7 +89,7 @@ fn multi_sum_check_test(
             pool_account_index: 0,
             pool_index: 0,
             bump: 255,
-            decimals: 0,
+            decimals: 9,
         }]
     });
 
@@ -354,7 +354,7 @@ fn test_multi_mint_scenario(
             pool_account_index: 0,
             pool_index: 0,
             bump: 255,
-            decimals: 0,
+            decimals: 9,
         })
         .collect();
 
diff --git a/programs/compressed-token/program/tests/print_error_codes.rs b/programs/compressed-token/program/tests/print_error_codes.rs
index 9da9accceb..60c9ef7f08 100644
--- a/programs/compressed-token/program/tests/print_error_codes.rs
+++ b/programs/compressed-token/program/tests/print_error_codes.rs
@@ -189,8 +189,8 @@ fn main() {
             ErrorCode::ZeroCopyExpectedDelegate,
         ),
         (
-            "TokenDataTlvUnimplemented",
-            ErrorCode::TokenDataTlvUnimplemented,
+            "UnsupportedTlvExtensionType",
+            ErrorCode::UnsupportedTlvExtensionType,
         ),
         (
             "MintActionNoActionsProvided",
diff --git a/programs/compressed-token/program/tests/token_input.rs b/programs/compressed-token/program/tests/token_input.rs
index 39578d41c5..fc14065fee 100644
--- a/programs/compressed-token/program/tests/token_input.rs
+++ b/programs/compressed-token/program/tests/token_input.rs
@@ -2,6 +2,7 @@ use anchor_compressed_token::TokenData as AnchorTokenData;
 use anchor_lang::prelude::*;
 use borsh::{BorshDeserialize, BorshSerialize};
 use light_account_checks::account_info::test_account_info::pinocchio::get_account_info;
+use light_array_map::ArrayMap;
 use light_compressed_account::instruction_data::with_readonly::{
     InAccount, InstructionDataInvokeCpiWithReadOnly,
 };
@@ -10,11 +11,12 @@ use light_compressed_token::{
         TOKEN_COMPRESSED_ACCOUNT_DISCRIMINATOR, TOKEN_COMPRESSED_ACCOUNT_V2_DISCRIMINATOR,
         TOKEN_COMPRESSED_ACCOUNT_V3_DISCRIMINATOR,
     },
+    extensions::MintExtensionChecks,
     shared::{
         cpi_bytes_size::{
             allocate_invoke_with_read_only_cpi_bytes, cpi_bytes_config, CpiConfigInput,
         },
-        token_input::{set_input_compressed_account, set_input_compressed_account_frozen},
+        token_input::set_input_compressed_account,
     },
 };
 use light_ctoken_interface::{
@@ -110,24 +112,24 @@ fn test_rnd_create_input_compressed_account() {
 
             let mut hash_cache = HashCache::new();
 
+            // Create mint extension cache with default checks for mint at index 0
+            let mut mint_cache: ArrayMap<u8, MintExtensionChecks, 5> = ArrayMap::new();
+            mint_cache
+                .insert(0, MintExtensionChecks::default(), ())
+                .unwrap();
+
             // Call the function under test
-            let result = if is_frozen {
-                set_input_compressed_account_frozen(
-                    input_account,
-                    &mut hash_cache,
-                    &z_input_data,
-                    remaining_accounts.as_slice(),
-                    lamports,
-                )
-            } else {
-                set_input_compressed_account(
-                    input_account,
-                    &mut hash_cache,
-                    &z_input_data,
-                    remaining_accounts.as_slice(),
-                    lamports,
-                )
-            };
+            let result = set_input_compressed_account(
+                input_account,
+                &mut hash_cache,
+                &z_input_data,
+                remaining_accounts.as_slice(),
+                remaining_accounts.as_slice(),
+                lamports,
+                None, // No TLV data in test
+                &mint_cache,
+                is_frozen,
+            );
 
             assert!(result.is_ok(), "Function failed: {:?}", result.err());
 
diff --git a/programs/compressed-token/program/tests/token_output.rs b/programs/compressed-token/program/tests/token_output.rs
index 841020c3d2..0375534695 100644
--- a/programs/compressed-token/program/tests/token_output.rs
+++ b/programs/compressed-token/program/tests/token_output.rs
@@ -9,19 +9,26 @@ use light_compressed_account::{
     Pubkey,
 };
 use light_compressed_token::{
-    constants::TOKEN_COMPRESSED_ACCOUNT_V2_DISCRIMINATOR,
+    constants::{
+        TOKEN_COMPRESSED_ACCOUNT_V2_DISCRIMINATOR, TOKEN_COMPRESSED_ACCOUNT_V3_DISCRIMINATOR,
+    },
     shared::{
         cpi_bytes_size::{
-            allocate_invoke_with_read_only_cpi_bytes, compressed_token_data_len, cpi_bytes_config,
-            CpiConfigInput,
+            allocate_invoke_with_read_only_cpi_bytes, cpi_bytes_config, CpiConfigInput,
         },
         token_output::set_output_compressed_account,
     },
 };
 use light_ctoken_interface::{
-    hash_cache::HashCache, state::CompressedTokenAccountState as AccountState,
+    hash_cache::HashCache,
+    instructions::extensions::{CompressedOnlyExtensionInstructionData, ExtensionInstructionData},
+    state::{
+        CompressedOnlyExtension, CompressedTokenAccountState as AccountState, ExtensionStruct,
+        ExtensionStructConfig, TokenData, TokenDataConfig,
+    },
 };
-use light_zero_copy::ZeroCopyNew;
+use light_hasher::Hasher;
+use light_zero_copy::{traits::ZeroCopyAt, ZeroCopyNew};
 
 #[test]
 fn test_rnd_create_output_compressed_accounts() {
@@ -41,6 +48,9 @@ fn test_rnd_create_output_compressed_accounts() {
         let mut delegate_flags = Vec::new();
         let mut lamports_vec = Vec::new();
         let mut merkle_tree_indices = Vec::new();
+        let mut tlv_flags = Vec::new();
+        let mut tlv_delegated_amounts = Vec::new();
+        let mut tlv_withheld_fees = Vec::new();
 
         for _ in 0..num_outputs {
             owner_pubkeys.push(Pubkey::new_from_array(rng.gen::<[u8; 32]>()));
@@ -52,6 +62,9 @@ fn test_rnd_create_output_compressed_accounts() {
                 None
             });
             merkle_tree_indices.push(rng.gen_range(0..=255u8));
+            tlv_flags.push(rng.gen_bool(0.3)); // 30% chance of having TLV
+            tlv_delegated_amounts.push(rng.gen_range(0..=u64::MAX));
+            tlv_withheld_fees.push(rng.gen_range(0..=u64::MAX));
         }
 
         // Random delegate
@@ -67,10 +80,20 @@ fn test_rnd_create_output_compressed_accounts() {
             None
         };
 
-        // Create output config
+        // Create output config with proper TLV sizes
         let mut outputs = tinyvec::ArrayVec::<[(bool, u32); 35]>::new();
-        for &has_delegate in &delegate_flags {
-            outputs.push((false, compressed_token_data_len(has_delegate))); // Token accounts don't have addresses
+        for i in 0..num_outputs {
+            let tlv_config = if tlv_flags[i] {
+                vec![ExtensionStructConfig::CompressedOnly(())]
+            } else {
+                vec![]
+            };
+            let token_config = TokenDataConfig {
+                delegate: (delegate_flags[i], ()),
+                tlv: (!tlv_config.is_empty(), tlv_config),
+            };
+            let data_len = TokenData::byte_len(&token_config).unwrap() as u32;
+            outputs.push((false, data_len)); // Token accounts don't have addresses
         }
 
         let config_input = CpiConfigInput {
@@ -88,6 +111,40 @@ fn test_rnd_create_output_compressed_accounts() {
         )
         .unwrap();
 
+        // Create TLV instruction data for each output
+        let mut tlv_instruction_data_vecs: Vec<Vec<ExtensionInstructionData>> = Vec::new();
+        let mut tlv_bytes_vecs: Vec<Vec<u8>> = Vec::new();
+
+        for i in 0..num_outputs {
+            if tlv_flags[i] {
+                let ext = ExtensionInstructionData::CompressedOnly(
+                    CompressedOnlyExtensionInstructionData {
+                        delegated_amount: tlv_delegated_amounts[i],
+                        withheld_transfer_fee: tlv_withheld_fees[i],
+                        is_frozen: rng.gen_bool(0.2), // 20% chance of frozen
+                        compression_index: i as u8,
+                    },
+                );
+                tlv_instruction_data_vecs.push(vec![ext.clone()]);
+                tlv_bytes_vecs.push(vec![ext].try_to_vec().unwrap());
+            } else {
+                tlv_instruction_data_vecs.push(vec![]);
+                // Empty vec needs explicit type annotation and borsh serialization
+                let empty_vec: Vec<ExtensionInstructionData> = vec![];
+                tlv_bytes_vecs.push(empty_vec.try_to_vec().unwrap());
+            }
+        }
+
+        // Parse TLV bytes to zero-copy for set_output_compressed_account calls
+        let tlv_zero_copy_vecs: Vec<_> = tlv_bytes_vecs
+            .iter()
+            .map(|bytes| {
+                Vec::<ExtensionInstructionData>::zero_copy_at(bytes.as_slice())
+                    .unwrap()
+                    .0
+            })
+            .collect();
+
         let mut hash_cache = HashCache::new();
         for (index, output_account) in cpi_instruction_struct
             .output_compressed_accounts
@@ -100,6 +157,16 @@ fn test_rnd_create_output_compressed_accounts() {
                 None
             };
 
+            // Use version 3 when TLV is present, version 2 otherwise
+            let version = if tlv_flags[index] { 3 } else { 2 };
+
+            // Get TLV data slice (empty slice if no TLV)
+            let tlv_slice = if tlv_flags[index] && !tlv_zero_copy_vecs[index].is_empty() {
+                Some(tlv_zero_copy_vecs[index].as_slice())
+            } else {
+                None
+            };
+
             set_output_compressed_account(
                 output_account,
                 &mut hash_cache,
@@ -109,7 +176,9 @@ fn test_rnd_create_output_compressed_accounts() {
                 lamports.as_ref().and_then(|l| l[index]),
                 mint_pubkey,
                 merkle_tree_indices[index],
-                2,
+                version,
+                tlv_slice,
+                false, // Not frozen in tests
             )
             .unwrap();
         }
@@ -124,15 +193,38 @@ fn test_rnd_create_output_compressed_accounts() {
             let token_delegate = if delegate_flags[i] { delegate } else { None };
             let account_lamports = lamports_vec[i].unwrap_or(0);
 
+            // Build TLV if flag is set
+            let tlv = if tlv_flags[i] {
+                Some(vec![ExtensionStruct::CompressedOnly(
+                    CompressedOnlyExtension {
+                        delegated_amount: tlv_delegated_amounts[i],
+                        withheld_transfer_fee: tlv_withheld_fees[i],
+                    },
+                )])
+            } else {
+                None
+            };
+
             let token_data = AnchorTokenData {
                 mint: mint_pubkey,
                 owner: owner_pubkeys[i],
                 amount: amounts[i],
                 delegate: token_delegate,
                 state: AccountState::Initialized as u8,
-                tlv: None,
+                tlv: tlv.clone(),
+            };
+
+            // Use V3 hash (SHA256 of serialized data) when TLV present, V2 hash otherwise
+            let (data_hash, discriminator) = if tlv_flags[i] {
+                let serialized = token_data.try_to_vec().unwrap();
+                let hash = light_hasher::sha256::Sha256BE::hash(&serialized).unwrap();
+                (hash, TOKEN_COMPRESSED_ACCOUNT_V3_DISCRIMINATOR)
+            } else {
+                (
+                    token_data.hash_v2().unwrap(),
+                    TOKEN_COMPRESSED_ACCOUNT_V2_DISCRIMINATOR,
+                )
             };
-            let data_hash = token_data.hash_v2().unwrap();
 
             expected_accounts.push(OutputCompressedAccountWithPackedContext {
                 compressed_account: CompressedAccount {
@@ -141,7 +233,7 @@ fn test_rnd_create_output_compressed_accounts() {
                     lamports: account_lamports,
                     data: Some(CompressedAccountData {
                         data: token_data.try_to_vec().unwrap(),
-                        discriminator: TOKEN_COMPRESSED_ACCOUNT_V2_DISCRIMINATOR,
+                        discriminator,
                         data_hash,
                     }),
                 },
diff --git a/programs/registry/Cargo.toml b/programs/registry/Cargo.toml
index 367115c837..52cd664c4b 100644
--- a/programs/registry/Cargo.toml
+++ b/programs/registry/Cargo.toml
@@ -26,6 +26,7 @@ anchor-lang = { workspace = true, features = ["init-if-needed"] }
 account-compression = { workspace = true }
 light-compressible = { workspace = true, features = ["anchor"] }
 light-ctoken-interface = { workspace = true, features = ["anchor"] }
+light-zero-copy = { workspace = true }
 light-system-program-anchor = { workspace = true, features = ["cpi"] }
 light-account-checks = { workspace = true, features = ["solana", "std", "msg"] }
 light-program-profiler = { workspace = true }
diff --git a/programs/registry/src/compressible/compressed_token/compress_and_close.rs b/programs/registry/src/compressible/compressed_token/compress_and_close.rs
index 915c23a1b4..9d43e4b1b5 100644
--- a/programs/registry/src/compressible/compressed_token/compress_and_close.rs
+++ b/programs/registry/src/compressible/compressed_token/compress_and_close.rs
@@ -1,13 +1,17 @@
 use anchor_lang::{prelude::ProgramError, pubkey, AnchorDeserialize, AnchorSerialize, Result};
 use light_account_checks::packed_accounts::ProgramPackedAccounts;
 use light_ctoken_interface::{
-    instructions::transfer2::{
-        CompressedTokenInstructionDataTransfer2, Compression, CompressionMode,
-        MultiTokenTransferOutputData,
+    instructions::{
+        extensions::{CompressedOnlyExtensionInstructionData, ExtensionInstructionData},
+        transfer2::{
+            CompressedTokenInstructionDataTransfer2, Compression, CompressionMode,
+            MultiTokenTransferOutputData,
+        },
     },
-    state::CToken,
+    state::{CToken, ZExtensionStruct},
 };
 use light_program_profiler::profile;
+use light_zero_copy::traits::ZeroCopyAt;
 use solana_account_info::AccountInfo;
 use solana_instruction::{AccountMeta, Instruction};
 use solana_pubkey::Pubkey;
@@ -30,6 +34,7 @@ pub struct CompressAndCloseIndices {
     pub mint_index: u8,
     pub owner_index: u8,
     pub rent_sponsor_index: u8, // Can vary with custom rent sponsors
+    pub delegate_index: u8,     // Index to delegate in packed_accounts, 0 if no delegate
 }
 
 /// Compress and close compressed token accounts with pre-computed indices
@@ -74,6 +79,7 @@ pub fn compress_and_close_ctoken_accounts_with_indices<'info>(
     // Create one output per compression (no deduplication)
     let mut output_accounts = Vec::with_capacity(indices.len());
     let mut compressions = Vec::with_capacity(indices.len());
+    let mut out_tlv: Vec<Vec<ExtensionInstructionData>> = Vec::with_capacity(indices.len());
 
     // Process each set of indices
     for (i, idx) in indices.iter().enumerate() {
@@ -91,14 +97,71 @@ pub fn compress_and_close_ctoken_accounts_with_indices<'info>(
             RegistryError::InvalidTokenAccountData
         })?;
 
+        // Parse the full CToken to check for marker extensions
+        let (ctoken, _) = CToken::zero_copy_at(&account_data).map_err(|e| {
+            anchor_lang::prelude::msg!("Failed to parse CToken: {:?}", e);
+            RegistryError::InvalidSigner
+        })?;
+
+        // Check if this account has marker extensions that require CompressedOnly in output
+        let mut has_marker_extensions = false;
+        let mut withheld_transfer_fee: u64 = 0;
+        let delegated_amount: u64 = ctoken.delegated_amount.get();
+        // AccountState::Frozen = 2 in CToken
+        let is_frozen = ctoken.state == 2;
+
+        // Frozen accounts require CompressedOnly extension to preserve frozen state
+        if is_frozen {
+            has_marker_extensions = true;
+        }
+        // Delegate (even with delegated_amount=0) requires CompressedOnly to preserve delegate
+        if idx.delegate_index != 0 {
+            has_marker_extensions = true;
+        }
+        if ctoken.compression_only() {
+            has_marker_extensions = true;
+        }
+        if let Some(extensions) = &ctoken.extensions {
+            for ext in extensions.iter() {
+                match ext {
+                    ZExtensionStruct::PausableAccount(_)
+                    | ZExtensionStruct::PermanentDelegateAccount(_)
+                    | ZExtensionStruct::TransferHookAccount(_) => {
+                        has_marker_extensions = true;
+                    }
+                    ZExtensionStruct::TransferFeeAccount(fee_ext) => {
+                        has_marker_extensions = true;
+                        withheld_transfer_fee = fee_ext.withheld_amount.into();
+                    }
+                    _ => {}
+                }
+            }
+        }
+
+        // Build TLV extensions for this output if marker extensions are present
+        if has_marker_extensions {
+            out_tlv.push(vec![ExtensionInstructionData::CompressedOnly(
+                CompressedOnlyExtensionInstructionData {
+                    delegated_amount,
+                    withheld_transfer_fee,
+                    is_frozen,
+                    compression_index: i as u8,
+                },
+            )]);
+        } else {
+            out_tlv.push(vec![]);
+        }
+
         // Create one output account per compression operation
+        // has_delegate must be true if delegate is set (delegate_index != 0),
+        // even if delegated_amount is 0 (orphan delegate case)
         output_accounts.push(MultiTokenTransferOutputData {
             owner: idx.owner_index,
             amount,
-            delegate: 0,
+            delegate: idx.delegate_index,
             mint: idx.mint_index,
             version: 3, // Shaflat
-            has_delegate: false,
+            has_delegate: idx.delegate_index != 0,
         });
 
         let compression = Compression {
@@ -122,6 +185,8 @@ pub fn compress_and_close_ctoken_accounts_with_indices<'info>(
         .is_signer = true;
 
     // Build instruction data inline
+    // Only include out_tlv if any account has extensions
+    let has_any_tlv = out_tlv.iter().any(|v| !v.is_empty());
     let instruction_data = CompressedTokenInstructionDataTransfer2 {
         with_transaction_hash: false,
         with_lamports_change_account_merkle_tree_index: false,
@@ -134,7 +199,7 @@ pub fn compress_and_close_ctoken_accounts_with_indices<'info>(
         in_lamports: None,
         out_lamports: None,
         in_tlv: None,
-        out_tlv: None,
+        out_tlv: if has_any_tlv { Some(out_tlv) } else { None },
         compressions: Some(compressions),
         cpi_context: None,
         max_top_up: 0,
diff --git a/sdk-libs/client/Cargo.toml b/sdk-libs/client/Cargo.toml
index 026f1e813a..b5e929a6c3 100644
--- a/sdk-libs/client/Cargo.toml
+++ b/sdk-libs/client/Cargo.toml
@@ -44,6 +44,7 @@ light-sdk = { workspace = true }
 light-hasher = { workspace = true, features = ["poseidon"] }
 light-compressed-account = { workspace = true, features = ["solana", "poseidon"] }
 light-ctoken-sdk = { workspace = true }
+light-ctoken-interface = { workspace = true }
 light-event = { workspace = true }
 
 photon-api = { workspace = true }
diff --git a/sdk-libs/client/src/indexer/types.rs b/sdk-libs/client/src/indexer/types.rs
index d2f8ef89a2..ea275d47b1 100644
--- a/sdk-libs/client/src/indexer/types.rs
+++ b/sdk-libs/client/src/indexer/types.rs
@@ -1,3 +1,4 @@
+use borsh::BorshDeserialize;
 use light_compressed_account::{
     compressed_account::{
         CompressedAccount as ProgramCompressedAccount, CompressedAccountData,
@@ -6,6 +7,7 @@ use light_compressed_account::{
     instruction_data::compressed_proof::CompressedProof,
     TreeType,
 };
+use light_ctoken_interface::state::ExtensionStruct;
 use light_ctoken_sdk::compat::{AccountState, TokenData};
 use light_indexed_merkle_tree::array::IndexedElement;
 use light_sdk::instruction::{
@@ -882,9 +884,13 @@ impl TryFrom<&photon_api::models::TokenAccount> for CompressedTokenAccount {
                 .token_data
                 .tlv
                 .as_ref()
-                .map(|tlv| base64::decode_config(tlv, base64::STANDARD_NO_PAD))
-                .transpose()
-                .map_err(|_| IndexerError::InvalidResponseData)?,
+                .map(|tlv| {
+                    let bytes = base64::decode_config(tlv, base64::STANDARD_NO_PAD)
+                        .map_err(|_| IndexerError::InvalidResponseData)?;
+                    Vec::<ExtensionStruct>::deserialize(&mut bytes.as_slice())
+                        .map_err(|_| IndexerError::InvalidResponseData)
+                })
+                .transpose()?,
         };
 
         Ok(CompressedTokenAccount { token, account })
@@ -919,9 +925,13 @@ impl TryFrom<&photon_api::models::TokenAccountV2> for CompressedTokenAccount {
                 .token_data
                 .tlv
                 .as_ref()
-                .map(|tlv| base64::decode_config(tlv, base64::STANDARD_NO_PAD))
-                .transpose()
-                .map_err(|_| IndexerError::InvalidResponseData)?,
+                .map(|tlv| {
+                    let bytes = base64::decode_config(tlv, base64::STANDARD_NO_PAD)
+                        .map_err(|_| IndexerError::InvalidResponseData)?;
+                    Vec::<ExtensionStruct>::deserialize(&mut bytes.as_slice())
+                        .map_err(|_| IndexerError::InvalidResponseData)
+                })
+                .transpose()?,
         };
 
         Ok(CompressedTokenAccount { token, account })
diff --git a/sdk-libs/ctoken-sdk/src/compressed_token/v2/account2.rs b/sdk-libs/ctoken-sdk/src/compressed_token/v2/account2.rs
index 6fe6eeaf2d..63721bf9a6 100644
--- a/sdk-libs/ctoken-sdk/src/compressed_token/v2/account2.rs
+++ b/sdk-libs/ctoken-sdk/src/compressed_token/v2/account2.rs
@@ -190,6 +190,7 @@ impl CTokenAccount2 {
     }
 
     #[profile]
+    #[allow(clippy::too_many_arguments)]
     pub fn compress_spl(
         &mut self,
         amount: u64,
@@ -198,6 +199,7 @@ impl CTokenAccount2 {
         pool_account_index: u8,
         pool_index: u8,
         bump: u8,
+        decimals: u8,
     ) -> Result<(), CTokenSdkError> {
         // Check if there's already a compression set
         if self.compression.is_some() {
@@ -213,6 +215,7 @@ impl CTokenAccount2 {
             pool_account_index,
             pool_index,
             bump,
+            decimals,
         ));
         self.method_used = true;
 
@@ -254,6 +257,7 @@ impl CTokenAccount2 {
         pool_account_index: u8,
         pool_index: u8,
         bump: u8,
+        decimals: u8,
     ) -> Result<(), CTokenSdkError> {
         // Check if there's already a compression set
         if self.compression.is_some() {
@@ -272,6 +276,7 @@ impl CTokenAccount2 {
             pool_account_index,
             pool_index,
             bump,
+            decimals,
         ));
         self.method_used = true;
 
@@ -306,7 +311,7 @@ impl CTokenAccount2 {
             pool_account_index: 0,
             pool_index: 0,
             bump: 0,
-            decimals: 0,
+            decimals: 0, // Not used for ctoken compression
         });
         self.method_used = true;
 
diff --git a/sdk-libs/ctoken-sdk/src/compressed_token/v2/compress_and_close.rs b/sdk-libs/ctoken-sdk/src/compressed_token/v2/compress_and_close.rs
index 5c465ddd73..4549fe24ba 100644
--- a/sdk-libs/ctoken-sdk/src/compressed_token/v2/compress_and_close.rs
+++ b/sdk-libs/ctoken-sdk/src/compressed_token/v2/compress_and_close.rs
@@ -1,7 +1,4 @@
-use light_ctoken_interface::{
-    instructions::transfer2::CompressedCpiContext,
-    state::{CToken, ZExtensionStruct},
-};
+use light_ctoken_interface::{instructions::transfer2::CompressedCpiContext, state::CToken};
 use light_program_profiler::profile;
 use light_sdk::{
     error::LightSdkError,
@@ -43,59 +40,23 @@ pub fn pack_for_compress_and_close(
     ctoken_account_pubkey: Pubkey,
     ctoken_account_data: &[u8],
     packed_accounts: &mut PackedAccounts,
-    signer_is_compression_authority: bool, // if yes rent authority must be signer
 ) -> Result<CompressAndCloseIndices, CTokenSdkError> {
     let (ctoken_account, _) = CToken::zero_copy_at(ctoken_account_data)?;
     let source_index = packed_accounts.insert_or_get(ctoken_account_pubkey);
     let mint_index = packed_accounts.insert_or_get(Pubkey::from(ctoken_account.mint.to_bytes()));
     let owner_index = packed_accounts.insert_or_get(Pubkey::from(ctoken_account.owner.to_bytes()));
 
-    let (rent_sponsor_index, authority_index, destination_index) =
-        if signer_is_compression_authority {
-            // When using rent authority from extension, find the rent recipient from extension
-            let mut recipient_index = owner_index; // Default to owner if no extension found
-            let mut authority_index = owner_index; // Default to owner if no extension found
-            if let Some(extensions) = &ctoken_account.extensions {
-                for extension in extensions {
-                    if let ZExtensionStruct::Compressible(e) = extension {
-                        authority_index = packed_accounts.insert_or_get_config(
-                            Pubkey::from(e.info.compression_authority),
-                            true,
-                            true,
-                        );
-                        recipient_index =
-                            packed_accounts.insert_or_get(Pubkey::from(e.info.rent_sponsor));
-
-                        break;
-                    }
-                }
-            }
-            // When rent authority closes, everything goes to rent recipient
-            (recipient_index, authority_index, recipient_index)
-        } else {
-            // Owner is the authority and needs to sign
-            // Check if there's a compressible extension to get the rent_sponsor
-            let mut recipient_index = owner_index; // Default to owner if no extension
-            if let Some(extensions) = &ctoken_account.extensions {
-                for extension in extensions {
-                    if let ZExtensionStruct::Compressible(e) = extension {
-                        recipient_index =
-                            packed_accounts.insert_or_get(Pubkey::from(e.info.rent_sponsor));
-
-                        break;
-                    }
-                }
-            }
-            (
-                recipient_index,
-                packed_accounts.insert_or_get_config(
-                    Pubkey::from(ctoken_account.owner.to_bytes()),
-                    true,
-                    false,
-                ),
-                owner_index, // User funds go to owner
-            )
-        };
+    // Get compression info from base
+    let compression = &ctoken_account.base.compression;
+    let authority_index = packed_accounts.insert_or_get_config(
+        Pubkey::from(compression.compression_authority),
+        true,
+        true,
+    );
+    let rent_sponsor_index = packed_accounts.insert_or_get(Pubkey::from(compression.rent_sponsor));
+    // When compression authority closes, everything goes to rent sponsor
+    let destination_index = rent_sponsor_index;
+
     Ok(CompressAndCloseIndices {
         source_index,
         mint_index,
@@ -117,7 +78,6 @@ fn find_account_indices(
     authority: &Pubkey,
     rent_sponsor_pubkey: &Pubkey,
     destination_pubkey: &Pubkey,
-    // output_tree_pubkey: &Pubkey,
 ) -> Result<CompressAndCloseIndices, CTokenSdkError> {
     let source_index = find_index(ctoken_account_key).ok_or_else(|| {
         msg!("Source ctoken account not found in packed_accounts");
@@ -172,7 +132,6 @@ fn find_account_indices(
 #[profile]
 pub fn compress_and_close_ctoken_accounts_with_indices<'info>(
     fee_payer: Pubkey,
-    rent_sponsor_is_signer: bool,
     cpi_context_pubkey: Option<Pubkey>,
     indices: &[CompressAndCloseIndices],
     packed_accounts: &[AccountInfo<'info>],
@@ -218,11 +177,8 @@ pub fn compress_and_close_ctoken_accounts_with_indices<'info>(
             idx.destination_index, // destination for user funds
         )?;
 
-        if rent_sponsor_is_signer {
-            packed_account_metas[idx.authority_index as usize].is_signer = true;
-        } else {
-            packed_account_metas[idx.owner_index as usize].is_signer = true;
-        }
+        // Compression authority must sign
+        packed_account_metas[idx.authority_index as usize].is_signer = true;
 
         token_accounts.push(token_account);
     }
@@ -268,9 +224,7 @@ pub fn compress_and_close_ctoken_accounts_with_indices<'info>(
 ///
 /// # Arguments
 /// * `fee_payer` - The fee payer pubkey
-/// * `with_compression_authority` - If true, use rent authority from compressible token extension
 /// * `output_queue_pubkey` - The output queue pubkey where compressed accounts will be stored
-/// * `cpi_context_pubkey` - Optional CPI context account for optimized multi-program transactions
 /// * `ctoken_solana_accounts` - Slice of ctoken Solana account infos to compress and close
 /// * `packed_accounts` - Slice of all accounts that will be used in the instruction (tree accounts)
 ///
@@ -279,7 +233,6 @@ pub fn compress_and_close_ctoken_accounts_with_indices<'info>(
 #[profile]
 pub fn compress_and_close_ctoken_accounts<'info>(
     fee_payer: Pubkey,
-    with_compression_authority: bool,
     output_queue: AccountInfo<'info>,
     ctoken_solana_accounts: &[&AccountInfo<'info>],
     packed_accounts: &[AccountInfo<'info>],
@@ -303,7 +256,6 @@ pub fn compress_and_close_ctoken_accounts<'info>(
     let mut indices_vec = Vec::with_capacity(ctoken_solana_accounts.len());
 
     for ctoken_account_info in ctoken_solana_accounts.iter() {
-        let mut rent_sponsor_pubkey: Option<Pubkey> = None;
         // Deserialize the ctoken Solana account using light zero copy
         let account_data = ctoken_account_info
             .try_borrow_data()
@@ -318,62 +270,13 @@ pub fn compress_and_close_ctoken_accounts<'info>(
         let mint_pubkey = Pubkey::from(compressed_token.mint.to_bytes());
         let owner_pubkey = Pubkey::from(compressed_token.owner.to_bytes());
 
-        // Check if there's a compressible token extension to get the rent authority
-        let authority = if with_compression_authority {
-            // Find the compressible token extension
-            let mut compression_authority = owner_pubkey;
-            if let Some(extensions) = &compressed_token.extensions {
-                for extension in extensions {
-                    if let ZExtensionStruct::Compressible(extension) = extension {
-                        // Check if compression_authority is set (non-zero)
-                        if extension.info.compression_authority != [0u8; 32] {
-                            compression_authority =
-                                Pubkey::from(extension.info.compression_authority);
-                        }
-                        break;
-                    }
-                }
-            }
-            compression_authority
-        } else {
-            // If not using rent authority, always use the owner
-            owner_pubkey
-        };
-
-        // Determine rent recipient from extension or use default
-        let actual_rent_sponsor = if let Some(sponsor) = rent_sponsor_pubkey {
-            sponsor
-        } else {
-            // Check if there's a rent recipient in the compressible extension
-            if let Some(extensions) = &compressed_token.extensions {
-                for extension in extensions {
-                    if let ZExtensionStruct::Compressible(ext) = extension {
-                        // Check if rent_sponsor is set (non-zero)
-                        if ext.info.rent_sponsor != [0u8; 32] {
-                            rent_sponsor_pubkey = Some(Pubkey::from(ext.info.rent_sponsor));
-                        }
-                        break;
-                    }
-                }
-            }
-
-            // If still no rent recipient, find the fee payer (first signer)
-            if rent_sponsor_pubkey.is_none() {
-                for account in packed_accounts.iter() {
-                    if account.is_signer {
-                        rent_sponsor_pubkey = Some(*account.key);
-                        break;
-                    }
-                }
-            }
-            rent_sponsor_pubkey.ok_or(CTokenSdkError::InvalidAccountData)?
-        };
+        // Get compression info from base
+        let compression = &compressed_token.base.compression;
+        let authority = Pubkey::from(compression.compression_authority);
+        let rent_sponsor = Pubkey::from(compression.rent_sponsor);
 
-        let destination_pubkey = if with_compression_authority {
-            actual_rent_sponsor
-        } else {
-            owner_pubkey
-        };
+        // When compression authority closes, everything goes to rent sponsor
+        let destination_pubkey = rent_sponsor;
 
         let indices = find_account_indices(
             find_index,
@@ -381,7 +284,7 @@ pub fn compress_and_close_ctoken_accounts<'info>(
             &mint_pubkey,
             &owner_pubkey,
             &authority,
-            &actual_rent_sponsor,
+            &rent_sponsor,
             &destination_pubkey,
         )?;
         indices_vec.push(indices);
@@ -392,7 +295,6 @@ pub fn compress_and_close_ctoken_accounts<'info>(
 
     compress_and_close_ctoken_accounts_with_indices(
         fee_payer,
-        with_compression_authority,
         None,
         &indices_vec,
         packed_accounts_vec.as_slice(),
@@ -419,7 +321,6 @@ pub fn compress_and_close_ctoken_accounts_signed<'b, 'info>(
     cpi_authority: AccountInfo<'info>,
     post_system: &[AccountInfo<'info>],
     remaining_accounts: &[AccountInfo<'info>],
-    with_compression_authority: bool,
 ) -> Result<(), CTokenSdkError> {
     let mut packed_accounts = Vec::with_capacity(post_system.len() + 4);
     packed_accounts.extend_from_slice(post_system);
@@ -433,7 +334,6 @@ pub fn compress_and_close_ctoken_accounts_signed<'b, 'info>(
 
     let instruction = compress_and_close_ctoken_accounts(
         *fee_payer.key,
-        with_compression_authority,
         output_queue,
         &ctoken_infos,
         &packed_accounts,
diff --git a/sdk-libs/ctoken-sdk/src/compressed_token/v2/decompress_full.rs b/sdk-libs/ctoken-sdk/src/compressed_token/v2/decompress_full.rs
index b1a49b764d..700b0a89b1 100644
--- a/sdk-libs/ctoken-sdk/src/compressed_token/v2/decompress_full.rs
+++ b/sdk-libs/ctoken-sdk/src/compressed_token/v2/decompress_full.rs
@@ -1,6 +1,7 @@
 use light_compressed_account::compressed_account::PackedMerkleContext;
-use light_ctoken_interface::instructions::transfer2::{
-    CompressedCpiContext, MultiInputTokenDataWithContext,
+use light_ctoken_interface::instructions::{
+    extensions::ExtensionInstructionData,
+    transfer2::{CompressedCpiContext, MultiInputTokenDataWithContext},
 };
 use light_program_profiler::profile;
 use light_sdk::{
@@ -19,15 +20,19 @@ use super::{
     },
 };
 use crate::{
-    compat::TokenData, error::CTokenSdkError, utils::CTokenDefaultAccounts, ValidityProof,
+    compat::TokenData, error::CTokenSdkError, utils::CTokenDefaultAccounts, AnchorDeserialize,
+    AnchorSerialize, ValidityProof,
 };
 
 /// Struct to hold all the data needed for DecompressFull operation
 /// Contains the complete compressed account data and destination index
-#[derive(Debug, Clone, crate::AnchorSerialize, crate::AnchorDeserialize)]
+#[derive(Debug, Clone, AnchorDeserialize, AnchorSerialize)]
 pub struct DecompressFullIndices {
     pub source: MultiInputTokenDataWithContext, // Complete compressed account data with merkle context
     pub destination_index: u8,                  // Destination ctoken Solana account (must exist)
+    /// TLV extensions for this compressed account (e.g., CompressedOnly extension).
+    /// Used to transfer extension state during decompress.
+    pub tlv: Option<Vec<ExtensionInstructionData>>,
 }
 
 /// Decompress full balance from compressed token accounts with pre-computed indices
@@ -55,6 +60,8 @@ pub fn decompress_full_ctoken_accounts_with_indices<'info>(
 
     // Process each set of indices
     let mut token_accounts = Vec::with_capacity(indices.len());
+    let mut in_tlv_data: Vec<Vec<ExtensionInstructionData>> = Vec::with_capacity(indices.len());
+    let mut has_any_tlv = false;
 
     // Convert packed_accounts to AccountMetas
     // TODO: we may have to add conditional delegate signers for delegate
@@ -71,6 +78,14 @@ pub fn decompress_full_ctoken_accounts_with_indices<'info>(
         token_account.decompress_ctoken(idx.source.amount, idx.destination_index)?;
         token_accounts.push(token_account);
 
+        // Collect TLV data for this input
+        if let Some(tlv) = &idx.tlv {
+            has_any_tlv = true;
+            in_tlv_data.push(tlv.clone());
+        } else {
+            in_tlv_data.push(Vec::new());
+        }
+
         let owner_idx = idx.source.owner as usize;
         if owner_idx >= signer_flags.len() {
             return Err(CTokenSdkError::InvalidAccountData);
@@ -120,6 +135,7 @@ pub fn decompress_full_ctoken_accounts_with_indices<'info>(
         token_accounts,
         transfer_config,
         validity_proof,
+        in_tlv: if has_any_tlv { Some(in_tlv_data) } else { None },
         ..Default::default()
     };
 
@@ -134,7 +150,8 @@ pub fn decompress_full_ctoken_accounts_with_indices<'info>(
 /// * `tree_infos` - Packed tree info for each compressed account
 /// * `destination_indices` - Destination account indices for each decompression
 /// * `packed_accounts` - PackedAccounts that will be used to insert/get indices
-/// * `version` - Token data version (from TokenDataVersion enum)
+/// * `tlv` - Optional TLV extensions for the compressed account
+/// * `version` - TokenDataVersion (1=V1, 2=V2, 3=ShaFlat) for hash computation
 ///
 /// # Returns
 /// Vec of DecompressFullIndices ready to use with decompress_full_ctoken_accounts_with_indices
@@ -144,6 +161,7 @@ pub fn pack_for_decompress_full(
     tree_info: &PackedStateTreeInfo,
     destination: Pubkey,
     packed_accounts: &mut PackedAccounts,
+    tlv: Option<Vec<ExtensionInstructionData>>,
     version: u8,
 ) -> DecompressFullIndices {
     let source = MultiInputTokenDataWithContext {
@@ -168,6 +186,7 @@ pub fn pack_for_decompress_full(
     DecompressFullIndices {
         source,
         destination_index: packed_accounts.insert_or_get(destination),
+        tlv,
     }
 }
 
diff --git a/sdk-libs/ctoken-sdk/src/compressed_token/v2/mod.rs b/sdk-libs/ctoken-sdk/src/compressed_token/v2/mod.rs
index fe0eb8c70f..cd1b9f1711 100644
--- a/sdk-libs/ctoken-sdk/src/compressed_token/v2/mod.rs
+++ b/sdk-libs/ctoken-sdk/src/compressed_token/v2/mod.rs
@@ -9,3 +9,4 @@ pub mod transfer2;
 pub mod update_compressed_mint;
 
 pub use account2::*;
+pub use compress_and_close::*;
diff --git a/sdk-libs/ctoken-sdk/src/compressed_token/v2/transfer2/instruction.rs b/sdk-libs/ctoken-sdk/src/compressed_token/v2/transfer2/instruction.rs
index 2e60d2eaa3..ebaed42366 100644
--- a/sdk-libs/ctoken-sdk/src/compressed_token/v2/transfer2/instruction.rs
+++ b/sdk-libs/ctoken-sdk/src/compressed_token/v2/transfer2/instruction.rs
@@ -1,8 +1,11 @@
+use light_compressed_account::instruction_data::compressed_proof::ValidityProof;
 use light_ctoken_interface::{
-    instructions::transfer2::{CompressedCpiContext, CompressedTokenInstructionDataTransfer2},
-    CTOKEN_PROGRAM_ID,
+    instructions::{
+        extensions::ExtensionInstructionData,
+        transfer2::{CompressedCpiContext, CompressedTokenInstructionDataTransfer2},
+    },
+    CTOKEN_PROGRAM_ID, TRANSFER2,
 };
-use light_ctoken_types::{constants::TRANSFER2, ValidityProof};
 use light_program_profiler::profile;
 use solana_instruction::Instruction;
 use solana_pubkey::Pubkey;
@@ -70,6 +73,9 @@ pub struct Transfer2Inputs {
     pub in_lamports: Option<Vec<u64>>,
     pub out_lamports: Option<Vec<u64>>,
     pub output_queue: u8,
+    /// TLV extensions for input compressed accounts (one Vec per input account).
+    /// Used to pass extension state (e.g., CompressedOnly) for decompress operations.
+    pub in_tlv: Option<Vec<Vec<ExtensionInstructionData>>>,
 }
 
 /// Create the instruction for compressed token multi-transfer operations
@@ -83,6 +89,7 @@ pub fn create_transfer2_instruction(inputs: Transfer2Inputs) -> Result<Instructi
         in_lamports,
         out_lamports,
         output_queue,
+        in_tlv,
     } = inputs;
     let mut input_token_data_with_context = Vec::new();
     let mut output_compressed_accounts = Vec::new();
@@ -116,8 +123,8 @@ pub fn create_transfer2_instruction(inputs: Transfer2Inputs) -> Result<Instructi
         out_token_data: output_compressed_accounts,
         in_lamports,
         out_lamports,
-        in_tlv: None,  // TLV is unimplemented
-        out_tlv: None, // TLV is unimplemented
+        in_tlv,
+        out_tlv: None, // Out TLV is only for CompressAndClose by rent authority
         compressions: if collected_compressions.is_empty() {
             None
         } else {
diff --git a/sdk-libs/ctoken-sdk/src/compressible/decompress_runtime.rs b/sdk-libs/ctoken-sdk/src/compressible/decompress_runtime.rs
index a606316e74..52c48816a9 100644
--- a/sdk-libs/ctoken-sdk/src/compressible/decompress_runtime.rs
+++ b/sdk-libs/ctoken-sdk/src/compressible/decompress_runtime.rs
@@ -1,5 +1,7 @@
 //! Runtime helpers for token decompression.
-use light_ctoken_interface::instructions::transfer2::MultiInputTokenDataWithContext;
+use light_ctoken_interface::instructions::{
+    create_ctoken_account::CompressToPubkey, transfer2::MultiInputTokenDataWithContext,
+};
 use light_sdk::{cpi::v2::CpiAccounts, instruction::ValidityProof};
 use light_sdk_types::instruction::account_meta::CompressedAccountMetaNoLamportsNoAddress;
 use solana_account_info::AccountInfo;
@@ -131,7 +133,7 @@ where
                     .take(ctoken_signer_seeds.len().saturating_sub(1))
                     .cloned()
                     .collect();
-                light_ctoken_interface::instructions::extensions::compressible::CompressToPubkey {
+                CompressToPubkey {
                     bump,
                     program_id: program_id.to_bytes(),
                     seeds: seeds_without_bump,
@@ -143,7 +145,7 @@ where
             account: (*owner_info).clone(),
             mint: (*mint_info).clone(),
             owner: *authority.key,
-            compressible: Some(crate::ctoken::CompressibleParamsCpi {
+            compressible: crate::ctoken::CompressibleParamsCpi {
                 compressible_config: ctoken_config.clone(),
                 rent_sponsor: ctoken_rent_sponsor.clone(),
                 system_program: cpi_accounts
@@ -154,7 +156,8 @@ where
                 lamports_per_write: None,
                 compress_to_account_pubkey: compress_to_pubkey,
                 token_account_version: light_ctoken_interface::state::TokenDataVersion::ShaFlat,
-            }),
+                compression_only: false,
+            },
         }
         .invoke_signed(&[seeds_slice])?;
 
@@ -171,6 +174,7 @@ where
         let decompress_index = crate::compressed_token::decompress_full::DecompressFullIndices {
             source,
             destination_index: owner_index,
+            tlv: None,
         };
         token_decompress_indices.push(decompress_index);
         token_signers_seed_groups.push(ctoken_signer_seeds);
diff --git a/sdk-libs/ctoken-sdk/src/ctoken/approve.rs b/sdk-libs/ctoken-sdk/src/ctoken/approve.rs
new file mode 100644
index 0000000000..7089e2c8e5
--- /dev/null
+++ b/sdk-libs/ctoken-sdk/src/ctoken/approve.rs
@@ -0,0 +1,115 @@
+use light_sdk_types::C_TOKEN_PROGRAM_ID;
+use solana_account_info::AccountInfo;
+use solana_cpi::{invoke, invoke_signed};
+use solana_instruction::{AccountMeta, Instruction};
+use solana_program_error::ProgramError;
+use solana_pubkey::Pubkey;
+
+/// # Approve a delegate for a CToken account:
+/// ```rust
+/// # use solana_pubkey::Pubkey;
+/// # use light_ctoken_sdk::ctoken::ApproveCToken;
+/// # let token_account = Pubkey::new_unique();
+/// # let delegate = Pubkey::new_unique();
+/// # let owner = Pubkey::new_unique();
+/// let instruction = ApproveCToken {
+///     token_account,
+///     delegate,
+///     owner,
+///     amount: 100,
+/// }.instruction()?;
+/// # Ok::<(), solana_program_error::ProgramError>(())
+/// ```
+pub struct ApproveCToken {
+    /// CToken account to approve delegation for
+    pub token_account: Pubkey,
+    /// Delegate to approve
+    pub delegate: Pubkey,
+    /// Owner of the CToken account (signer, payer for top-up)
+    pub owner: Pubkey,
+    /// Amount of tokens to delegate
+    pub amount: u64,
+}
+
+/// # Approve CToken via CPI:
+/// ```rust,no_run
+/// # use light_ctoken_sdk::ctoken::ApproveCTokenCpi;
+/// # use solana_account_info::AccountInfo;
+/// # let token_account: AccountInfo = todo!();
+/// # let delegate: AccountInfo = todo!();
+/// # let owner: AccountInfo = todo!();
+/// # let system_program: AccountInfo = todo!();
+/// ApproveCTokenCpi {
+///     token_account,
+///     delegate,
+///     owner,
+///     system_program,
+///     amount: 100,
+/// }
+/// .invoke()?;
+/// # Ok::<(), solana_program_error::ProgramError>(())
+/// ```
+pub struct ApproveCTokenCpi<'info> {
+    pub token_account: AccountInfo<'info>,
+    pub delegate: AccountInfo<'info>,
+    pub owner: AccountInfo<'info>,
+    pub system_program: AccountInfo<'info>,
+    pub amount: u64,
+}
+
+impl<'info> ApproveCTokenCpi<'info> {
+    pub fn instruction(&self) -> Result<Instruction, ProgramError> {
+        ApproveCToken::from(self).instruction()
+    }
+
+    pub fn invoke(self) -> Result<(), ProgramError> {
+        let instruction = ApproveCToken::from(&self).instruction()?;
+        let account_infos = [
+            self.token_account,
+            self.delegate,
+            self.owner,
+            self.system_program,
+        ];
+        invoke(&instruction, &account_infos)
+    }
+
+    pub fn invoke_signed(self, signer_seeds: &[&[&[u8]]]) -> Result<(), ProgramError> {
+        let instruction = ApproveCToken::from(&self).instruction()?;
+        let account_infos = [
+            self.token_account,
+            self.delegate,
+            self.owner,
+            self.system_program,
+        ];
+        invoke_signed(&instruction, &account_infos, signer_seeds)
+    }
+}
+
+impl<'info> From<&ApproveCTokenCpi<'info>> for ApproveCToken {
+    fn from(cpi: &ApproveCTokenCpi<'info>) -> Self {
+        Self {
+            token_account: *cpi.token_account.key,
+            delegate: *cpi.delegate.key,
+            owner: *cpi.owner.key,
+            amount: cpi.amount,
+        }
+    }
+}
+
+impl ApproveCToken {
+    pub fn instruction(self) -> Result<Instruction, ProgramError> {
+        let mut data = vec![4u8]; // CTokenApprove discriminator
+        data.extend_from_slice(&self.amount.to_le_bytes());
+
+        Ok(Instruction {
+            program_id: Pubkey::from(C_TOKEN_PROGRAM_ID),
+            accounts: vec![
+                AccountMeta::new(self.token_account, false),
+                AccountMeta::new_readonly(self.delegate, false),
+                AccountMeta::new(self.owner, true),
+                AccountMeta::new_readonly(Pubkey::default(), false),
+            ],
+            data,
+        })
+    }
+}
diff --git a/sdk-libs/ctoken-sdk/src/ctoken/approve_checked.rs b/sdk-libs/ctoken-sdk/src/ctoken/approve_checked.rs
new file mode 100644
index 0000000000..6997051f1b
--- /dev/null
+++ b/sdk-libs/ctoken-sdk/src/ctoken/approve_checked.rs
@@ -0,0 +1,144 @@
+use light_sdk_types::C_TOKEN_PROGRAM_ID;
+use solana_account_info::AccountInfo;
+use solana_cpi::{invoke, invoke_signed};
+use solana_instruction::{AccountMeta, Instruction};
+use solana_program_error::ProgramError;
+use solana_pubkey::Pubkey;
+
+/// # Approve a delegate for a CToken account with decimals validation:
+/// ```rust
+/// # use solana_pubkey::Pubkey;
+/// # use light_ctoken_sdk::ctoken::ApproveCTokenChecked;
+/// # let token_account = Pubkey::new_unique();
+/// # let mint = Pubkey::new_unique();
+/// # let delegate = Pubkey::new_unique();
+/// # let owner = Pubkey::new_unique();
+/// let instruction = ApproveCTokenChecked {
+///     token_account,
+///     mint,
+///     delegate,
+///     owner,
+///     amount: 100,
+///     decimals: 8,
+///     max_top_up: None,
+/// }.instruction()?;
+/// # Ok::<(), solana_program_error::ProgramError>(())
+/// ```
+pub struct ApproveCTokenChecked {
+    /// CToken account to approve delegation for
+    pub token_account: Pubkey,
+    /// Mint account (for decimals validation - may be skipped if CToken has cached decimals)
+    pub mint: Pubkey,
+    /// Delegate to approve
+    pub delegate: Pubkey,
+    /// Owner of the CToken account (signer, payer for top-up)
+    pub owner: Pubkey,
+    /// Amount of tokens to delegate
+    pub amount: u64,
+    /// Expected token decimals
+    pub decimals: u8,
+    /// Maximum lamports for rent top-up. Transaction fails if exceeded. (0 = no limit)
+    pub max_top_up: Option<u16>,
+}
+
+/// # Approve CToken via CPI with decimals validation:
+/// ```rust,no_run
+/// # use light_ctoken_sdk::ctoken::ApproveCTokenCheckedCpi;
+/// # use solana_account_info::AccountInfo;
+/// # let token_account: AccountInfo = todo!();
+/// # let mint: AccountInfo = todo!();
+/// # let delegate: AccountInfo = todo!();
+/// # let owner: AccountInfo = todo!();
+/// # let system_program: AccountInfo = todo!();
+/// ApproveCTokenCheckedCpi {
+///     token_account,
+///     mint,
+///     delegate,
+///     owner,
+///     system_program,
+///     amount: 100,
+///     decimals: 8,
+///     max_top_up: None,
+/// }
+/// .invoke()?;
+/// # Ok::<(), solana_program_error::ProgramError>(())
+/// ```
+pub struct ApproveCTokenCheckedCpi<'info> {
+    pub token_account: AccountInfo<'info>,
+    pub mint: AccountInfo<'info>,
+    pub delegate: AccountInfo<'info>,
+    pub owner: AccountInfo<'info>,
+    pub system_program: AccountInfo<'info>,
+    pub amount: u64,
+    pub decimals: u8,
+    /// Maximum lamports for rent top-up. Transaction fails if exceeded. (0 = no limit)
+    pub max_top_up: Option<u16>,
+}
+
+impl<'info> ApproveCTokenCheckedCpi<'info> {
+    pub fn instruction(&self) -> Result<Instruction, ProgramError> {
+        ApproveCTokenChecked::from(self).instruction()
+    }
+
+    pub fn invoke(self) -> Result<(), ProgramError> {
+        let instruction = ApproveCTokenChecked::from(&self).instruction()?;
+        let account_infos = [
+            self.token_account,
+            self.mint,
+            self.delegate,
+            self.owner,
+            self.system_program,
+        ];
+        invoke(&instruction, &account_infos)
+    }
+
+    pub fn invoke_signed(self, signer_seeds: &[&[&[u8]]]) -> Result<(), ProgramError> {
+        let instruction = ApproveCTokenChecked::from(&self).instruction()?;
+        let account_infos = [
+            self.token_account,
+            self.mint,
+            self.delegate,
+            self.owner,
+            self.system_program,
+        ];
+        invoke_signed(&instruction, &account_infos, signer_seeds)
+    }
+}
+
+impl<'info> From<&ApproveCTokenCheckedCpi<'info>> for ApproveCTokenChecked {
+    fn from(cpi: &ApproveCTokenCheckedCpi<'info>) -> Self {
+        Self {
+            token_account: *cpi.token_account.key,
+            mint: *cpi.mint.key,
+            delegate: *cpi.delegate.key,
+            owner: *cpi.owner.key,
+            amount: cpi.amount,
+            decimals: cpi.decimals,
+            max_top_up: cpi.max_top_up,
+        }
+    }
+}
+
+impl ApproveCTokenChecked {
+    pub fn instruction(self) -> Result<Instruction, ProgramError> {
+        let mut data = vec![12u8]; // CTokenApproveChecked discriminator
+        data.extend_from_slice(&self.amount.to_le_bytes());
+        data.push(self.decimals);
+        // Include max_top_up if set (11-byte format)
+        if let Some(max_top_up) = self.max_top_up {
+            data.extend_from_slice(&max_top_up.to_le_bytes());
+        }
+
+        Ok(Instruction {
+            program_id: Pubkey::from(C_TOKEN_PROGRAM_ID),
+            accounts: vec![
+                AccountMeta::new(self.token_account, false),
+                AccountMeta::new_readonly(self.mint, false),
+                AccountMeta::new_readonly(self.delegate, false),
+                AccountMeta::new(self.owner, true),
+                AccountMeta::new_readonly(Pubkey::default(), false),
+            ],
+            data,
+        })
+    }
+}
diff --git a/sdk-libs/ctoken-sdk/src/ctoken/burn_checked.rs b/sdk-libs/ctoken-sdk/src/ctoken/burn_checked.rs
new file mode 100644
index 0000000000..6291974a27
--- /dev/null
+++ b/sdk-libs/ctoken-sdk/src/ctoken/burn_checked.rs
@@ -0,0 +1,121 @@
+use light_sdk_types::C_TOKEN_PROGRAM_ID;
+use solana_account_info::AccountInfo;
+use solana_cpi::{invoke, invoke_signed};
+use solana_instruction::{AccountMeta, Instruction};
+use solana_program_error::ProgramError;
+use solana_pubkey::Pubkey;
+
+/// # Burn tokens from a ctoken account with decimals validation:
+/// ```rust
+/// # use solana_pubkey::Pubkey;
+/// # use light_ctoken_sdk::ctoken::BurnCTokenChecked;
+/// # let source = Pubkey::new_unique();
+/// # let cmint = Pubkey::new_unique();
+/// # let authority = Pubkey::new_unique();
+/// let instruction = BurnCTokenChecked {
+///     source,
+///     cmint,
+///     amount: 100,
+///     decimals: 8,
+///     authority,
+///     max_top_up: None,
+/// }.instruction()?;
+/// # Ok::<(), solana_program_error::ProgramError>(())
+/// ```
+pub struct BurnCTokenChecked {
+    /// CToken account to burn from
+    pub source: Pubkey,
+    /// CMint account (supply tracking)
+    pub cmint: Pubkey,
+    /// Amount of tokens to burn
+    pub amount: u64,
+    /// Expected token decimals
+    pub decimals: u8,
+    /// Owner of the CToken account
+    pub authority: Pubkey,
+    /// Maximum lamports for rent and top-up combined. Transaction fails if exceeded. (0 = no limit)
+    /// When set to a non-zero value, includes max_top_up in instruction data
+    pub max_top_up: Option<u16>,
+}
+
+/// # Burn ctoken via CPI with decimals validation:
+/// ```rust,no_run
+/// # use light_ctoken_sdk::ctoken::BurnCTokenCheckedCpi;
+/// # use solana_account_info::AccountInfo;
+/// # let source: AccountInfo = todo!();
+/// # let cmint: AccountInfo = todo!();
+/// # let authority: AccountInfo = todo!();
+/// BurnCTokenCheckedCpi {
+///     source,
+///     cmint,
+///     amount: 100,
+///     decimals: 8,
+///     authority,
+///     max_top_up: None,
+/// }
+/// .invoke()?;
+/// # Ok::<(), solana_program_error::ProgramError>(())
+/// ```
+pub struct BurnCTokenCheckedCpi<'info> {
+    pub source: AccountInfo<'info>,
+    pub cmint: AccountInfo<'info>,
+    pub amount: u64,
+    pub decimals: u8,
+    pub authority: AccountInfo<'info>,
+    /// Maximum lamports for rent and top-up combined. Transaction fails if exceeded. (0 = no limit)
+    pub max_top_up: Option<u16>,
+}
+
+impl<'info> BurnCTokenCheckedCpi<'info> {
+    pub fn instruction(&self) -> Result<Instruction, ProgramError> {
+        BurnCTokenChecked::from(self).instruction()
+    }
+
+    pub fn invoke(self) -> Result<(), ProgramError> {
+        let instruction = BurnCTokenChecked::from(&self).instruction()?;
+        let account_infos = [self.source, self.cmint, self.authority];
+        invoke(&instruction, &account_infos)
+    }
+
+    pub fn invoke_signed(self, signer_seeds: &[&[&[u8]]]) -> Result<(), ProgramError> {
+        let instruction = BurnCTokenChecked::from(&self).instruction()?;
+        let account_infos = [self.source, self.cmint, self.authority];
+        invoke_signed(&instruction, &account_infos, signer_seeds)
+    }
+}
+
+impl<'info> From<&BurnCTokenCheckedCpi<'info>> for BurnCTokenChecked {
+    fn from(cpi: &BurnCTokenCheckedCpi<'info>) -> Self {
+        Self {
+            source: *cpi.source.key,
+            cmint: *cpi.cmint.key,
+            amount: cpi.amount,
+            decimals: cpi.decimals,
+            authority: *cpi.authority.key,
+            max_top_up: cpi.max_top_up,
+        }
+    }
+}
+
+impl BurnCTokenChecked {
+    pub fn instruction(self) -> Result<Instruction, ProgramError> {
+        Ok(Instruction {
+            program_id: Pubkey::from(C_TOKEN_PROGRAM_ID),
+            accounts: vec![
+                AccountMeta::new(self.source, false),
+                AccountMeta::new(self.cmint, false),
+                AccountMeta::new_readonly(self.authority, true),
+            ],
+            data: {
+                let mut data = vec![15u8]; // CTokenBurnChecked discriminator
+                data.extend_from_slice(&self.amount.to_le_bytes());
+                data.push(self.decimals);
+                // Include max_top_up if set (11-byte format)
+                if let Some(max_top_up) = self.max_top_up {
+                    data.extend_from_slice(&max_top_up.to_le_bytes());
+                }
+                data
+            },
+        })
+    }
+}
diff --git a/sdk-libs/ctoken-sdk/src/ctoken/close.rs b/sdk-libs/ctoken-sdk/src/ctoken/close.rs
index 9bfe026d6c..021efd701a 100644
--- a/sdk-libs/ctoken-sdk/src/ctoken/close.rs
+++ b/sdk-libs/ctoken-sdk/src/ctoken/close.rs
@@ -23,7 +23,7 @@ pub struct CloseCTokenAccount {
     pub account: Pubkey,
     pub destination: Pubkey,
     pub owner: Pubkey,
-    pub rent_sponsor: Option<Pubkey>,
+    pub rent_sponsor: Pubkey,
 }
 
 impl CloseCTokenAccount {
@@ -33,12 +33,12 @@ impl CloseCTokenAccount {
             account,
             destination,
             owner,
-            rent_sponsor: Some(RENT_SPONSOR),
+            rent_sponsor: RENT_SPONSOR,
         }
     }
 
     pub fn custom_rent_sponsor(mut self, rent_sponsor: Pubkey) -> Self {
-        self.rent_sponsor = Some(rent_sponsor);
+        self.rent_sponsor = rent_sponsor;
         self
     }
 
@@ -46,17 +46,13 @@ impl CloseCTokenAccount {
         // CloseAccount discriminator is 9 (no additional instruction data)
         let data = vec![9u8];
 
-        let mut accounts = vec![
+        let accounts = vec![
             AccountMeta::new(self.account, false),
             AccountMeta::new(self.destination, false),
             AccountMeta::new(self.owner, true), // signer, mutable to receive write_top_up
+            AccountMeta::new(self.rent_sponsor, false),
         ];
 
-        // Add rent sponsor for compressible accounts
-        if let Some(rent_sponsor) = self.rent_sponsor {
-            accounts.push(AccountMeta::new(rent_sponsor, false));
-        }
-
         Ok(Instruction {
             program_id: self.token_program,
             accounts,
@@ -80,7 +76,7 @@ impl CloseCTokenAccount {
 ///     account,
 ///     destination,
 ///     owner,
-///     rent_sponsor: Some(rent_sponsor),
+///     rent_sponsor,
 /// }
 /// .invoke()?;
 /// # Ok::<(), solana_program_error::ProgramError>(())
@@ -90,7 +86,7 @@ pub struct CloseCTokenAccountCpi<'info> {
     pub account: AccountInfo<'info>,
     pub destination: AccountInfo<'info>,
     pub owner: AccountInfo<'info>,
-    pub rent_sponsor: Option<AccountInfo<'info>>,
+    pub rent_sponsor: AccountInfo<'info>,
 }
 
 impl<'info> CloseCTokenAccountCpi<'info> {
@@ -100,24 +96,24 @@ impl<'info> CloseCTokenAccountCpi<'info> {
 
     pub fn invoke(self) -> Result<(), ProgramError> {
         let instruction = self.instruction()?;
-        if let Some(rent_sponsor) = self.rent_sponsor {
-            let account_infos = [self.account, self.destination, self.owner, rent_sponsor];
-            invoke(&instruction, &account_infos)
-        } else {
-            let account_infos = [self.account, self.destination, self.owner];
-            invoke(&instruction, &account_infos)
-        }
+        let account_infos = [
+            self.account,
+            self.destination,
+            self.owner,
+            self.rent_sponsor,
+        ];
+        invoke(&instruction, &account_infos)
     }
 
     pub fn invoke_signed(self, signer_seeds: &[&[&[u8]]]) -> Result<(), ProgramError> {
         let instruction = self.instruction()?;
-        if let Some(rent_sponsor) = self.rent_sponsor {
-            let account_infos = [self.account, self.destination, self.owner, rent_sponsor];
-            invoke_signed(&instruction, &account_infos, signer_seeds)
-        } else {
-            let account_infos = [self.account, self.destination, self.owner];
-            invoke_signed(&instruction, &account_infos, signer_seeds)
-        }
+        let account_infos = [
+            self.account,
+            self.destination,
+            self.owner,
+            self.rent_sponsor,
+        ];
+        invoke_signed(&instruction, &account_infos, signer_seeds)
     }
 }
 
@@ -128,7 +124,7 @@ impl<'info> From<&CloseCTokenAccountCpi<'info>> for CloseCTokenAccount {
             account: *account_infos.account.key,
             destination: *account_infos.destination.key,
             owner: *account_infos.owner.key,
-            rent_sponsor: account_infos.rent_sponsor.as_ref().map(|ai| *ai.key),
+            rent_sponsor: *account_infos.rent_sponsor.key,
         }
     }
 }
diff --git a/sdk-libs/ctoken-sdk/src/ctoken/compressible.rs b/sdk-libs/ctoken-sdk/src/ctoken/compressible.rs
index b3ecb8c322..0edc4d56af 100644
--- a/sdk-libs/ctoken-sdk/src/ctoken/compressible.rs
+++ b/sdk-libs/ctoken-sdk/src/ctoken/compressible.rs
@@ -1,5 +1,5 @@
 use light_ctoken_interface::{
-    instructions::extensions::compressible::CompressToPubkey, state::TokenDataVersion,
+    instructions::create_ctoken_account::CompressToPubkey, state::TokenDataVersion,
 };
 use solana_account_info::AccountInfo;
 use solana_pubkey::Pubkey;
@@ -34,6 +34,7 @@ pub struct CompressibleParams {
     pub compress_to_account_pubkey: Option<CompressToPubkey>,
     pub compressible_config: Pubkey,
     pub rent_sponsor: Pubkey,
+    pub compression_only: bool,
 }
 
 impl Default for CompressibleParams {
@@ -45,6 +46,7 @@ impl Default for CompressibleParams {
             lamports_per_write: Some(766),
             compress_to_account_pubkey: None,
             token_account_version: TokenDataVersion::ShaFlat,
+            compression_only: false,
         }
     }
 }
@@ -91,6 +93,7 @@ pub struct CompressibleParamsCpi<'info> {
     pub lamports_per_write: Option<u32>,
     pub compress_to_account_pubkey: Option<CompressToPubkey>,
     pub token_account_version: TokenDataVersion,
+    pub compression_only: bool,
 }
 
 impl<'info> CompressibleParamsCpi<'info> {
@@ -107,7 +110,8 @@ impl<'info> CompressibleParamsCpi<'info> {
             pre_pay_num_epochs: defaults.pre_pay_num_epochs,
             lamports_per_write: defaults.lamports_per_write,
             compress_to_account_pubkey: None,
-            token_account_version: TokenDataVersion::ShaFlat,
+            token_account_version: defaults.token_account_version,
+            compression_only: defaults.compression_only,
         }
     }
 
diff --git a/sdk-libs/ctoken-sdk/src/ctoken/create.rs b/sdk-libs/ctoken-sdk/src/ctoken/create.rs
index 3640926938..f55500fbc0 100644
--- a/sdk-libs/ctoken-sdk/src/ctoken/create.rs
+++ b/sdk-libs/ctoken-sdk/src/ctoken/create.rs
@@ -1,8 +1,5 @@
 use borsh::BorshSerialize;
-use light_ctoken_interface::instructions::{
-    create_ctoken_account::CreateTokenAccountInstructionData,
-    extensions::compressible::CompressibleExtensionInstructionData,
-};
+use light_ctoken_interface::instructions::create_ctoken_account::CreateTokenAccountInstructionData;
 use solana_account_info::AccountInfo;
 use solana_cpi::{invoke, invoke_signed};
 use solana_instruction::{AccountMeta, Instruction};
@@ -30,7 +27,7 @@ pub struct CreateCTokenAccount {
     pub account: Pubkey,
     pub mint: Pubkey,
     pub owner: Pubkey,
-    pub compressible: Option<CompressibleParams>,
+    pub compressible: CompressibleParams,
 }
 
 impl CreateCTokenAccount {
@@ -40,30 +37,23 @@ impl CreateCTokenAccount {
             account,
             mint,
             owner,
-            compressible: Some(CompressibleParams::default()),
+            compressible: CompressibleParams::default(),
         }
     }
 
     pub fn with_compressible(mut self, compressible: CompressibleParams) -> Self {
-        self.compressible = Some(compressible);
+        self.compressible = compressible;
         self
     }
 
     pub fn instruction(self) -> Result<Instruction, ProgramError> {
-        let compressible_extension =
-            self.compressible
-                .as_ref()
-                .map(|config| CompressibleExtensionInstructionData {
-                    token_account_version: config.token_account_version as u8,
-                    rent_payment: config.pre_pay_num_epochs,
-                    compression_only: 0,
-                    write_top_up: config.lamports_per_write.unwrap_or(0),
-                    compress_to_account_pubkey: config.compress_to_account_pubkey.clone(),
-                });
-
         let instruction_data = CreateTokenAccountInstructionData {
             owner: light_compressed_account::Pubkey::from(self.owner.to_bytes()),
-            compressible_config: compressible_extension,
+            token_account_version: self.compressible.token_account_version as u8,
+            rent_payment: self.compressible.pre_pay_num_epochs,
+            compression_only: self.compressible.compression_only as u8,
+            write_top_up: self.compressible.lamports_per_write.unwrap_or(0),
+            compressible_config: self.compressible.compress_to_account_pubkey.clone(),
         };
 
         let mut data = Vec::new();
@@ -72,23 +62,14 @@ impl CreateCTokenAccount {
             .serialize(&mut data)
             .map_err(|e| ProgramError::BorshIoError(e.to_string()))?;
 
-        let accounts = if let Some(config) = &self.compressible {
-            // Compressible account: requires payer, system program, config, and rent sponsor
-            vec![
-                AccountMeta::new(self.account, true),
-                AccountMeta::new_readonly(self.mint, false),
-                AccountMeta::new(self.payer, true),
-                AccountMeta::new_readonly(config.compressible_config, false),
-                AccountMeta::new_readonly(Pubkey::default(), false), // system_program
-                AccountMeta::new(config.rent_sponsor, false),
-            ]
-        } else {
-            // Non-compressible account: only account and mint
-            vec![
-                AccountMeta::new(self.account, false),
-                AccountMeta::new_readonly(self.mint, false),
-            ]
-        };
+        let accounts = vec![
+            AccountMeta::new(self.account, true),
+            AccountMeta::new_readonly(self.mint, false),
+            AccountMeta::new(self.payer, true),
+            AccountMeta::new_readonly(self.compressible.compressible_config, false),
+            AccountMeta::new_readonly(Pubkey::default(), false), // system_program
+            AccountMeta::new(self.compressible.rent_sponsor, false),
+        ];
 
         Ok(Instruction {
             program_id: Pubkey::from(light_ctoken_interface::CTOKEN_PROGRAM_ID),
@@ -113,7 +94,7 @@ impl CreateCTokenAccount {
 ///     account,
 ///     mint,
 ///     owner,
-///     compressible: Some(compressible),
+///     compressible,
 /// }
 /// .invoke()?;
 /// # Ok::<(), solana_program_error::ProgramError>(())
@@ -123,7 +104,7 @@ pub struct CreateCTokenAccountCpi<'info> {
     pub account: AccountInfo<'info>,
     pub mint: AccountInfo<'info>,
     pub owner: Pubkey,
-    pub compressible: Option<CompressibleParamsCpi<'info>>,
+    pub compressible: CompressibleParamsCpi<'info>,
 }
 
 impl<'info> CreateCTokenAccountCpi<'info> {
@@ -139,7 +120,7 @@ impl<'info> CreateCTokenAccountCpi<'info> {
             account,
             mint,
             owner,
-            compressible: Some(compressible),
+            compressible,
         }
     }
 
@@ -149,38 +130,28 @@ impl<'info> CreateCTokenAccountCpi<'info> {
 
     pub fn invoke(self) -> Result<(), ProgramError> {
         let instruction = self.instruction()?;
-        if let Some(compressible) = self.compressible {
-            let account_infos = [
-                self.account,
-                self.mint,
-                self.payer,
-                compressible.compressible_config,
-                compressible.system_program,
-                compressible.rent_sponsor,
-            ];
-            invoke(&instruction, &account_infos)
-        } else {
-            let account_infos = [self.account, self.mint];
-            invoke(&instruction, &account_infos)
-        }
+        let account_infos = [
+            self.account,
+            self.mint,
+            self.payer,
+            self.compressible.compressible_config,
+            self.compressible.system_program,
+            self.compressible.rent_sponsor,
+        ];
+        invoke(&instruction, &account_infos)
     }
 
     pub fn invoke_signed(self, signer_seeds: &[&[&[u8]]]) -> Result<(), ProgramError> {
         let instruction = self.instruction()?;
-        if let Some(compressible) = self.compressible {
-            let account_infos = [
-                self.account,
-                self.mint,
-                self.payer,
-                compressible.compressible_config,
-                compressible.system_program,
-                compressible.rent_sponsor,
-            ];
-            invoke_signed(&instruction, &account_infos, signer_seeds)
-        } else {
-            let account_infos = [self.account, self.mint];
-            invoke_signed(&instruction, &account_infos, signer_seeds)
-        }
+        let account_infos = [
+            self.account,
+            self.mint,
+            self.payer,
+            self.compressible.compressible_config,
+            self.compressible.system_program,
+            self.compressible.rent_sponsor,
+        ];
+        invoke_signed(&instruction, &account_infos, signer_seeds)
     }
 }
 
@@ -191,17 +162,18 @@ impl<'info> From<&CreateCTokenAccountCpi<'info>> for CreateCTokenAccount {
             account: *account_infos.account.key,
             mint: *account_infos.mint.key,
             owner: account_infos.owner,
-            compressible: account_infos
-                .compressible
-                .as_ref()
-                .map(|config| CompressibleParams {
-                    compressible_config: *config.compressible_config.key,
-                    rent_sponsor: *config.rent_sponsor.key,
-                    pre_pay_num_epochs: config.pre_pay_num_epochs,
-                    lamports_per_write: config.lamports_per_write,
-                    compress_to_account_pubkey: config.compress_to_account_pubkey.clone(),
-                    token_account_version: config.token_account_version,
-                }),
+            compressible: CompressibleParams {
+                compressible_config: *account_infos.compressible.compressible_config.key,
+                rent_sponsor: *account_infos.compressible.rent_sponsor.key,
+                pre_pay_num_epochs: account_infos.compressible.pre_pay_num_epochs,
+                lamports_per_write: account_infos.compressible.lamports_per_write,
+                compress_to_account_pubkey: account_infos
+                    .compressible
+                    .compress_to_account_pubkey
+                    .clone(),
+                token_account_version: account_infos.compressible.token_account_version,
+                compression_only: account_infos.compressible.compression_only,
+            },
         }
     }
 }
diff --git a/sdk-libs/ctoken-sdk/src/ctoken/create_associated_token_account.rs b/sdk-libs/ctoken-sdk/src/ctoken/create_associated_token_account.rs
new file mode 100644
index 0000000000..f8b88f9b63
--- /dev/null
+++ b/sdk-libs/ctoken-sdk/src/ctoken/create_associated_token_account.rs
@@ -0,0 +1,493 @@
+use borsh::BorshSerialize;
+use light_ctoken_types::{
+    instructions::{
+        create_associated_token_account::CreateAssociatedTokenAccountInstructionData,
+        create_associated_token_account2::CreateAssociatedTokenAccount2InstructionData,
+        extensions::compressible::CompressibleExtensionInstructionData,
+    },
+    state::TokenDataVersion,
+};
+use solana_account_info::AccountInfo;
+use solana_instruction::Instruction;
+use solana_pubkey::Pubkey;
+
+use crate::error::{Result, TokenSdkError};
+
+/// Discriminators for create ATA instructions
+const CREATE_ATA_DISCRIMINATOR: u8 = 100;
+const CREATE_ATA_IDEMPOTENT_DISCRIMINATOR: u8 = 102;
+const CREATE_ATA2_DISCRIMINATOR: u8 = 106;
+const CREATE_ATA2_IDEMPOTENT_DISCRIMINATOR: u8 = 107;
+
+/// Input parameters for creating an associated token account with compressible extension
+#[derive(Debug, Clone)]
+pub struct CreateCompressibleAssociatedTokenAccountInputs {
+    /// The payer for the account creation
+    pub payer: Pubkey,
+    /// The owner of the associated token account
+    pub owner: Pubkey,
+    /// The mint for the associated token account
+    pub mint: Pubkey,
+    /// The CompressibleConfig account
+    pub compressible_config: Pubkey,
+    /// The recipient of lamports when the account is closed by rent authority (fee_payer_pda)
+    pub rent_sponsor: Pubkey,
+    /// Number of epochs of rent to prepay
+    pub pre_pay_num_epochs: u8,
+    /// Initial lamports to top up for rent payments (optional)
+    pub lamports_per_write: Option<u32>,
+    /// Version of the compressed token account when ctoken account is
+    /// compressed and closed. (The version specifies the hashing scheme.)
+    pub token_account_version: TokenDataVersion,
+}
+
+/// Creates a compressible associated token account instruction (non-idempotent)
+pub fn create_compressible_associated_token_account(
+    inputs: CreateCompressibleAssociatedTokenAccountInputs,
+) -> Result<Instruction> {
+    create_compressible_associated_token_account_with_mode::<false>(inputs)
+}
+
+/// Creates a compressible associated token account instruction (idempotent)
+pub fn create_compressible_associated_token_account_idempotent(
+    inputs: CreateCompressibleAssociatedTokenAccountInputs,
+) -> Result<Instruction> {
+    create_compressible_associated_token_account_with_mode::<true>(inputs)
+}
+
+/// Creates a compressible associated token account instruction with compile-time idempotent mode
+pub fn create_compressible_associated_token_account_with_mode<const IDEMPOTENT: bool>(
+    inputs: CreateCompressibleAssociatedTokenAccountInputs,
+) -> Result<Instruction> {
+    let (ata_pubkey, bump) = derive_ctoken_ata(&inputs.owner, &inputs.mint);
+    create_compressible_associated_token_account_with_bump_and_mode::<IDEMPOTENT>(
+        inputs, ata_pubkey, bump,
+    )
+}
+
+/// Creates a compressible associated token account instruction with a specified bump (non-idempotent)
+pub fn create_compressible_associated_token_account_with_bump(
+    inputs: CreateCompressibleAssociatedTokenAccountInputs,
+    ata_pubkey: Pubkey,
+    bump: u8,
+) -> Result<Instruction> {
+    create_compressible_associated_token_account_with_bump_and_mode::<false>(
+        inputs, ata_pubkey, bump,
+    )
+}
+
+/// Creates a compressible associated token account instruction with a specified bump and mode
+pub fn create_compressible_associated_token_account_with_bump_and_mode<const IDEMPOTENT: bool>(
+    inputs: CreateCompressibleAssociatedTokenAccountInputs,
+    ata_pubkey: Pubkey,
+    bump: u8,
+) -> Result<Instruction> {
+    create_ata_instruction_unified::<IDEMPOTENT, true>(
+        inputs.payer,
+        inputs.owner,
+        inputs.mint,
+        ata_pubkey,
+        bump,
+        Some((
+            inputs.pre_pay_num_epochs,
+            inputs.lamports_per_write,
+            inputs.rent_sponsor,
+            inputs.compressible_config,
+            inputs.token_account_version,
+        )),
+    )
+}
+
+/// Creates a basic associated token account instruction (non-idempotent)
+pub fn create_associated_token_account(
+    payer: Pubkey,
+    owner: Pubkey,
+    mint: Pubkey,
+) -> Result<Instruction> {
+    create_associated_token_account_with_mode::<false>(payer, owner, mint)
+}
+
+/// Creates a basic associated token account instruction (idempotent)
+pub fn create_associated_token_account_idempotent(
+    payer: Pubkey,
+    owner: Pubkey,
+    mint: Pubkey,
+) -> Result<Instruction> {
+    create_associated_token_account_with_mode::<true>(payer, owner, mint)
+}
+
+/// Creates a basic associated token account instruction with compile-time idempotent mode
+pub fn create_associated_token_account_with_mode<const IDEMPOTENT: bool>(
+    payer: Pubkey,
+    owner: Pubkey,
+    mint: Pubkey,
+) -> Result<Instruction> {
+    let (ata_pubkey, bump) = derive_ctoken_ata(&owner, &mint);
+    create_associated_token_account_with_bump_and_mode::<IDEMPOTENT>(
+        payer, owner, mint, ata_pubkey, bump,
+    )
+}
+
+/// Creates a basic associated token account instruction with a specified bump (non-idempotent)
+pub fn create_associated_token_account_with_bump(
+    payer: Pubkey,
+    owner: Pubkey,
+    mint: Pubkey,
+    ata_pubkey: Pubkey,
+    bump: u8,
+) -> Result<Instruction> {
+    create_associated_token_account_with_bump_and_mode::<false>(
+        payer, owner, mint, ata_pubkey, bump,
+    )
+}
+
+/// Creates a basic associated token account instruction with specified bump and mode
+pub fn create_associated_token_account_with_bump_and_mode<const IDEMPOTENT: bool>(
+    payer: Pubkey,
+    owner: Pubkey,
+    mint: Pubkey,
+    ata_pubkey: Pubkey,
+    bump: u8,
+) -> Result<Instruction> {
+    create_ata_instruction_unified::<IDEMPOTENT, false>(payer, owner, mint, ata_pubkey, bump, None)
+}
+
+/// Unified function to create ATA instructions with compile-time configuration
+fn create_ata_instruction_unified<const IDEMPOTENT: bool, const COMPRESSIBLE: bool>(
+    payer: Pubkey,
+    owner: Pubkey,
+    mint: Pubkey,
+    ata_pubkey: Pubkey,
+    bump: u8,
+    compressible_config: Option<(u8, Option<u32>, Pubkey, Pubkey, TokenDataVersion)>, // (pre_pay_num_epochs, lamports_per_write, rent_sponsor, compressible_config_account, token_account_version)
+) -> Result<Instruction> {
+    // Select discriminator based on idempotent mode
+    let discriminator = if IDEMPOTENT {
+        CREATE_ATA_IDEMPOTENT_DISCRIMINATOR
+    } else {
+        CREATE_ATA_DISCRIMINATOR
+    };
+
+    // Create the instruction data struct
+    let compressible_extension = if COMPRESSIBLE {
+        if let Some((pre_pay_num_epochs, lamports_per_write, _, _, token_account_version)) =
+            compressible_config
+        {
+            Some(CompressibleExtensionInstructionData {
+                token_account_version: token_account_version as u8,
+                rent_payment: pre_pay_num_epochs,
+                compression_only: 0,
+                write_top_up: lamports_per_write.unwrap_or(0),
+                compress_to_account_pubkey: None, // Not used for ATA creation
+            })
+        } else {
+            return Err(TokenSdkError::InvalidAccountData);
+        }
+    } else {
+        None
+    };
+
+    let instruction_data = CreateAssociatedTokenAccountInstructionData {
+        owner: light_compressed_account::Pubkey::from(owner.to_bytes()),
+        mint: light_compressed_account::Pubkey::from(mint.to_bytes()),
+        bump,
+        compressible_config: compressible_extension,
+    };
+
+    // Serialize with Borsh
+    let mut data = Vec::new();
+    data.push(discriminator);
+    instruction_data
+        .serialize(&mut data)
+        .map_err(|_| TokenSdkError::SerializationError)?;
+
+    // Build accounts list based on whether it's compressible
+    let mut accounts = vec![
+        solana_instruction::AccountMeta::new(payer, true), // fee_payer (signer)
+        solana_instruction::AccountMeta::new(ata_pubkey, false), // associated_token_account
+        solana_instruction::AccountMeta::new_readonly(Pubkey::new_from_array([0; 32]), false), // system_program
+    ];
+
+    // Add compressible-specific accounts
+    if COMPRESSIBLE {
+        if let Some((_, _, rent_sponsor, compressible_config_account, _)) = compressible_config {
+            accounts.push(solana_instruction::AccountMeta::new_readonly(
+                compressible_config_account,
+                false,
+            )); // compressible_config
+            accounts.push(solana_instruction::AccountMeta::new(rent_sponsor, false));
+            // fee_payer_pda (rent_sponsor)
+        }
+    }
+
+    Ok(Instruction {
+        program_id: Pubkey::from(light_ctoken_types::COMPRESSED_TOKEN_PROGRAM_ID),
+        accounts,
+        data,
+    })
+}
+
+pub fn derive_ctoken_ata(owner: &Pubkey, mint: &Pubkey) -> (Pubkey, u8) {
+    Pubkey::find_program_address(
+        &[
+            owner.as_ref(),
+            light_ctoken_types::COMPRESSED_TOKEN_PROGRAM_ID.as_ref(),
+            mint.as_ref(),
+        ],
+        &Pubkey::from(light_ctoken_types::COMPRESSED_TOKEN_PROGRAM_ID),
+    )
+}
+
+// ============================================================================
+// CreateAssociatedTokenAccount2 - Owner and mint as accounts
+// ============================================================================
+
+/// Creates a compressible associated token account instruction v2 (non-idempotent)
+/// Owner and mint are passed as account infos instead of instruction data
+pub fn create_compressible_associated_token_account2(
+    inputs: CreateCompressibleAssociatedTokenAccountInputs,
+) -> Result<Instruction> {
+    create_compressible_associated_token_account2_with_mode::<false>(inputs)
+}
+
+/// Creates a compressible associated token account instruction v2 (idempotent)
+/// Owner and mint are passed as account infos instead of instruction data
+pub fn create_compressible_associated_token_account2_idempotent(
+    inputs: CreateCompressibleAssociatedTokenAccountInputs,
+) -> Result<Instruction> {
+    create_compressible_associated_token_account2_with_mode::<true>(inputs)
+}
+
+/// Creates a compressible associated token account instruction v2 with compile-time idempotent mode
+fn create_compressible_associated_token_account2_with_mode<const IDEMPOTENT: bool>(
+    inputs: CreateCompressibleAssociatedTokenAccountInputs,
+) -> Result<Instruction> {
+    let (ata_pubkey, bump) = derive_ctoken_ata(&inputs.owner, &inputs.mint);
+    create_compressible_associated_token_account2_with_bump_and_mode::<IDEMPOTENT>(
+        inputs, ata_pubkey, bump,
+    )
+}
+
+/// Creates a compressible associated token account instruction v2 with specified bump and mode
+fn create_compressible_associated_token_account2_with_bump_and_mode<const IDEMPOTENT: bool>(
+    inputs: CreateCompressibleAssociatedTokenAccountInputs,
+    ata_pubkey: Pubkey,
+    bump: u8,
+) -> Result<Instruction> {
+    create_ata2_instruction_unified::<IDEMPOTENT, true>(
+        inputs.payer,
+        inputs.owner,
+        inputs.mint,
+        ata_pubkey,
+        bump,
+        Some((
+            inputs.pre_pay_num_epochs,
+            inputs.lamports_per_write,
+            inputs.rent_sponsor,
+            inputs.compressible_config,
+            inputs.token_account_version,
+        )),
+    )
+}
+
+/// Creates a basic associated token account instruction v2 (non-idempotent)
+/// Owner and mint are passed as account infos instead of instruction data
+pub fn create_associated_token_account2(
+    payer: Pubkey,
+    owner: Pubkey,
+    mint: Pubkey,
+) -> Result<Instruction> {
+    create_associated_token_account2_with_mode::<false>(payer, owner, mint)
+}
+
+/// Creates a basic associated token account instruction v2 (idempotent)
+/// Owner and mint are passed as account infos instead of instruction data
+pub fn create_associated_token_account2_idempotent(
+    payer: Pubkey,
+    owner: Pubkey,
+    mint: Pubkey,
+) -> Result<Instruction> {
+    create_associated_token_account2_with_mode::<true>(payer, owner, mint)
+}
+
+/// Creates a basic associated token account instruction v2 with compile-time idempotent mode
+fn create_associated_token_account2_with_mode<const IDEMPOTENT: bool>(
+    payer: Pubkey,
+    owner: Pubkey,
+    mint: Pubkey,
+) -> Result<Instruction> {
+    let (ata_pubkey, bump) = derive_ctoken_ata(&owner, &mint);
+    create_associated_token_account2_with_bump_and_mode::<IDEMPOTENT>(
+        payer, owner, mint, ata_pubkey, bump,
+    )
+}
+
+/// Creates a basic associated token account instruction v2 with specified bump and mode
+fn create_associated_token_account2_with_bump_and_mode<const IDEMPOTENT: bool>(
+    payer: Pubkey,
+    owner: Pubkey,
+    mint: Pubkey,
+    ata_pubkey: Pubkey,
+    bump: u8,
+) -> Result<Instruction> {
+    create_ata2_instruction_unified::<IDEMPOTENT, false>(payer, owner, mint, ata_pubkey, bump, None)
+}
+
+/// Unified function to create ATA2 instructions with compile-time configuration
+/// Account order: [owner, mint, fee_payer, ata, system_program, ...]
+fn create_ata2_instruction_unified<const IDEMPOTENT: bool, const COMPRESSIBLE: bool>(
+    payer: Pubkey,
+    owner: Pubkey,
+    mint: Pubkey,
+    ata_pubkey: Pubkey,
+    bump: u8,
+    compressible_config: Option<(u8, Option<u32>, Pubkey, Pubkey, TokenDataVersion)>,
+) -> Result<Instruction> {
+    let discriminator = if IDEMPOTENT {
+        CREATE_ATA2_IDEMPOTENT_DISCRIMINATOR
+    } else {
+        CREATE_ATA2_DISCRIMINATOR
+    };
+
+    let compressible_extension = if COMPRESSIBLE {
+        if let Some((pre_pay_num_epochs, lamports_per_write, _, _, token_account_version)) =
+            compressible_config
+        {
+            Some(CompressibleExtensionInstructionData {
+                token_account_version: token_account_version as u8,
+                rent_payment: pre_pay_num_epochs,
+                compression_only: 0,
+                write_top_up: lamports_per_write.unwrap_or(0),
+                compress_to_account_pubkey: None,
+            })
+        } else {
+            return Err(TokenSdkError::InvalidAccountData);
+        }
+    } else {
+        None
+    };
+
+    let instruction_data = CreateAssociatedTokenAccount2InstructionData {
+        bump,
+        compressible_config: compressible_extension,
+    };
+
+    let mut data = Vec::new();
+    data.push(discriminator);
+    instruction_data
+        .serialize(&mut data)
+        .map_err(|_| TokenSdkError::SerializationError)?;
+
+    let mut accounts = vec![
+        solana_instruction::AccountMeta::new_readonly(owner, false),
+        solana_instruction::AccountMeta::new_readonly(mint, false),
+        solana_instruction::AccountMeta::new(payer, true),
+        solana_instruction::AccountMeta::new(ata_pubkey, false),
+        solana_instruction::AccountMeta::new_readonly(Pubkey::new_from_array([0; 32]), false),
+    ];
+
+    if COMPRESSIBLE {
+        if let Some((_, _, rent_sponsor, compressible_config_account, _)) = compressible_config {
+            accounts.push(solana_instruction::AccountMeta::new_readonly(
+                compressible_config_account,
+                false,
+            ));
+            accounts.push(solana_instruction::AccountMeta::new(rent_sponsor, false));
+        }
+    }
+
+    Ok(Instruction {
+        program_id: Pubkey::from(light_ctoken_types::COMPRESSED_TOKEN_PROGRAM_ID),
+        accounts,
+        data,
+    })
+}
+
+/// CPI wrapper to create a compressible c-token associated token account.
+#[allow(clippy::too_many_arguments)]
+pub fn create_associated_ctoken_account<'info>(
+    payer: AccountInfo<'info>,
+    associated_token_account: AccountInfo<'info>,
+    system_program: AccountInfo<'info>,
+    compressible_config: AccountInfo<'info>,
+    rent_sponsor: AccountInfo<'info>,
+    authority: AccountInfo<'info>,
+    mint: Pubkey,
+    bump: u8,
+    pre_pay_num_epochs: Option<u8>,
+    lamports_per_write: Option<u32>,
+) -> std::result::Result<(), solana_program_error::ProgramError> {
+    let inputs = CreateCompressibleAssociatedTokenAccountInputs {
+        payer: *payer.key,
+        owner: *authority.key,
+        mint,
+        compressible_config: *compressible_config.key,
+        rent_sponsor: *rent_sponsor.key,
+        pre_pay_num_epochs: pre_pay_num_epochs.unwrap_or(2),
+        lamports_per_write,
+        token_account_version: TokenDataVersion::ShaFlat,
+    };
+
+    // TODO: switch to wrapper ixn using accounts instead of ixdata.
+    let ix = create_compressible_associated_token_account_with_bump(
+        inputs,
+        *associated_token_account.key,
+        bump,
+    )?;
+
+    solana_cpi::invoke(
+        &ix,
+        &[
+            payer,
+            associated_token_account,
+            system_program,
+            compressible_config,
+            rent_sponsor,
+            authority,
+        ],
+    )
+}
+
+/// CPI wrapper to create a compressible c-token associated token account
+/// idempotently.
+#[allow(clippy::too_many_arguments)]
+pub fn create_associated_ctoken_account_idempotent<'info>(
+    payer: AccountInfo<'info>,
+    associated_token_account: AccountInfo<'info>,
+    system_program: AccountInfo<'info>,
+    compressible_config: AccountInfo<'info>,
+    rent_sponsor: AccountInfo<'info>,
+    authority: Pubkey,
+    mint: Pubkey,
+    bump: u8,
+    pre_pay_num_epochs: Option<u8>,
+    lamports_per_write: Option<u32>,
+) -> std::result::Result<(), solana_program_error::ProgramError> {
+    let inputs = CreateCompressibleAssociatedTokenAccountInputs {
+        payer: *payer.key,
+        owner: authority,
+        mint,
+        compressible_config: *compressible_config.key,
+        rent_sponsor: *rent_sponsor.key,
+        pre_pay_num_epochs: pre_pay_num_epochs.unwrap_or(2),
+        lamports_per_write,
+        token_account_version: TokenDataVersion::ShaFlat,
+    };
+
+    let ix = create_compressible_associated_token_account_with_bump_and_mode::<true>(
+        inputs,
+        *associated_token_account.key,
+        bump,
+    )?;
+
+    solana_cpi::invoke(
+        &ix,
+        &[
+            payer,
+            associated_token_account,
+            system_program,
+            compressible_config,
+            rent_sponsor,
+        ],
+    )
+}
diff --git a/sdk-libs/ctoken-sdk/src/ctoken/create_ata.rs b/sdk-libs/ctoken-sdk/src/ctoken/create_ata.rs
index 31ca9cd0cc..e21d6330d4 100644
--- a/sdk-libs/ctoken-sdk/src/ctoken/create_ata.rs
+++ b/sdk-libs/ctoken-sdk/src/ctoken/create_ata.rs
@@ -1,8 +1,5 @@
 use borsh::BorshSerialize;
-use light_ctoken_interface::instructions::{
-    create_associated_token_account::CreateAssociatedTokenAccountInstructionData,
-    extensions::compressible::CompressibleExtensionInstructionData,
-};
+use light_ctoken_interface::instructions::create_associated_token_account::CreateAssociatedTokenAccountInstructionData;
 use solana_account_info::AccountInfo;
 use solana_cpi::{invoke, invoke_signed};
 use solana_instruction::{AccountMeta, Instruction};
@@ -44,7 +41,7 @@ pub struct CreateAssociatedCTokenAccount {
     pub mint: Pubkey,
     pub associated_token_account: Pubkey,
     pub bump: u8,
-    pub compressible: Option<CompressibleParams>,
+    pub compressible: CompressibleParams,
     pub idempotent: bool,
 }
 
@@ -57,7 +54,7 @@ impl CreateAssociatedCTokenAccount {
             mint,
             associated_token_account: ata,
             bump,
-            compressible: Some(CompressibleParams::default()),
+            compressible: CompressibleParams::default(),
             idempotent: false,
         }
     }
@@ -75,13 +72,13 @@ impl CreateAssociatedCTokenAccount {
             mint,
             associated_token_account,
             bump,
-            compressible: Some(CompressibleParams::default()),
+            compressible: CompressibleParams::default(),
             idempotent: false,
         }
     }
 
     pub fn with_compressible(mut self, compressible_params: CompressibleParams) -> Self {
-        self.compressible = Some(compressible_params);
+        self.compressible = compressible_params;
         self
     }
 
@@ -91,20 +88,13 @@ impl CreateAssociatedCTokenAccount {
     }
 
     pub fn instruction(self) -> Result<Instruction, ProgramError> {
-        let compressible_extension =
-            self.compressible
-                .as_ref()
-                .map(|config| CompressibleExtensionInstructionData {
-                    token_account_version: config.token_account_version as u8,
-                    rent_payment: config.pre_pay_num_epochs,
-                    compression_only: 0,
-                    write_top_up: config.lamports_per_write.unwrap_or(0),
-                    compress_to_account_pubkey: None,
-                });
-
         let instruction_data = CreateAssociatedTokenAccountInstructionData {
             bump: self.bump,
-            compressible_config: compressible_extension,
+            token_account_version: self.compressible.token_account_version as u8,
+            rent_payment: self.compressible.pre_pay_num_epochs,
+            compression_only: self.compressible.compression_only as u8,
+            write_top_up: self.compressible.lamports_per_write.unwrap_or(0),
+            compressible_config: self.compressible.compress_to_account_pubkey.clone(),
         };
 
         let discriminator = if self.idempotent {
@@ -119,19 +109,16 @@ impl CreateAssociatedCTokenAccount {
             .serialize(&mut data)
             .map_err(|e| ProgramError::BorshIoError(e.to_string()))?;
 
-        let mut accounts = vec![
+        let accounts = vec![
             AccountMeta::new_readonly(self.owner, false),
             AccountMeta::new_readonly(self.mint, false),
             AccountMeta::new(self.payer, true),
             AccountMeta::new(self.associated_token_account, false),
             AccountMeta::new_readonly(Pubkey::new_from_array([0; 32]), false), // system_program
+            AccountMeta::new_readonly(self.compressible.compressible_config, false),
+            AccountMeta::new(self.compressible.rent_sponsor, false),
         ];
 
-        if let Some(config) = &self.compressible {
-            accounts.push(AccountMeta::new_readonly(config.compressible_config, false));
-            accounts.push(AccountMeta::new(config.rent_sponsor, false));
-        }
-
         Ok(Instruction {
             program_id: Pubkey::from(light_ctoken_interface::CTOKEN_PROGRAM_ID),
             accounts,
@@ -158,7 +145,7 @@ impl CreateAssociatedCTokenAccount {
 ///     associated_token_account,
 ///     system_program,
 ///     bump,
-///     compressible: Some(compressible),
+///     compressible,
 ///     idempotent: true,
 /// }
 /// .invoke()?;
@@ -171,7 +158,7 @@ pub struct CreateAssociatedCTokenAccountCpi<'info> {
     pub associated_token_account: AccountInfo<'info>,
     pub system_program: AccountInfo<'info>,
     pub bump: u8,
-    pub compressible: Option<CompressibleParamsCpi<'info>>,
+    pub compressible: CompressibleParamsCpi<'info>,
     pub idempotent: bool,
 }
 
@@ -182,52 +169,30 @@ impl<'info> CreateAssociatedCTokenAccountCpi<'info> {
 
     pub fn invoke(self) -> Result<(), ProgramError> {
         let instruction = self.instruction()?;
-        if let Some(compressible) = self.compressible {
-            let account_infos = [
-                self.owner,
-                self.mint,
-                self.payer,
-                self.associated_token_account,
-                self.system_program,
-                compressible.compressible_config,
-                compressible.rent_sponsor,
-            ];
-            invoke(&instruction, &account_infos)
-        } else {
-            let account_infos = [
-                self.owner,
-                self.mint,
-                self.payer,
-                self.associated_token_account,
-                self.system_program,
-            ];
-            invoke(&instruction, &account_infos)
-        }
+        let account_infos = [
+            self.owner,
+            self.mint,
+            self.payer,
+            self.associated_token_account,
+            self.system_program,
+            self.compressible.compressible_config,
+            self.compressible.rent_sponsor,
+        ];
+        invoke(&instruction, &account_infos)
     }
 
     pub fn invoke_signed(self, signer_seeds: &[&[&[u8]]]) -> Result<(), ProgramError> {
         let instruction = self.instruction()?;
-        if let Some(compressible) = self.compressible {
-            let account_infos = [
-                self.owner,
-                self.mint,
-                self.payer,
-                self.associated_token_account,
-                self.system_program,
-                compressible.compressible_config,
-                compressible.rent_sponsor,
-            ];
-            invoke_signed(&instruction, &account_infos, signer_seeds)
-        } else {
-            let account_infos = [
-                self.owner,
-                self.mint,
-                self.payer,
-                self.associated_token_account,
-                self.system_program,
-            ];
-            invoke_signed(&instruction, &account_infos, signer_seeds)
-        }
+        let account_infos = [
+            self.owner,
+            self.mint,
+            self.payer,
+            self.associated_token_account,
+            self.system_program,
+            self.compressible.compressible_config,
+            self.compressible.rent_sponsor,
+        ];
+        invoke_signed(&instruction, &account_infos, signer_seeds)
     }
 }
 
@@ -239,17 +204,18 @@ impl<'info> From<&CreateAssociatedCTokenAccountCpi<'info>> for CreateAssociatedC
             mint: *account_infos.mint.key,
             associated_token_account: *account_infos.associated_token_account.key,
             bump: account_infos.bump,
-            compressible: account_infos
-                .compressible
-                .as_ref()
-                .map(|config| CompressibleParams {
-                    compressible_config: *config.compressible_config.key,
-                    rent_sponsor: *config.rent_sponsor.key,
-                    pre_pay_num_epochs: config.pre_pay_num_epochs,
-                    lamports_per_write: config.lamports_per_write,
-                    compress_to_account_pubkey: None,
-                    token_account_version: config.token_account_version,
-                }),
+            compressible: CompressibleParams {
+                compressible_config: *account_infos.compressible.compressible_config.key,
+                rent_sponsor: *account_infos.compressible.rent_sponsor.key,
+                pre_pay_num_epochs: account_infos.compressible.pre_pay_num_epochs,
+                lamports_per_write: account_infos.compressible.lamports_per_write,
+                compress_to_account_pubkey: account_infos
+                    .compressible
+                    .compress_to_account_pubkey
+                    .clone(),
+                token_account_version: account_infos.compressible.token_account_version,
+                compression_only: account_infos.compressible.compression_only,
+            },
             idempotent: account_infos.idempotent,
         }
     }
diff --git a/sdk-libs/ctoken-sdk/src/ctoken/create_cmint.rs b/sdk-libs/ctoken-sdk/src/ctoken/create_cmint.rs
index 803de5b187..d9331947b2 100644
--- a/sdk-libs/ctoken-sdk/src/ctoken/create_cmint.rs
+++ b/sdk-libs/ctoken-sdk/src/ctoken/create_cmint.rs
@@ -21,7 +21,7 @@ use crate::{
     },
     ctoken::SystemAccountInfos,
 };
-
+// TODO: modify so that it creates a decompressed mint, if you want a compressed mint use light_ctoken_sdk::compressed_token::create_cmint
 /// Parameters for creating a compressed mint.
 #[derive(Debug, Clone)]
 pub struct CreateCMintParams {
diff --git a/sdk-libs/ctoken-sdk/src/ctoken/ctoken_mint_to.rs b/sdk-libs/ctoken-sdk/src/ctoken/ctoken_mint_to.rs
index 1b001a5ca6..ededc8e340 100644
--- a/sdk-libs/ctoken-sdk/src/ctoken/ctoken_mint_to.rs
+++ b/sdk-libs/ctoken-sdk/src/ctoken/ctoken_mint_to.rs
@@ -42,11 +42,13 @@ pub struct CTokenMintTo {
 /// # let cmint: AccountInfo = todo!();
 /// # let destination: AccountInfo = todo!();
 /// # let authority: AccountInfo = todo!();
+/// # let system_program: AccountInfo = todo!();
 /// CTokenMintToCpi {
 ///     cmint,
 ///     destination,
 ///     amount: 100,
 ///     authority,
+///     system_program,
 ///     max_top_up: None,
 /// }
 /// .invoke()?;
@@ -57,6 +59,7 @@ pub struct CTokenMintToCpi<'info> {
     pub destination: AccountInfo<'info>,
     pub amount: u64,
     pub authority: AccountInfo<'info>,
+    pub system_program: AccountInfo<'info>,
     /// Maximum lamports for rent and top-up combined. Transaction fails if exceeded. (0 = no limit)
     pub max_top_up: Option<u16>,
 }
@@ -68,13 +71,23 @@ impl<'info> CTokenMintToCpi<'info> {
 
     pub fn invoke(self) -> Result<(), ProgramError> {
         let instruction = CTokenMintTo::from(&self).instruction()?;
-        let account_infos = [self.cmint, self.destination, self.authority];
+        let account_infos = [
+            self.cmint,
+            self.destination,
+            self.authority,
+            self.system_program,
+        ];
         invoke(&instruction, &account_infos)
     }
 
     pub fn invoke_signed(self, signer_seeds: &[&[&[u8]]]) -> Result<(), ProgramError> {
         let instruction = CTokenMintTo::from(&self).instruction()?;
-        let account_infos = [self.cmint, self.destination, self.authority];
+        let account_infos = [
+            self.cmint,
+            self.destination,
+            self.authority,
+            self.system_program,
+        ];
         invoke_signed(&instruction, &account_infos, signer_seeds)
     }
 }
@@ -98,7 +111,8 @@ impl CTokenMintTo {
             accounts: vec![
                 AccountMeta::new(self.cmint, false),
                 AccountMeta::new(self.destination, false),
-                AccountMeta::new_readonly(self.authority, true),
+                AccountMeta::new(self.authority, true),
+                AccountMeta::new_readonly(Pubkey::default(), false), // System program for lamport transfers
             ],
             data: {
                 let mut data = vec![7u8]; // CTokenMintTo discriminator
diff --git a/sdk-libs/ctoken-sdk/src/ctoken/ctoken_mint_to_checked.rs b/sdk-libs/ctoken-sdk/src/ctoken/ctoken_mint_to_checked.rs
new file mode 100644
index 0000000000..303f13974f
--- /dev/null
+++ b/sdk-libs/ctoken-sdk/src/ctoken/ctoken_mint_to_checked.rs
@@ -0,0 +1,121 @@
+use light_sdk_types::C_TOKEN_PROGRAM_ID;
+use solana_account_info::AccountInfo;
+use solana_cpi::{invoke, invoke_signed};
+use solana_instruction::{AccountMeta, Instruction};
+use solana_program_error::ProgramError;
+use solana_pubkey::Pubkey;
+
+/// # Mint tokens to a ctoken account with decimals validation:
+/// ```rust
+/// # use solana_pubkey::Pubkey;
+/// # use light_ctoken_sdk::ctoken::CTokenMintToChecked;
+/// # let cmint = Pubkey::new_unique();
+/// # let destination = Pubkey::new_unique();
+/// # let authority = Pubkey::new_unique();
+/// let instruction = CTokenMintToChecked {
+///     cmint,
+///     destination,
+///     amount: 100,
+///     decimals: 8,
+///     authority,
+///     max_top_up: None,
+/// }.instruction()?;
+/// # Ok::<(), solana_program_error::ProgramError>(())
+/// ```
+pub struct CTokenMintToChecked {
+    /// CMint account (supply tracking)
+    pub cmint: Pubkey,
+    /// Destination CToken account to mint to
+    pub destination: Pubkey,
+    /// Amount of tokens to mint
+    pub amount: u64,
+    /// Expected token decimals
+    pub decimals: u8,
+    /// Mint authority
+    pub authority: Pubkey,
+    /// Maximum lamports for rent and top-up combined. Transaction fails if exceeded. (0 = no limit)
+    /// When set to a non-zero value, includes max_top_up in instruction data
+    pub max_top_up: Option<u16>,
+}
+
+/// # Mint to ctoken via CPI with decimals validation:
+/// ```rust,no_run
+/// # use light_ctoken_sdk::ctoken::CTokenMintToCheckedCpi;
+/// # use solana_account_info::AccountInfo;
+/// # let cmint: AccountInfo = todo!();
+/// # let destination: AccountInfo = todo!();
+/// # let authority: AccountInfo = todo!();
+/// CTokenMintToCheckedCpi {
+///     cmint,
+///     destination,
+///     amount: 100,
+///     decimals: 8,
+///     authority,
+///     max_top_up: None,
+/// }
+/// .invoke()?;
+/// # Ok::<(), solana_program_error::ProgramError>(())
+/// ```
+pub struct CTokenMintToCheckedCpi<'info> {
+    pub cmint: AccountInfo<'info>,
+    pub destination: AccountInfo<'info>,
+    pub amount: u64,
+    pub decimals: u8,
+    pub authority: AccountInfo<'info>,
+    /// Maximum lamports for rent and top-up combined. Transaction fails if exceeded. (0 = no limit)
+    pub max_top_up: Option<u16>,
+}
+
+impl<'info> CTokenMintToCheckedCpi<'info> {
+    pub fn instruction(&self) -> Result<Instruction, ProgramError> {
+        CTokenMintToChecked::from(self).instruction()
+    }
+
+    pub fn invoke(self) -> Result<(), ProgramError> {
+        let instruction = CTokenMintToChecked::from(&self).instruction()?;
+        let account_infos = [self.cmint, self.destination, self.authority];
+        invoke(&instruction, &account_infos)
+    }
+
+    pub fn invoke_signed(self, signer_seeds: &[&[&[u8]]]) -> Result<(), ProgramError> {
+        let instruction = CTokenMintToChecked::from(&self).instruction()?;
+        let account_infos = [self.cmint, self.destination, self.authority];
+        invoke_signed(&instruction, &account_infos, signer_seeds)
+    }
+}
+
+impl<'info> From<&CTokenMintToCheckedCpi<'info>> for CTokenMintToChecked {
+    fn from(cpi: &CTokenMintToCheckedCpi<'info>) -> Self {
+        Self {
+            cmint: *cpi.cmint.key,
+            destination: *cpi.destination.key,
+            amount: cpi.amount,
+            decimals: cpi.decimals,
+            authority: *cpi.authority.key,
+            max_top_up: cpi.max_top_up,
+        }
+    }
+}
+
+impl CTokenMintToChecked {
+    pub fn instruction(self) -> Result<Instruction, ProgramError> {
+        Ok(Instruction {
+            program_id: Pubkey::from(C_TOKEN_PROGRAM_ID),
+            accounts: vec![
+                AccountMeta::new(self.cmint, false),
+                AccountMeta::new(self.destination, false),
+                AccountMeta::new_readonly(self.authority, true),
+            ],
+            data: {
+                let mut data = vec![14u8]; // CTokenMintToChecked discriminator
+                data.extend_from_slice(&self.amount.to_le_bytes());
+                data.push(self.decimals);
+                // Include max_top_up if set (11-byte format)
+                if let Some(max_top_up) = self.max_top_up {
+                    data.extend_from_slice(&max_top_up.to_le_bytes());
+                }
+                data
+            },
+        })
+    }
+}
diff --git a/sdk-libs/ctoken-sdk/src/ctoken/decompress.rs b/sdk-libs/ctoken-sdk/src/ctoken/decompress.rs
index a050a25cce..f885955f3a 100644
--- a/sdk-libs/ctoken-sdk/src/ctoken/decompress.rs
+++ b/sdk-libs/ctoken-sdk/src/ctoken/decompress.rs
@@ -1,12 +1,15 @@
 use light_compressed_account::instruction_data::compressed_proof::ValidityProof;
-use light_ctoken_interface::state::TokenDataVersion;
+use light_ctoken_interface::{
+    instructions::extensions::{CompressedOnlyExtensionInstructionData, ExtensionInstructionData},
+    state::{ExtensionStruct, TokenDataVersion},
+};
 use light_sdk::instruction::{PackedAccounts, PackedStateTreeInfo};
 use solana_instruction::Instruction;
 use solana_program_error::ProgramError;
 use solana_pubkey::Pubkey;
 
 use crate::{
-    compat::TokenData,
+    compat::{AccountState, TokenData},
     compressed_token::{
         decompress_full::pack_for_decompress_full,
         transfer2::{
@@ -85,16 +88,42 @@ impl DecompressToCtoken {
             root_index: self.root_index,
             prove_by_index,
         };
-
+        // Extract version from discriminator
         let version = TokenDataVersion::from_discriminator(self.discriminator)
-            .map_err(|_| ProgramError::InvalidAccountData)?;
+            .map_err(|_| ProgramError::InvalidAccountData)? as u8;
+
+        // Convert TLV extensions from state format to instruction format
+        let is_frozen = self.token_data.state == AccountState::Frozen;
+        let tlv: Option<Vec<ExtensionInstructionData>> =
+            self.token_data.tlv.as_ref().map(|extensions| {
+                extensions
+                    .iter()
+                    .filter_map(|ext| match ext {
+                        ExtensionStruct::CompressedOnly(compressed_only) => {
+                            Some(ExtensionInstructionData::CompressedOnly(
+                                CompressedOnlyExtensionInstructionData {
+                                    delegated_amount: compressed_only.delegated_amount,
+                                    withheld_transfer_fee: compressed_only.withheld_transfer_fee,
+                                    is_frozen,
+                                    compression_index: 0,
+                                },
+                            ))
+                        }
+                        _ => None,
+                    })
+                    .collect()
+            });
+
+        // Clone tlv for passing to Transfer2Inputs.in_tlv
+        let in_tlv = tlv.clone().map(|t| vec![t]);
 
         let indices = pack_for_decompress_full(
             &self.token_data,
             &tree_info,
             self.destination_ctoken_account,
             &mut packed_accounts,
-            version as u8,
+            tlv,
+            version,
         );
         // Build CTokenAccount2 with decompress operation
         let mut token_account = CTokenAccount2::new(vec![indices.source])
@@ -113,6 +142,7 @@ impl DecompressToCtoken {
             token_accounts: vec![token_account],
             transfer_config,
             validity_proof: self.validity_proof,
+            in_tlv,
             ..Default::default()
         };
 
diff --git a/sdk-libs/ctoken-sdk/src/ctoken/decompress_cmint.rs b/sdk-libs/ctoken-sdk/src/ctoken/decompress_cmint.rs
new file mode 100644
index 0000000000..3c2952e5b8
--- /dev/null
+++ b/sdk-libs/ctoken-sdk/src/ctoken/decompress_cmint.rs
@@ -0,0 +1,237 @@
+use light_compressed_account::instruction_data::{
+    compressed_proof::ValidityProof, traits::LightInstructionData,
+};
+use light_ctoken_interface::instructions::mint_action::{
+    CompressedMintWithContext, DecompressMintAction, MintActionCompressedInstructionData,
+};
+use solana_account_info::AccountInfo;
+use solana_cpi::{invoke, invoke_signed};
+use solana_instruction::Instruction;
+use solana_program_error::ProgramError;
+use solana_pubkey::Pubkey;
+
+pub use super::find_cmint_address;
+use super::{config_pda, rent_sponsor_pda, SystemAccountInfos};
+use crate::compressed_token::mint_action::MintActionMetaConfig;
+
+/// Decompress a compressed mint to a CMint Solana account.
+///
+/// Creates an on-chain CMint PDA that becomes the source of truth.
+/// The CMint is always compressible.
+///
+/// # Example
+/// ```rust,ignore
+/// let instruction = DecompressCMint {
+///     mint_seed_pubkey,
+///     payer,
+///     authority,
+///     state_tree,
+///     input_queue,
+///     output_queue,
+///     compressed_mint_with_context,
+///     proof,
+///     rent_payment: 16,       // epochs (~24 hours rent)
+///     write_top_up: 766,      // lamports (~3 hours rent per write)
+/// }.instruction()?;
+/// ```
+#[derive(Debug, Clone)]
+pub struct DecompressCMint {
+    /// Mint seed pubkey (used to derive CMint PDA)
+    pub mint_seed_pubkey: Pubkey,
+    /// Fee payer
+    pub payer: Pubkey,
+    /// Mint authority (must sign)
+    pub authority: Pubkey,
+    /// State tree for the compressed mint
+    pub state_tree: Pubkey,
+    /// Input queue for reading compressed mint
+    pub input_queue: Pubkey,
+    /// Output queue for updated compressed mint
+    pub output_queue: Pubkey,
+    /// Compressed mint with context (from indexer)
+    pub compressed_mint_with_context: CompressedMintWithContext,
+    /// Validity proof for the compressed mint
+    pub proof: ValidityProof,
+    /// Rent payment in epochs (must be >= 2)
+    pub rent_payment: u8,
+    /// Lamports for future write operations
+    pub write_top_up: u32,
+}
+
+impl DecompressCMint {
+    pub fn instruction(self) -> Result<Instruction, ProgramError> {
+        // Derive CMint PDA
+        let (cmint_pda, cmint_bump) = find_cmint_address(&self.mint_seed_pubkey);
+
+        // Build DecompressMintAction
+        let action = DecompressMintAction {
+            cmint_bump,
+            rent_payment: self.rent_payment,
+            write_top_up: self.write_top_up,
+        };
+
+        // Build instruction data
+        let instruction_data = MintActionCompressedInstructionData::new(
+            self.compressed_mint_with_context,
+            self.proof.0,
+        )
+        .with_decompress_mint(action);
+
+        // Build account metas with compressible CMint
+        let meta_config = MintActionMetaConfig::new(
+            self.payer,
+            self.authority,
+            self.state_tree,
+            self.input_queue,
+            self.output_queue,
+        )
+        .with_compressible_cmint(cmint_pda, config_pda(), rent_sponsor_pda())
+        .with_mint_signer_no_sign(self.mint_seed_pubkey);
+
+        let account_metas = meta_config.to_account_metas();
+
+        let data = instruction_data
+            .data()
+            .map_err(|e| ProgramError::BorshIoError(e.to_string()))?;
+
+        Ok(Instruction {
+            program_id: Pubkey::new_from_array(light_ctoken_interface::CTOKEN_PROGRAM_ID),
+            accounts: account_metas,
+            data,
+        })
+    }
+}
+
+// ============================================================================
+// CPI Struct: DecompressCMintCpi
+// ============================================================================
+
+/// Decompress a compressed mint to a CMint Solana account via CPI.
+///
+/// Creates an on-chain CMint PDA that becomes the source of truth.
+/// The CMint is always compressible.
+///
+/// # Example
+/// ```rust,ignore
+/// DecompressCMintCpi {
+///     mint_seed: mint_seed_account,
+///     authority: authority_account,
+///     payer: payer_account,
+///     cmint: cmint_account,
+///     compressible_config: config_account,
+///     rent_sponsor: rent_sponsor_account,
+///     state_tree: state_tree_account,
+///     input_queue: input_queue_account,
+///     output_queue: output_queue_account,
+///     system_accounts,
+///     compressed_mint_with_context,
+///     proof,
+///     rent_payment: 16,
+///     write_top_up: 766,
+/// }
+/// .invoke()?;
+/// ```
+pub struct DecompressCMintCpi<'info> {
+    /// Mint seed account (used to derive CMint PDA, does not sign)
+    pub mint_seed: AccountInfo<'info>,
+    /// Mint authority (must sign)
+    pub authority: AccountInfo<'info>,
+    /// Fee payer
+    pub payer: AccountInfo<'info>,
+    /// CMint PDA account (writable)
+    pub cmint: AccountInfo<'info>,
+    /// CompressibleConfig account
+    pub compressible_config: AccountInfo<'info>,
+    /// Rent sponsor PDA account
+    pub rent_sponsor: AccountInfo<'info>,
+    /// State tree for the compressed mint
+    pub state_tree: AccountInfo<'info>,
+    /// Input queue for reading compressed mint
+    pub input_queue: AccountInfo<'info>,
+    /// Output queue for updated compressed mint
+    pub output_queue: AccountInfo<'info>,
+    /// System accounts for Light Protocol
+    pub system_accounts: SystemAccountInfos<'info>,
+    /// Compressed mint with context (from indexer)
+    pub compressed_mint_with_context: CompressedMintWithContext,
+    /// Validity proof for the compressed mint
+    pub proof: ValidityProof,
+    /// Rent payment in epochs (must be >= 2)
+    pub rent_payment: u8,
+    /// Lamports for future write operations
+    pub write_top_up: u32,
+}
+
+impl<'info> DecompressCMintCpi<'info> {
+    pub fn instruction(&self) -> Result<Instruction, ProgramError> {
+        DecompressCMint::try_from(self)?.instruction()
+    }
+
+    pub fn invoke(self) -> Result<(), ProgramError> {
+        let instruction = self.instruction()?;
+
+        // Account order must match to_account_metas() from MintActionMetaConfig:
+        // 1. light_system_program
+        // 2. mint_signer (no sign for decompress)
+        // 3. authority (signer)
+        // 4. compressible_config
+        // 5. cmint
+        // 6. rent_sponsor
+        // 7. fee_payer (signer)
+        // 8. cpi_authority_pda
+        // 9. registered_program_pda
+        // 10. account_compression_authority
+        // 11. account_compression_program
+        // 12. system_program
+        // 13. output_queue
+        // 14. tree_pubkey (state_tree)
+        // 15. input_queue
+        let account_infos = self.build_account_infos();
+        invoke(&instruction, &account_infos)
+    }
+
+    pub fn invoke_signed(self, signer_seeds: &[&[&[u8]]]) -> Result<(), ProgramError> {
+        let instruction = self.instruction()?;
+        let account_infos = self.build_account_infos();
+        invoke_signed(&instruction, &account_infos, signer_seeds)
+    }
+
+    fn build_account_infos(&self) -> Vec<AccountInfo<'info>> {
+        vec![
+            self.system_accounts.light_system_program.clone(),
+            self.mint_seed.clone(),
+            self.authority.clone(),
+            self.compressible_config.clone(),
+            self.cmint.clone(),
+            self.rent_sponsor.clone(),
+            self.payer.clone(),
+            self.system_accounts.cpi_authority_pda.clone(),
+            self.system_accounts.registered_program_pda.clone(),
+            self.system_accounts.account_compression_authority.clone(),
+            self.system_accounts.account_compression_program.clone(),
+            self.system_accounts.system_program.clone(),
+            self.output_queue.clone(),
+            self.state_tree.clone(),
+            self.input_queue.clone(),
+        ]
+    }
+}
+
+impl<'info> TryFrom<&DecompressCMintCpi<'info>> for DecompressCMint {
+    type Error = ProgramError;
+
+    fn try_from(cpi: &DecompressCMintCpi<'info>) -> Result<Self, Self::Error> {
+        Ok(Self {
+            mint_seed_pubkey: *cpi.mint_seed.key,
+            payer: *cpi.payer.key,
+            authority: *cpi.authority.key,
+            state_tree: *cpi.state_tree.key,
+            input_queue: *cpi.input_queue.key,
+            output_queue: *cpi.output_queue.key,
+            compressed_mint_with_context: cpi.compressed_mint_with_context.clone(),
+            proof: cpi.proof,
+            rent_payment: cpi.rent_payment,
+            write_top_up: cpi.write_top_up,
+        })
+    }
+}
diff --git a/sdk-libs/ctoken-sdk/src/ctoken/freeze.rs b/sdk-libs/ctoken-sdk/src/ctoken/freeze.rs
new file mode 100644
index 0000000000..9675fee219
--- /dev/null
+++ b/sdk-libs/ctoken-sdk/src/ctoken/freeze.rs
@@ -0,0 +1,92 @@
+use light_sdk_types::C_TOKEN_PROGRAM_ID;
+use solana_account_info::AccountInfo;
+use solana_cpi::{invoke, invoke_signed};
+use solana_instruction::{AccountMeta, Instruction};
+use solana_program_error::ProgramError;
+use solana_pubkey::Pubkey;
+
+/// # Freeze a CToken account:
+/// ```rust
+/// # use solana_pubkey::Pubkey;
+/// # use light_ctoken_sdk::ctoken::FreezeCToken;
+/// # let token_account = Pubkey::new_unique();
+/// # let mint = Pubkey::new_unique();
+/// # let freeze_authority = Pubkey::new_unique();
+/// let instruction = FreezeCToken {
+///     token_account,
+///     mint,
+///     freeze_authority,
+/// }.instruction()?;
+/// # Ok::<(), solana_program_error::ProgramError>(())
+/// ```
+pub struct FreezeCToken {
+    /// CToken account to freeze
+    pub token_account: Pubkey,
+    /// Mint of the token account
+    pub mint: Pubkey,
+    /// Freeze authority (signer)
+    pub freeze_authority: Pubkey,
+}
+
+/// # Freeze CToken via CPI:
+/// ```rust,no_run
+/// # use light_ctoken_sdk::ctoken::FreezeCTokenCpi;
+/// # use solana_account_info::AccountInfo;
+/// # let token_account: AccountInfo = todo!();
+/// # let mint: AccountInfo = todo!();
+/// # let freeze_authority: AccountInfo = todo!();
+/// FreezeCTokenCpi {
+///     token_account,
+///     mint,
+///     freeze_authority,
+/// }
+/// .invoke()?;
+/// # Ok::<(), solana_program_error::ProgramError>(())
+/// ```
+pub struct FreezeCTokenCpi<'info> {
+    pub token_account: AccountInfo<'info>,
+    pub mint: AccountInfo<'info>,
+    pub freeze_authority: AccountInfo<'info>,
+}
+
+impl<'info> FreezeCTokenCpi<'info> {
+    pub fn instruction(&self) -> Result<Instruction, ProgramError> {
+        FreezeCToken::from(self).instruction()
+    }
+
+    pub fn invoke(self) -> Result<(), ProgramError> {
+        let instruction = FreezeCToken::from(&self).instruction()?;
+        let account_infos = [self.token_account, self.mint, self.freeze_authority];
+        invoke(&instruction, &account_infos)
+    }
+
+    pub fn invoke_signed(self, signer_seeds: &[&[&[u8]]]) -> Result<(), ProgramError> {
+        let instruction = FreezeCToken::from(&self).instruction()?;
+        let account_infos = [self.token_account, self.mint, self.freeze_authority];
+        invoke_signed(&instruction, &account_infos, signer_seeds)
+    }
+}
+
+impl<'info> From<&FreezeCTokenCpi<'info>> for FreezeCToken {
+    fn from(cpi: &FreezeCTokenCpi<'info>) -> Self {
+        Self {
+            token_account: *cpi.token_account.key,
+            mint: *cpi.mint.key,
+            freeze_authority: *cpi.freeze_authority.key,
+        }
+    }
+}
+
+impl FreezeCToken {
+    pub fn instruction(self) -> Result<Instruction, ProgramError> {
+        Ok(Instruction {
+            program_id: Pubkey::from(C_TOKEN_PROGRAM_ID),
+            accounts: vec![
+                AccountMeta::new(self.token_account, false),
+                AccountMeta::new_readonly(self.mint, false),
+                AccountMeta::new_readonly(self.freeze_authority, true),
+            ],
+            data: vec![10u8], // CTokenFreezeAccount discriminator
+        })
+    }
+}
diff --git a/sdk-libs/ctoken-sdk/src/ctoken/mint_to.rs b/sdk-libs/ctoken-sdk/src/ctoken/mint_to.rs
index 5918c3968b..6dbea67f7d 100644
--- a/sdk-libs/ctoken-sdk/src/ctoken/mint_to.rs
+++ b/sdk-libs/ctoken-sdk/src/ctoken/mint_to.rs
@@ -14,7 +14,7 @@ use crate::compressed_token::mint_action::{
     get_mint_action_instruction_account_metas_cpi_write, MintActionMetaConfig,
     MintActionMetaConfigCpiWrite,
 };
-
+// TODO: move to compressed_token.
 /// Parameters for minting tokens to a ctoken account.
 #[derive(Debug, Clone)]
 pub struct MintToCTokenParams {
diff --git a/sdk-libs/ctoken-sdk/src/ctoken/mod.rs b/sdk-libs/ctoken-sdk/src/ctoken/mod.rs
index dc98ca674b..121749dc4c 100644
--- a/sdk-libs/ctoken-sdk/src/ctoken/mod.rs
+++ b/sdk-libs/ctoken-sdk/src/ctoken/mod.rs
@@ -65,41 +65,59 @@
 //! ```
 //!
 
+mod approve;
+mod approve_checked;
 mod burn;
+mod burn_checked;
 mod close;
 mod compressible;
 mod create;
 mod create_ata;
 mod create_cmint;
 mod ctoken_mint_to;
+mod ctoken_mint_to_checked;
 mod decompress;
+mod decompress_cmint;
+mod freeze;
 mod mint_to;
+mod revoke;
+mod thaw;
 mod transfer_ctoken;
+mod transfer_ctoken_checked;
 mod transfer_ctoken_spl;
 mod transfer_interface;
 mod transfer_spl_ctoken;
 
+pub use approve::*;
+pub use approve_checked::*;
 pub use burn::*;
+pub use burn_checked::*;
 pub use close::*;
 pub use compressible::{CompressibleParams, CompressibleParamsCpi};
 pub use create::*;
 pub use create_ata::*;
 pub use create_cmint::*;
 pub use ctoken_mint_to::*;
+pub use ctoken_mint_to_checked::*;
 pub use decompress::DecompressToCtoken;
+pub use decompress_cmint::*;
+pub use freeze::*;
 use light_compressible::config::CompressibleConfig;
 pub use light_ctoken_interface::{
     instructions::{
-        extensions::{compressible::CompressToPubkey, ExtensionInstructionData},
+        create_ctoken_account::CompressToPubkey, extensions::ExtensionInstructionData,
         mint_action::CompressedMintWithContext,
     },
     state::{CToken, TokenDataVersion},
 };
 use light_ctoken_types::POOL_SEED;
 pub use mint_to::*;
+pub use revoke::*;
 use solana_account_info::AccountInfo;
 use solana_pubkey::{pubkey, Pubkey};
+pub use thaw::*;
 pub use transfer_ctoken::*;
+pub use transfer_ctoken_checked::*;
 pub use transfer_ctoken_spl::{TransferCTokenToSpl, TransferCTokenToSplCpi};
 pub use transfer_interface::{SplInterface, TransferInterfaceCpi};
 pub use transfer_spl_ctoken::{TransferSplToCtoken, TransferSplToCtokenCpi};
diff --git a/sdk-libs/ctoken-sdk/src/ctoken/revoke.rs b/sdk-libs/ctoken-sdk/src/ctoken/revoke.rs
new file mode 100644
index 0000000000..8066fdef72
--- /dev/null
+++ b/sdk-libs/ctoken-sdk/src/ctoken/revoke.rs
@@ -0,0 +1,87 @@
+use light_sdk_types::C_TOKEN_PROGRAM_ID;
+use solana_account_info::AccountInfo;
+use solana_cpi::{invoke, invoke_signed};
+use solana_instruction::{AccountMeta, Instruction};
+use solana_program_error::ProgramError;
+use solana_pubkey::Pubkey;
+
+/// # Revoke delegation for a CToken account:
+/// ```rust
+/// # use solana_pubkey::Pubkey;
+/// # use light_ctoken_sdk::ctoken::RevokeCToken;
+/// # let token_account = Pubkey::new_unique();
+/// # let owner = Pubkey::new_unique();
+/// let instruction = RevokeCToken {
+///     token_account,
+///     owner,
+/// }.instruction()?;
+/// # Ok::<(), solana_program_error::ProgramError>(())
+/// ```
+pub struct RevokeCToken {
+    /// CToken account to revoke delegation for
+    pub token_account: Pubkey,
+    /// Owner of the CToken account (signer, payer for top-up)
+    pub owner: Pubkey,
+}
+
+/// # Revoke CToken via CPI:
+/// ```rust,no_run
+/// # use light_ctoken_sdk::ctoken::RevokeCTokenCpi;
+/// # use solana_account_info::AccountInfo;
+/// # let token_account: AccountInfo = todo!();
+/// # let owner: AccountInfo = todo!();
+/// # let system_program: AccountInfo = todo!();
+/// RevokeCTokenCpi {
+///     token_account,
+///     owner,
+///     system_program,
+/// }
+/// .invoke()?;
+/// # Ok::<(), solana_program_error::ProgramError>(())
+/// ```
+pub struct RevokeCTokenCpi<'info> {
+    pub token_account: AccountInfo<'info>,
+    pub owner: AccountInfo<'info>,
+    pub system_program: AccountInfo<'info>,
+}
+
+impl<'info> RevokeCTokenCpi<'info> {
+    pub fn instruction(&self) -> Result<Instruction, ProgramError> {
+        RevokeCToken::from(self).instruction()
+    }
+
+    pub fn invoke(self) -> Result<(), ProgramError> {
+        let instruction = RevokeCToken::from(&self).instruction()?;
+        let account_infos = [self.token_account, self.owner, self.system_program];
+        invoke(&instruction, &account_infos)
+    }
+
+    pub fn invoke_signed(self, signer_seeds: &[&[&[u8]]]) -> Result<(), ProgramError> {
+        let instruction = RevokeCToken::from(&self).instruction()?;
+        let account_infos = [self.token_account, self.owner, self.system_program];
+        invoke_signed(&instruction, &account_infos, signer_seeds)
+    }
+}
+
+impl<'info> From<&RevokeCTokenCpi<'info>> for RevokeCToken {
+    fn from(cpi: &RevokeCTokenCpi<'info>) -> Self {
+        Self {
+            token_account: *cpi.token_account.key,
+            owner: *cpi.owner.key,
+        }
+    }
+}
+
+impl RevokeCToken {
+    pub fn instruction(self) -> Result<Instruction, ProgramError> {
+        Ok(Instruction {
+            program_id: Pubkey::from(C_TOKEN_PROGRAM_ID),
+            accounts: vec![
+                AccountMeta::new(self.token_account, false),
+                AccountMeta::new(self.owner, true),
+                AccountMeta::new_readonly(Pubkey::default(), false),
+            ],
+            data: vec![5u8], // CTokenRevoke discriminator
+        })
+    }
+}
diff --git a/sdk-libs/ctoken-sdk/src/ctoken/thaw.rs b/sdk-libs/ctoken-sdk/src/ctoken/thaw.rs
new file mode 100644
index 0000000000..975806d4d1
--- /dev/null
+++ b/sdk-libs/ctoken-sdk/src/ctoken/thaw.rs
@@ -0,0 +1,92 @@
+use light_sdk_types::C_TOKEN_PROGRAM_ID;
+use solana_account_info::AccountInfo;
+use solana_cpi::{invoke, invoke_signed};
+use solana_instruction::{AccountMeta, Instruction};
+use solana_program_error::ProgramError;
+use solana_pubkey::Pubkey;
+
+/// # Thaw a frozen CToken account:
+/// ```rust
+/// # use solana_pubkey::Pubkey;
+/// # use light_ctoken_sdk::ctoken::ThawCToken;
+/// # let token_account = Pubkey::new_unique();
+/// # let mint = Pubkey::new_unique();
+/// # let freeze_authority = Pubkey::new_unique();
+/// let instruction = ThawCToken {
+///     token_account,
+///     mint,
+///     freeze_authority,
+/// }.instruction()?;
+/// # Ok::<(), solana_program_error::ProgramError>(())
+/// ```
+pub struct ThawCToken {
+    /// CToken account to thaw
+    pub token_account: Pubkey,
+    /// Mint of the token account
+    pub mint: Pubkey,
+    /// Freeze authority (signer)
+    pub freeze_authority: Pubkey,
+}
+
+/// # Thaw CToken via CPI:
+/// ```rust,no_run
+/// # use light_ctoken_sdk::ctoken::ThawCTokenCpi;
+/// # use solana_account_info::AccountInfo;
+/// # let token_account: AccountInfo = todo!();
+/// # let mint: AccountInfo = todo!();
+/// # let freeze_authority: AccountInfo = todo!();
+/// ThawCTokenCpi {
+///     token_account,
+///     mint,
+///     freeze_authority,
+/// }
+/// .invoke()?;
+/// # Ok::<(), solana_program_error::ProgramError>(())
+/// ```
+pub struct ThawCTokenCpi<'info> {
+    pub token_account: AccountInfo<'info>,
+    pub mint: AccountInfo<'info>,
+    pub freeze_authority: AccountInfo<'info>,
+}
+
+impl<'info> ThawCTokenCpi<'info> {
+    pub fn instruction(&self) -> Result<Instruction, ProgramError> {
+        ThawCToken::from(self).instruction()
+    }
+
+    pub fn invoke(self) -> Result<(), ProgramError> {
+        let instruction = ThawCToken::from(&self).instruction()?;
+        let account_infos = [self.token_account, self.mint, self.freeze_authority];
+        invoke(&instruction, &account_infos)
+    }
+
+    pub fn invoke_signed(self, signer_seeds: &[&[&[u8]]]) -> Result<(), ProgramError> {
+        let instruction = ThawCToken::from(&self).instruction()?;
+        let account_infos = [self.token_account, self.mint, self.freeze_authority];
+        invoke_signed(&instruction, &account_infos, signer_seeds)
+    }
+}
+
+impl<'info> From<&ThawCTokenCpi<'info>> for ThawCToken {
+    fn from(cpi: &ThawCTokenCpi<'info>) -> Self {
+        Self {
+            token_account: *cpi.token_account.key,
+            mint: *cpi.mint.key,
+            freeze_authority: *cpi.freeze_authority.key,
+        }
+    }
+}
+
+impl ThawCToken {
+    pub fn instruction(self) -> Result<Instruction, ProgramError> {
+        Ok(Instruction {
+            program_id: Pubkey::from(C_TOKEN_PROGRAM_ID),
+            accounts: vec![
+                AccountMeta::new(self.token_account, false),
+                AccountMeta::new_readonly(self.mint, false),
+                AccountMeta::new_readonly(self.freeze_authority, true),
+            ],
+            data: vec![11u8], // CTokenThawAccount discriminator
+        })
+    }
+}
diff --git a/sdk-libs/ctoken-sdk/src/ctoken/transfer_ctoken_checked.rs b/sdk-libs/ctoken-sdk/src/ctoken/transfer_ctoken_checked.rs
new file mode 100644
index 0000000000..2425f93e8e
--- /dev/null
+++ b/sdk-libs/ctoken-sdk/src/ctoken/transfer_ctoken_checked.rs
@@ -0,0 +1,125 @@
+use light_sdk_types::C_TOKEN_PROGRAM_ID;
+use solana_account_info::AccountInfo;
+use solana_cpi::{invoke, invoke_signed};
+use solana_instruction::{AccountMeta, Instruction};
+use solana_program_error::ProgramError;
+use solana_pubkey::Pubkey;
+
+/// # Create a transfer ctoken checked instruction:
+/// ```rust
+/// # use solana_pubkey::Pubkey;
+/// # use light_ctoken_sdk::ctoken::TransferCTokenChecked;
+/// # let source = Pubkey::new_unique();
+/// # let mint = Pubkey::new_unique();
+/// # let destination = Pubkey::new_unique();
+/// # let authority = Pubkey::new_unique();
+/// let instruction = TransferCTokenChecked {
+///     source,
+///     mint,
+///     destination,
+///     amount: 100,
+///     decimals: 9,
+///     authority,
+///     max_top_up: None,
+/// }.instruction()?;
+/// # Ok::<(), solana_program_error::ProgramError>(())
+/// ```
+pub struct TransferCTokenChecked {
+    pub source: Pubkey,
+    pub mint: Pubkey,
+    pub destination: Pubkey,
+    pub amount: u64,
+    pub decimals: u8,
+    pub authority: Pubkey,
+    /// Maximum lamports for rent and top-up combined. Transaction fails if exceeded. (0 = no limit)
+    /// When set to a non-zero value, includes max_top_up in instruction data
+    pub max_top_up: Option<u16>,
+}
+
+/// # Transfer ctoken checked via CPI:
+/// ```rust,no_run
+/// # use light_ctoken_sdk::ctoken::TransferCTokenCheckedCpi;
+/// # use solana_account_info::AccountInfo;
+/// # let source: AccountInfo = todo!();
+/// # let mint: AccountInfo = todo!();
+/// # let destination: AccountInfo = todo!();
+/// # let authority: AccountInfo = todo!();
+/// TransferCTokenCheckedCpi {
+///     source,
+///     mint,
+///     destination,
+///     amount: 100,
+///     decimals: 9,
+///     authority,
+///     max_top_up: None,
+/// }
+/// .invoke()?;
+/// # Ok::<(), solana_program_error::ProgramError>(())
+/// ```
+pub struct TransferCTokenCheckedCpi<'info> {
+    pub source: AccountInfo<'info>,
+    pub mint: AccountInfo<'info>,
+    pub destination: AccountInfo<'info>,
+    pub amount: u64,
+    pub decimals: u8,
+    pub authority: AccountInfo<'info>,
+    /// Maximum lamports for rent and top-up combined. Transaction fails if exceeded. (0 = no limit)
+    pub max_top_up: Option<u16>,
+}
+
+impl<'info> TransferCTokenCheckedCpi<'info> {
+    pub fn instruction(&self) -> Result<Instruction, ProgramError> {
+        TransferCTokenChecked::from(self).instruction()
+    }
+
+    pub fn invoke(self) -> Result<(), ProgramError> {
+        let instruction = TransferCTokenChecked::from(&self).instruction()?;
+        let account_infos = [self.source, self.mint, self.destination, self.authority];
+        invoke(&instruction, &account_infos)
+    }
+
+    pub fn invoke_signed(self, signer_seeds: &[&[&[u8]]]) -> Result<(), ProgramError> {
+        let instruction = TransferCTokenChecked::from(&self).instruction()?;
+        let account_infos = [self.source, self.mint, self.destination, self.authority];
+        invoke_signed(&instruction, &account_infos, signer_seeds)
+    }
+}
+
+impl<'info> From<&TransferCTokenCheckedCpi<'info>> for TransferCTokenChecked {
+    fn from(account_infos: &TransferCTokenCheckedCpi<'info>) -> Self {
+        Self {
+            source: *account_infos.source.key,
+            mint: *account_infos.mint.key,
+            destination: *account_infos.destination.key,
+            amount: account_infos.amount,
+            decimals: account_infos.decimals,
+            authority: *account_infos.authority.key,
+            max_top_up: account_infos.max_top_up,
+        }
+    }
+}
+
+impl TransferCTokenChecked {
+    pub fn instruction(self) -> Result<Instruction, ProgramError> {
+        Ok(Instruction {
+            program_id: Pubkey::from(C_TOKEN_PROGRAM_ID),
+            accounts: vec![
+                AccountMeta::new(self.source, false),
+                AccountMeta::new_readonly(self.mint, false),
+                AccountMeta::new(self.destination, false),
+                AccountMeta::new_readonly(self.authority, true),
+            ],
+            data: {
+                // Discriminator (1) + amount (8) + decimals (1) + optional max_top_up (2)
+                let mut data = vec![6u8];
+                data.extend_from_slice(&self.amount.to_le_bytes());
+                data.push(self.decimals);
+                // Include max_top_up if set (11-byte format)
+                if let Some(max_top_up) = self.max_top_up {
+                    data.extend_from_slice(&max_top_up.to_le_bytes());
+                }
+                data
+            },
+        })
+    }
+}
diff --git a/sdk-libs/ctoken-sdk/src/ctoken/transfer_ctoken_spl.rs b/sdk-libs/ctoken-sdk/src/ctoken/transfer_ctoken_spl.rs
index ce78ecded2..1587f7c1d2 100644
--- a/sdk-libs/ctoken-sdk/src/ctoken/transfer_ctoken_spl.rs
+++ b/sdk-libs/ctoken-sdk/src/ctoken/transfer_ctoken_spl.rs
@@ -34,6 +34,7 @@ use crate::compressed_token::{
 ///     payer,
 ///     spl_interface_pda,
 ///     spl_interface_pda_bump: 255,
+///     decimals: 9,
 ///     spl_token_program,
 /// }.instruction()?;
 /// # Ok::<(), solana_program_error::ProgramError>(())
@@ -47,6 +48,7 @@ pub struct TransferCTokenToSpl {
     pub payer: Pubkey,
     pub spl_interface_pda: Pubkey,
     pub spl_interface_pda_bump: u8,
+    pub decimals: u8,
     pub spl_token_program: Pubkey,
 }
 
@@ -71,6 +73,7 @@ pub struct TransferCTokenToSpl {
 ///     payer,
 ///     spl_interface_pda,
 ///     spl_interface_pda_bump: 255,
+///     decimals: 9,
 ///     spl_token_program,
 ///     compressed_token_program_authority,
 /// }
@@ -86,6 +89,7 @@ pub struct TransferCTokenToSplCpi<'info> {
     pub payer: AccountInfo<'info>,
     pub spl_interface_pda: AccountInfo<'info>,
     pub spl_interface_pda_bump: u8,
+    pub decimals: u8,
     pub spl_token_program: AccountInfo<'info>,
     pub compressed_token_program_authority: AccountInfo<'info>,
 }
@@ -139,6 +143,7 @@ impl<'info> From<&TransferCTokenToSplCpi<'info>> for TransferCTokenToSpl {
             payer: *account_infos.payer.key,
             spl_interface_pda: *account_infos.spl_interface_pda.key,
             spl_interface_pda_bump: account_infos.spl_interface_pda_bump,
+            decimals: account_infos.decimals,
             spl_token_program: *account_infos.spl_token_program.key,
         }
     }
@@ -187,6 +192,7 @@ impl TransferCTokenToSpl {
                 4, // pool_account_index
                 0, // pool_index (TODO: make dynamic)
                 self.spl_interface_pda_bump,
+                self.decimals,
             )),
             delegate_is_set: false,
             method_used: true,
@@ -203,6 +209,7 @@ impl TransferCTokenToSpl {
             out_lamports: None,
             token_accounts: vec![compress_to_pool, decompress_to_spl],
             output_queue: 0, // Decompressed accounts only, no output queue needed
+            in_tlv: None,
         };
 
         create_transfer2_instruction(inputs).map_err(ProgramError::from)
diff --git a/sdk-libs/ctoken-sdk/src/ctoken/transfer_interface.rs b/sdk-libs/ctoken-sdk/src/ctoken/transfer_interface.rs
index 4f7f648c4a..881a289465 100644
--- a/sdk-libs/ctoken-sdk/src/ctoken/transfer_interface.rs
+++ b/sdk-libs/ctoken-sdk/src/ctoken/transfer_interface.rs
@@ -17,38 +17,48 @@ pub struct SplInterface<'info> {
 
 pub struct TransferInterfaceCpi<'info> {
     pub amount: u64,
+    pub decimals: u8,
     pub source_account: AccountInfo<'info>,
     pub destination_account: AccountInfo<'info>,
     pub authority: AccountInfo<'info>,
     pub payer: AccountInfo<'info>,
     pub compressed_token_program_authority: AccountInfo<'info>,
     pub spl_interface: Option<SplInterface<'info>>,
+    /// System program - required for compressible account lamport top-ups
+    pub system_program: AccountInfo<'info>,
 }
 
 impl<'info> TransferInterfaceCpi<'info> {
     /// # Arguments
     /// * `amount` - Amount to transfer
+    /// * `decimals` - Token decimals (required for SPL transfers)
     /// * `source_account` - Source token account (can be ctoken or SPL)
     /// * `destination_account` - Destination token account (can be ctoken or SPL)
     /// * `authority` - Authority for the transfer (must be signer)
     /// * `payer` - Payer for the transaction
     /// * `compressed_token_program_authority` - Compressed token program authority
+    /// * `system_program` - System program (required for compressible account lamport top-ups)
+    #[allow(clippy::too_many_arguments)]
     pub fn new(
         amount: u64,
+        decimals: u8,
         source_account: AccountInfo<'info>,
         destination_account: AccountInfo<'info>,
         authority: AccountInfo<'info>,
         payer: AccountInfo<'info>,
         compressed_token_program_authority: AccountInfo<'info>,
+        system_program: AccountInfo<'info>,
     ) -> Self {
         Self {
             source_account,
             destination_account,
             authority,
             amount,
+            decimals,
             payer,
             compressed_token_program_authority,
             spl_interface: None,
+            system_program,
         }
     }
 
@@ -120,6 +130,7 @@ impl<'info> TransferInterfaceCpi<'info> {
                     payer: self.payer.clone(),
                     spl_interface_pda: config.spl_interface_pda.clone(),
                     spl_interface_pda_bump: config.spl_interface_pda_bump,
+                    decimals: self.decimals,
                     spl_token_program: config.spl_token_program.clone(),
                     compressed_token_program_authority: self
                         .compressed_token_program_authority
@@ -142,10 +153,12 @@ impl<'info> TransferInterfaceCpi<'info> {
                     payer: self.payer.clone(),
                     spl_interface_pda: config.spl_interface_pda.clone(),
                     spl_interface_pda_bump: config.spl_interface_pda_bump,
+                    decimals: self.decimals,
                     spl_token_program: config.spl_token_program.clone(),
                     compressed_token_program_authority: self
                         .compressed_token_program_authority
                         .clone(),
+                    system_program: self.system_program.clone(),
                 }
                 .invoke()
             }
@@ -190,6 +203,7 @@ impl<'info> TransferInterfaceCpi<'info> {
                     payer: self.payer.clone(),
                     spl_interface_pda: config.spl_interface_pda.clone(),
                     spl_interface_pda_bump: config.spl_interface_pda_bump,
+                    decimals: self.decimals,
                     spl_token_program: config.spl_token_program.clone(),
                     compressed_token_program_authority: self
                         .compressed_token_program_authority
@@ -212,10 +226,12 @@ impl<'info> TransferInterfaceCpi<'info> {
                     payer: self.payer.clone(),
                     spl_interface_pda: config.spl_interface_pda.clone(),
                     spl_interface_pda_bump: config.spl_interface_pda_bump,
+                    decimals: self.decimals,
                     spl_token_program: config.spl_token_program.clone(),
                     compressed_token_program_authority: self
                         .compressed_token_program_authority
                         .clone(),
+                    system_program: self.system_program.clone(),
                 }
                 .invoke_signed(signer_seeds)
             }
diff --git a/sdk-libs/ctoken-sdk/src/ctoken/transfer_spl_ctoken.rs b/sdk-libs/ctoken-sdk/src/ctoken/transfer_spl_ctoken.rs
index e67bada1c9..65d50e42da 100644
--- a/sdk-libs/ctoken-sdk/src/ctoken/transfer_spl_ctoken.rs
+++ b/sdk-libs/ctoken-sdk/src/ctoken/transfer_spl_ctoken.rs
@@ -27,6 +27,7 @@ use crate::compressed_token::{
 /// let instruction = TransferSplToCtoken {
 ///     amount: 100,
 ///     spl_interface_pda_bump: 255,
+///     decimals: 9,
 ///     source_spl_token_account,
 ///     destination_ctoken_account,
 ///     authority,
@@ -40,6 +41,7 @@ use crate::compressed_token::{
 pub struct TransferSplToCtoken {
     pub amount: u64,
     pub spl_interface_pda_bump: u8,
+    pub decimals: u8,
     pub source_spl_token_account: Pubkey,
     /// Destination ctoken account (writable)
     pub destination_ctoken_account: Pubkey,
@@ -62,9 +64,11 @@ pub struct TransferSplToCtoken {
 /// # let spl_interface_pda: AccountInfo = todo!();
 /// # let spl_token_program: AccountInfo = todo!();
 /// # let compressed_token_program_authority: AccountInfo = todo!();
+/// # let system_program: AccountInfo = todo!();
 /// TransferSplToCtokenCpi {
 ///     amount: 100,
 ///     spl_interface_pda_bump: 255,
+///     decimals: 9,
 ///     source_spl_token_account,
 ///     destination_ctoken_account,
 ///     authority,
@@ -73,6 +77,7 @@ pub struct TransferSplToCtoken {
 ///     spl_interface_pda,
 ///     spl_token_program,
 ///     compressed_token_program_authority,
+///     system_program,
 /// }
 /// .invoke()?;
 /// # Ok::<(), solana_program_error::ProgramError>(())
@@ -80,6 +85,7 @@ pub struct TransferSplToCtoken {
 pub struct TransferSplToCtokenCpi<'info> {
     pub amount: u64,
     pub spl_interface_pda_bump: u8,
+    pub decimals: u8,
     pub source_spl_token_account: AccountInfo<'info>,
     /// Destination ctoken account (writable)
     pub destination_ctoken_account: AccountInfo<'info>,
@@ -89,6 +95,8 @@ pub struct TransferSplToCtokenCpi<'info> {
     pub spl_interface_pda: AccountInfo<'info>,
     pub spl_token_program: AccountInfo<'info>,
     pub compressed_token_program_authority: AccountInfo<'info>,
+    /// System program - required for compressible account lamport top-ups
+    pub system_program: AccountInfo<'info>,
 }
 
 impl<'info> TransferSplToCtokenCpi<'info> {
@@ -108,6 +116,7 @@ impl<'info> TransferSplToCtokenCpi<'info> {
             self.source_spl_token_account,           // Index 3: Source SPL token account
             self.spl_interface_pda,                  // Index 4: SPL interface PDA
             self.spl_token_program,                  // Index 5: SPL Token program
+            self.system_program,                     // Index 6: System program
         ];
         invoke(&instruction, &account_infos)
     }
@@ -124,6 +133,7 @@ impl<'info> TransferSplToCtokenCpi<'info> {
             self.source_spl_token_account,           // Index 3: Source SPL token account
             self.spl_interface_pda,                  // Index 4: SPL interface PDA
             self.spl_token_program,                  // Index 5: SPL Token program
+            self.system_program,                     // Index 6: System program
         ];
         invoke_signed(&instruction, &account_infos, signer_seeds)
     }
@@ -140,6 +150,7 @@ impl<'info> From<&TransferSplToCtokenCpi<'info>> for TransferSplToCtoken {
             payer: *account_infos.payer.key,
             spl_interface_pda: *account_infos.spl_interface_pda.key,
             spl_interface_pda_bump: account_infos.spl_interface_pda_bump,
+            decimals: account_infos.decimals,
             spl_token_program: *account_infos.spl_token_program.key,
         }
     }
@@ -160,6 +171,8 @@ impl TransferSplToCtoken {
             AccountMeta::new(self.spl_interface_pda, false),
             // SPL Token program (index 5) - needed for CPI
             AccountMeta::new_readonly(self.spl_token_program, false),
+            // System program (index 6) - needed for compressible account lamport top-ups
+            AccountMeta::new_readonly(Pubkey::default(), false),
         ];
 
         let wrap_spl_to_ctoken_account = CTokenAccount2 {
@@ -173,6 +186,7 @@ impl TransferSplToCtoken {
                 4, // pool_account_index:
                 0, // pool_index
                 self.spl_interface_pda_bump,
+                self.decimals,
             )),
             delegate_is_set: false,
             method_used: true,
@@ -197,6 +211,7 @@ impl TransferSplToCtoken {
             out_lamports: None,
             token_accounts: vec![wrap_spl_to_ctoken_account, ctoken_account],
             output_queue: 0, // Decompressed accounts only, no output queue needed
+            in_tlv: None,
         };
 
         create_transfer2_instruction(inputs).map_err(ProgramError::from)
diff --git a/sdk-libs/ctoken-sdk/src/pack.rs b/sdk-libs/ctoken-sdk/src/pack.rs
index d995e7443a..b62c5581f7 100644
--- a/sdk-libs/ctoken-sdk/src/pack.rs
+++ b/sdk-libs/ctoken-sdk/src/pack.rs
@@ -108,8 +108,8 @@ pub mod compat {
         pub delegate: Option<Pubkey>,
         /// The account's state
         pub state: AccountState,
-        /// Placeholder for TokenExtension tlv data (unimplemented)
-        pub tlv: Option<Vec<u8>>,
+        /// TLV extensions for compressed token accounts
+        pub tlv: Option<Vec<light_ctoken_interface::state::ExtensionStruct>>,
     }
 
     impl TokenData {
diff --git a/sdk-libs/ctoken-sdk/src/spl_interface.rs b/sdk-libs/ctoken-sdk/src/spl_interface.rs
index 5317074225..fdba7dab2d 100644
--- a/sdk-libs/ctoken-sdk/src/spl_interface.rs
+++ b/sdk-libs/ctoken-sdk/src/spl_interface.rs
@@ -1,7 +1,16 @@
 //! SPL interface PDA derivation utilities.
+//!
+//! Re-exports from `light_ctoken_interface` with convenience wrappers.
 
-use light_ctoken_interface::CTOKEN_PROGRAM_ID;
-use light_ctoken_types::constants::{CPI_AUTHORITY_PDA, CREATE_TOKEN_POOL, POOL_SEED};
+use light_ctoken_interface::{
+    discriminator::{ADD_TOKEN_POOL, CREATE_TOKEN_POOL},
+    CPI_AUTHORITY, CTOKEN_PROGRAM_ID,
+};
+// Re-export derivation functions from ctoken-interface
+pub use light_ctoken_interface::{
+    find_spl_interface_pda, find_spl_interface_pda_with_index, get_spl_interface_pda,
+    has_restricted_extensions, is_valid_spl_interface_pda, NUM_MAX_POOL_ACCOUNTS,
+};
 use solana_instruction::{AccountMeta, Instruction};
 use solana_pubkey::Pubkey;
 
@@ -14,30 +23,9 @@ pub struct SplInterfacePda {
     pub index: u8,
 }
 
-/// Derive the spl interface pda for a given mint
-pub fn get_spl_interface_pda(mint: &Pubkey) -> Pubkey {
-    get_spl_interface_pda_with_index(mint, 0)
-}
-
-/// Find the spl interface pda for a given mint and index
-pub fn find_spl_interface_pda_with_index(mint: &Pubkey, spl_interface_index: u8) -> (Pubkey, u8) {
-    let seeds = &[POOL_SEED, mint.as_ref(), &[spl_interface_index]];
-    let seeds = if spl_interface_index == 0 {
-        &seeds[..2]
-    } else {
-        &seeds[..]
-    };
-    Pubkey::find_program_address(seeds, &Pubkey::from(CTOKEN_PROGRAM_ID))
-}
-
-/// Get the spl interface pda for a given mint and index
-pub fn get_spl_interface_pda_with_index(mint: &Pubkey, spl_interface_index: u8) -> Pubkey {
-    find_spl_interface_pda_with_index(mint, spl_interface_index).0
-}
-
 /// Derive spl interface pda information for a given mint
-pub fn derive_spl_interface_pda(mint: &solana_pubkey::Pubkey, index: u8) -> SplInterfacePda {
-    let (pubkey, bump) = find_spl_interface_pda_with_index(mint, index);
+pub fn derive_spl_interface_pda(mint: &Pubkey, index: u8, restricted: bool) -> SplInterfacePda {
+    let (pubkey, bump) = find_spl_interface_pda_with_index(mint, index, restricted);
     SplInterfacePda {
         pubkey,
         bump,
@@ -47,7 +35,7 @@ pub fn derive_spl_interface_pda(mint: &solana_pubkey::Pubkey, index: u8) -> SplI
 
 /// # Create SPL interface PDA (token pool) instruction builder
 ///
-/// Creates the spl interface pda for an SPL mint with index 0.
+/// Creates or adds an spl interface pda for an SPL mint.
 /// Spl interface pdas store spl tokens that are wrapped in ctoken or compressed token accounts.
 ///
 /// ```rust
@@ -57,7 +45,11 @@ pub fn derive_spl_interface_pda(mint: &solana_pubkey::Pubkey, index: u8) -> SplI
 /// # let fee_payer = Pubkey::new_unique();
 /// # let mint = Pubkey::new_unique();
 /// # let token_program = SPL_TOKEN_PROGRAM_ID;
-/// let instruction = CreateSplInterfacePda::new(fee_payer, mint, token_program)
+/// // Create initial pool (index 0)
+/// let instruction = CreateSplInterfacePda::new(fee_payer, mint, token_program, false)
+///     .instruction();
+/// // Add additional pool (index 1)
+/// let instruction = CreateSplInterfacePda::new_with_index(fee_payer, mint, token_program, 1, false)
 ///     .instruction();
 /// ```
 pub struct CreateSplInterfacePda {
@@ -65,32 +57,77 @@ pub struct CreateSplInterfacePda {
     pub mint: Pubkey,
     pub token_program: Pubkey,
     pub spl_interface_pda: Pubkey,
+    pub existing_spl_interface_pda: Option<Pubkey>,
+    pub index: u8,
 }
 
 impl CreateSplInterfacePda {
     /// Derives the spl interface pda for an SPL mint with index 0.
-    pub fn new(fee_payer: Pubkey, mint: Pubkey, token_program: Pubkey) -> Self {
-        let (spl_interface_pda, _) = find_spl_interface_pda_with_index(&mint, 0);
+    pub fn new(fee_payer: Pubkey, mint: Pubkey, token_program: Pubkey, restricted: bool) -> Self {
+        Self::new_with_index(fee_payer, mint, token_program, 0, restricted)
+    }
+
+    /// Derives the spl interface pda for an SPL mint with a specific index.
+    /// For index 0, creates the initial pool. For index > 0, adds an additional pool.
+    pub fn new_with_index(
+        fee_payer: Pubkey,
+        mint: Pubkey,
+        token_program: Pubkey,
+        index: u8,
+        restricted: bool,
+    ) -> Self {
+        let (spl_interface_pda, _) = find_spl_interface_pda_with_index(&mint, index, restricted);
+        let existing_spl_interface_pda = if index > 0 {
+            let (existing_pda, _) =
+                find_spl_interface_pda_with_index(&mint, index.saturating_sub(1), restricted);
+            Some(existing_pda)
+        } else {
+            None
+        };
         Self {
             fee_payer,
             mint,
             token_program,
             spl_interface_pda,
+            existing_spl_interface_pda,
+            index,
         }
     }
 
     pub fn instruction(self) -> Instruction {
-        Instruction {
-            program_id: Pubkey::from(CTOKEN_PROGRAM_ID),
-            accounts: vec![
-                AccountMeta::new(self.fee_payer, true),
-                AccountMeta::new(self.spl_interface_pda, false),
-                AccountMeta::new_readonly(Pubkey::default(), false), // system_program
-                AccountMeta::new(self.mint, false),
-                AccountMeta::new_readonly(self.token_program, false),
-                AccountMeta::new_readonly(Pubkey::from(CPI_AUTHORITY_PDA), false),
-            ],
-            data: CREATE_TOKEN_POOL.to_vec(),
+        let cpi_authority = Pubkey::from(CPI_AUTHORITY);
+
+        if self.index == 0 {
+            // CreateTokenPool instruction
+            Instruction {
+                program_id: Pubkey::from(CTOKEN_PROGRAM_ID),
+                accounts: vec![
+                    AccountMeta::new(self.fee_payer, true),
+                    AccountMeta::new(self.spl_interface_pda, false),
+                    AccountMeta::new_readonly(Pubkey::default(), false), // system_program
+                    AccountMeta::new(self.mint, false),
+                    AccountMeta::new_readonly(self.token_program, false),
+                    AccountMeta::new_readonly(cpi_authority, false),
+                ],
+                data: CREATE_TOKEN_POOL.to_vec(),
+            }
+        } else {
+            // AddTokenPool instruction
+            let mut data = ADD_TOKEN_POOL.to_vec();
+            data.push(self.index);
+            Instruction {
+                program_id: Pubkey::from(CTOKEN_PROGRAM_ID),
+                accounts: vec![
+                    AccountMeta::new(self.fee_payer, true),
+                    AccountMeta::new(self.spl_interface_pda, false),
+                    AccountMeta::new_readonly(self.existing_spl_interface_pda.unwrap(), false),
+                    AccountMeta::new_readonly(Pubkey::default(), false), // system_program
+                    AccountMeta::new(self.mint, false),
+                    AccountMeta::new_readonly(self.token_program, false),
+                    AccountMeta::new_readonly(cpi_authority, false),
+                ],
+                data,
+            }
         }
     }
 }
diff --git a/sdk-libs/ctoken-sdk/src/utils.rs b/sdk-libs/ctoken-sdk/src/utils.rs
index 09072eea4c..d85cb0fb08 100644
--- a/sdk-libs/ctoken-sdk/src/utils.rs
+++ b/sdk-libs/ctoken-sdk/src/utils.rs
@@ -1,24 +1,20 @@
 //! Utility functions and default account configurations.
 
-use light_ctoken_interface::instructions::transfer2::MultiInputTokenDataWithContext;
+use light_ctoken_interface::{
+    instructions::transfer2::MultiInputTokenDataWithContext, state::CToken,
+};
 use light_sdk_types::C_TOKEN_PROGRAM_ID;
 use solana_account_info::AccountInfo;
 use solana_instruction::AccountMeta;
 use solana_pubkey::Pubkey;
-use spl_pod::bytemuck::pod_from_bytes;
-use spl_token_2022::pod::PodAccount;
 
 use crate::{error::CTokenSdkError, AnchorDeserialize, AnchorSerialize};
 
 pub fn get_token_account_balance(token_account_info: &AccountInfo) -> Result<u64, CTokenSdkError> {
-    let token_account_data = token_account_info
+    let data = token_account_info
         .try_borrow_data()
         .map_err(|_| CTokenSdkError::AccountBorrowFailed)?;
-
-    let pod_account = pod_from_bytes::<PodAccount>(&token_account_data)
-        .map_err(|_| CTokenSdkError::InvalidAccountData)?;
-
-    Ok(pod_account.amount.into())
+    CToken::amount_from_slice(&data).map_err(|_| CTokenSdkError::InvalidAccountData)
 }
 
 pub fn is_ctoken_account(account_info: &AccountInfo) -> Result<bool, CTokenSdkError> {
diff --git a/sdk-libs/program-test/src/compressible.rs b/sdk-libs/program-test/src/compressible.rs
index f672404bac..f13d302e76 100644
--- a/sdk-libs/program-test/src/compressible.rs
+++ b/sdk-libs/program-test/src/compressible.rs
@@ -8,15 +8,16 @@ use borsh::BorshDeserialize;
 #[cfg(feature = "devenv")]
 use light_client::rpc::{Rpc, RpcError};
 #[cfg(feature = "devenv")]
+use light_compressible::compression_info::CompressionInfo;
+#[cfg(feature = "devenv")]
 use light_compressible::config::CompressibleConfig as CtokenCompressibleConfig;
 #[cfg(feature = "devenv")]
 use light_compressible::rent::RentConfig;
 #[cfg(feature = "devenv")]
 use light_compressible::rent::SLOTS_PER_EPOCH;
 #[cfg(feature = "devenv")]
-use light_ctoken_interface::{
-    state::{CToken, ExtensionStruct},
-    COMPRESSIBLE_TOKEN_ACCOUNT_SIZE,
+use light_ctoken_interface::state::{
+    CToken, CompressedMint, ACCOUNT_TYPE_MINT, ACCOUNT_TYPE_TOKEN_ACCOUNT,
 };
 #[cfg(feature = "devenv")]
 use light_sdk::compressible::CompressibleConfig as CpdaCompressibleConfig;
@@ -26,6 +27,40 @@ use solana_pubkey::Pubkey;
 #[cfg(feature = "devenv")]
 use crate::{litesvm_extensions::LiteSvmExtensions, LightProgramTest};
 
+/// Determines account type from account data.
+/// - If account is exactly 165 bytes: CToken (legacy size without extensions)
+/// - If account is > 165 bytes: read byte 165 for discriminator
+/// - If account is < 165 bytes: invalid (returns None)
+#[cfg(feature = "devenv")]
+fn determine_account_type(data: &[u8]) -> Option<u8> {
+    const ACCOUNT_TYPE_OFFSET: usize = 165;
+
+    match data.len().cmp(&ACCOUNT_TYPE_OFFSET) {
+        std::cmp::Ordering::Less => None,
+        std::cmp::Ordering::Equal => Some(ACCOUNT_TYPE_TOKEN_ACCOUNT), // 165 bytes = CToken
+        std::cmp::Ordering::Greater => Some(data[ACCOUNT_TYPE_OFFSET]),
+    }
+}
+
+/// Extracts CompressionInfo and account type from account data, handling both CToken and CMint.
+/// Returns (CompressionInfo, account_type) or None if parsing fails.
+#[cfg(feature = "devenv")]
+fn extract_compression_info(data: &[u8]) -> Option<(CompressionInfo, u8)> {
+    let account_type = determine_account_type(data)?;
+
+    match account_type {
+        ACCOUNT_TYPE_TOKEN_ACCOUNT => {
+            let ctoken = CToken::deserialize(&mut &data[..]).ok()?;
+            Some((ctoken.compression, account_type))
+        }
+        ACCOUNT_TYPE_MINT => {
+            let cmint = CompressedMint::deserialize(&mut &data[..]).ok()?;
+            Some((cmint.compression, account_type))
+        }
+        _ => None,
+    }
+}
+
 #[cfg(feature = "devenv")]
 pub type CompressibleAccountStore = HashMap<Pubkey, StoredCompressibleAccount>;
 
@@ -34,7 +69,9 @@ pub type CompressibleAccountStore = HashMap<Pubkey, StoredCompressibleAccount>;
 pub struct StoredCompressibleAccount {
     pub pubkey: Pubkey,
     pub last_paid_slot: u64,
-    pub account: CToken,
+    pub compression: CompressionInfo,
+    /// Account type: ACCOUNT_TYPE_TOKEN_ACCOUNT (2) or ACCOUNT_TYPE_MINT (1)
+    pub account_type: u8,
 }
 
 #[cfg(feature = "devenv")]
@@ -87,7 +124,7 @@ pub async fn claim_and_compress(
     let forester_keypair = rpc.test_accounts.protocol.forester.insecure_clone();
     let payer = rpc.get_payer().insecure_clone();
 
-    // Get all compressible token accounts
+    // Get all compressible token/mint accounts (both CToken and CMint)
     let compressible_ctoken_accounts = rpc
         .context
         .get_program_accounts(&light_compressed_token::ID);
@@ -96,42 +133,35 @@ pub async fn claim_and_compress(
         .iter()
         .filter(|e| e.1.data.len() > 200 && e.1.lamports > 0)
     {
-        let des_account = CToken::deserialize(&mut account.1.data.as_slice())?;
-        if let Some(extensions) = des_account.extensions.as_ref() {
-            for extension in extensions.iter() {
-                if let ExtensionStruct::Compressible(e) = extension {
-                    let base_lamports = rpc
-                        .get_minimum_balance_for_rent_exemption(
-                            COMPRESSIBLE_TOKEN_ACCOUNT_SIZE as usize,
-                        )
-                        .await
-                        .unwrap();
-                    let last_funded_epoch = e
-                        .info
-                        .get_last_funded_epoch(
-                            account.1.data.len() as u64,
-                            account.1.lamports,
-                            base_lamports,
-                        )
-                        .unwrap();
-                    let last_funded_slot = last_funded_epoch * SLOTS_PER_EPOCH;
-                    stored_compressible_accounts.insert(
-                        account.0,
-                        StoredCompressibleAccount {
-                            pubkey: account.0,
-                            last_paid_slot: last_funded_slot,
-                            account: des_account.clone(),
-                        },
-                    );
-                }
-            }
-        }
+        // Extract compression info and account type, handling both CToken and CMint
+        let Some((compression, account_type)) = extract_compression_info(&account.1.data) else {
+            continue;
+        };
+
+        let base_lamports = rpc
+            .get_minimum_balance_for_rent_exemption(account.1.data.len())
+            .await
+            .unwrap();
+        let last_funded_epoch = compression
+            .get_last_funded_epoch(
+                account.1.data.len() as u64,
+                account.1.lamports,
+                base_lamports,
+            )
+            .unwrap();
+        let last_funded_slot = last_funded_epoch * SLOTS_PER_EPOCH;
+        stored_compressible_accounts.insert(
+            account.0,
+            StoredCompressibleAccount {
+                pubkey: account.0,
+                last_paid_slot: last_funded_slot,
+                compression,
+                account_type,
+            },
+        );
     }
 
     let current_slot = rpc.get_slot().await?;
-    let rent_exemption = rpc
-        .get_minimum_balance_for_rent_exemption(COMPRESSIBLE_TOKEN_ACCOUNT_SIZE as usize)
-        .await?;
 
     let mut compress_accounts = Vec::new();
     let mut claim_accounts = Vec::new();
@@ -139,56 +169,52 @@ pub async fn claim_and_compress(
     // For each stored account, determine action using AccountRentState
     for (pubkey, stored_account) in stored_compressible_accounts.iter() {
         let account = rpc.get_account(*pubkey).await?.unwrap();
+        let rent_exemption = rpc
+            .get_minimum_balance_for_rent_exemption(account.data.len())
+            .await?;
 
-        // Get compressible extension
-        if let Some(extensions) = stored_account.account.extensions.as_ref() {
-            for extension in extensions.iter() {
-                if let ExtensionStruct::Compressible(comp_ext) = extension {
-                    use light_compressible::rent::AccountRentState;
-
-                    // Create state for rent calculation
-                    let state = AccountRentState {
-                        num_bytes: account.data.len() as u64,
-                        current_slot,
-                        current_lamports: account.lamports,
-                        last_claimed_slot: comp_ext.info.last_claimed_slot,
-                    };
-
-                    // Check what action is needed
-                    match state.calculate_claimable_rent(&comp_ext.info.rent_config, rent_exemption)
-                    {
-                        None => {
-                            // Account is compressible (has rent deficit)
-                            compress_accounts.push(*pubkey);
-                        }
-                        Some(claimable_amount) if claimable_amount > 0 => {
-                            // Has rent to claim from completed epochs
-                            claim_accounts.push(*pubkey);
-                        }
-                        Some(_) => {
-                            // Well-funded, nothing to claim (0 completed epochs)
-                            // Do nothing - skip this account
-                        }
-                    }
+        use light_compressible::rent::AccountRentState;
+
+        let compression = &stored_account.compression;
+
+        // Create state for rent calculation
+        let state = AccountRentState {
+            num_bytes: account.data.len() as u64,
+            current_slot,
+            current_lamports: account.lamports,
+            last_claimed_slot: compression.last_claimed_slot,
+        };
+
+        // Check what action is needed
+        match state.calculate_claimable_rent(&compression.rent_config, rent_exemption) {
+            None => {
+                // Account is compressible (has rent deficit)
+                // Only CToken accounts can be compressed via compress_and_close_forester
+                // CMint accounts have a different compression flow
+                if stored_account.account_type == ACCOUNT_TYPE_TOKEN_ACCOUNT {
+                    compress_accounts.push(*pubkey);
                 }
             }
+            Some(claimable_amount) if claimable_amount > 0 => {
+                // Has rent to claim from completed epochs
+                // Both CToken and CMint can be claimed
+                claim_accounts.push(*pubkey);
+            }
+            Some(_) => {
+                // Well-funded, nothing to claim (0 completed epochs)
+                // Do nothing - skip this account
+            }
         }
     }
 
     // Process claimable accounts in batches
     for token_accounts in claim_accounts.as_slice().chunks(20) {
-        println!(
-            "Claim from {} accounts: {:?}",
-            token_accounts.len(),
-            token_accounts
-        );
         claim_forester(rpc, token_accounts, &forester_keypair, &payer).await?;
     }
 
     // Process compressible accounts in batches
     const BATCH_SIZE: usize = 10;
     for chunk in compress_accounts.chunks(BATCH_SIZE) {
-        println!("Compress and close {} accounts: {:?}", chunk.len(), chunk);
         compress_and_close_forester(rpc, chunk, &forester_keypair, &payer, None).await?;
 
         // Remove compressed accounts from HashMap
diff --git a/sdk-libs/program-test/src/forester/compress_and_close_forester.rs b/sdk-libs/program-test/src/forester/compress_and_close_forester.rs
index ddbc504034..f1d3e00d64 100644
--- a/sdk-libs/program-test/src/forester/compress_and_close_forester.rs
+++ b/sdk-libs/program-test/src/forester/compress_and_close_forester.rs
@@ -6,7 +6,7 @@ use light_client::{
     rpc::{Rpc, RpcError},
 };
 use light_compressible::config::CompressibleConfig;
-use light_ctoken_sdk::compressed_token::compress_and_close::CompressAndCloseAccounts as CTokenCompressAndCloseAccounts;
+use light_ctoken_sdk::compressed_token::CompressAndCloseAccounts as CTokenCompressAndCloseAccounts;
 use light_registry::{
     accounts::CompressAndCloseContext as CompressAndCloseAccounts,
     compressible::compressed_token::CompressAndCloseIndices, instruction::CompressAndClose,
@@ -83,7 +83,7 @@ pub async fn compress_and_close_forester<R: Rpc + Indexer>(
     packed_accounts.insert_or_get(output_queue);
 
     // Parse the ctoken account to get required pubkeys
-    use light_ctoken_interface::state::{CToken, ZExtensionStruct};
+    use light_ctoken_interface::state::CToken;
     use light_zero_copy::traits::ZeroCopyAt;
 
     let mut indices_vec = Vec::with_capacity(solana_ctoken_accounts.len());
@@ -121,35 +121,38 @@ pub async fn compress_and_close_forester<R: Rpc + Indexer>(
         let mint_index =
             packed_accounts.insert_or_get(Pubkey::from(ctoken_account.mint.to_bytes()));
 
-        let mut compressed_token_owner = Pubkey::from(ctoken_account.owner.to_bytes());
-        let mut rent_sponsor_pubkey = Pubkey::from(ctoken_account.owner.to_bytes());
-
-        if let Some(extensions) = &ctoken_account.extensions {
-            for extension in extensions {
-                if let ZExtensionStruct::Compressible(e) = extension {
-                    let current_authority = Pubkey::from(e.info.compression_authority);
-                    rent_sponsor_pubkey = Pubkey::from(e.info.rent_sponsor);
-
-                    if compression_authority_pubkey.is_none() {
-                        compression_authority_pubkey = Some(current_authority);
-                    }
-
-                    if e.info.compress_to_pubkey() {
-                        compressed_token_owner = *solana_ctoken_account_pubkey;
-                    }
-                    break;
-                }
-            }
+        // Get compression info from meta
+        let compression = &ctoken_account.compression;
+        let current_authority = Pubkey::from(compression.compression_authority);
+        let rent_sponsor_pubkey = Pubkey::from(compression.rent_sponsor);
+
+        if compression_authority_pubkey.is_none() {
+            compression_authority_pubkey = Some(current_authority);
         }
 
+        let compressed_token_owner = if compression.compress_to_pubkey == 1 {
+            *solana_ctoken_account_pubkey
+        } else {
+            Pubkey::from(ctoken_account.owner.to_bytes())
+        };
+
         let owner_index = packed_accounts.insert_or_get(compressed_token_owner);
         let rent_sponsor_index = packed_accounts.insert_or_get(rent_sponsor_pubkey);
 
+        // Get delegate if present
+        let delegate_index = if ctoken_account.delegate != [0u8; 32] {
+            let delegate_pubkey = Pubkey::from(ctoken_account.delegate);
+            packed_accounts.insert_or_get(delegate_pubkey)
+        } else {
+            0 // 0 means no delegate
+        };
+
         let indices = CompressAndCloseIndices {
             source_index,
             mint_index,
             owner_index,
             rent_sponsor_index,
+            delegate_index,
         };
 
         indices_vec.push(indices);
diff --git a/sdk-libs/program-test/src/utils/assert.rs b/sdk-libs/program-test/src/utils/assert.rs
index 7cbed18f68..94ef51e1c5 100644
--- a/sdk-libs/program-test/src/utils/assert.rs
+++ b/sdk-libs/program-test/src/utils/assert.rs
@@ -58,7 +58,7 @@ pub fn assert_rpc_error<T>(
                 (InstructionError::UninitializedAccount, 10) => Ok(()),
                 (InstructionError::NotEnoughAccountKeys, 11) => Ok(()),
                 (InstructionError::AccountBorrowFailed, 12) => Ok(()),
-                (InstructionError::MaxSeedLengthExceeded, 13) => Ok(()),
+                (InstructionError::ExternalAccountDataModified, 13) => Ok(()),
                 (InstructionError::InvalidSeeds, 14) => Ok(()),
                 (InstructionError::BorshIoError(_), 15) => Ok(()),
                 (InstructionError::AccountNotRentExempt, 16) => Ok(()),
@@ -102,7 +102,7 @@ pub fn assert_rpc_error<T>(
             (InstructionError::UninitializedAccount, 10) => Ok(()),
             (InstructionError::NotEnoughAccountKeys, 11) => Ok(()),
             (InstructionError::AccountBorrowFailed, 12) => Ok(()),
-            (InstructionError::MaxSeedLengthExceeded, 13) => Ok(()),
+            (InstructionError::ExternalAccountDataModified, 13) => Ok(()),
             (InstructionError::InvalidSeeds, 14) => Ok(()),
             (InstructionError::BorshIoError(_), 15) => Ok(()),
             (InstructionError::AccountNotRentExempt, 16) => Ok(()),
diff --git a/sdk-libs/token-client/Cargo.toml b/sdk-libs/token-client/Cargo.toml
index 0997cfa463..126ec238cf 100644
--- a/sdk-libs/token-client/Cargo.toml
+++ b/sdk-libs/token-client/Cargo.toml
@@ -23,6 +23,7 @@ solana-msg = { workspace = true }
 solana-keypair = { workspace = true }
 solana-signer = { workspace = true }
 solana-signature = { workspace = true }
+solana-system-interface = { workspace = true }
 spl-token-2022 = { workspace = true }
 spl-pod = { workspace = true }
 borsh = { workspace = true }
diff --git a/sdk-libs/token-client/src/actions/create_compressible_token_account.rs b/sdk-libs/token-client/src/actions/create_compressible_token_account.rs
index a9432fca18..083ad68789 100644
--- a/sdk-libs/token-client/src/actions/create_compressible_token_account.rs
+++ b/sdk-libs/token-client/src/actions/create_compressible_token_account.rs
@@ -1,5 +1,5 @@
 use light_client::rpc::{Rpc, RpcError};
-use light_ctoken_interface::state::TokenDataVersion;
+use light_ctoken_interface::{has_restricted_extensions, state::TokenDataVersion};
 use light_ctoken_sdk::ctoken::{CompressibleParams, CreateCTokenAccount};
 use solana_keypair::Keypair;
 use solana_pubkey::Pubkey;
@@ -54,6 +54,12 @@ pub async fn create_compressible_token_account<R: Rpc>(
         &solana_pubkey::pubkey!("cTokenmWW8bLPjZEBAUgYy3zKxQZW6VKi7bqNFEVv3m"),
     );
 
+    // Check if mint has restricted extensions that require compression_only mode
+    let compression_only = match rpc.get_account(mint).await {
+        Ok(Some(mint_account)) => has_restricted_extensions(&mint_account.data),
+        _ => false,
+    };
+
     let compressible_params = CompressibleParams {
         compressible_config,
         rent_sponsor,
@@ -61,6 +67,7 @@ pub async fn create_compressible_token_account<R: Rpc>(
         lamports_per_write,
         compress_to_account_pubkey: None,
         token_account_version,
+        compression_only,
     };
 
     let create_token_account_ix =
diff --git a/sdk-libs/token-client/src/actions/ctoken_transfer.rs b/sdk-libs/token-client/src/actions/ctoken_transfer.rs
index a6bb29bb2c..381b08da4d 100644
--- a/sdk-libs/token-client/src/actions/ctoken_transfer.rs
+++ b/sdk-libs/token-client/src/actions/ctoken_transfer.rs
@@ -5,6 +5,8 @@ use solana_pubkey::Pubkey;
 use solana_signature::Signature;
 use solana_signer::Signer;
 
+const SYSTEM_PROGRAM_ID: [u8; 32] = [0u8; 32];
+
 /// Transfer from one c-token account to another.
 ///
 /// # Arguments
@@ -60,8 +62,8 @@ pub fn create_transfer_ctoken_instruction(
         accounts: vec![
             AccountMeta::new(source, false),      // Source token account
             AccountMeta::new(destination, false), // Destination token account
-            AccountMeta::new(authority, true),
-            AccountMeta::new_readonly(Pubkey::default(), false),
+            AccountMeta::new(authority, true), // Authority must be writable for potential top-ups
+            AccountMeta::new_readonly(Pubkey::from(SYSTEM_PROGRAM_ID), false), // System program for rent top-ups
         ],
         data: {
             // CTokenTransfer discriminator
diff --git a/sdk-libs/token-client/src/actions/mod.rs b/sdk-libs/token-client/src/actions/mod.rs
index d343e691e3..9578a66cc6 100644
--- a/sdk-libs/token-client/src/actions/mod.rs
+++ b/sdk-libs/token-client/src/actions/mod.rs
@@ -3,11 +3,14 @@ mod create_mint;
 mod ctoken_transfer;
 mod mint_action;
 mod mint_to_compressed;
+mod spl_interface;
 pub mod transfer2;
+mod update_compressed_mint;
+
 pub use create_compressible_token_account::*;
 pub use create_mint::*;
 pub use ctoken_transfer::*;
 pub use mint_action::*;
 pub use mint_to_compressed::*;
-mod update_compressed_mint;
+pub use spl_interface::*;
 pub use update_compressed_mint::*;
diff --git a/sdk-libs/token-client/src/actions/spl_interface.rs b/sdk-libs/token-client/src/actions/spl_interface.rs
new file mode 100644
index 0000000000..a24ec1b7cf
--- /dev/null
+++ b/sdk-libs/token-client/src/actions/spl_interface.rs
@@ -0,0 +1,95 @@
+//! SPL interface PDA actions for Light Protocol.
+//!
+//! This module provides actions for working with SPL interface PDAs (token pools).
+
+use light_client::rpc::{Rpc, RpcError};
+use light_ctoken_interface::has_restricted_extensions;
+use light_ctoken_sdk::spl_interface::{find_spl_interface_pda, CreateSplInterfacePda};
+use solana_keypair::Keypair;
+use solana_pubkey::Pubkey;
+use solana_signature::Signature;
+use solana_signer::Signer;
+
+/// Check if a mint has restricted extensions that require a restricted pool derivation.
+///
+/// Restricted extensions include: Pausable, PermanentDelegate, TransferFeeConfig, TransferHook.
+/// These extensions require using a different pool PDA derivation path.
+///
+/// # Arguments
+/// * `rpc` - RPC client
+/// * `mint` - The mint public key to check
+///
+/// # Returns
+/// * `Ok(true)` if the mint is a Token-2022 mint with restricted extensions
+/// * `Ok(false)` if the mint is not Token-2022 or has no restricted extensions
+/// * `Err` if the mint account could not be fetched
+pub async fn is_mint_restricted<R: Rpc>(rpc: &mut R, mint: &Pubkey) -> Result<bool, RpcError> {
+    let mint_account = rpc
+        .get_account(*mint)
+        .await?
+        .ok_or_else(|| RpcError::CustomError("Mint account not found".to_string()))?;
+
+    // Return early if not a Token-2022 mint
+    if mint_account.owner != spl_token_2022::ID {
+        return Ok(false);
+    }
+
+    Ok(has_restricted_extensions(&mint_account.data))
+}
+
+/// Create an SPL interface PDA (token pool) for a mint.
+///
+/// This action automatically determines if the mint has restricted extensions
+/// and uses the appropriate pool derivation path.
+///
+/// # Arguments
+/// * `rpc` - RPC client
+/// * `mint` - The mint public key
+/// * `payer` - Transaction fee payer keypair
+///
+/// # Returns
+/// * `Ok(Signature)` - The transaction signature
+/// * `Err` - If the transaction failed
+pub async fn create_spl_interface_pda<R: Rpc>(
+    rpc: &mut R,
+    mint: Pubkey,
+    payer: &Keypair,
+) -> Result<Signature, RpcError> {
+    let mint_account = rpc
+        .get_account(mint)
+        .await?
+        .ok_or_else(|| RpcError::CustomError("Mint account not found".to_string()))?;
+
+    let token_program = mint_account.owner;
+
+    // Check if restricted - only for Token-2022 mints
+    let restricted = if token_program == spl_token_2022::ID {
+        has_restricted_extensions(&mint_account.data)
+    } else {
+        false
+    };
+
+    let ix =
+        CreateSplInterfacePda::new(payer.pubkey(), mint, token_program, restricted).instruction();
+
+    rpc.create_and_send_transaction(&[ix], &payer.pubkey(), &[payer])
+        .await
+}
+
+/// Get the SPL interface PDA address for a mint, automatically detecting if restricted.
+///
+/// # Arguments
+/// * `rpc` - RPC client
+/// * `mint` - The mint public key
+///
+/// # Returns
+/// * `Ok((Pubkey, u8, bool))` - The PDA address, bump, and whether it's restricted
+/// * `Err` - If the mint account could not be fetched
+pub async fn get_spl_interface_pda_for_mint<R: Rpc>(
+    rpc: &mut R,
+    mint: &Pubkey,
+) -> Result<(Pubkey, u8, bool), RpcError> {
+    let restricted = is_mint_restricted(rpc, mint).await?;
+    let (pda, bump) = find_spl_interface_pda(mint, restricted);
+    Ok((pda, bump, restricted))
+}
diff --git a/sdk-libs/token-client/src/actions/transfer2/compress.rs b/sdk-libs/token-client/src/actions/transfer2/compress.rs
index 6c45066358..e64555db46 100644
--- a/sdk-libs/token-client/src/actions/transfer2/compress.rs
+++ b/sdk-libs/token-client/src/actions/transfer2/compress.rs
@@ -22,6 +22,7 @@ use crate::instructions::transfer2::{
 /// * `to` - Recipient pubkey for the compressed tokens
 /// * `authority` - Authority that can spend from the token account
 /// * `payer` - Transaction fee payer
+/// * `decimals` - Mint decimals for SPL transfer_checked
 ///
 /// # Returns
 /// `Result<Instruction, CTokenSdkError>` - The compression instruction
@@ -32,6 +33,7 @@ pub async fn compress<R: Rpc + Indexer>(
     to: Pubkey,
     authority: &Keypair,
     payer: &Keypair,
+    decimals: u8,
 ) -> Result<Signature, RpcError> {
     // Get mint from token account
     let token_account_info = rpc
@@ -57,6 +59,7 @@ pub async fn compress<R: Rpc + Indexer>(
             authority: authority.pubkey(),
             output_queue,
             pool_index: None,
+            decimals,
         })],
         payer.pubkey(),
         false,
diff --git a/sdk-libs/token-client/src/actions/transfer2/ctoken_to_spl.rs b/sdk-libs/token-client/src/actions/transfer2/ctoken_to_spl.rs
index b26822347e..99222b3613 100644
--- a/sdk-libs/token-client/src/actions/transfer2/ctoken_to_spl.rs
+++ b/sdk-libs/token-client/src/actions/transfer2/ctoken_to_spl.rs
@@ -4,7 +4,7 @@ use light_client::{
 };
 use light_ctoken_sdk::{
     constants::SPL_TOKEN_PROGRAM_ID, ctoken::TransferCTokenToSpl,
-    spl_interface::find_spl_interface_pda_with_index,
+    spl_interface::find_spl_interface_pda,
 };
 use solana_keypair::Keypair;
 use solana_pubkey::Pubkey;
@@ -12,6 +12,7 @@ use solana_signature::Signature;
 use solana_signer::Signer;
 
 /// Transfer tokens from a compressed token account to an SPL token account
+#[allow(clippy::too_many_arguments)]
 pub async fn transfer_ctoken_to_spl<R: Rpc + Indexer>(
     rpc: &mut R,
     source_ctoken_account: Pubkey,
@@ -20,8 +21,9 @@ pub async fn transfer_ctoken_to_spl<R: Rpc + Indexer>(
     authority: &Keypair,
     mint: Pubkey,
     payer: &Keypair,
+    decimals: u8,
 ) -> Result<Signature, RpcError> {
-    let (spl_interface_pda, spl_interface_pda_bump) = find_spl_interface_pda_with_index(&mint, 0);
+    let (spl_interface_pda, spl_interface_pda_bump) = find_spl_interface_pda(&mint, false);
 
     let transfer_ix = TransferCTokenToSpl {
         source_ctoken_account,
@@ -33,6 +35,7 @@ pub async fn transfer_ctoken_to_spl<R: Rpc + Indexer>(
         spl_interface_pda,
         spl_interface_pda_bump,
         spl_token_program: SPL_TOKEN_PROGRAM_ID, // TODO: make dynamic
+        decimals,
     }
     .instruction()
     .map_err(|e| RpcError::AssertRpcError(format!("Failed to create instruction: {:?}", e)))?;
diff --git a/sdk-libs/token-client/src/actions/transfer2/decompress.rs b/sdk-libs/token-client/src/actions/transfer2/decompress.rs
index 91ad01bc73..daf2503f8a 100644
--- a/sdk-libs/token-client/src/actions/transfer2/decompress.rs
+++ b/sdk-libs/token-client/src/actions/transfer2/decompress.rs
@@ -30,6 +30,7 @@ pub async fn decompress<R: Rpc + Indexer>(
     solana_token_account: Pubkey,
     authority: &Keypair,
     payer: &Keypair,
+    decimals: u8,
 ) -> Result<Signature, RpcError> {
     let ix = create_generic_transfer2_instruction(
         rpc,
@@ -39,6 +40,8 @@ pub async fn decompress<R: Rpc + Indexer>(
             solana_token_account,
             amount: decompress_amount,
             pool_index: None,
+            decimals,
+            in_tlv: None,
         })],
         payer.pubkey(),
         false,
diff --git a/sdk-libs/token-client/src/actions/transfer2/spl_to_ctoken.rs b/sdk-libs/token-client/src/actions/transfer2/spl_to_ctoken.rs
index 62cd551bd5..f78665398a 100644
--- a/sdk-libs/token-client/src/actions/transfer2/spl_to_ctoken.rs
+++ b/sdk-libs/token-client/src/actions/transfer2/spl_to_ctoken.rs
@@ -4,7 +4,7 @@ use light_client::{
 };
 use light_ctoken_sdk::{
     constants::SPL_TOKEN_PROGRAM_ID, ctoken::TransferSplToCtoken,
-    spl_interface::find_spl_interface_pda_with_index,
+    spl_interface::find_spl_interface_pda,
 };
 use solana_keypair::Keypair;
 use solana_pubkey::Pubkey;
@@ -21,6 +21,7 @@ pub async fn spl_to_ctoken_transfer<R: Rpc + Indexer>(
     amount: u64,
     authority: &Keypair,
     payer: &Keypair,
+    decimals: u8,
 ) -> Result<Signature, RpcError> {
     let token_account_info = rpc
         .get_account(source_spl_token_account)
@@ -32,7 +33,7 @@ pub async fn spl_to_ctoken_transfer<R: Rpc + Indexer>(
 
     let mint = pod_account.mint;
 
-    let (spl_interface_pda, spl_interface_pda_bump) = find_spl_interface_pda_with_index(&mint, 0);
+    let (spl_interface_pda, spl_interface_pda_bump) = find_spl_interface_pda(&mint, false);
 
     let ix = TransferSplToCtoken {
         amount,
@@ -44,6 +45,7 @@ pub async fn spl_to_ctoken_transfer<R: Rpc + Indexer>(
         payer: payer.pubkey(),
         spl_interface_pda,
         spl_token_program: SPL_TOKEN_PROGRAM_ID, // TODO: make dynamic
+        decimals,
     }
     .instruction()
     .map_err(|e| RpcError::CustomError(e.to_string()))?;
diff --git a/sdk-libs/token-client/src/instructions/transfer2.rs b/sdk-libs/token-client/src/instructions/transfer2.rs
index 64622564e7..c4b4d171d5 100644
--- a/sdk-libs/token-client/src/instructions/transfer2.rs
+++ b/sdk-libs/token-client/src/instructions/transfer2.rs
@@ -3,7 +3,10 @@ use light_client::{
     rpc::Rpc,
 };
 use light_ctoken_interface::{
-    instructions::transfer2::{MultiInputTokenDataWithContext, MultiTokenTransferOutputData},
+    instructions::{
+        extensions::ExtensionInstructionData,
+        transfer2::{MultiInputTokenDataWithContext, MultiTokenTransferOutputData},
+    },
     state::TokenDataVersion,
     CTOKEN_PROGRAM_ID,
 };
@@ -72,6 +75,7 @@ pub async fn create_decompress_instruction<R: Rpc + Indexer>(
     decompress_amount: u64,
     solana_token_account: Pubkey,
     payer: Pubkey,
+    decimals: u8,
 ) -> Result<Instruction, CTokenSdkError> {
     create_generic_transfer2_instruction(
         rpc,
@@ -81,6 +85,8 @@ pub async fn create_decompress_instruction<R: Rpc + Indexer>(
             solana_token_account,
             amount: decompress_amount,
             pool_index: None,
+            decimals,
+            in_tlv: None,
         })],
         payer,
         false,
@@ -104,6 +110,9 @@ pub struct DecompressInput {
     pub solana_token_account: Pubkey,
     pub amount: u64,
     pub pool_index: Option<u8>, // For SPL only. None = default (0), Some(n) = specific pool
+    pub decimals: u8,           // Mint decimals for SPL transfer_checked
+    /// TLV extensions for each input compressed account (required for version 3 accounts with extensions).
+    pub in_tlv: Option<Vec<Vec<ExtensionInstructionData>>>,
 }
 
 #[derive(Debug, Clone, PartialEq)]
@@ -116,6 +125,7 @@ pub struct CompressInput {
     pub authority: Pubkey,
     pub output_queue: Pubkey,
     pub pool_index: Option<u8>, // For SPL only. None = default (0), Some(n) = specific pool
+    pub decimals: u8,           // Mint decimals for SPL transfer_checked
 }
 
 #[derive(Debug, Clone, PartialEq)]
@@ -214,6 +224,8 @@ pub async fn create_generic_transfer2_instruction<R: Rpc + Indexer>(
     let mut in_lamports = Vec::new();
     let mut out_lamports = Vec::new();
     let mut token_accounts = Vec::new();
+    let mut collected_in_tlv: Vec<Vec<ExtensionInstructionData>> = Vec::new();
+    let mut has_any_tlv = false;
     for action in actions {
         match action {
             Transfer2InstructionType::Compress(input) => {
@@ -278,7 +290,7 @@ pub async fn create_generic_transfer2_instruction<R: Rpc + Indexer>(
                     // Use pool_index from input, default to 0
                     let pool_index = input.pool_index.unwrap_or(0);
                     let (spl_interface_pda, bump) =
-                        find_spl_interface_pda_with_index(&mint, pool_index);
+                        find_spl_interface_pda_with_index(&mint, pool_index, false);
                     let pool_account_index = packed_tree_accounts.insert_or_get(spl_interface_pda);
 
                     // Use the new SPL-specific compress method
@@ -289,6 +301,7 @@ pub async fn create_generic_transfer2_instruction<R: Rpc + Indexer>(
                         pool_account_index,
                         pool_index,
                         bump,
+                        input.decimals,
                     )?;
                 } else {
                     // Regular compression for compressed token accounts
@@ -297,6 +310,17 @@ pub async fn create_generic_transfer2_instruction<R: Rpc + Indexer>(
                 token_accounts.push(token_account);
             }
             Transfer2InstructionType::Decompress(input) => {
+                // Collect in_tlv data if provided
+                if let Some(ref tlv_data) = input.in_tlv {
+                    has_any_tlv = true;
+                    collected_in_tlv.extend(tlv_data.iter().cloned());
+                } else {
+                    // Add empty TLV entries for each input (needed for proper indexing)
+                    for _ in 0..input.compressed_token_account.len() {
+                        collected_in_tlv.push(Vec::new());
+                    }
+                }
+
                 let token_data = input
                     .compressed_token_account
                     .iter()
@@ -345,7 +369,7 @@ pub async fn create_generic_transfer2_instruction<R: Rpc + Indexer>(
                     // Use pool_index from input, default to 0
                     let pool_index = input.pool_index.unwrap_or(0);
                     let (spl_interface_pda, bump) =
-                        find_spl_interface_pda_with_index(&mint, pool_index);
+                        find_spl_interface_pda_with_index(&mint, pool_index, false);
                     let pool_account_index = packed_tree_accounts.insert_or_get(spl_interface_pda);
 
                     // Use the new SPL-specific decompress method
@@ -355,6 +379,7 @@ pub async fn create_generic_transfer2_instruction<R: Rpc + Indexer>(
                         pool_account_index,
                         pool_index,
                         bump,
+                        input.decimals,
                     )?;
                 } else {
                     // Use the new SPL-specific decompress method
@@ -504,45 +529,19 @@ pub async fn create_generic_transfer2_instruction<R: Rpc + Indexer>(
                     .ok_or(CTokenSdkError::InvalidAccountData)?;
 
                 // Parse the compressed token account using zero-copy deserialization
-                use light_ctoken_interface::state::{CToken, ZExtensionStruct};
+                use light_ctoken_interface::state::CToken;
                 use light_zero_copy::traits::ZeroCopyAt;
                 let (compressed_token, _) = CToken::zero_copy_at(&token_account_info.data)
                     .map_err(|_| CTokenSdkError::InvalidAccountData)?;
                 let mint = compressed_token.mint;
-                let balance = compressed_token.amount;
+                let balance: u64 = compressed_token.amount.into();
                 let owner = compressed_token.owner;
 
-                // Extract rent_sponsor, compression_authority, and compress_to_pubkey from compressible extension
-                // For non-compressible accounts, use the owner as the rent_sponsor
-                let (rent_sponsor, _compression_authority, compress_to_pubkey) = if input
-                    .is_compressible
-                {
-                    if let Some(extensions) = compressed_token.extensions.as_ref() {
-                        let mut found_rent_sponsor = None;
-                        let mut found_compression_authority = None;
-                        let mut found_compress_to_pubkey = false;
-                        for extension in extensions {
-                            if let ZExtensionStruct::Compressible(compressible_ext) = extension {
-                                found_rent_sponsor = Some(compressible_ext.info.rent_sponsor);
-                                found_compression_authority =
-                                    Some(compressible_ext.info.compression_authority);
-                                found_compress_to_pubkey =
-                                    compressible_ext.info.compress_to_pubkey == 1;
-                                break;
-                            }
-                        }
-                        (
-                            found_rent_sponsor.ok_or(CTokenSdkError::InvalidAccountData)?,
-                            found_compression_authority,
-                            found_compress_to_pubkey,
-                        )
-                    } else {
-                        return Err(CTokenSdkError::InvalidAccountData);
-                    }
-                } else {
-                    // Non-compressible account: use owner as rent_sponsor
-                    (owner.to_bytes(), None, false)
-                };
+                // Extract rent_sponsor, compression_authority, and compress_to_pubkey from compression info
+                let compression = &compressed_token.base.compression;
+                let rent_sponsor = compression.rent_sponsor;
+                let _compression_authority = compression.compression_authority;
+                let compress_to_pubkey = compression.compress_to_pubkey == 1;
 
                 // Add source account first (it's being closed, so needs to be writable)
                 let source_index = packed_tree_accounts.insert_or_get(input.solana_ctoken_account);
@@ -579,7 +578,7 @@ pub async fn create_generic_transfer2_instruction<R: Rpc + Indexer>(
                     .unwrap_or(authority_index); // Default to authority if no destination specified
 
                 token_account.compress_and_close(
-                    (*balance).into(),
+                    balance,
                     source_index,
                     authority_index,
                     rent_sponsor_index,         // Use the extracted rent_sponsor
@@ -621,6 +620,11 @@ pub async fn create_generic_transfer2_instruction<R: Rpc + Indexer>(
         },
         token_accounts,
         output_queue: shared_output_queue,
+        in_tlv: if has_any_tlv {
+            Some(collected_in_tlv)
+        } else {
+            None
+        },
     };
     create_transfer2_instruction(inputs)
 }
diff --git a/sdk-tests/sdk-compressible-test/src/instructions/decompress_accounts_idempotent.rs b/sdk-tests/sdk-compressible-test/src/instructions/decompress_accounts_idempotent.rs
index 258b212013..bb9648654a 100644
--- a/sdk-tests/sdk-compressible-test/src/instructions/decompress_accounts_idempotent.rs
+++ b/sdk-tests/sdk-compressible-test/src/instructions/decompress_accounts_idempotent.rs
@@ -217,7 +217,7 @@ pub fn decompress_accounts_idempotent<'info>(
                     .cloned()
                     .collect();
                 let compress_to_pubkey =
-                    light_ctoken_interface::instructions::extensions::compressible::CompressToPubkey {
+                    light_ctoken_interface::instructions::create_ctoken_account::CompressToPubkey {
                         bump,
                         program_id: crate::ID.to_bytes(),
                         seeds: seeds_without_bump,
@@ -228,7 +228,7 @@ pub fn decompress_accounts_idempotent<'info>(
                     account: owner_info.clone(),
                     mint: mint_info.clone(),
                     owner: *authority.clone().to_account_info().key,
-                    compressible: Some(CompressibleParamsCpi {
+                    compressible: CompressibleParamsCpi {
                         compressible_config: ctoken_config.to_account_info(),
                         rent_sponsor: ctoken_rent_sponsor.clone().to_account_info(),
                         system_program: accounts.system_program.to_account_info(),
@@ -237,7 +237,8 @@ pub fn decompress_accounts_idempotent<'info>(
                         compress_to_account_pubkey: Some(compress_to_pubkey),
                         token_account_version:
                             light_ctoken_interface::state::TokenDataVersion::ShaFlat,
-                    }),
+                        compression_only: false,
+                    },
                 }
                 .invoke_signed(&[seeds_slice])?;
             }
@@ -258,6 +259,7 @@ pub fn decompress_accounts_idempotent<'info>(
                 light_ctoken_sdk::compressed_token::decompress_full::DecompressFullIndices {
                     source,
                     destination_index: owner_index,
+                    tlv: None,
                 };
             token_decompress_indices.push(decompress_index);
             token_signers_seed_groups.push(ctoken_signer_seeds);
diff --git a/sdk-tests/sdk-ctoken-test/Cargo.toml b/sdk-tests/sdk-ctoken-test/Cargo.toml
index 3f7c7d567b..71f40e4adc 100644
--- a/sdk-tests/sdk-ctoken-test/Cargo.toml
+++ b/sdk-tests/sdk-ctoken-test/Cargo.toml
@@ -37,6 +37,7 @@ solana-sdk = { version = "2.2", optional = true }
 [dev-dependencies]
 light-program-test = { workspace = true, features = ["devenv"] }
 light-client = { workspace = true }
+light-compressible = { workspace = true }
 light-compressible-client = { workspace = true }
 light-compressed-account = { workspace = true }
 light-test-utils = { workspace = true, features = ["devenv"] }
diff --git a/sdk-tests/sdk-ctoken-test/src/approve.rs b/sdk-tests/sdk-ctoken-test/src/approve.rs
new file mode 100644
index 0000000000..fa0c875155
--- /dev/null
+++ b/sdk-tests/sdk-ctoken-test/src/approve.rs
@@ -0,0 +1,76 @@
+use borsh::{BorshDeserialize, BorshSerialize};
+use light_ctoken_sdk::ctoken::ApproveCTokenCpi;
+use solana_program::{account_info::AccountInfo, program_error::ProgramError, pubkey::Pubkey};
+
+use crate::{ID, TOKEN_ACCOUNT_SEED};
+
+/// Instruction data for approve operations
+#[derive(BorshSerialize, BorshDeserialize)]
+pub struct ApproveData {
+    pub amount: u64,
+}
+
+/// Handler for approving a delegate for a CToken account (invoke)
+///
+/// Account order:
+/// - accounts[0]: token_account (writable)
+/// - accounts[1]: delegate
+/// - accounts[2]: owner (signer)
+/// - accounts[3]: system_program
+/// - accounts[4]: ctoken_program
+pub fn process_approve_invoke(
+    accounts: &[AccountInfo],
+    data: ApproveData,
+) -> Result<(), ProgramError> {
+    if accounts.len() < 5 {
+        return Err(ProgramError::NotEnoughAccountKeys);
+    }
+
+    ApproveCTokenCpi {
+        token_account: accounts[0].clone(),
+        delegate: accounts[1].clone(),
+        owner: accounts[2].clone(),
+        system_program: accounts[3].clone(),
+        amount: data.amount,
+    }
+    .invoke()?;
+
+    Ok(())
+}
+
+/// Handler for approving a delegate for a PDA-owned CToken account (invoke_signed)
+///
+/// Account order:
+/// - accounts[0]: token_account (writable)
+/// - accounts[1]: delegate
+/// - accounts[2]: PDA owner (program signs)
+/// - accounts[3]: system_program
+/// - accounts[4]: ctoken_program
+pub fn process_approve_invoke_signed(
+    accounts: &[AccountInfo],
+    data: ApproveData,
+) -> Result<(), ProgramError> {
+    if accounts.len() < 5 {
+        return Err(ProgramError::NotEnoughAccountKeys);
+    }
+
+    // Derive the PDA for the owner
+    let (pda, bump) = Pubkey::find_program_address(&[TOKEN_ACCOUNT_SEED], &ID);
+
+    // Verify the owner account is the PDA we expect
+    if &pda != accounts[2].key {
+        return Err(ProgramError::InvalidSeeds);
+    }
+
+    let signer_seeds: &[&[u8]] = &[TOKEN_ACCOUNT_SEED, &[bump]];
+    ApproveCTokenCpi {
+        token_account: accounts[0].clone(),
+        delegate: accounts[1].clone(),
+        owner: accounts[2].clone(),
+        system_program: accounts[3].clone(),
+        amount: data.amount,
+    }
+    .invoke_signed(&[signer_seeds])?;
+
+    Ok(())
+}
diff --git a/sdk-tests/sdk-ctoken-test/src/burn.rs b/sdk-tests/sdk-ctoken-test/src/burn.rs
new file mode 100644
index 0000000000..8f223054ec
--- /dev/null
+++ b/sdk-tests/sdk-ctoken-test/src/burn.rs
@@ -0,0 +1,71 @@
+use borsh::{BorshDeserialize, BorshSerialize};
+use light_ctoken_sdk::ctoken::BurnCTokenCpi;
+use solana_program::{account_info::AccountInfo, program_error::ProgramError, pubkey::Pubkey};
+
+use crate::{ID, TOKEN_ACCOUNT_SEED};
+
+/// Instruction data for burn operations
+#[derive(BorshSerialize, BorshDeserialize)]
+pub struct BurnData {
+    pub amount: u64,
+}
+
+/// Handler for burning CTokens (invoke)
+///
+/// Account order:
+/// - accounts[0]: source (CToken account, writable)
+/// - accounts[1]: cmint (writable)
+/// - accounts[2]: authority (owner, signer)
+/// - accounts[3]: ctoken_program
+pub fn process_burn_invoke(accounts: &[AccountInfo], amount: u64) -> Result<(), ProgramError> {
+    if accounts.len() < 4 {
+        return Err(ProgramError::NotEnoughAccountKeys);
+    }
+
+    BurnCTokenCpi {
+        source: accounts[0].clone(),
+        cmint: accounts[1].clone(),
+        amount,
+        authority: accounts[2].clone(),
+        max_top_up: None,
+    }
+    .invoke()?;
+
+    Ok(())
+}
+
+/// Handler for burning CTokens with PDA authority (invoke_signed)
+///
+/// Account order:
+/// - accounts[0]: source (CToken account, writable)
+/// - accounts[1]: cmint (writable)
+/// - accounts[2]: PDA authority (owner, program signs)
+/// - accounts[3]: ctoken_program
+pub fn process_burn_invoke_signed(
+    accounts: &[AccountInfo],
+    amount: u64,
+) -> Result<(), ProgramError> {
+    if accounts.len() < 4 {
+        return Err(ProgramError::NotEnoughAccountKeys);
+    }
+
+    // Derive the PDA for the token account owner
+    let (pda, bump) = Pubkey::find_program_address(&[TOKEN_ACCOUNT_SEED], &ID);
+
+    // Verify the authority account is the PDA we expect
+    if &pda != accounts[2].key {
+        return Err(ProgramError::InvalidSeeds);
+    }
+
+    let signer_seeds: &[&[u8]] = &[TOKEN_ACCOUNT_SEED, &[bump]];
+    BurnCTokenCpi {
+        source: accounts[0].clone(),
+        cmint: accounts[1].clone(),
+        amount,
+        authority: accounts[2].clone(),
+        max_top_up: None,
+    }
+    .invoke_signed(&[signer_seeds])?;
+
+    Ok(())
+}
diff --git a/sdk-tests/sdk-ctoken-test/src/close.rs b/sdk-tests/sdk-ctoken-test/src/close.rs
index 33b4d9cd0c..6fc9889508 100644
--- a/sdk-tests/sdk-ctoken-test/src/close.rs
+++ b/sdk-tests/sdk-ctoken-test/src/close.rs
@@ -10,24 +10,18 @@ use crate::{ID, TOKEN_ACCOUNT_SEED};
 /// - accounts[1]: account to close (writable)
 /// - accounts[2]: destination for lamports (writable)
 /// - accounts[3]: owner/authority (signer)
-/// - accounts[4]: rent_sponsor (optional, writable)
+/// - accounts[4]: rent_sponsor (writable)
 pub fn process_close_account_invoke(accounts: &[AccountInfo]) -> Result<(), ProgramError> {
-    if accounts.len() < 4 {
+    if accounts.len() < 5 {
         return Err(ProgramError::NotEnoughAccountKeys);
     }
 
-    let rent_sponsor = if accounts.len() > 4 {
-        Some(accounts[4].clone())
-    } else {
-        None
-    };
-
     CloseCTokenAccountCpi {
         token_program: accounts[0].clone(),
         account: accounts[1].clone(),
         destination: accounts[2].clone(),
         owner: accounts[3].clone(),
-        rent_sponsor,
+        rent_sponsor: accounts[4].clone(),
     }
     .invoke()?;
 
@@ -41,9 +35,9 @@ pub fn process_close_account_invoke(accounts: &[AccountInfo]) -> Result<(), Prog
 /// - accounts[1]: account to close (writable)
 /// - accounts[2]: destination for lamports (writable)
 /// - accounts[3]: PDA owner/authority (not signer, program signs)
-/// - accounts[4]: rent_sponsor (optional, writable)
+/// - accounts[4]: rent_sponsor (writable)
 pub fn process_close_account_invoke_signed(accounts: &[AccountInfo]) -> Result<(), ProgramError> {
-    if accounts.len() < 4 {
+    if accounts.len() < 5 {
         return Err(ProgramError::NotEnoughAccountKeys);
     }
 
@@ -55,19 +49,13 @@ pub fn process_close_account_invoke_signed(accounts: &[AccountInfo]) -> Result<(
         return Err(ProgramError::InvalidSeeds);
     }
 
-    let rent_sponsor = if accounts.len() > 4 {
-        Some(accounts[4].clone())
-    } else {
-        None
-    };
-
     let signer_seeds: &[&[u8]] = &[TOKEN_ACCOUNT_SEED, &[bump]];
     CloseCTokenAccountCpi {
         token_program: accounts[0].clone(),
         account: accounts[1].clone(),
         destination: accounts[2].clone(),
         owner: accounts[3].clone(),
-        rent_sponsor,
+        rent_sponsor: accounts[4].clone(),
     }
     .invoke_signed(&[signer_seeds])?;
 
diff --git a/sdk-tests/sdk-ctoken-test/src/create_ata.rs b/sdk-tests/sdk-ctoken-test/src/create_ata.rs
index c1aee227b7..5d63f48798 100644
--- a/sdk-tests/sdk-ctoken-test/src/create_ata.rs
+++ b/sdk-tests/sdk-ctoken-test/src/create_ata.rs
@@ -45,7 +45,7 @@ pub fn process_create_ata_invoke(
         associated_token_account: accounts[3].clone(),
         system_program: accounts[4].clone(),
         bump: data.bump,
-        compressible: Some(compressible_params),
+        compressible: compressible_params,
         idempotent: false,
     }
     .invoke()?;
@@ -94,7 +94,7 @@ pub fn process_create_ata_invoke_signed(
         associated_token_account: accounts[3].clone(),
         system_program: accounts[4].clone(),
         bump: data.bump,
-        compressible: Some(compressible_params),
+        compressible: compressible_params,
         idempotent: false,
     };
 
diff --git a/sdk-tests/sdk-ctoken-test/src/create_ata2.rs b/sdk-tests/sdk-ctoken-test/src/create_ata2.rs
deleted file mode 100644
index 4c599bee4c..0000000000
--- a/sdk-tests/sdk-ctoken-test/src/create_ata2.rs
+++ /dev/null
@@ -1,100 +0,0 @@
-use borsh::{BorshDeserialize, BorshSerialize};
-use light_ctoken_sdk::ctoken::{CompressibleParamsCpi, CreateAssociatedCTokenAccountCpi};
-use solana_program::{account_info::AccountInfo, program_error::ProgramError, pubkey::Pubkey};
-
-use crate::{ATA_SEED, ID};
-
-/// Instruction data for create ATA V2 (owner/mint as accounts)
-#[derive(BorshSerialize, BorshDeserialize, Debug)]
-pub struct CreateAta2Data {
-    pub bump: u8,
-    pub pre_pay_num_epochs: u8,
-    pub lamports_per_write: u32,
-}
-
-/// Handler for creating ATA using V2 variant (invoke)
-///
-/// Account order:
-/// - accounts[0]: owner (readonly)
-/// - accounts[1]: mint (readonly)
-/// - accounts[2]: payer (signer, writable)
-/// - accounts[3]: associated_token_account (writable)
-/// - accounts[4]: system_program
-/// - accounts[5]: compressible_config
-/// - accounts[6]: rent_sponsor (writable)
-pub fn process_create_ata2_invoke(
-    accounts: &[AccountInfo],
-    data: CreateAta2Data,
-) -> Result<(), ProgramError> {
-    if accounts.len() < 7 {
-        return Err(ProgramError::NotEnoughAccountKeys);
-    }
-
-    let compressible_params = CompressibleParamsCpi::new(
-        accounts[5].clone(),
-        accounts[6].clone(),
-        accounts[4].clone(),
-    );
-
-    CreateAssociatedCTokenAccountCpi {
-        owner: accounts[0].clone(),
-        mint: accounts[1].clone(),
-        payer: accounts[2].clone(),
-        associated_token_account: accounts[3].clone(),
-        system_program: accounts[4].clone(),
-        bump: data.bump,
-        compressible: Some(compressible_params),
-        idempotent: false,
-    }
-    .invoke()?;
-
-    Ok(())
-}
-
-/// Handler for creating ATA using V2 variant with PDA ownership (invoke_signed)
-///
-/// Account order:
-/// - accounts[0]: owner (PDA, readonly)
-/// - accounts[1]: mint (readonly)
-/// - accounts[2]: payer (PDA, writable, not signer - program signs)
-/// - accounts[3]: associated_token_account (writable)
-/// - accounts[4]: system_program
-/// - accounts[5]: compressible_config
-/// - accounts[6]: rent_sponsor (writable)
-pub fn process_create_ata2_invoke_signed(
-    accounts: &[AccountInfo],
-    data: CreateAta2Data,
-) -> Result<(), ProgramError> {
-    if accounts.len() < 7 {
-        return Err(ProgramError::NotEnoughAccountKeys);
-    }
-
-    // Derive the PDA that will act as payer
-    let (pda, bump) = Pubkey::find_program_address(&[ATA_SEED], &ID);
-
-    // Verify the payer is the PDA
-    if &pda != accounts[2].key {
-        return Err(ProgramError::InvalidSeeds);
-    }
-
-    let compressible_params = CompressibleParamsCpi::new(
-        accounts[5].clone(),
-        accounts[6].clone(),
-        accounts[4].clone(),
-    );
-
-    let signer_seeds: &[&[u8]] = &[ATA_SEED, &[bump]];
-    CreateAssociatedCTokenAccountCpi {
-        owner: accounts[0].clone(),
-        mint: accounts[1].clone(),
-        payer: accounts[2].clone(), // PDA
-        associated_token_account: accounts[3].clone(),
-        system_program: accounts[4].clone(),
-        bump: data.bump,
-        compressible: Some(compressible_params),
-        idempotent: false,
-    }
-    .invoke_signed(&[signer_seeds])?;
-
-    Ok(())
-}
diff --git a/sdk-tests/sdk-ctoken-test/src/create_token_account.rs b/sdk-tests/sdk-ctoken-test/src/create_token_account.rs
index b0e2231f22..14803a89bc 100644
--- a/sdk-tests/sdk-ctoken-test/src/create_token_account.rs
+++ b/sdk-tests/sdk-ctoken-test/src/create_token_account.rs
@@ -46,7 +46,7 @@ pub fn process_create_token_account_invoke(
         account: accounts[1].clone(),
         mint: accounts[2].clone(),
         owner: data.owner,
-        compressible: Some(compressible_params),
+        compressible: compressible_params,
     }
     .invoke()?;
 
@@ -91,7 +91,7 @@ pub fn process_create_token_account_invoke_signed(
         account: accounts[1].clone(),
         mint: accounts[2].clone(),
         owner: data.owner,
-        compressible: Some(compressible_params),
+        compressible: compressible_params,
     };
 
     // Invoke with PDA signing
diff --git a/sdk-tests/sdk-ctoken-test/src/ctoken_mint_to.rs b/sdk-tests/sdk-ctoken-test/src/ctoken_mint_to.rs
new file mode 100644
index 0000000000..181246baa9
--- /dev/null
+++ b/sdk-tests/sdk-ctoken-test/src/ctoken_mint_to.rs
@@ -0,0 +1,78 @@
+use borsh::{BorshDeserialize, BorshSerialize};
+use light_ctoken_sdk::ctoken::CTokenMintToCpi;
+use solana_program::{account_info::AccountInfo, program_error::ProgramError, pubkey::Pubkey};
+
+use crate::{mint_to_ctoken::MINT_AUTHORITY_SEED, ID};
+
+/// Instruction data for CTokenMintTo operations
+#[derive(BorshSerialize, BorshDeserialize)]
+pub struct MintToData {
+    pub amount: u64,
+}
+
+/// Handler for minting to CToken (invoke)
+///
+/// Account order:
+/// - accounts[0]: cmint (writable)
+/// - accounts[1]: destination (CToken account, writable)
+/// - accounts[2]: authority (mint authority, signer)
+/// - accounts[3]: system_program
+/// - accounts[4]: ctoken_program
+pub fn process_ctoken_mint_to_invoke(
+    accounts: &[AccountInfo],
+    amount: u64,
+) -> Result<(), ProgramError> {
+    if accounts.len() < 5 {
+        return Err(ProgramError::NotEnoughAccountKeys);
+    }
+
+    CTokenMintToCpi {
+        cmint: accounts[0].clone(),
+        destination: accounts[1].clone(),
+        amount,
+        authority: accounts[2].clone(),
+        system_program: accounts[3].clone(),
+        max_top_up: None,
+    }
+    .invoke()?;
+
+    Ok(())
+}
+
+/// Handler for minting to CToken with PDA authority (invoke_signed)
+///
+/// Account order:
+/// - accounts[0]: cmint (writable)
+/// - accounts[1]: destination (CToken account, writable)
+/// - accounts[2]: PDA authority (mint authority, program signs)
+/// - accounts[3]: system_program
+/// - accounts[4]: ctoken_program
+pub fn process_ctoken_mint_to_invoke_signed(
+    accounts: &[AccountInfo],
+    amount: u64,
+) -> Result<(), ProgramError> {
+    if accounts.len() < 5 {
+        return Err(ProgramError::NotEnoughAccountKeys);
+    }
+
+    // Derive the PDA for the mint authority
+    let (pda, bump) = Pubkey::find_program_address(&[MINT_AUTHORITY_SEED], &ID);
+
+    // Verify the authority account is the PDA we expect
+    if &pda != accounts[2].key {
+        return Err(ProgramError::InvalidSeeds);
+    }
+
+    let signer_seeds: &[&[u8]] = &[MINT_AUTHORITY_SEED, &[bump]];
+    CTokenMintToCpi {
+        cmint: accounts[0].clone(),
+        destination: accounts[1].clone(),
+        amount,
+        authority: accounts[2].clone(),
+        system_program: accounts[3].clone(),
+        max_top_up: None,
+    }
+    .invoke_signed(&[signer_seeds])?;
+
+    Ok(())
+}
diff --git a/sdk-tests/sdk-ctoken-test/src/decompress_cmint.rs b/sdk-tests/sdk-ctoken-test/src/decompress_cmint.rs
new file mode 100644
index 0000000000..7e30460fec
--- /dev/null
+++ b/sdk-tests/sdk-ctoken-test/src/decompress_cmint.rs
@@ -0,0 +1,82 @@
+use borsh::{BorshDeserialize, BorshSerialize};
+use light_ctoken_sdk::{
+    ctoken::{CompressedMintWithContext, DecompressCMintCpi, SystemAccountInfos},
+    ValidityProof,
+};
+use solana_program::{account_info::AccountInfo, program_error::ProgramError, pubkey::Pubkey};
+
+use crate::{mint_to_ctoken::MINT_AUTHORITY_SEED, ID};
+
+/// Instruction data for DecompressCMint operations
+#[derive(BorshSerialize, BorshDeserialize)]
+pub struct DecompressCmintData {
+    pub compressed_mint_with_context: CompressedMintWithContext,
+    pub proof: ValidityProof,
+    pub rent_payment: u8,
+    pub write_top_up: u32,
+}
+
+/// Handler for decompressing CMint with PDA authority (invoke_signed)
+///
+/// Account order:
+/// - accounts[0]: mint_seed (readonly)
+/// - accounts[1]: authority (PDA, readonly - program signs)
+/// - accounts[2]: payer (signer, writable)
+/// - accounts[3]: cmint (writable)
+/// - accounts[4]: compressible_config (readonly)
+/// - accounts[5]: rent_sponsor (writable)
+/// - accounts[6]: state_tree (writable)
+/// - accounts[7]: input_queue (writable)
+/// - accounts[8]: output_queue (writable)
+/// - accounts[9]: light_system_program (readonly)
+/// - accounts[10]: cpi_authority_pda (readonly)
+/// - accounts[11]: registered_program_pda (readonly)
+/// - accounts[12]: account_compression_authority (readonly)
+/// - accounts[13]: account_compression_program (readonly)
+/// - accounts[14]: system_program (readonly)
+pub fn process_decompress_cmint_invoke_signed(
+    accounts: &[AccountInfo],
+    data: DecompressCmintData,
+) -> Result<(), ProgramError> {
+    if accounts.len() < 15 {
+        return Err(ProgramError::NotEnoughAccountKeys);
+    }
+
+    // Derive the PDA for the mint authority
+    let (pda, bump) = Pubkey::find_program_address(&[MINT_AUTHORITY_SEED], &ID);
+
+    // Verify the authority account is the PDA we expect
+    if &pda != accounts[1].key {
+        return Err(ProgramError::InvalidSeeds);
+    }
+
+    let system_accounts = SystemAccountInfos {
+        light_system_program: accounts[9].clone(),
+        cpi_authority_pda: accounts[10].clone(),
+        registered_program_pda: accounts[11].clone(),
+        account_compression_authority: accounts[12].clone(),
+        account_compression_program: accounts[13].clone(),
+        system_program: accounts[14].clone(),
+    };
+
+    let signer_seeds: &[&[u8]] = &[MINT_AUTHORITY_SEED, &[bump]];
+    DecompressCMintCpi {
+        mint_seed: accounts[0].clone(),
+        authority: accounts[1].clone(),
+        payer: accounts[2].clone(),
+        cmint: accounts[3].clone(),
+        compressible_config: accounts[4].clone(),
+        rent_sponsor: accounts[5].clone(),
+        state_tree: accounts[6].clone(),
+        input_queue: accounts[7].clone(),
+        output_queue: accounts[8].clone(),
+        system_accounts,
+        compressed_mint_with_context: data.compressed_mint_with_context,
+        proof: data.proof,
+        rent_payment: data.rent_payment,
+        write_top_up: data.write_top_up,
+    }
+    .invoke_signed(&[signer_seeds])?;
+
+    Ok(())
+}
diff --git a/sdk-tests/sdk-ctoken-test/src/freeze.rs b/sdk-tests/sdk-ctoken-test/src/freeze.rs
new file mode 100644
index 0000000000..f65a36f17a
--- /dev/null
+++ b/sdk-tests/sdk-ctoken-test/src/freeze.rs
@@ -0,0 +1,57 @@
+use light_ctoken_sdk::ctoken::FreezeCTokenCpi;
+use solana_program::{account_info::AccountInfo, program_error::ProgramError, pubkey::Pubkey};
+
+use crate::{FREEZE_AUTHORITY_SEED, ID};
+
+/// Handler for freezing a CToken account (invoke)
+///
+/// Account order:
+/// - accounts[0]: token_account (writable)
+/// - accounts[1]: mint
+/// - accounts[2]: freeze_authority (signer)
+/// - accounts[3]: ctoken_program
+pub fn process_freeze_invoke(accounts: &[AccountInfo]) -> Result<(), ProgramError> {
+    if accounts.len() < 4 {
+        return Err(ProgramError::NotEnoughAccountKeys);
+    }
+
+    FreezeCTokenCpi {
+        token_account: accounts[0].clone(),
+        mint: accounts[1].clone(),
+        freeze_authority: accounts[2].clone(),
+    }
+    .invoke()?;
+
+    Ok(())
+}
+
+/// Handler for freezing a CToken account with PDA freeze authority (invoke_signed)
+///
+/// Account order:
+/// - accounts[0]: token_account (writable)
+/// - accounts[1]: mint
+/// - accounts[2]: PDA freeze_authority (program signs)
+/// - accounts[3]: ctoken_program
+pub fn process_freeze_invoke_signed(accounts: &[AccountInfo]) -> Result<(), ProgramError> {
+    if accounts.len() < 4 {
+        return Err(ProgramError::NotEnoughAccountKeys);
+    }
+
+    // Derive the PDA for the freeze authority
+    let (pda, bump) = Pubkey::find_program_address(&[FREEZE_AUTHORITY_SEED], &ID);
+
+    // Verify the freeze_authority account is the PDA we expect
+    if &pda != accounts[2].key {
+        return Err(ProgramError::InvalidSeeds);
+    }
+
+    let signer_seeds: &[&[u8]] = &[FREEZE_AUTHORITY_SEED, &[bump]];
+    FreezeCTokenCpi {
+        token_account: accounts[0].clone(),
+        mint: accounts[1].clone(),
+        freeze_authority: accounts[2].clone(),
+    }
+    .invoke_signed(&[signer_seeds])?;
+
+    Ok(())
+}
diff --git a/sdk-tests/sdk-ctoken-test/src/lib.rs b/sdk-tests/sdk-ctoken-test/src/lib.rs
index fd9d253c72..e23638b2cd 100644
--- a/sdk-tests/sdk-ctoken-test/src/lib.rs
+++ b/sdk-tests/sdk-ctoken-test/src/lib.rs
@@ -1,21 +1,27 @@
 #![allow(unexpected_cfgs)]
 
+mod approve;
+mod burn;
 mod close;
 mod create_ata;
-mod create_ata2;
 mod create_cmint;
 mod create_token_account;
+mod ctoken_mint_to;
+mod decompress_cmint;
+mod freeze;
 mod mint_to_ctoken;
+mod revoke;
+mod thaw;
 mod transfer;
+mod transfer_checked;
 mod transfer_interface;
 mod transfer_spl_ctoken;
 
 // Re-export all instruction data types
+pub use approve::{process_approve_invoke, process_approve_invoke_signed, ApproveData};
+pub use burn::{process_burn_invoke, process_burn_invoke_signed, BurnData};
 pub use close::{process_close_account_invoke, process_close_account_invoke_signed};
 pub use create_ata::{process_create_ata_invoke, process_create_ata_invoke_signed, CreateAtaData};
-pub use create_ata2::{
-    process_create_ata2_invoke, process_create_ata2_invoke_signed, CreateAta2Data,
-};
 pub use create_cmint::{
     process_create_cmint, process_create_cmint_invoke_signed,
     process_create_cmint_with_pda_authority, CreateCmintData, MINT_SIGNER_SEED,
@@ -24,14 +30,24 @@ pub use create_token_account::{
     process_create_token_account_invoke, process_create_token_account_invoke_signed,
     CreateTokenAccountData,
 };
+pub use ctoken_mint_to::{
+    process_ctoken_mint_to_invoke, process_ctoken_mint_to_invoke_signed, MintToData,
+};
+pub use decompress_cmint::{process_decompress_cmint_invoke_signed, DecompressCmintData};
+pub use freeze::{process_freeze_invoke, process_freeze_invoke_signed};
 pub use mint_to_ctoken::{
     process_mint_to_ctoken, process_mint_to_ctoken_invoke_signed, MintToCTokenData,
     MINT_AUTHORITY_SEED,
 };
+pub use revoke::{process_revoke_invoke, process_revoke_invoke_signed};
 use solana_program::{
     account_info::AccountInfo, entrypoint, program_error::ProgramError, pubkey, pubkey::Pubkey,
 };
+pub use thaw::{process_thaw_invoke, process_thaw_invoke_signed};
 pub use transfer::{process_transfer_invoke, process_transfer_invoke_signed, TransferData};
+pub use transfer_checked::{
+    process_transfer_checked_invoke, process_transfer_checked_invoke_signed, TransferCheckedData,
+};
 pub use transfer_interface::{
     process_transfer_interface_invoke, process_transfer_interface_invoke_signed,
     TransferInterfaceData, TRANSFER_INTERFACE_AUTHORITY_SEED,
@@ -48,6 +64,7 @@ pub const ID: Pubkey = pubkey!("CToknNtvExmp1eProgram11111111111111111111112");
 /// PDA seeds for invoke_signed instructions
 pub const TOKEN_ACCOUNT_SEED: &[u8] = b"token_account";
 pub const ATA_SEED: &[u8] = b"ata";
+pub const FREEZE_AUTHORITY_SEED: &[u8] = b"freeze_authority";
 
 entrypoint!(process_instruction);
 
@@ -97,6 +114,36 @@ pub enum InstructionType {
     TransferInterfaceInvoke = 19,
     /// Unified transfer interface with PDA authority (invoke_signed)
     TransferInterfaceInvokeSigned = 20,
+    /// Approve delegate for CToken account (invoke)
+    ApproveInvoke = 21,
+    /// Approve delegate for PDA-owned CToken account (invoke_signed)
+    ApproveInvokeSigned = 22,
+    /// Revoke delegation for CToken account (invoke)
+    RevokeInvoke = 23,
+    /// Revoke delegation for PDA-owned CToken account (invoke_signed)
+    RevokeInvokeSigned = 24,
+    /// Freeze CToken account (invoke)
+    FreezeInvoke = 25,
+    /// Freeze CToken account with PDA freeze authority (invoke_signed)
+    FreezeInvokeSigned = 26,
+    /// Thaw frozen CToken account (invoke)
+    ThawInvoke = 27,
+    /// Thaw frozen CToken account with PDA freeze authority (invoke_signed)
+    ThawInvokeSigned = 28,
+    /// Burn CTokens (invoke)
+    BurnInvoke = 29,
+    /// Burn CTokens with PDA authority (invoke_signed)
+    BurnInvokeSigned = 30,
+    /// Mint to CToken from decompressed CMint (invoke)
+    CTokenMintToInvoke = 31,
+    /// Mint to CToken from decompressed CMint with PDA authority (invoke_signed)
+    CTokenMintToInvokeSigned = 32,
+    /// Decompress CMint with PDA authority (invoke_signed)
+    DecompressCmintInvokeSigned = 33,
+    /// Transfer cTokens with checked decimals (invoke)
+    CTokenTransferCheckedInvoke = 34,
+    /// Transfer cTokens with checked decimals from PDA-owned account (invoke_signed)
+    CTokenTransferCheckedInvokeSigned = 35,
 }
 
 impl TryFrom<u8> for InstructionType {
@@ -125,6 +172,21 @@ impl TryFrom<u8> for InstructionType {
             18 => Ok(InstructionType::CtokenToSplInvokeSigned),
             19 => Ok(InstructionType::TransferInterfaceInvoke),
             20 => Ok(InstructionType::TransferInterfaceInvokeSigned),
+            21 => Ok(InstructionType::ApproveInvoke),
+            22 => Ok(InstructionType::ApproveInvokeSigned),
+            23 => Ok(InstructionType::RevokeInvoke),
+            24 => Ok(InstructionType::RevokeInvokeSigned),
+            25 => Ok(InstructionType::FreezeInvoke),
+            26 => Ok(InstructionType::FreezeInvokeSigned),
+            27 => Ok(InstructionType::ThawInvoke),
+            28 => Ok(InstructionType::ThawInvokeSigned),
+            29 => Ok(InstructionType::BurnInvoke),
+            30 => Ok(InstructionType::BurnInvokeSigned),
+            31 => Ok(InstructionType::CTokenMintToInvoke),
+            32 => Ok(InstructionType::CTokenMintToInvokeSigned),
+            33 => Ok(InstructionType::DecompressCmintInvokeSigned),
+            34 => Ok(InstructionType::CTokenTransferCheckedInvoke),
+            35 => Ok(InstructionType::CTokenTransferCheckedInvokeSigned),
             _ => Err(ProgramError::InvalidInstructionData),
         }
     }
@@ -191,16 +253,6 @@ pub fn process_instruction(
         }
         InstructionType::CloseAccountInvoke => process_close_account_invoke(accounts),
         InstructionType::CloseAccountInvokeSigned => process_close_account_invoke_signed(accounts),
-        InstructionType::CreateAta2Invoke => {
-            let data = CreateAta2Data::try_from_slice(&instruction_data[1..])
-                .map_err(|_| ProgramError::InvalidInstructionData)?;
-            process_create_ata2_invoke(accounts, data)
-        }
-        InstructionType::CreateAta2InvokeSigned => {
-            let data = CreateAta2Data::try_from_slice(&instruction_data[1..])
-                .map_err(|_| ProgramError::InvalidInstructionData)?;
-            process_create_ata2_invoke_signed(accounts, data)
-        }
         InstructionType::CreateCmintInvokeSigned => {
             let data = CreateCmintData::try_from_slice(&instruction_data[1..])
                 .map_err(|_| ProgramError::InvalidInstructionData)?;
@@ -246,6 +298,58 @@ pub fn process_instruction(
                 .map_err(|_| ProgramError::InvalidInstructionData)?;
             process_transfer_interface_invoke_signed(accounts, data)
         }
+        InstructionType::ApproveInvoke => {
+            let data = ApproveData::try_from_slice(&instruction_data[1..])
+                .map_err(|_| ProgramError::InvalidInstructionData)?;
+            process_approve_invoke(accounts, data)
+        }
+        InstructionType::ApproveInvokeSigned => {
+            let data = ApproveData::try_from_slice(&instruction_data[1..])
+                .map_err(|_| ProgramError::InvalidInstructionData)?;
+            process_approve_invoke_signed(accounts, data)
+        }
+        InstructionType::RevokeInvoke => process_revoke_invoke(accounts),
+        InstructionType::RevokeInvokeSigned => process_revoke_invoke_signed(accounts),
+        InstructionType::FreezeInvoke => process_freeze_invoke(accounts),
+        InstructionType::FreezeInvokeSigned => process_freeze_invoke_signed(accounts),
+        InstructionType::ThawInvoke => process_thaw_invoke(accounts),
+        InstructionType::ThawInvokeSigned => process_thaw_invoke_signed(accounts),
+        InstructionType::BurnInvoke => {
+            let data = BurnData::try_from_slice(&instruction_data[1..])
+                .map_err(|_| ProgramError::InvalidInstructionData)?;
+            process_burn_invoke(accounts, data.amount)
+        }
+        InstructionType::BurnInvokeSigned => {
+            let data = BurnData::try_from_slice(&instruction_data[1..])
+                .map_err(|_| ProgramError::InvalidInstructionData)?;
+            process_burn_invoke_signed(accounts, data.amount)
+        }
+        InstructionType::CTokenMintToInvoke => {
+            let data = MintToData::try_from_slice(&instruction_data[1..])
+                .map_err(|_| ProgramError::InvalidInstructionData)?;
+            process_ctoken_mint_to_invoke(accounts, data.amount)
+        }
+        InstructionType::CTokenMintToInvokeSigned => {
+            let data = MintToData::try_from_slice(&instruction_data[1..])
+                .map_err(|_| ProgramError::InvalidInstructionData)?;
+            process_ctoken_mint_to_invoke_signed(accounts, data.amount)
+        }
+        InstructionType::DecompressCmintInvokeSigned => {
+            let data = DecompressCmintData::try_from_slice(&instruction_data[1..])
+                .map_err(|_| ProgramError::InvalidInstructionData)?;
+            process_decompress_cmint_invoke_signed(accounts, data)
+        }
+        InstructionType::CTokenTransferCheckedInvoke => {
+            let data = TransferCheckedData::try_from_slice(&instruction_data[1..])
+                .map_err(|_| ProgramError::InvalidInstructionData)?;
+            process_transfer_checked_invoke(accounts, data)
+        }
+        InstructionType::CTokenTransferCheckedInvokeSigned => {
+            let data = TransferCheckedData::try_from_slice(&instruction_data[1..])
+                .map_err(|_| ProgramError::InvalidInstructionData)?;
+            process_transfer_checked_invoke_signed(accounts, data)
+        }
+        _ => Err(ProgramError::InvalidInstructionData),
     }
 }
 
@@ -276,6 +380,21 @@ mod tests {
         assert_eq!(InstructionType::CtokenToSplInvokeSigned as u8, 18);
         assert_eq!(InstructionType::TransferInterfaceInvoke as u8, 19);
         assert_eq!(InstructionType::TransferInterfaceInvokeSigned as u8, 20);
+        assert_eq!(InstructionType::ApproveInvoke as u8, 21);
+        assert_eq!(InstructionType::ApproveInvokeSigned as u8, 22);
+        assert_eq!(InstructionType::RevokeInvoke as u8, 23);
+        assert_eq!(InstructionType::RevokeInvokeSigned as u8, 24);
+        assert_eq!(InstructionType::FreezeInvoke as u8, 25);
+        assert_eq!(InstructionType::FreezeInvokeSigned as u8, 26);
+        assert_eq!(InstructionType::ThawInvoke as u8, 27);
+        assert_eq!(InstructionType::ThawInvokeSigned as u8, 28);
+        assert_eq!(InstructionType::BurnInvoke as u8, 29);
+        assert_eq!(InstructionType::BurnInvokeSigned as u8, 30);
+        assert_eq!(InstructionType::CTokenMintToInvoke as u8, 31);
+        assert_eq!(InstructionType::CTokenMintToInvokeSigned as u8, 32);
+        assert_eq!(InstructionType::DecompressCmintInvokeSigned as u8, 33);
+        assert_eq!(InstructionType::CTokenTransferCheckedInvoke as u8, 34);
+        assert_eq!(InstructionType::CTokenTransferCheckedInvokeSigned as u8, 35);
     }
 
     #[test]
@@ -364,6 +483,66 @@ mod tests {
             InstructionType::try_from(20).unwrap(),
             InstructionType::TransferInterfaceInvokeSigned
         );
-        assert!(InstructionType::try_from(21).is_err());
+        assert_eq!(
+            InstructionType::try_from(21).unwrap(),
+            InstructionType::ApproveInvoke
+        );
+        assert_eq!(
+            InstructionType::try_from(22).unwrap(),
+            InstructionType::ApproveInvokeSigned
+        );
+        assert_eq!(
+            InstructionType::try_from(23).unwrap(),
+            InstructionType::RevokeInvoke
+        );
+        assert_eq!(
+            InstructionType::try_from(24).unwrap(),
+            InstructionType::RevokeInvokeSigned
+        );
+        assert_eq!(
+            InstructionType::try_from(25).unwrap(),
+            InstructionType::FreezeInvoke
+        );
+        assert_eq!(
+            InstructionType::try_from(26).unwrap(),
+            InstructionType::FreezeInvokeSigned
+        );
+        assert_eq!(
+            InstructionType::try_from(27).unwrap(),
+            InstructionType::ThawInvoke
+        );
+        assert_eq!(
+            InstructionType::try_from(28).unwrap(),
+            InstructionType::ThawInvokeSigned
+        );
+        assert_eq!(
+            InstructionType::try_from(29).unwrap(),
+            InstructionType::BurnInvoke
+        );
+        assert_eq!(
+            InstructionType::try_from(30).unwrap(),
+            InstructionType::BurnInvokeSigned
+        );
+        assert_eq!(
+            InstructionType::try_from(31).unwrap(),
+            InstructionType::CTokenMintToInvoke
+        );
+        assert_eq!(
+            InstructionType::try_from(32).unwrap(),
+            InstructionType::CTokenMintToInvokeSigned
+        );
+        assert_eq!(
+            InstructionType::try_from(33).unwrap(),
+            InstructionType::DecompressCmintInvokeSigned
+        );
+        assert_eq!(
+            InstructionType::try_from(34).unwrap(),
+            InstructionType::CTokenTransferCheckedInvoke
+        );
+        assert_eq!(
+            InstructionType::try_from(35).unwrap(),
+            InstructionType::CTokenTransferCheckedInvokeSigned
+        );
+        assert!(InstructionType::try_from(36).is_err());
     }
 }
diff --git a/sdk-tests/sdk-ctoken-test/src/revoke.rs b/sdk-tests/sdk-ctoken-test/src/revoke.rs
new file mode 100644
index 0000000000..e3cc641ac3
--- /dev/null
+++ b/sdk-tests/sdk-ctoken-test/src/revoke.rs
@@ -0,0 +1,57 @@
+use light_ctoken_sdk::ctoken::RevokeCTokenCpi;
+use solana_program::{account_info::AccountInfo, program_error::ProgramError, pubkey::Pubkey};
+
+use crate::{ID, TOKEN_ACCOUNT_SEED};
+
+/// Handler for revoking delegation on a CToken account (invoke)
+///
+/// Account order:
+/// - accounts[0]: token_account (writable)
+/// - accounts[1]: owner (signer)
+/// - accounts[2]: system_program
+/// - accounts[3]: ctoken_program
+pub fn process_revoke_invoke(accounts: &[AccountInfo]) -> Result<(), ProgramError> {
+    if accounts.len() < 4 {
+        return Err(ProgramError::NotEnoughAccountKeys);
+    }
+
+    RevokeCTokenCpi {
+        token_account: accounts[0].clone(),
+        owner: accounts[1].clone(),
+        system_program: accounts[2].clone(),
+    }
+    .invoke()?;
+
+    Ok(())
+}
+
+/// Handler for revoking delegation on a PDA-owned CToken account (invoke_signed)
+///
+/// Account order:
+/// - accounts[0]: token_account (writable)
+/// - accounts[1]: PDA owner (program signs)
+/// - accounts[2]: system_program
+/// - accounts[3]: ctoken_program
+pub fn process_revoke_invoke_signed(accounts: &[AccountInfo]) -> Result<(), ProgramError> {
+    if accounts.len() < 4 {
+        return Err(ProgramError::NotEnoughAccountKeys);
+    }
+
+    // Derive the PDA for the owner
+    let (pda, bump) = Pubkey::find_program_address(&[TOKEN_ACCOUNT_SEED], &ID);
+
+    // Verify the owner account is the PDA we expect
+    if &pda != accounts[1].key {
+        return Err(ProgramError::InvalidSeeds);
+    }
+
+    let signer_seeds: &[&[u8]] = &[TOKEN_ACCOUNT_SEED, &[bump]];
+    RevokeCTokenCpi {
+        token_account: accounts[0].clone(),
+        owner: accounts[1].clone(),
+        system_program: accounts[2].clone(),
+    }
+    .invoke_signed(&[signer_seeds])?;
+
+    Ok(())
+}
diff --git a/sdk-tests/sdk-ctoken-test/src/thaw.rs b/sdk-tests/sdk-ctoken-test/src/thaw.rs
new file mode 100644
index 0000000000..7530f5f04c
--- /dev/null
+++ b/sdk-tests/sdk-ctoken-test/src/thaw.rs
@@ -0,0 +1,57 @@
+use light_ctoken_sdk::ctoken::ThawCTokenCpi;
+use solana_program::{account_info::AccountInfo, program_error::ProgramError, pubkey::Pubkey};
+
+use crate::{FREEZE_AUTHORITY_SEED, ID};
+
+/// Handler for thawing a frozen CToken account (invoke)
+///
+/// Account order:
+/// - accounts[0]: token_account (writable)
+/// - accounts[1]: mint
+/// - accounts[2]: freeze_authority (signer)
+/// - accounts[3]: ctoken_program
+pub fn process_thaw_invoke(accounts: &[AccountInfo]) -> Result<(), ProgramError> {
+    if accounts.len() < 4 {
+        return Err(ProgramError::NotEnoughAccountKeys);
+    }
+
+    ThawCTokenCpi {
+        token_account: accounts[0].clone(),
+        mint: accounts[1].clone(),
+        freeze_authority: accounts[2].clone(),
+    }
+    .invoke()?;
+
+    Ok(())
+}
+
+/// Handler for thawing a frozen CToken account with PDA freeze authority (invoke_signed)
+///
+/// Account order:
+/// - accounts[0]: token_account (writable)
+/// - accounts[1]: mint
+/// - accounts[2]: PDA freeze_authority (program signs)
+/// - accounts[3]: ctoken_program
+pub fn process_thaw_invoke_signed(accounts: &[AccountInfo]) -> Result<(), ProgramError> {
+    if accounts.len() < 4 {
+        return Err(ProgramError::NotEnoughAccountKeys);
+    }
+
+    // Derive the PDA for the freeze authority
+    let (pda, bump) = Pubkey::find_program_address(&[FREEZE_AUTHORITY_SEED], &ID);
+
+    // Verify the freeze_authority account is the PDA we expect
+    if &pda != accounts[2].key {
+        return Err(ProgramError::InvalidSeeds);
+    }
+
+    let signer_seeds: &[&[u8]] = &[FREEZE_AUTHORITY_SEED, &[bump]];
+    ThawCTokenCpi {
+        token_account: accounts[0].clone(),
+        mint: accounts[1].clone(),
+        freeze_authority: accounts[2].clone(),
+    }
+    .invoke_signed(&[signer_seeds])?;
+
+    Ok(())
+}
diff --git a/sdk-tests/sdk-ctoken-test/src/transfer_checked.rs b/sdk-tests/sdk-ctoken-test/src/transfer_checked.rs
new file mode 100644
index 0000000000..3cb7ec4f13
--- /dev/null
+++ b/sdk-tests/sdk-ctoken-test/src/transfer_checked.rs
@@ -0,0 +1,81 @@
+use borsh::{BorshDeserialize, BorshSerialize};
+use light_ctoken_sdk::ctoken::TransferCTokenCheckedCpi;
+use solana_program::{account_info::AccountInfo, program_error::ProgramError, pubkey::Pubkey};
+
+use crate::{ID, TOKEN_ACCOUNT_SEED};
+
+/// Instruction data for transfer_checked operations
+#[derive(BorshSerialize, BorshDeserialize, Debug)]
+pub struct TransferCheckedData {
+    pub amount: u64,
+    pub decimals: u8,
+}
+
+/// Handler for transferring cTokens with checked decimals (invoke)
+///
+/// Account order:
+/// - accounts[0]: source ctoken account
+/// - accounts[1]: mint (SPL, T22, or decompressed CMint)
+/// - accounts[2]: destination ctoken account
+/// - accounts[3]: authority (signer)
+pub fn process_transfer_checked_invoke(
+    accounts: &[AccountInfo],
+    data: TransferCheckedData,
+) -> Result<(), ProgramError> {
+    if accounts.len() < 4 {
+        return Err(ProgramError::NotEnoughAccountKeys);
+    }
+
+    TransferCTokenCheckedCpi {
+        source: accounts[0].clone(),
+        mint: accounts[1].clone(),
+        destination: accounts[2].clone(),
+        amount: data.amount,
+        decimals: data.decimals,
+        authority: accounts[3].clone(),
+        max_top_up: None,
+    }
+    .invoke()?;
+
+    Ok(())
+}
+
+/// Handler for transferring cTokens with checked decimals from PDA-owned account (invoke_signed)
+///
+/// Account order:
+/// - accounts[0]: source ctoken account (PDA-owned)
+/// - accounts[1]: mint (SPL, T22, or decompressed CMint)
+/// - accounts[2]: destination ctoken account
+/// - accounts[3]: authority (PDA)
+pub fn process_transfer_checked_invoke_signed(
+    accounts: &[AccountInfo],
+    data: TransferCheckedData,
+) -> Result<(), ProgramError> {
+    if accounts.len() < 4 {
+        return Err(ProgramError::NotEnoughAccountKeys);
+    }
+
+    // Derive the PDA for the authority
+    let (pda, bump) = Pubkey::find_program_address(&[TOKEN_ACCOUNT_SEED], &ID);
+
+    // Verify the authority account is the PDA we expect
+    if &pda != accounts[3].key {
+        return Err(ProgramError::InvalidSeeds);
+    }
+
+    let transfer_accounts = TransferCTokenCheckedCpi {
+        source: accounts[0].clone(),
+        mint: accounts[1].clone(),
+        destination: accounts[2].clone(),
+        amount: data.amount,
+        decimals: data.decimals,
+        authority: accounts[3].clone(),
+        max_top_up: None,
+    };
+
+    // Invoke with PDA signing
+    let signer_seeds: &[&[u8]] = &[TOKEN_ACCOUNT_SEED, &[bump]];
+    transfer_accounts.invoke_signed(&[signer_seeds])?;
+
+    Ok(())
+}
diff --git a/sdk-tests/sdk-ctoken-test/src/transfer_interface.rs b/sdk-tests/sdk-ctoken-test/src/transfer_interface.rs
index c04c2a54de..be518bf8c7 100644
--- a/sdk-tests/sdk-ctoken-test/src/transfer_interface.rs
+++ b/sdk-tests/sdk-ctoken-test/src/transfer_interface.rs
@@ -11,6 +11,7 @@ pub const TRANSFER_INTERFACE_AUTHORITY_SEED: &[u8] = b"transfer_interface_author
 #[derive(BorshSerialize, BorshDeserialize, Debug)]
 pub struct TransferInterfaceData {
     pub amount: u64,
+    pub decimals: u8,
     /// Required for SPL<->CToken transfers, None for CToken->CToken
     pub spl_interface_pda_bump: Option<u8>,
 }
@@ -29,33 +30,36 @@ pub struct TransferInterfaceData {
 /// - accounts[3]: authority (signer)
 /// - accounts[4]: payer (signer)
 /// - accounts[5]: compressed_token_program_authority
+/// - accounts[6]: system_program
 ///   For SPL bridge (optional, required for SPL<->CToken):
-/// - accounts[6]: mint
-/// - accounts[7]: spl_interface_pda
-/// - accounts[8]: spl_token_program
+/// - accounts[7]: mint
+/// - accounts[8]: spl_interface_pda
+/// - accounts[9]: spl_token_program
 pub fn process_transfer_interface_invoke(
     accounts: &[AccountInfo],
     data: TransferInterfaceData,
 ) -> Result<(), ProgramError> {
-    if accounts.len() < 6 {
+    if accounts.len() < 7 {
         return Err(ProgramError::NotEnoughAccountKeys);
     }
 
     let mut transfer = TransferInterfaceCpi::new(
         data.amount,
+        data.decimals,
         accounts[1].clone(), // source_account
         accounts[2].clone(), // destination_account
         accounts[3].clone(), // authority
         accounts[4].clone(), // payer
         accounts[5].clone(), // compressed_token_program_authority
+        accounts[6].clone(), // system_program
     );
 
     // Add SPL bridge config if provided
-    if accounts.len() >= 9 && data.spl_interface_pda_bump.is_some() {
+    if accounts.len() >= 10 && data.spl_interface_pda_bump.is_some() {
         transfer = transfer.with_spl_interface(
-            Some(accounts[6].clone()), // mint
-            Some(accounts[8].clone()), // spl_token_program
-            Some(accounts[7].clone()), // spl_interface_pda
+            Some(accounts[7].clone()), // mint
+            Some(accounts[9].clone()), // spl_token_program
+            Some(accounts[8].clone()), // spl_interface_pda
             data.spl_interface_pda_bump,
         )?;
     }
@@ -76,15 +80,16 @@ pub fn process_transfer_interface_invoke(
 /// - accounts[3]: authority (PDA, not signer - program signs)
 /// - accounts[4]: payer (signer)
 /// - accounts[5]: compressed_token_program_authority
+/// - accounts[6]: system_program
 ///   For SPL bridge (optional, required for SPL<->CToken):
-/// - accounts[6]: mint
-/// - accounts[7]: spl_interface_pda
-/// - accounts[8]: spl_token_program
+/// - accounts[7]: mint
+/// - accounts[8]: spl_interface_pda
+/// - accounts[9]: spl_token_program
 pub fn process_transfer_interface_invoke_signed(
     accounts: &[AccountInfo],
     data: TransferInterfaceData,
 ) -> Result<(), ProgramError> {
-    if accounts.len() < 6 {
+    if accounts.len() < 7 {
         return Err(ProgramError::NotEnoughAccountKeys);
     }
 
@@ -99,19 +104,21 @@ pub fn process_transfer_interface_invoke_signed(
 
     let mut transfer = TransferInterfaceCpi::new(
         data.amount,
+        data.decimals,
         accounts[1].clone(), // source_account
         accounts[2].clone(), // destination_account
         accounts[3].clone(), // authority (PDA)
         accounts[4].clone(), // payer
         accounts[5].clone(), // compressed_token_program_authority
+        accounts[6].clone(), // system_program
     );
 
     // Add SPL bridge config if provided
-    if accounts.len() >= 9 && data.spl_interface_pda_bump.is_some() {
+    if accounts.len() >= 10 && data.spl_interface_pda_bump.is_some() {
         transfer = transfer.with_spl_interface(
-            Some(accounts[6].clone()), // mint
-            Some(accounts[8].clone()), // spl_token_program
-            Some(accounts[7].clone()), // spl_interface_pda
+            Some(accounts[7].clone()), // mint
+            Some(accounts[9].clone()), // spl_token_program
+            Some(accounts[8].clone()), // spl_interface_pda
             data.spl_interface_pda_bump,
         )?;
     }
diff --git a/sdk-tests/sdk-ctoken-test/src/transfer_spl_ctoken.rs b/sdk-tests/sdk-ctoken-test/src/transfer_spl_ctoken.rs
index f2b60f8bb7..265fefb5fc 100644
--- a/sdk-tests/sdk-ctoken-test/src/transfer_spl_ctoken.rs
+++ b/sdk-tests/sdk-ctoken-test/src/transfer_spl_ctoken.rs
@@ -12,6 +12,7 @@ pub const TRANSFER_AUTHORITY_SEED: &[u8] = b"transfer_authority";
 pub struct TransferSplToCtokenData {
     pub amount: u64,
     pub spl_interface_pda_bump: u8,
+    pub decimals: u8,
 }
 
 /// Instruction data for CToken to SPL transfer
@@ -19,6 +20,7 @@ pub struct TransferSplToCtokenData {
 pub struct TransferCTokenToSplData {
     pub amount: u64,
     pub spl_interface_pda_bump: u8,
+    pub decimals: u8,
 }
 
 /// Handler for transferring SPL tokens to CToken (invoke)
@@ -33,11 +35,12 @@ pub struct TransferCTokenToSplData {
 /// - accounts[6]: spl_interface_pda
 /// - accounts[7]: spl_token_program
 /// - accounts[8]: compressed_token_program_authority
+/// - accounts[9]: system_program
 pub fn process_spl_to_ctoken_invoke(
     accounts: &[AccountInfo],
     data: TransferSplToCtokenData,
 ) -> Result<(), ProgramError> {
-    if accounts.len() < 9 {
+    if accounts.len() < 10 {
         return Err(ProgramError::NotEnoughAccountKeys);
     }
 
@@ -50,8 +53,10 @@ pub fn process_spl_to_ctoken_invoke(
         payer: accounts[5].clone(),
         spl_interface_pda: accounts[6].clone(),
         spl_interface_pda_bump: data.spl_interface_pda_bump,
+        decimals: data.decimals,
         spl_token_program: accounts[7].clone(),
         compressed_token_program_authority: accounts[8].clone(),
+        system_program: accounts[9].clone(),
     }
     .invoke()?;
 
@@ -72,11 +77,12 @@ pub fn process_spl_to_ctoken_invoke(
 /// - accounts[6]: spl_interface_pda
 /// - accounts[7]: spl_token_program
 /// - accounts[8]: compressed_token_program_authority
+/// - accounts[9]: system_program
 pub fn process_spl_to_ctoken_invoke_signed(
     accounts: &[AccountInfo],
     data: TransferSplToCtokenData,
 ) -> Result<(), ProgramError> {
-    if accounts.len() < 9 {
+    if accounts.len() < 10 {
         return Err(ProgramError::NotEnoughAccountKeys);
     }
 
@@ -98,8 +104,10 @@ pub fn process_spl_to_ctoken_invoke_signed(
         payer: accounts[5].clone(),
         spl_interface_pda: accounts[6].clone(),
         spl_interface_pda_bump: data.spl_interface_pda_bump,
+        decimals: data.decimals,
         spl_token_program: accounts[7].clone(),
         compressed_token_program_authority: accounts[8].clone(),
+        system_program: accounts[9].clone(),
     };
 
     // Invoke with PDA signing
@@ -138,6 +146,7 @@ pub fn process_ctoken_to_spl_invoke(
         payer: accounts[5].clone(),
         spl_interface_pda: accounts[6].clone(),
         spl_interface_pda_bump: data.spl_interface_pda_bump,
+        decimals: data.decimals,
         spl_token_program: accounts[7].clone(),
         compressed_token_program_authority: accounts[8].clone(),
     }
@@ -186,6 +195,7 @@ pub fn process_ctoken_to_spl_invoke_signed(
         payer: accounts[5].clone(),
         spl_interface_pda: accounts[6].clone(),
         spl_interface_pda_bump: data.spl_interface_pda_bump,
+        decimals: data.decimals,
         spl_token_program: accounts[7].clone(),
         compressed_token_program_authority: accounts[8].clone(),
     };
diff --git a/sdk-tests/sdk-ctoken-test/tests/scenario_cmint.rs b/sdk-tests/sdk-ctoken-test/tests/scenario_cmint.rs
index e344d9c8aa..0831ceda01 100644
--- a/sdk-tests/sdk-ctoken-test/tests/scenario_cmint.rs
+++ b/sdk-tests/sdk-ctoken-test/tests/scenario_cmint.rs
@@ -48,17 +48,18 @@ async fn test_cmint_to_ctoken_scenario() {
     let mint_amount2 = 5_000u64;
     let transfer_amount = 3_000u64;
 
-    let (mint, _compression_address, ata_pubkeys) = shared::setup_create_compressed_mint(
-        &mut rpc,
-        &payer,
-        payer.pubkey(), // mint_authority
-        9,              // decimals
-        vec![
-            (mint_amount1, owner1.pubkey()),
-            (mint_amount2, owner2.pubkey()),
-        ],
-    )
-    .await;
+    let (mint, _compression_address, ata_pubkeys, _mint_seed) =
+        shared::setup_create_compressed_mint(
+            &mut rpc,
+            &payer,
+            payer.pubkey(), // mint_authority
+            9,              // decimals
+            vec![
+                (mint_amount1, owner1.pubkey()),
+                (mint_amount2, owner2.pubkey()),
+            ],
+        )
+        .await;
 
     let ctoken_ata1 = ata_pubkeys[0];
     let ctoken_ata2 = ata_pubkeys[1];
@@ -205,6 +206,8 @@ async fn test_cmint_to_ctoken_scenario() {
         "cToken ATA should exist after recreation"
     );
     println!("  - cToken ATA recreated: {}", ctoken_ata2);
+    let deserialized_ata = CToken::try_from_slice(ctoken_account_data.data.as_slice()).unwrap();
+    println!("deserialized ata {:?}", deserialized_ata);
 
     // 10. Get validity proof for the compressed account
     let compressed_hashes: Vec<_> = compressed_accounts
@@ -232,6 +235,8 @@ async fn test_cmint_to_ctoken_scenario() {
 
     // 11. Decompress compressed tokens to cToken account
     println!("Decompressing tokens to cToken account...");
+    println!("discriminator {:?}", discriminator);
+    println!("token_data {:?}", token_data);
     let decompress_instruction = DecompressToCtoken {
         token_data,
         discriminator,
diff --git a/sdk-tests/sdk-ctoken-test/tests/scenario_cmint_compression_only.rs b/sdk-tests/sdk-ctoken-test/tests/scenario_cmint_compression_only.rs
new file mode 100644
index 0000000000..457ab743bf
--- /dev/null
+++ b/sdk-tests/sdk-ctoken-test/tests/scenario_cmint_compression_only.rs
@@ -0,0 +1,299 @@
+// cMint to cToken scenario test with compression_only: true
+//
+// This test demonstrates the complete flow with compression_only flag enabled:
+// 1. Create cMint (compressed mint)
+// 2. Create 2 cToken ATAs for different owners with compression_only: true
+// 3. Mint cTokens to both accounts
+// 4. Transfer cTokens from account 1 to account 2
+// 5. Advance epochs to trigger compression
+// 6. Verify cToken account is compressed and closed (with TLV data)
+// 7. Recreate cToken ATA
+// 8. Decompress compressed tokens back to cToken account
+// 9. Verify cToken account has tokens again
+
+mod shared;
+
+use borsh::BorshDeserialize;
+use light_client::{indexer::Indexer, rpc::Rpc};
+use light_ctoken_sdk::ctoken::{
+    CToken, CompressibleParams, CreateAssociatedCTokenAccount, DecompressToCtoken, TransferCToken,
+};
+use light_program_test::{program_test::TestRpc, LightProgramTest, ProgramTestConfig};
+use solana_sdk::{signature::Keypair, signer::Signer};
+
+/// Test the complete cMint to cToken flow with compression_only: true
+#[tokio::test]
+async fn test_cmint_to_ctoken_scenario_compression_only() {
+    // 1. Setup test environment
+    let mut rpc = LightProgramTest::new(ProgramTestConfig::new_v2(false, None))
+        .await
+        .unwrap();
+
+    let payer = rpc.get_payer().insecure_clone();
+
+    // 2. Create two token owners
+    let owner1 = Keypair::new();
+    let owner2 = Keypair::new();
+
+    // Airdrop lamports to owners (needed for signing transactions)
+    light_test_utils::airdrop_lamports(&mut rpc, &owner1.pubkey(), 1_000_000_000)
+        .await
+        .unwrap();
+    light_test_utils::airdrop_lamports(&mut rpc, &owner2.pubkey(), 1_000_000_000)
+        .await
+        .unwrap();
+
+    // 3. Create cMint and cToken ATAs with initial balances
+    let mint_amount1 = 10_000u64;
+    let mint_amount2 = 5_000u64;
+    let transfer_amount = 3_000u64;
+
+    // Use compression_only: true for this test
+    let (mint, _compression_address, ata_pubkeys) =
+        shared::setup_create_compressed_mint_with_compression_only(
+            &mut rpc,
+            &payer,
+            payer.pubkey(), // mint_authority
+            9,              // decimals
+            vec![
+                (mint_amount1, owner1.pubkey()),
+                (mint_amount2, owner2.pubkey()),
+            ],
+            true, // compression_only
+        )
+        .await;
+
+    let ctoken_ata1 = ata_pubkeys[0];
+    let ctoken_ata2 = ata_pubkeys[1];
+
+    // 4. Verify initial balances
+    let ctoken_account_data = rpc.get_account(ctoken_ata1).await.unwrap().unwrap();
+    let ctoken_account = CToken::deserialize(&mut &ctoken_account_data.data[..]).unwrap();
+    let balance1 = ctoken_account.amount;
+    assert_eq!(balance1, mint_amount1, "cToken account 1 initial balance");
+
+    let ctoken_account_data = rpc.get_account(ctoken_ata2).await.unwrap().unwrap();
+    let ctoken_account = CToken::deserialize(&mut &ctoken_account_data.data[..]).unwrap();
+    let balance2 = ctoken_account.amount;
+    assert_eq!(balance2, mint_amount2, "cToken account 2 initial balance");
+
+    println!("cMint scenario test (compression_only: true) setup complete!");
+    println!("  - Created cMint: {}", mint);
+    println!(
+        "  - cToken account 1: {} (balance: {})",
+        ctoken_ata1, balance1
+    );
+    println!(
+        "  - cToken account 2: {} (balance: {})",
+        ctoken_ata2, balance2
+    );
+
+    // 5. Transfer cTokens from account 1 to account 2
+    let transfer_instruction = TransferCToken {
+        source: ctoken_ata1,
+        destination: ctoken_ata2,
+        amount: transfer_amount,
+        authority: owner1.pubkey(),
+        max_top_up: None,
+    }
+    .instruction()
+    .unwrap();
+
+    rpc.create_and_send_transaction(&[transfer_instruction], &payer.pubkey(), &[&payer, &owner1])
+        .await
+        .unwrap();
+
+    // 6. Verify balances after transfer
+    let ctoken_account_data = rpc.get_account(ctoken_ata1).await.unwrap().unwrap();
+    let ctoken_account = CToken::deserialize(&mut &ctoken_account_data.data[..]).unwrap();
+    let balance1_after = ctoken_account.amount;
+    assert_eq!(
+        balance1_after,
+        mint_amount1 - transfer_amount,
+        "cToken account 1 balance after transfer"
+    );
+
+    let ctoken_account_data = rpc.get_account(ctoken_ata2).await.unwrap().unwrap();
+    let ctoken_account = CToken::deserialize(&mut &ctoken_account_data.data[..]).unwrap();
+    let balance2_after = ctoken_account.amount;
+    assert_eq!(
+        balance2_after,
+        mint_amount2 + transfer_amount,
+        "cToken account 2 balance after transfer"
+    );
+
+    println!("\nTransfer completed!");
+    println!(
+        "  - Transferred {} from account 1 to account 2",
+        transfer_amount
+    );
+    println!(
+        "  - cToken account 1 balance: {} -> {}",
+        balance1, balance1_after
+    );
+    println!(
+        "  - cToken account 2 balance: {} -> {}",
+        balance2, balance2_after
+    );
+
+    // 7. Advance 25 epochs to trigger compression (default prepaid is 16 epochs)
+    println!("\nAdvancing 25 epochs to trigger compression...");
+    rpc.warp_epoch_forward(25).await.unwrap();
+
+    // 8. Verify cToken account 2 is compressed and closed
+    let closed_account = rpc.get_account(ctoken_ata2).await.unwrap();
+    match closed_account {
+        Some(account) => {
+            assert_eq!(
+                account.lamports, 0,
+                "cToken account 2 should be closed (0 lamports)"
+            );
+        }
+        None => {
+            println!("  - cToken account 2 no longer exists (closed)");
+        }
+    }
+
+    // Verify compressed token account exists for owner2
+    let compressed_accounts = rpc
+        .get_compressed_token_accounts_by_owner(&owner2.pubkey(), None, None)
+        .await
+        .unwrap()
+        .value
+        .items;
+
+    assert!(
+        !compressed_accounts.is_empty(),
+        "Compressed token account should exist after compression"
+    );
+
+    let compressed_account = &compressed_accounts[0];
+    assert_eq!(
+        compressed_account.token.owner,
+        owner2.pubkey(),
+        "Compressed account owner should match"
+    );
+    assert_eq!(
+        compressed_account.token.amount,
+        mint_amount2 + transfer_amount,
+        "Compressed account should have the expected tokens"
+    );
+
+    println!("  - cToken account 2 compressed and closed");
+    println!(
+        "  - Compressed token account owner: {}",
+        compressed_account.token.owner
+    );
+    println!(
+        "  - Compressed token account amount: {}",
+        compressed_account.token.amount
+    );
+
+    // 9. Recreate cToken ATA for decompression (idempotent) with compression_only: true
+    println!("\nRecreating cToken ATA for decompression...");
+    let compressible_params = CompressibleParams {
+        compression_only: true,
+        ..Default::default()
+    };
+    let create_ata_instruction =
+        CreateAssociatedCTokenAccount::new(payer.pubkey(), owner2.pubkey(), mint)
+            .with_compressible(compressible_params)
+            .idempotent()
+            .instruction()
+            .unwrap();
+
+    rpc.create_and_send_transaction(&[create_ata_instruction], &payer.pubkey(), &[&payer])
+        .await
+        .unwrap();
+
+    // Verify cToken ATA was recreated
+    let ctoken_account_data = rpc.get_account(ctoken_ata2).await.unwrap().unwrap();
+    assert!(
+        !ctoken_account_data.data.is_empty(),
+        "cToken ATA should exist after recreation"
+    );
+    println!("  - cToken ATA recreated: {}", ctoken_ata2);
+    let deserialized_ata = CToken::try_from_slice(ctoken_account_data.data.as_slice()).unwrap();
+    println!("deserialized ata {:?}", deserialized_ata);
+
+    // 10. Get validity proof for the compressed account
+    let compressed_hashes: Vec<_> = compressed_accounts
+        .iter()
+        .map(|acc| acc.account.hash)
+        .collect();
+
+    let rpc_result = rpc
+        .get_validity_proof(compressed_hashes, vec![], None)
+        .await
+        .unwrap()
+        .value;
+
+    // Get token data and discriminator from compressed account
+    let token_data = compressed_accounts[0].token.clone();
+    let discriminator = compressed_accounts[0]
+        .account
+        .data
+        .as_ref()
+        .unwrap()
+        .discriminator;
+
+    // Get tree info from validity proof result
+    let account_proof = &rpc_result.accounts[0];
+
+    // 11. Decompress compressed tokens to cToken account
+    println!("Decompressing tokens to cToken account...");
+    println!("discriminator {:?}", discriminator);
+    println!("token_data {:?}", token_data);
+    let decompress_instruction = DecompressToCtoken {
+        token_data,
+        discriminator,
+        merkle_tree: account_proof.tree_info.tree,
+        queue: account_proof.tree_info.queue,
+        leaf_index: account_proof.leaf_index as u32,
+        root_index: account_proof.root_index.root_index().unwrap_or(0),
+        destination_ctoken_account: ctoken_ata2,
+        payer: payer.pubkey(),
+        validity_proof: rpc_result.proof,
+    }
+    .instruction()
+    .unwrap();
+
+    rpc.create_and_send_transaction(
+        &[decompress_instruction],
+        &payer.pubkey(),
+        &[&payer, &owner2],
+    )
+    .await
+    .unwrap();
+
+    // 12. Verify compressed accounts are consumed
+    let remaining_compressed = rpc
+        .get_compressed_token_accounts_by_owner(&owner2.pubkey(), None, None)
+        .await
+        .unwrap()
+        .value
+        .items;
+
+    assert_eq!(
+        remaining_compressed.len(),
+        0,
+        "All compressed accounts should be consumed after decompression"
+    );
+    println!("  - Compressed accounts consumed");
+
+    // 13. Verify cToken account has tokens again
+    let ctoken_account_data = rpc.get_account(ctoken_ata2).await.unwrap().unwrap();
+    let ctoken_account = CToken::deserialize(&mut &ctoken_account_data.data[..]).unwrap();
+    let decompressed_balance = ctoken_account.amount;
+    assert_eq!(
+        decompressed_balance,
+        mint_amount2 + transfer_amount,
+        "cToken account should have the decompressed tokens"
+    );
+    println!(
+        "  - cToken account balance after decompression: {}",
+        decompressed_balance
+    );
+
+    println!("\ncMint to cToken scenario test (compression_only: true) with compression and decompression passed!");
+}
diff --git a/sdk-tests/sdk-ctoken-test/tests/scenario_spl.rs b/sdk-tests/sdk-ctoken-test/tests/scenario_spl.rs
index 35926ab610..91c895c77a 100644
--- a/sdk-tests/sdk-ctoken-test/tests/scenario_spl.rs
+++ b/sdk-tests/sdk-ctoken-test/tests/scenario_spl.rs
@@ -1,23 +1,27 @@
 // SPL to cToken scenario test - Direct SDK calls without wrapper program
 //
 // This test demonstrates the complete flow:
-// 1. Create SPL mint manually
+// 1. Create SPL mint manually (with freeze authority)
 // 2. Create token pool (SPL interface PDA) using SDK instruction
 // 3. Create SPL token account
 // 4. Mint SPL tokens
 // 5. Create cToken ATA (compressible)
 // 6. Transfer SPL tokens to cToken account
-// 7. Advance epochs to trigger compression
-// 8. Verify cToken account is compressed and closed
-// 9. Recreate cToken ATA
-// 10. Decompress compressed tokens back to cToken account
-// 11. Verify cToken account has tokens again
+// 7. Verify transfer results
+// 8. Freeze cToken account
+// 9. Thaw cToken account
+// 10. Advance epochs to trigger compression
+// 11. Verify cToken account is compressed and closed
+// 12. Recreate cToken ATA
+// 13. Decompress compressed tokens back to cToken account
+// 14. Verify cToken account has tokens again
 
 use anchor_spl::token::{spl_token, Mint};
 use light_client::{indexer::Indexer, rpc::Rpc};
 use light_ctoken_sdk::{
     ctoken::{
-        derive_ctoken_ata, CreateAssociatedCTokenAccount, DecompressToCtoken, TransferSplToCtoken,
+        derive_ctoken_ata, CreateAssociatedCTokenAccount, DecompressToCtoken, FreezeCToken,
+        ThawCToken, TransferSplToCtoken,
     },
     spl_interface::{find_spl_interface_pda_with_index, CreateSplInterfacePda},
 };
@@ -66,8 +70,8 @@ async fn test_spl_to_ctoken_scenario() {
     let initialize_mint_ix = spl_token::instruction::initialize_mint(
         &spl_token::ID,
         &mint,
-        &payer.pubkey(), // mint authority
-        None,            // freeze authority
+        &payer.pubkey(),       // mint authority
+        Some(&payer.pubkey()), // freeze authority
         decimals,
     )
     .unwrap();
@@ -82,7 +86,8 @@ async fn test_spl_to_ctoken_scenario() {
 
     // 3. Create token pool (SPL interface PDA) using SDK instruction
     let create_pool_ix =
-        CreateSplInterfacePda::new(payer.pubkey(), mint, anchor_spl::token::ID).instruction();
+        CreateSplInterfacePda::new(payer.pubkey(), mint, anchor_spl::token::ID, false)
+            .instruction();
 
     rpc.create_and_send_transaction(&[create_pool_ix], &payer.pubkey(), &[&payer])
         .await
@@ -145,11 +150,13 @@ async fn test_spl_to_ctoken_scenario() {
     );
 
     // 7. Transfer SPL tokens to cToken account
-    let (spl_interface_pda, spl_interface_pda_bump) = find_spl_interface_pda_with_index(&mint, 0);
+    let (spl_interface_pda, spl_interface_pda_bump) =
+        find_spl_interface_pda_with_index(&mint, 0, false);
 
     let transfer_instruction = TransferSplToCtoken {
         amount: transfer_amount,
         spl_interface_pda_bump,
+        decimals,
         source_spl_token_account: spl_token_account_keypair.pubkey(),
         destination_ctoken_account: ctoken_ata,
         authority: token_owner.pubkey(),
@@ -212,11 +219,61 @@ async fn test_spl_to_ctoken_scenario() {
         final_spl_balance, ctoken_balance
     );
 
-    // 8. Advance 25 epochs to trigger compression (default prepaid is 16 epochs)
+    // 8. Freeze the cToken account
+    println!("\nFreezing cToken account...");
+    let freeze_instruction = FreezeCToken {
+        token_account: ctoken_ata,
+        mint,
+        freeze_authority: payer.pubkey(),
+    }
+    .instruction()
+    .unwrap();
+
+    rpc.create_and_send_transaction(&[freeze_instruction], &payer.pubkey(), &[&payer])
+        .await
+        .unwrap();
+
+    // Verify account is frozen (state == 2)
+    let ctoken_account_data = rpc.get_account(ctoken_ata).await.unwrap().unwrap();
+    let ctoken_account =
+        spl_pod::bytemuck::pod_from_bytes::<PodAccount>(&ctoken_account_data.data[..165]).unwrap();
+    assert_eq!(
+        ctoken_account.state,
+        spl_token_2022::state::AccountState::Frozen as u8,
+        "cToken account should be frozen"
+    );
+    println!("  - cToken account frozen");
+
+    // 9. Thaw the cToken account
+    println!("Thawing cToken account...");
+    let thaw_instruction = ThawCToken {
+        token_account: ctoken_ata,
+        mint,
+        freeze_authority: payer.pubkey(),
+    }
+    .instruction()
+    .unwrap();
+
+    rpc.create_and_send_transaction(&[thaw_instruction], &payer.pubkey(), &[&payer])
+        .await
+        .unwrap();
+
+    // Verify account is thawed (state == 1)
+    let ctoken_account_data = rpc.get_account(ctoken_ata).await.unwrap().unwrap();
+    let ctoken_account =
+        spl_pod::bytemuck::pod_from_bytes::<PodAccount>(&ctoken_account_data.data[..165]).unwrap();
+    assert_eq!(
+        ctoken_account.state,
+        spl_token_2022::state::AccountState::Initialized as u8,
+        "cToken account should be thawed (initialized)"
+    );
+    println!("  - cToken account thawed");
+
+    // 10. Advance 25 epochs to trigger compression (default prepaid is 16 epochs)
     println!("\nAdvancing 25 epochs to trigger compression...");
     rpc.warp_epoch_forward(25).await.unwrap();
 
-    // 9. Verify cToken account is compressed and closed
+    // 11. Verify cToken account is compressed and closed
     let closed_account = rpc.get_account(ctoken_ata).await.unwrap();
     match closed_account {
         Some(account) => {
@@ -264,7 +321,7 @@ async fn test_spl_to_ctoken_scenario() {
         compressed_account.token.amount
     );
 
-    // 10. Recreate cToken ATA for decompression (idempotent)
+    // 12. Recreate cToken ATA for decompression (idempotent)
     println!("\nRecreating cToken ATA for decompression...");
     let create_ata_instruction =
         CreateAssociatedCTokenAccount::new(payer.pubkey(), ctoken_recipient.pubkey(), mint)
@@ -284,7 +341,7 @@ async fn test_spl_to_ctoken_scenario() {
     );
     println!("  - cToken ATA recreated: {}", ctoken_ata);
 
-    // 11. Get validity proof for the compressed account
+    // Get validity proof for the compressed account
     let compressed_hashes: Vec<_> = compressed_accounts
         .iter()
         .map(|acc| acc.account.hash)
@@ -308,7 +365,7 @@ async fn test_spl_to_ctoken_scenario() {
     // Get tree info from validity proof result
     let account_proof = &rpc_result.accounts[0];
 
-    // 12. Decompress compressed tokens to cToken account
+    // 13. Decompress compressed tokens to cToken account
     println!("Decompressing tokens to cToken account...");
     let decompress_instruction = DecompressToCtoken {
         token_data,
@@ -332,7 +389,7 @@ async fn test_spl_to_ctoken_scenario() {
     .await
     .unwrap();
 
-    // 13. Verify compressed accounts are consumed
+    // Verify compressed accounts are consumed
     let remaining_compressed = rpc
         .get_compressed_token_accounts_by_owner(&ctoken_recipient.pubkey(), None, None)
         .await
diff --git a/sdk-tests/sdk-ctoken-test/tests/scenario_spl_restricted_ext.rs b/sdk-tests/sdk-ctoken-test/tests/scenario_spl_restricted_ext.rs
new file mode 100644
index 0000000000..67c4be2de3
--- /dev/null
+++ b/sdk-tests/sdk-ctoken-test/tests/scenario_spl_restricted_ext.rs
@@ -0,0 +1,321 @@
+// Token-2022 with restricted extensions to cToken scenario test
+//
+// This test demonstrates the complete flow with Token-2022 restricted extensions:
+// 1. Create Token-2022 mint with restricted extensions (PermanentDelegate, Pausable, etc.)
+// 2. Create token pool (SPL interface PDA) using SDK instruction
+// 3. Create Token-2022 token account
+// 4. Mint Token-2022 tokens
+// 5. Create cToken ATA with compression_only: true (required for restricted extensions)
+// 6. Transfer Token-2022 tokens to cToken account
+// 7. Advance epochs to trigger compression
+// 8. Verify cToken account is compressed and closed (with TLV data)
+// 9. Recreate cToken ATA with compression_only: true
+// 10. Decompress compressed tokens back to cToken account
+// 11. Verify cToken account has tokens again
+
+use light_client::{indexer::Indexer, rpc::Rpc};
+use light_ctoken_sdk::{
+    ctoken::{
+        derive_ctoken_ata, CompressibleParams, CreateAssociatedCTokenAccount, DecompressToCtoken,
+        TransferSplToCtoken,
+    },
+    spl_interface::find_spl_interface_pda_with_index,
+};
+use light_program_test::{program_test::TestRpc, LightProgramTest, ProgramTestConfig};
+use light_test_utils::mint_2022::{
+    create_mint_22_with_extensions, create_token_22_account, mint_spl_tokens_22,
+};
+use solana_sdk::{signature::Keypair, signer::Signer};
+use spl_token_2022::pod::PodAccount;
+
+/// Test the complete Token-2022 (restricted extensions) to cToken flow
+#[tokio::test]
+async fn test_t22_restricted_to_ctoken_scenario() {
+    // 1. Setup test environment
+    let mut rpc = LightProgramTest::new(ProgramTestConfig::new_v2(false, None))
+        .await
+        .unwrap();
+
+    let payer = rpc.get_payer().insecure_clone();
+
+    // Create a token owner
+    let token_owner = Keypair::new();
+    light_test_utils::airdrop_lamports(&mut rpc, &token_owner.pubkey(), 1_000_000_000)
+        .await
+        .unwrap();
+
+    // 2. Create Token-2022 mint with restricted extensions
+    let decimals = 2u8;
+    let (mint_keypair, _extension_config) =
+        create_mint_22_with_extensions(&mut rpc, &payer, decimals).await;
+    let mint = mint_keypair.pubkey();
+
+    // Note: create_mint_22_with_extensions already creates the token pool
+
+    let mint_amount = 10_000u64;
+    let transfer_amount = 5_000u64;
+
+    // 4. Create Token-2022 token account
+    let t22_token_account =
+        create_token_22_account(&mut rpc, &payer, &mint, &token_owner.pubkey()).await;
+
+    // 5. Mint Token-2022 tokens to the account
+    mint_spl_tokens_22(&mut rpc, &payer, &mint, &t22_token_account, mint_amount).await;
+
+    // Verify T22 account has tokens
+    let t22_account_data = rpc.get_account(t22_token_account).await.unwrap().unwrap();
+    let t22_account =
+        spl_pod::bytemuck::pod_from_bytes::<PodAccount>(&t22_account_data.data[..165]).unwrap();
+    let initial_t22_balance: u64 = t22_account.amount.into();
+    assert_eq!(initial_t22_balance, mint_amount);
+
+    // 6. Create cToken ATA for the recipient with compression_only: true (required for restricted extensions)
+    let ctoken_recipient = Keypair::new();
+    light_test_utils::airdrop_lamports(&mut rpc, &ctoken_recipient.pubkey(), 1_000_000_000)
+        .await
+        .unwrap();
+
+    let (ctoken_ata, _bump) = derive_ctoken_ata(&ctoken_recipient.pubkey(), &mint);
+    let compressible_params = CompressibleParams {
+        compression_only: true,
+        ..Default::default()
+    };
+    let create_ata_instruction =
+        CreateAssociatedCTokenAccount::new(payer.pubkey(), ctoken_recipient.pubkey(), mint)
+            .with_compressible(compressible_params)
+            .instruction()
+            .unwrap();
+
+    rpc.create_and_send_transaction(&[create_ata_instruction], &payer.pubkey(), &[&payer])
+        .await
+        .unwrap();
+
+    // Verify cToken ATA was created
+    let ctoken_account_data = rpc.get_account(ctoken_ata).await.unwrap().unwrap();
+    assert!(
+        !ctoken_account_data.data.is_empty(),
+        "cToken ATA should exist"
+    );
+
+    // 7. Transfer Token-2022 tokens to cToken account (use restricted=true for mints with restricted extensions)
+    let (spl_interface_pda, spl_interface_pda_bump) =
+        find_spl_interface_pda_with_index(&mint, 0, true);
+
+    let transfer_instruction = TransferSplToCtoken {
+        amount: transfer_amount,
+        spl_interface_pda_bump,
+        decimals,
+        source_spl_token_account: t22_token_account,
+        destination_ctoken_account: ctoken_ata,
+        authority: token_owner.pubkey(),
+        mint,
+        payer: payer.pubkey(),
+        spl_interface_pda,
+        spl_token_program: spl_token_2022::ID,
+    }
+    .instruction()
+    .unwrap();
+
+    rpc.create_and_send_transaction(
+        &[transfer_instruction],
+        &payer.pubkey(),
+        &[&payer, &token_owner],
+    )
+    .await
+    .unwrap();
+
+    // 7. Verify results
+    // Check T22 account balance decreased
+    let t22_account_data = rpc.get_account(t22_token_account).await.unwrap().unwrap();
+    let t22_account =
+        spl_pod::bytemuck::pod_from_bytes::<PodAccount>(&t22_account_data.data[..165]).unwrap();
+    let final_t22_balance: u64 = t22_account.amount.into();
+    assert_eq!(
+        final_t22_balance,
+        mint_amount - transfer_amount,
+        "T22 account balance should have decreased by transfer amount"
+    );
+
+    // Check cToken account balance increased
+    let ctoken_account_data = rpc.get_account(ctoken_ata).await.unwrap().unwrap();
+    let ctoken_account =
+        spl_pod::bytemuck::pod_from_bytes::<PodAccount>(&ctoken_account_data.data[..165]).unwrap();
+    let ctoken_balance: u64 = ctoken_account.amount.into();
+    assert_eq!(
+        ctoken_balance, transfer_amount,
+        "cToken account should have received the transferred tokens"
+    );
+
+    println!("Token-2022 to cToken transfer completed!");
+    println!("  - Created T22 mint with restricted extensions: {}", mint);
+    println!("  - Created T22 token account: {}", t22_token_account);
+    println!("  - Minted {} tokens to T22 account", mint_amount);
+    println!(
+        "  - Created cToken ATA (compression_only: true): {}",
+        ctoken_ata
+    );
+    println!(
+        "  - Transferred {} tokens from T22 to cToken",
+        transfer_amount
+    );
+    println!(
+        "  - Final T22 balance: {}, cToken balance: {}",
+        final_t22_balance, ctoken_balance
+    );
+
+    // 8. Advance 25 epochs to trigger compression (default prepaid is 16 epochs)
+    println!("\nAdvancing 25 epochs to trigger compression...");
+    rpc.warp_epoch_forward(25).await.unwrap();
+
+    // 9. Verify cToken account is compressed and closed
+    let closed_account = rpc.get_account(ctoken_ata).await.unwrap();
+    match closed_account {
+        Some(account) => {
+            assert_eq!(
+                account.lamports, 0,
+                "cToken account should be closed (0 lamports)"
+            );
+        }
+        None => {
+            println!("  - cToken account no longer exists (closed)");
+        }
+    }
+
+    // Verify compressed token account exists
+    let compressed_accounts = rpc
+        .get_compressed_token_accounts_by_owner(&ctoken_recipient.pubkey(), None, None)
+        .await
+        .unwrap()
+        .value
+        .items;
+
+    assert!(
+        !compressed_accounts.is_empty(),
+        "Compressed token account should exist after compression"
+    );
+
+    let compressed_account = &compressed_accounts[0];
+    assert_eq!(
+        compressed_account.token.owner,
+        ctoken_recipient.pubkey(),
+        "Compressed account owner should match"
+    );
+    assert_eq!(
+        compressed_account.token.amount, transfer_amount,
+        "Compressed account should have the transferred tokens"
+    );
+
+    println!("  - cToken account compressed and closed");
+    println!(
+        "  - Compressed token account owner: {}",
+        compressed_account.token.owner
+    );
+    println!(
+        "  - Compressed token account amount: {}",
+        compressed_account.token.amount
+    );
+
+    // 10. Recreate cToken ATA for decompression with compression_only: true
+    println!("\nRecreating cToken ATA for decompression...");
+    let compressible_params = CompressibleParams {
+        compression_only: true,
+        ..Default::default()
+    };
+    let create_ata_instruction =
+        CreateAssociatedCTokenAccount::new(payer.pubkey(), ctoken_recipient.pubkey(), mint)
+            .with_compressible(compressible_params)
+            .idempotent()
+            .instruction()
+            .unwrap();
+
+    rpc.create_and_send_transaction(&[create_ata_instruction], &payer.pubkey(), &[&payer])
+        .await
+        .unwrap();
+
+    // Verify cToken ATA was recreated
+    let ctoken_account_data = rpc.get_account(ctoken_ata).await.unwrap().unwrap();
+    assert!(
+        !ctoken_account_data.data.is_empty(),
+        "cToken ATA should exist after recreation"
+    );
+    println!("  - cToken ATA recreated: {}", ctoken_ata);
+
+    // 11. Get validity proof for the compressed account
+    let compressed_hashes: Vec<_> = compressed_accounts
+        .iter()
+        .map(|acc| acc.account.hash)
+        .collect();
+
+    let rpc_result = rpc
+        .get_validity_proof(compressed_hashes, vec![], None)
+        .await
+        .unwrap()
+        .value;
+
+    // Get token data and discriminator from compressed account
+    let token_data = compressed_accounts[0].token.clone();
+    let discriminator = compressed_accounts[0]
+        .account
+        .data
+        .as_ref()
+        .unwrap()
+        .discriminator;
+
+    // Get tree info from validity proof result
+    let account_proof = &rpc_result.accounts[0];
+
+    // 12. Decompress compressed tokens to cToken account
+    println!("Decompressing tokens to cToken account...");
+    let decompress_instruction = DecompressToCtoken {
+        token_data,
+        discriminator,
+        merkle_tree: account_proof.tree_info.tree,
+        queue: account_proof.tree_info.queue,
+        leaf_index: account_proof.leaf_index as u32,
+        root_index: account_proof.root_index.root_index().unwrap_or(0),
+        destination_ctoken_account: ctoken_ata,
+        payer: payer.pubkey(),
+        validity_proof: rpc_result.proof,
+    }
+    .instruction()
+    .unwrap();
+
+    rpc.create_and_send_transaction(
+        &[decompress_instruction],
+        &payer.pubkey(),
+        &[&payer, &ctoken_recipient],
+    )
+    .await
+    .unwrap();
+
+    // 13. Verify compressed accounts are consumed
+    let remaining_compressed = rpc
+        .get_compressed_token_accounts_by_owner(&ctoken_recipient.pubkey(), None, None)
+        .await
+        .unwrap()
+        .value
+        .items;
+
+    assert_eq!(
+        remaining_compressed.len(),
+        0,
+        "All compressed accounts should be consumed after decompression"
+    );
+    println!("  - Compressed accounts consumed");
+
+    // 14. Verify cToken account has tokens again
+    let ctoken_account_data = rpc.get_account(ctoken_ata).await.unwrap().unwrap();
+    let ctoken_account =
+        spl_pod::bytemuck::pod_from_bytes::<PodAccount>(&ctoken_account_data.data[..165]).unwrap();
+    let decompressed_balance: u64 = ctoken_account.amount.into();
+    assert_eq!(
+        decompressed_balance, transfer_amount,
+        "cToken account should have the decompressed tokens"
+    );
+    println!(
+        "  - cToken account balance after decompression: {}",
+        decompressed_balance
+    );
+
+    println!("\nToken-2022 (restricted extensions) to cToken scenario test passed!");
+}
diff --git a/sdk-tests/sdk-ctoken-test/tests/shared.rs b/sdk-tests/sdk-ctoken-test/tests/shared.rs
index 3f728be9f3..6b5f6c7c22 100644
--- a/sdk-tests/sdk-ctoken-test/tests/shared.rs
+++ b/sdk-tests/sdk-ctoken-test/tests/shared.rs
@@ -6,7 +6,7 @@ use solana_sdk::{pubkey::Pubkey, signature::Keypair, signer::Signer};
 
 /// Setup helper: Creates a compressed mint directly using the ctoken SDK (not via wrapper program)
 /// Optionally creates ATAs and mints tokens for each recipient.
-/// Returns (mint_pda, compression_address, ata_pubkeys)
+/// Returns (mint_pda, compression_address, ata_pubkeys, mint_seed_keypair)
 #[allow(unused)]
 pub async fn setup_create_compressed_mint(
     rpc: &mut (impl Rpc + Indexer),
@@ -14,7 +14,7 @@ pub async fn setup_create_compressed_mint(
     mint_authority: Pubkey,
     decimals: u8,
     recipients: Vec<(u64, Pubkey)>,
-) -> (Pubkey, [u8; 32], Vec<Pubkey>) {
+) -> (Pubkey, [u8; 32], Vec<Pubkey>, Keypair) {
     use light_ctoken_sdk::ctoken::{
         CreateAssociatedCTokenAccount, CreateCMint, CreateCMintParams, MintToCToken,
         MintToCTokenParams,
@@ -85,6 +85,237 @@ pub async fn setup_create_compressed_mint(
         "Compressed mint should exist after setup"
     );
 
+    // If no recipients, return early
+    if recipients.is_empty() {
+        return (mint, compression_address, vec![], mint_seed);
+    }
+
+    // Create ATAs for each recipient
+    use light_ctoken_sdk::ctoken::derive_ctoken_ata;
+
+    let mut ata_pubkeys = Vec::with_capacity(recipients.len());
+
+    for (_amount, owner) in &recipients {
+        let (ata_address, _bump) = derive_ctoken_ata(owner, &mint);
+        ata_pubkeys.push(ata_address);
+
+        let create_ata = CreateAssociatedCTokenAccount::new(payer.pubkey(), *owner, mint);
+        let ata_instruction = create_ata.instruction().unwrap();
+
+        rpc.create_and_send_transaction(&[ata_instruction], &payer.pubkey(), &[payer])
+            .await
+            .unwrap();
+    }
+
+    // Mint tokens to recipients with amount > 0
+    let recipients_with_amount: Vec<_> = recipients
+        .iter()
+        .enumerate()
+        .filter(|(_, (amount, _))| *amount > 0)
+        .collect();
+
+    if !recipients_with_amount.is_empty() {
+        // Get the compressed mint account for minting
+        let compressed_mint_account = rpc
+            .get_compressed_account(compression_address, None)
+            .await
+            .unwrap()
+            .value
+            .expect("Compressed mint should exist");
+
+        use light_ctoken_interface::state::CompressedMint;
+        let compressed_mint =
+            CompressedMint::deserialize(&mut compressed_mint_account.data.unwrap().data.as_slice())
+                .unwrap();
+
+        // Get validity proof for the mint operation
+        let rpc_result = rpc
+            .get_validity_proof(vec![compressed_mint_account.hash], vec![], None)
+            .await
+            .unwrap()
+            .value;
+
+        // Build CompressedMintWithContext
+        use light_ctoken_interface::instructions::mint_action::CompressedMintWithContext;
+        let compressed_mint_with_context = CompressedMintWithContext {
+            address: compression_address,
+            leaf_index: compressed_mint_account.leaf_index,
+            prove_by_index: true,
+            root_index: rpc_result.accounts[0]
+                .root_index
+                .root_index()
+                .unwrap_or_default(),
+            mint: Some(compressed_mint.try_into().unwrap()),
+        };
+
+        // Build mint params with first recipient
+        let (first_idx, (first_amount, _)) = recipients_with_amount[0];
+        let mut mint_params = MintToCTokenParams::new(
+            compressed_mint_with_context,
+            *first_amount,
+            mint_authority,
+            rpc_result.proof,
+        );
+        // Override the account_index for the first action
+        mint_params.mint_to_actions[0].account_index = first_idx as u8;
+
+        // Add remaining recipients
+        for (idx, (amount, _)) in recipients_with_amount.iter().skip(1) {
+            mint_params = mint_params.add_mint_to_action(*idx as u8, *amount);
+        }
+
+        // Build MintToCToken instruction
+        let mint_to_ctoken = MintToCToken::new(
+            mint_params,
+            payer.pubkey(),
+            compressed_mint_account.tree_info.tree,
+            compressed_mint_account.tree_info.queue,
+            compressed_mint_account.tree_info.queue,
+            ata_pubkeys.clone(),
+        );
+        let mint_instruction = mint_to_ctoken.instruction().unwrap();
+
+        rpc.create_and_send_transaction(&[mint_instruction], &payer.pubkey(), &[payer])
+            .await
+            .unwrap();
+    }
+
+    (mint, compression_address, ata_pubkeys, mint_seed)
+}
+
+/// Same as setup_create_compressed_mint but with optional freeze_authority
+/// Returns (mint_pda, compression_address, ata_pubkeys)
+#[allow(unused)]
+pub async fn setup_create_compressed_mint_with_freeze_authority(
+    rpc: &mut (impl Rpc + Indexer),
+    payer: &Keypair,
+    mint_authority: Pubkey,
+    freeze_authority: Option<Pubkey>,
+    decimals: u8,
+    recipients: Vec<(u64, Pubkey)>,
+) -> (Pubkey, [u8; 32], Vec<Pubkey>) {
+    use light_ctoken_sdk::ctoken::{
+        CreateAssociatedCTokenAccount, CreateCMint, CreateCMintParams, MintToCToken,
+        MintToCTokenParams,
+    };
+
+    let mint_seed = Keypair::new();
+    let address_tree = rpc.get_address_tree_v2();
+    let output_queue = rpc.get_random_state_tree_info().unwrap().queue;
+
+    // Derive compression address using SDK helpers
+    let compression_address = light_ctoken_sdk::ctoken::derive_cmint_compressed_address(
+        &mint_seed.pubkey(),
+        &address_tree.tree,
+    );
+
+    let mint = light_ctoken_sdk::ctoken::find_cmint_address(&mint_seed.pubkey()).0;
+
+    // Get validity proof for the address
+    let rpc_result = rpc
+        .get_validity_proof(
+            vec![],
+            vec![light_client::indexer::AddressWithTree {
+                address: compression_address,
+                tree: address_tree.tree,
+            }],
+            None,
+        )
+        .await
+        .unwrap()
+        .value;
+
+    // Build params for the SDK
+    let params = CreateCMintParams {
+        decimals,
+        address_merkle_tree_root_index: rpc_result.addresses[0].root_index,
+        mint_authority,
+        proof: rpc_result.proof.0.unwrap(),
+        compression_address,
+        mint,
+        freeze_authority,
+        extensions: None,
+    };
+
+    // Create instruction directly using SDK
+    let create_cmint_builder = CreateCMint::new(
+        params,
+        mint_seed.pubkey(),
+        payer.pubkey(),
+        address_tree.tree,
+        output_queue,
+    );
+    let instruction = create_cmint_builder.instruction().unwrap();
+
+    // Send transaction
+    rpc.create_and_send_transaction(&[instruction], &payer.pubkey(), &[payer, &mint_seed])
+        .await
+        .unwrap();
+
+    // Verify the compressed mint was created and get it for decompression
+    let compressed_mint_account = rpc
+        .get_compressed_account(compression_address, None)
+        .await
+        .unwrap()
+        .value
+        .expect("Compressed mint should exist after setup");
+
+    // Decompress the mint to create an on-chain CMint account
+    // This is required for freeze/thaw operations which need to read the mint
+    {
+        use light_ctoken_interface::{
+            instructions::mint_action::CompressedMintWithContext, state::CompressedMint,
+        };
+        use light_ctoken_sdk::ctoken::DecompressCMint;
+
+        let compressed_mint = CompressedMint::deserialize(
+            &mut compressed_mint_account
+                .data
+                .as_ref()
+                .unwrap()
+                .data
+                .as_slice(),
+        )
+        .unwrap();
+
+        // Get validity proof for the decompress operation
+        let rpc_result = rpc
+            .get_validity_proof(vec![compressed_mint_account.hash], vec![], None)
+            .await
+            .unwrap()
+            .value;
+
+        let compressed_mint_with_context = CompressedMintWithContext {
+            address: compression_address,
+            leaf_index: compressed_mint_account.leaf_index,
+            prove_by_index: true,
+            root_index: rpc_result.accounts[0]
+                .root_index
+                .root_index()
+                .unwrap_or_default(),
+            mint: Some(compressed_mint.try_into().unwrap()),
+        };
+
+        let decompress_ix = DecompressCMint {
+            mint_seed_pubkey: mint_seed.pubkey(),
+            payer: payer.pubkey(),
+            authority: mint_authority,
+            state_tree: compressed_mint_account.tree_info.tree,
+            input_queue: compressed_mint_account.tree_info.queue,
+            output_queue,
+            compressed_mint_with_context,
+            proof: rpc_result.proof,
+            rent_payment: 16,  // ~24 hours rent (16 epochs * 1.5h per epoch)
+            write_top_up: 766, // ~3 hours per write
+        }
+        .instruction()
+        .unwrap();
+
+        rpc.create_and_send_transaction(&[decompress_ix], &payer.pubkey(), &[payer])
+            .await
+            .unwrap();
+    }
+
     // If no recipients, return early
     if recipients.is_empty() {
         return (mint, compression_address, vec![]);
@@ -107,6 +338,146 @@ pub async fn setup_create_compressed_mint(
             .unwrap();
     }
 
+    // After decompression, use CTokenMintTo (simple 3-account instruction)
+    // instead of MintToCToken (which uses compressed mint)
+    let recipients_with_amount: Vec<_> = recipients
+        .iter()
+        .enumerate()
+        .filter(|(_, (amount, _))| *amount > 0)
+        .collect();
+
+    if !recipients_with_amount.is_empty() {
+        use light_ctoken_sdk::ctoken::CTokenMintTo;
+
+        for (idx, (amount, _)) in &recipients_with_amount {
+            let mint_instruction = CTokenMintTo {
+                cmint: mint,
+                destination: ata_pubkeys[*idx],
+                amount: *amount,
+                authority: mint_authority,
+                max_top_up: None,
+            }
+            .instruction()
+            .unwrap();
+
+            rpc.create_and_send_transaction(&[mint_instruction], &payer.pubkey(), &[payer])
+                .await
+                .unwrap();
+        }
+    }
+
+    (mint, compression_address, ata_pubkeys)
+}
+
+/// Same as setup_create_compressed_mint but with compression_only flag set
+#[allow(unused)]
+pub async fn setup_create_compressed_mint_with_compression_only(
+    rpc: &mut (impl Rpc + Indexer),
+    payer: &Keypair,
+    mint_authority: Pubkey,
+    decimals: u8,
+    recipients: Vec<(u64, Pubkey)>,
+    compression_only: bool,
+) -> (Pubkey, [u8; 32], Vec<Pubkey>) {
+    use light_ctoken_sdk::ctoken::{
+        CompressibleParams, CreateAssociatedCTokenAccount, CreateCMint, CreateCMintParams,
+        MintToCToken, MintToCTokenParams,
+    };
+
+    let mint_seed = Keypair::new();
+    let address_tree = rpc.get_address_tree_v2();
+    let output_queue = rpc.get_random_state_tree_info().unwrap().queue;
+
+    // Derive compression address using SDK helpers
+    let compression_address = light_ctoken_sdk::ctoken::derive_cmint_compressed_address(
+        &mint_seed.pubkey(),
+        &address_tree.tree,
+    );
+
+    let mint = light_ctoken_sdk::ctoken::find_cmint_address(&mint_seed.pubkey()).0;
+
+    // Get validity proof for the address
+    let rpc_result = rpc
+        .get_validity_proof(
+            vec![],
+            vec![light_client::indexer::AddressWithTree {
+                address: compression_address,
+                tree: address_tree.tree,
+            }],
+            None,
+        )
+        .await
+        .unwrap()
+        .value;
+
+    // Build params for the SDK
+    let params = CreateCMintParams {
+        decimals,
+        address_merkle_tree_root_index: rpc_result.addresses[0].root_index,
+        mint_authority,
+        proof: rpc_result.proof.0.unwrap(),
+        compression_address,
+        mint,
+        freeze_authority: None,
+        extensions: None,
+    };
+
+    // Create instruction directly using SDK
+    let create_cmint_builder = CreateCMint::new(
+        params,
+        mint_seed.pubkey(),
+        payer.pubkey(),
+        address_tree.tree,
+        output_queue,
+    );
+    let instruction = create_cmint_builder.instruction().unwrap();
+
+    // Send transaction
+    rpc.create_and_send_transaction(&[instruction], &payer.pubkey(), &[payer, &mint_seed])
+        .await
+        .unwrap();
+
+    // Verify the compressed mint was created
+    let compressed_account = rpc
+        .get_compressed_account(compression_address, None)
+        .await
+        .unwrap()
+        .value;
+
+    assert!(
+        compressed_account.is_some(),
+        "Compressed mint should exist after setup"
+    );
+
+    // If no recipients, return early
+    if recipients.is_empty() {
+        return (mint, compression_address, vec![]);
+    }
+
+    // Create ATAs for each recipient with custom compression_only setting
+    use light_ctoken_sdk::ctoken::derive_ctoken_ata;
+
+    let mut ata_pubkeys = Vec::with_capacity(recipients.len());
+
+    // Build custom CompressibleParams with compression_only flag
+    let compressible_params = CompressibleParams {
+        compression_only,
+        ..Default::default()
+    };
+
+    for (_amount, owner) in &recipients {
+        let (ata_address, _bump) = derive_ctoken_ata(owner, &mint);
+        ata_pubkeys.push(ata_address);
+
+        let create_ata = CreateAssociatedCTokenAccount::new(payer.pubkey(), *owner, mint)
+            .with_compressible(compressible_params.clone());
+        let ata_instruction = create_ata.instruction().unwrap();
+
+        rpc.create_and_send_transaction(&[ata_instruction], &payer.pubkey(), &[payer])
+            .await
+            .unwrap();
+    }
+
     // Mint tokens to recipients with amount > 0
     let recipients_with_amount: Vec<_> = recipients
         .iter()
diff --git a/sdk-tests/sdk-ctoken-test/tests/test_approve_revoke.rs b/sdk-tests/sdk-ctoken-test/tests/test_approve_revoke.rs
new file mode 100644
index 0000000000..1abca1dcc6
--- /dev/null
+++ b/sdk-tests/sdk-ctoken-test/tests/test_approve_revoke.rs
@@ -0,0 +1,311 @@
+// Tests for ApproveCTokenCpi and RevokeCTokenCpi invoke() and invoke_signed()
+
+mod shared;
+
+use borsh::{BorshDeserialize, BorshSerialize};
+use light_client::rpc::Rpc;
+use light_ctoken_interface::state::CToken;
+use light_program_test::{LightProgramTest, ProgramTestConfig};
+use light_sdk_types::C_TOKEN_PROGRAM_ID;
+use native_ctoken_examples::{ApproveData, InstructionType, ID, TOKEN_ACCOUNT_SEED};
+use shared::*;
+use solana_sdk::{
+    instruction::{AccountMeta, Instruction},
+    pubkey::Pubkey,
+    signature::Keypair,
+    signer::Signer,
+};
+
+/// Test approving a delegate using ApproveCTokenCpi::invoke()
+#[tokio::test]
+async fn test_approve_invoke() {
+    let config = ProgramTestConfig::new_v2(true, Some(vec![("native_ctoken_examples", ID)]));
+    let mut rpc = LightProgramTest::new(config).await.unwrap();
+    let payer = rpc.get_payer().insecure_clone();
+
+    // Create a compressed mint with an ATA for the payer with 1000 tokens
+    let (_mint_pda, _compression_address, ata_pubkeys, _mint_seed) = setup_create_compressed_mint(
+        &mut rpc,
+        &payer,
+        payer.pubkey(),
+        9,
+        vec![(1000, payer.pubkey())],
+    )
+    .await;
+
+    let ata = ata_pubkeys[0];
+    let delegate = Keypair::new();
+    let approve_amount = 100u64;
+
+    // Build approve instruction via wrapper program
+    let mut instruction_data = vec![InstructionType::ApproveInvoke as u8];
+    let approve_data = ApproveData {
+        amount: approve_amount,
+    };
+    approve_data.serialize(&mut instruction_data).unwrap();
+
+    let ctoken_program = Pubkey::from(C_TOKEN_PROGRAM_ID);
+    let instruction = Instruction {
+        program_id: ID,
+        accounts: vec![
+            AccountMeta::new(ata, false),                        // token_account
+            AccountMeta::new_readonly(delegate.pubkey(), false), // delegate
+            AccountMeta::new(payer.pubkey(), true),              // owner (signer)
+            AccountMeta::new_readonly(Pubkey::default(), false), // system_program
+            AccountMeta::new_readonly(ctoken_program, false),    // ctoken_program
+        ],
+        data: instruction_data,
+    };
+
+    // Execute the approve instruction
+    rpc.create_and_send_transaction(&[instruction], &payer.pubkey(), &[&payer])
+        .await
+        .unwrap();
+
+    // Verify the delegate was set
+    let ata_account = rpc.get_account(ata).await.unwrap().unwrap();
+    let ctoken = CToken::deserialize(&mut &ata_account.data[..]).unwrap();
+
+    assert_eq!(
+        ctoken.delegate,
+        Some(delegate.pubkey().to_bytes().into()),
+        "Delegate should be set after approve"
+    );
+    assert_eq!(
+        ctoken.delegated_amount, approve_amount,
+        "Delegated amount should match"
+    );
+}
+
+/// Test approving a delegate for a PDA-owned account using ApproveCTokenCpi::invoke_signed()
+#[tokio::test]
+async fn test_approve_invoke_signed() {
+    let config = ProgramTestConfig::new_v2(true, Some(vec![("native_ctoken_examples", ID)]));
+    let mut rpc = LightProgramTest::new(config).await.unwrap();
+    let payer = rpc.get_payer().insecure_clone();
+
+    // Derive the PDA that will own the token account
+    let (pda_owner, _bump) = Pubkey::find_program_address(&[TOKEN_ACCOUNT_SEED], &ID);
+
+    // Create a compressed mint with an ATA for the PDA owner with 1000 tokens
+    let (_mint_pda, _compression_address, ata_pubkeys, _mint_seed) =
+        setup_create_compressed_mint(&mut rpc, &payer, payer.pubkey(), 9, vec![(1000, pda_owner)])
+            .await;
+
+    let ata = ata_pubkeys[0];
+    let delegate = Keypair::new();
+    let approve_amount = 100u64;
+
+    // Build approve instruction via wrapper program using invoke_signed
+    let mut instruction_data = vec![InstructionType::ApproveInvokeSigned as u8];
+    let approve_data = ApproveData {
+        amount: approve_amount,
+    };
+    approve_data.serialize(&mut instruction_data).unwrap();
+
+    let ctoken_program = Pubkey::from(C_TOKEN_PROGRAM_ID);
+    let instruction = Instruction {
+        program_id: ID,
+        accounts: vec![
+            AccountMeta::new(ata, false),                        // token_account
+            AccountMeta::new_readonly(delegate.pubkey(), false), // delegate
+            AccountMeta::new(pda_owner, false),                  // PDA owner (program signs)
+            AccountMeta::new_readonly(Pubkey::default(), false), // system_program
+            AccountMeta::new_readonly(ctoken_program, false),    // ctoken_program
+        ],
+        data: instruction_data,
+    };
+
+    // Execute the approve instruction
+    rpc.create_and_send_transaction(&[instruction], &payer.pubkey(), &[&payer])
+        .await
+        .unwrap();
+
+    // Verify the delegate was set
+    let ata_account = rpc.get_account(ata).await.unwrap().unwrap();
+    let ctoken = CToken::deserialize(&mut &ata_account.data[..]).unwrap();
+
+    assert_eq!(
+        ctoken.delegate,
+        Some(delegate.pubkey().to_bytes().into()),
+        "Delegate should be set after approve"
+    );
+    assert_eq!(
+        ctoken.delegated_amount, approve_amount,
+        "Delegated amount should match"
+    );
+}
+
+/// Test revoking delegation using RevokeCTokenCpi::invoke()
+#[tokio::test]
+async fn test_revoke_invoke() {
+    let config = ProgramTestConfig::new_v2(true, Some(vec![("native_ctoken_examples", ID)]));
+    let mut rpc = LightProgramTest::new(config).await.unwrap();
+    let payer = rpc.get_payer().insecure_clone();
+
+    // Create a compressed mint with an ATA for the payer with 1000 tokens
+    let (_mint_pda, _compression_address, ata_pubkeys, _mint_seed) = setup_create_compressed_mint(
+        &mut rpc,
+        &payer,
+        payer.pubkey(),
+        9,
+        vec![(1000, payer.pubkey())],
+    )
+    .await;
+
+    let ata = ata_pubkeys[0];
+    let delegate = Keypair::new();
+    let approve_amount = 100u64;
+    let ctoken_program = Pubkey::from(C_TOKEN_PROGRAM_ID);
+
+    // First approve a delegate
+    let mut approve_instruction_data = vec![InstructionType::ApproveInvoke as u8];
+    let approve_data = ApproveData {
+        amount: approve_amount,
+    };
+    approve_data
+        .serialize(&mut approve_instruction_data)
+        .unwrap();
+
+    let approve_instruction = Instruction {
+        program_id: ID,
+        accounts: vec![
+            AccountMeta::new(ata, false),
+            AccountMeta::new_readonly(delegate.pubkey(), false),
+            AccountMeta::new(payer.pubkey(), true),
+            AccountMeta::new_readonly(Pubkey::default(), false),
+            AccountMeta::new_readonly(ctoken_program, false),
+        ],
+        data: approve_instruction_data,
+    };
+
+    rpc.create_and_send_transaction(&[approve_instruction], &payer.pubkey(), &[&payer])
+        .await
+        .unwrap();
+
+    // Verify delegate was set
+    let ata_account_after_approve = rpc.get_account(ata).await.unwrap().unwrap();
+    let ctoken_after_approve =
+        CToken::deserialize(&mut &ata_account_after_approve.data[..]).unwrap();
+    assert!(
+        ctoken_after_approve.delegate.is_some(),
+        "Delegate should be set"
+    );
+
+    // Now revoke the delegation
+    let revoke_instruction_data = vec![InstructionType::RevokeInvoke as u8];
+
+    let revoke_instruction = Instruction {
+        program_id: ID,
+        accounts: vec![
+            AccountMeta::new(ata, false),                        // token_account
+            AccountMeta::new(payer.pubkey(), true),              // owner (signer)
+            AccountMeta::new_readonly(Pubkey::default(), false), // system_program
+            AccountMeta::new_readonly(ctoken_program, false),    // ctoken_program
+        ],
+        data: revoke_instruction_data,
+    };
+
+    rpc.create_and_send_transaction(&[revoke_instruction], &payer.pubkey(), &[&payer])
+        .await
+        .unwrap();
+
+    // Verify the delegate was cleared
+    let ata_account_after_revoke = rpc.get_account(ata).await.unwrap().unwrap();
+    let ctoken_after_revoke = CToken::deserialize(&mut &ata_account_after_revoke.data[..]).unwrap();
+
+    assert_eq!(
+        ctoken_after_revoke.delegate, None,
+        "Delegate should be cleared after revoke"
+    );
+    assert_eq!(
+        ctoken_after_revoke.delegated_amount, 0,
+        "Delegated amount should be 0 after revoke"
+    );
+}
+
+/// Test revoking delegation for a PDA-owned account using RevokeCTokenCpi::invoke_signed()
+#[tokio::test]
+async fn test_revoke_invoke_signed() {
+    let config = ProgramTestConfig::new_v2(true, Some(vec![("native_ctoken_examples", ID)]));
+    let mut rpc = LightProgramTest::new(config).await.unwrap();
+    let payer = rpc.get_payer().insecure_clone();
+
+    // Derive the PDA that will own the token account
+    let (pda_owner, _bump) = Pubkey::find_program_address(&[TOKEN_ACCOUNT_SEED], &ID);
+
+    // Create a compressed mint with an ATA for the PDA owner with 1000 tokens
+    let (_mint_pda, _compression_address, ata_pubkeys, _mint_seed) =
+        setup_create_compressed_mint(&mut rpc, &payer, payer.pubkey(), 9, vec![(1000, pda_owner)])
+            .await;
+
+    let ata = ata_pubkeys[0];
+    let delegate = Keypair::new();
+    let approve_amount = 100u64;
+    let ctoken_program = Pubkey::from(C_TOKEN_PROGRAM_ID);
+
+    // First approve a delegate using invoke_signed
+    let mut approve_instruction_data = vec![InstructionType::ApproveInvokeSigned as u8];
+    let approve_data = ApproveData {
+        amount: approve_amount,
+    };
+    approve_data
+        .serialize(&mut approve_instruction_data)
+        .unwrap();
+
+    let approve_instruction = Instruction {
+        program_id: ID,
+        accounts: vec![
+            AccountMeta::new(ata, false),
+            AccountMeta::new_readonly(delegate.pubkey(), false),
+            AccountMeta::new(pda_owner, false),
+            AccountMeta::new_readonly(Pubkey::default(), false),
+            AccountMeta::new_readonly(ctoken_program, false),
+        ],
+        data: approve_instruction_data,
+    };
+
+    rpc.create_and_send_transaction(&[approve_instruction], &payer.pubkey(), &[&payer])
+        .await
+        .unwrap();
+
+    // Verify delegate was set
+    let ata_account_after_approve = rpc.get_account(ata).await.unwrap().unwrap();
+    let ctoken_after_approve =
+        CToken::deserialize(&mut &ata_account_after_approve.data[..]).unwrap();
+    assert!(
+        ctoken_after_approve.delegate.is_some(),
+        "Delegate should be set"
+    );
+
+    // Now revoke the delegation using invoke_signed
+    let revoke_instruction_data = vec![InstructionType::RevokeInvokeSigned as u8];
+
+    let revoke_instruction = Instruction {
+        program_id: ID,
+        accounts: vec![
+            AccountMeta::new(ata, false),                        // token_account
+            AccountMeta::new(pda_owner, false),                  // PDA owner (program signs)
+            AccountMeta::new_readonly(Pubkey::default(), false), // system_program
+            AccountMeta::new_readonly(ctoken_program, false),    // ctoken_program
+        ],
+        data: revoke_instruction_data,
+    };
+
+    rpc.create_and_send_transaction(&[revoke_instruction], &payer.pubkey(), &[&payer])
+        .await
+        .unwrap();
+
+    // Verify the delegate was cleared
+    let ata_account_after_revoke = rpc.get_account(ata).await.unwrap().unwrap();
+    let ctoken_after_revoke = CToken::deserialize(&mut &ata_account_after_revoke.data[..]).unwrap();
+
+    assert_eq!(
+        ctoken_after_revoke.delegate, None,
+        "Delegate should be cleared after revoke"
+    );
+    assert_eq!(
+        ctoken_after_revoke.delegated_amount, 0,
+        "Delegated amount should be 0 after revoke"
+    );
+}
diff --git a/sdk-tests/sdk-ctoken-test/tests/test_burn.rs b/sdk-tests/sdk-ctoken-test/tests/test_burn.rs
new file mode 100644
index 0000000000..9f1b8e3478
--- /dev/null
+++ b/sdk-tests/sdk-ctoken-test/tests/test_burn.rs
@@ -0,0 +1,145 @@
+// Tests for BurnCTokenCpi invoke() and invoke_signed()
+
+mod shared;
+
+use borsh::{BorshDeserialize, BorshSerialize};
+use light_client::rpc::Rpc;
+use light_ctoken_interface::state::CToken;
+use light_program_test::{LightProgramTest, ProgramTestConfig};
+use light_sdk_types::C_TOKEN_PROGRAM_ID;
+use native_ctoken_examples::{BurnData, InstructionType, ID, TOKEN_ACCOUNT_SEED};
+use shared::*;
+use solana_sdk::{
+    instruction::{AccountMeta, Instruction},
+    pubkey::Pubkey,
+    signer::Signer,
+};
+
+/// Test burning CTokens using BurnCTokenCpi::invoke()
+#[tokio::test]
+async fn test_burn_invoke() {
+    let config = ProgramTestConfig::new_v2(true, Some(vec![("native_ctoken_examples", ID)]));
+    let mut rpc = LightProgramTest::new(config).await.unwrap();
+    let payer = rpc.get_payer().insecure_clone();
+
+    // Create a decompressed mint (required for burn) with an ATA for the payer with 1000 tokens
+    let (mint_pda, _compression_address, ata_pubkeys) =
+        setup_create_compressed_mint_with_freeze_authority(
+            &mut rpc,
+            &payer,
+            payer.pubkey(),
+            None, // No freeze authority needed for burn test
+            9,
+            vec![(1000, payer.pubkey())],
+        )
+        .await;
+
+    let ata = ata_pubkeys[0];
+    let burn_amount = 300u64;
+
+    // Get initial state
+    let ata_account_before = rpc.get_account(ata).await.unwrap().unwrap();
+    let ctoken_before = CToken::deserialize(&mut &ata_account_before.data[..]).unwrap();
+
+    // Build burn instruction via wrapper program
+    let mut instruction_data = vec![InstructionType::BurnInvoke as u8];
+    let burn_data = BurnData {
+        amount: burn_amount,
+    };
+    burn_data.serialize(&mut instruction_data).unwrap();
+
+    let ctoken_program = Pubkey::from(C_TOKEN_PROGRAM_ID);
+    let instruction = Instruction {
+        program_id: ID,
+        accounts: vec![
+            AccountMeta::new(ata, false),                     // source
+            AccountMeta::new(mint_pda, false),                // cmint
+            AccountMeta::new_readonly(payer.pubkey(), true),  // authority (signer)
+            AccountMeta::new_readonly(ctoken_program, false), // ctoken_program
+        ],
+        data: instruction_data,
+    };
+
+    // Execute the burn instruction
+    rpc.create_and_send_transaction(&[instruction], &payer.pubkey(), &[&payer])
+        .await
+        .unwrap();
+
+    // Verify with single assert_eq
+    let ata_account_after = rpc.get_account(ata).await.unwrap().unwrap();
+    let ctoken_after = CToken::deserialize(&mut &ata_account_after.data[..]).unwrap();
+
+    let mut expected_ctoken = ctoken_before;
+    expected_ctoken.amount = 700; // 1000 - 300
+
+    assert_eq!(
+        ctoken_after, expected_ctoken,
+        "CToken should match expected state after burn"
+    );
+}
+
+/// Test burning CTokens with PDA authority using BurnCTokenCpi::invoke_signed()
+#[tokio::test]
+async fn test_burn_invoke_signed() {
+    let config = ProgramTestConfig::new_v2(true, Some(vec![("native_ctoken_examples", ID)]));
+    let mut rpc = LightProgramTest::new(config).await.unwrap();
+    let payer = rpc.get_payer().insecure_clone();
+
+    // Derive the PDA that will own the token account
+    let (pda_owner, _bump) = Pubkey::find_program_address(&[TOKEN_ACCOUNT_SEED], &ID);
+
+    // Create a decompressed mint with an ATA for the PDA owner with 1000 tokens
+    let (mint_pda, _compression_address, ata_pubkeys) =
+        setup_create_compressed_mint_with_freeze_authority(
+            &mut rpc,
+            &payer,
+            payer.pubkey(),
+            None, // No freeze authority needed for burn test
+            9,
+            vec![(1000, pda_owner)],
+        )
+        .await;
+
+    let ata = ata_pubkeys[0];
+    let burn_amount = 500u64;
+
+    // Get initial state
+    let ata_account_before = rpc.get_account(ata).await.unwrap().unwrap();
+    let ctoken_before = CToken::deserialize(&mut &ata_account_before.data[..]).unwrap();
+
+    // Build burn instruction via wrapper program using invoke_signed
+    let mut instruction_data = vec![InstructionType::BurnInvokeSigned as u8];
+    let burn_data = BurnData {
+        amount: burn_amount,
+    };
+    burn_data.serialize(&mut instruction_data).unwrap();
+
+    let ctoken_program = Pubkey::from(C_TOKEN_PROGRAM_ID);
+    let instruction = Instruction {
+        program_id: ID,
+        accounts: vec![
+            AccountMeta::new(ata, false),                     // source
+            AccountMeta::new(mint_pda, false),                // cmint
+            AccountMeta::new_readonly(pda_owner, false),      // PDA authority (program signs)
+            AccountMeta::new_readonly(ctoken_program, false), // ctoken_program
+        ],
+        data: instruction_data,
+    };
+
+    // Execute the burn instruction
+    rpc.create_and_send_transaction(&[instruction], &payer.pubkey(), &[&payer])
+        .await
+        .unwrap();
+
+    // Verify with single assert_eq
+    let ata_account_after = rpc.get_account(ata).await.unwrap().unwrap();
+    let ctoken_after = CToken::deserialize(&mut &ata_account_after.data[..]).unwrap();
+
+    let mut expected_ctoken = ctoken_before;
+    expected_ctoken.amount = 500; // 1000 - 500
+
+    assert_eq!(
+        ctoken_after, expected_ctoken,
+        "CToken should match expected state after burn"
+    );
+}
diff --git a/sdk-tests/sdk-ctoken-test/tests/test_close.rs b/sdk-tests/sdk-ctoken-test/tests/test_close.rs
index f87680de2b..9ff68e8401 100644
--- a/sdk-tests/sdk-ctoken-test/tests/test_close.rs
+++ b/sdk-tests/sdk-ctoken-test/tests/test_close.rs
@@ -21,7 +21,7 @@ async fn test_close_invoke() {
     let payer = rpc.get_payer().insecure_clone();
 
     // Create a compressed mint with an ATA for the payer
-    let (_mint_pda, _compression_address, ata_pubkeys) = setup_create_compressed_mint(
+    let (_mint_pda, _compression_address, ata_pubkeys, _mint_seed) = setup_create_compressed_mint(
         &mut rpc,
         &payer,
         payer.pubkey(),
@@ -78,7 +78,7 @@ async fn test_close_invoke_signed() {
     let (pda_owner, _bump) = Pubkey::find_program_address(&[TOKEN_ACCOUNT_SEED], &ID);
 
     // Create a compressed mint with an ATA for the PDA owner
-    let (_mint_pda, _compression_address, ata_pubkeys) = setup_create_compressed_mint(
+    let (_mint_pda, _compression_address, ata_pubkeys, _mint_seed) = setup_create_compressed_mint(
         &mut rpc,
         &payer,
         payer.pubkey(),
diff --git a/sdk-tests/sdk-ctoken-test/tests/test_create_ata.rs b/sdk-tests/sdk-ctoken-test/tests/test_create_ata.rs
index 33ef4bb81c..9e4a264deb 100644
--- a/sdk-tests/sdk-ctoken-test/tests/test_create_ata.rs
+++ b/sdk-tests/sdk-ctoken-test/tests/test_create_ata.rs
@@ -28,7 +28,7 @@ async fn test_create_ata_invoke() {
     let mint_authority = payer.pubkey();
 
     // Create compressed mint first (using helper)
-    let (mint_pda, _compression_address, _) =
+    let (mint_pda, _compression_address, _, _mint_seed) =
         setup_create_compressed_mint(&mut rpc, &payer, mint_authority, 9, vec![]).await;
 
     // Derive the ATA address
@@ -102,7 +102,7 @@ async fn test_create_ata_invoke_signed() {
     let mint_authority = payer.pubkey();
 
     // Create compressed mint first (using helper)
-    let (mint_pda, _compression_address, _) =
+    let (mint_pda, _compression_address, _, _mint_seed) =
         setup_create_compressed_mint(&mut rpc, &payer, mint_authority, 9, vec![]).await;
 
     // Derive the PDA that will act as payer/owner (using ATA_SEED)
diff --git a/sdk-tests/sdk-ctoken-test/tests/test_create_ata_v2.rs b/sdk-tests/sdk-ctoken-test/tests/test_create_ata_v2.rs
deleted file mode 100644
index bef5997c31..0000000000
--- a/sdk-tests/sdk-ctoken-test/tests/test_create_ata_v2.rs
+++ /dev/null
@@ -1,170 +0,0 @@
-// Tests for CreateAssociatedTokenAccount2Infos invoke() and invoke_signed()
-
-mod shared;
-
-use borsh::BorshSerialize;
-use light_client::rpc::Rpc;
-use light_ctoken_sdk::ctoken::{
-    config_pda, derive_ctoken_ata, rent_sponsor_pda, CTOKEN_PROGRAM_ID,
-};
-use light_program_test::{LightProgramTest, ProgramTestConfig};
-use native_ctoken_examples::{CreateAta2Data, InstructionType, ATA_SEED, ID};
-use shared::*;
-use solana_sdk::{
-    instruction::{AccountMeta, Instruction},
-    pubkey::Pubkey,
-    signer::Signer,
-};
-
-/// Test creating an ATA using V2 variant (owner/mint as accounts) with invoke()
-#[tokio::test]
-async fn test_create_ata2_invoke() {
-    let config = ProgramTestConfig::new_v2(true, Some(vec![("native_ctoken_examples", ID)]));
-    let mut rpc = LightProgramTest::new(config).await.unwrap();
-    let payer = rpc.get_payer().insecure_clone();
-
-    // Create a compressed mint (no recipients, just the mint)
-    let (mint_pda, _compression_address, _) =
-        setup_create_compressed_mint(&mut rpc, &payer, payer.pubkey(), 9, vec![]).await;
-
-    // Derive the ATA address
-    let owner = payer.pubkey();
-    let (ata_address, bump) = derive_ctoken_ata(&owner, &mint_pda);
-
-    // Verify ATA doesn't exist yet
-    let ata_account_before = rpc.get_account(ata_address).await.unwrap();
-    assert!(ata_account_before.is_none(), "ATA should not exist yet");
-
-    // Get config and rent sponsor
-    let compressible_config = config_pda();
-    let rent_sponsor = rent_sponsor_pda();
-
-    // Build instruction data
-    let create_ata2_data = CreateAta2Data {
-        bump,
-        pre_pay_num_epochs: 2,
-        lamports_per_write: 1000,
-    };
-    let instruction_data = [
-        vec![InstructionType::CreateAta2Invoke as u8],
-        create_ata2_data.try_to_vec().unwrap(),
-    ]
-    .concat();
-
-    // Account order for CreateAta2Invoke:
-    // - accounts[0]: owner (readonly)
-    // - accounts[1]: mint (readonly)
-    // - accounts[2]: payer (signer, writable)
-    // - accounts[3]: associated_token_account (writable)
-    // - accounts[4]: system_program
-    // - accounts[5]: compressible_config
-    // - accounts[6]: rent_sponsor (writable)
-    // - accounts[7]: ctoken_program (for CPI)
-    let instruction = Instruction {
-        program_id: ID,
-        accounts: vec![
-            AccountMeta::new_readonly(owner, false),
-            AccountMeta::new_readonly(mint_pda, false),
-            AccountMeta::new(payer.pubkey(), true),
-            AccountMeta::new(ata_address, false),
-            AccountMeta::new_readonly(Pubkey::default(), false), // system_program
-            AccountMeta::new_readonly(compressible_config, false),
-            AccountMeta::new(rent_sponsor, false),
-            AccountMeta::new_readonly(CTOKEN_PROGRAM_ID, false),
-        ],
-        data: instruction_data,
-    };
-
-    // Execute the instruction
-    rpc.create_and_send_transaction(&[instruction], &payer.pubkey(), &[&payer])
-        .await
-        .unwrap();
-
-    // Verify ATA was created
-    let ata_account_after = rpc.get_account(ata_address).await.unwrap();
-    assert!(
-        ata_account_after.is_some(),
-        "ATA should exist after create_ata2"
-    );
-}
-
-/// Test creating an ATA using V2 variant with PDA payer via invoke_signed()
-#[tokio::test]
-async fn test_create_ata2_invoke_signed() {
-    let config = ProgramTestConfig::new_v2(true, Some(vec![("native_ctoken_examples", ID)]));
-    let mut rpc = LightProgramTest::new(config).await.unwrap();
-    let payer = rpc.get_payer().insecure_clone();
-
-    // Create a compressed mint (no recipients, just the mint)
-    let (mint_pda, _compression_address, _) =
-        setup_create_compressed_mint(&mut rpc, &payer, payer.pubkey(), 9, vec![]).await;
-
-    // Derive the PDA that will act as payer
-    let (pda_payer, _pda_bump) = Pubkey::find_program_address(&[ATA_SEED], &ID);
-
-    // Fund the PDA payer so it can pay for the ATA creation
-    let fund_ix = solana_sdk::system_instruction::transfer(&payer.pubkey(), &pda_payer, 10_000_000);
-    rpc.create_and_send_transaction(&[fund_ix], &payer.pubkey(), &[&payer])
-        .await
-        .unwrap();
-
-    // The owner will be the regular payer (not the PDA)
-    let owner = payer.pubkey();
-    let (ata_address, bump) = derive_ctoken_ata(&owner, &mint_pda);
-
-    // Verify ATA doesn't exist yet
-    let ata_account_before = rpc.get_account(ata_address).await.unwrap();
-    assert!(ata_account_before.is_none(), "ATA should not exist yet");
-
-    // Get config and rent sponsor
-    let compressible_config = config_pda();
-    let rent_sponsor = rent_sponsor_pda();
-
-    // Build instruction data
-    let create_ata2_data = CreateAta2Data {
-        bump,
-        pre_pay_num_epochs: 2,
-        lamports_per_write: 1000,
-    };
-    let instruction_data = [
-        vec![InstructionType::CreateAta2InvokeSigned as u8],
-        create_ata2_data.try_to_vec().unwrap(),
-    ]
-    .concat();
-
-    // Account order for CreateAta2InvokeSigned:
-    // - accounts[0]: owner (readonly)
-    // - accounts[1]: mint (readonly)
-    // - accounts[2]: payer (PDA, writable, not signer - program signs)
-    // - accounts[3]: associated_token_account (writable)
-    // - accounts[4]: system_program
-    // - accounts[5]: compressible_config
-    // - accounts[6]: rent_sponsor (writable)
-    // - accounts[7]: ctoken_program (for CPI)
-    let instruction = Instruction {
-        program_id: ID,
-        accounts: vec![
-            AccountMeta::new_readonly(owner, false),
-            AccountMeta::new_readonly(mint_pda, false),
-            AccountMeta::new(pda_payer, false), // PDA payer, not signer
-            AccountMeta::new(ata_address, false),
-            AccountMeta::new_readonly(Pubkey::default(), false), // system_program
-            AccountMeta::new_readonly(compressible_config, false),
-            AccountMeta::new(rent_sponsor, false),
-            AccountMeta::new_readonly(CTOKEN_PROGRAM_ID, false),
-        ],
-        data: instruction_data,
-    };
-
-    // Execute the instruction
-    rpc.create_and_send_transaction(&[instruction], &payer.pubkey(), &[&payer])
-        .await
-        .unwrap();
-
-    // Verify ATA was created
-    let ata_account_after = rpc.get_account(ata_address).await.unwrap();
-    assert!(
-        ata_account_after.is_some(),
-        "ATA should exist after create_ata2_invoke_signed"
-    );
-}
diff --git a/sdk-tests/sdk-ctoken-test/tests/test_create_token_account.rs b/sdk-tests/sdk-ctoken-test/tests/test_create_token_account.rs
index 890b6ab51e..51cc49fdb3 100644
--- a/sdk-tests/sdk-ctoken-test/tests/test_create_token_account.rs
+++ b/sdk-tests/sdk-ctoken-test/tests/test_create_token_account.rs
@@ -29,7 +29,7 @@ async fn test_create_token_account_invoke() {
     let mint_authority = payer.pubkey();
 
     // Create compressed mint first (using helper)
-    let (mint_pda, _compression_address, _) =
+    let (mint_pda, _compression_address, _, _mint_seed) =
         setup_create_compressed_mint(&mut rpc, &payer, mint_authority, 9, vec![]).await;
 
     // Create ctoken account via wrapper program
@@ -102,7 +102,7 @@ async fn test_create_token_account_invoke_signed() {
     let mint_authority = payer.pubkey();
 
     // Create compressed mint first (using helper)
-    let (mint_pda, _compression_address, _) =
+    let (mint_pda, _compression_address, _, _mint_seed) =
         setup_create_compressed_mint(&mut rpc, &payer, mint_authority, 9, vec![]).await;
 
     // Derive the PDA for the token account (same seeds as in the program)
diff --git a/sdk-tests/sdk-ctoken-test/tests/test_ctoken_mint_to.rs b/sdk-tests/sdk-ctoken-test/tests/test_ctoken_mint_to.rs
new file mode 100644
index 0000000000..c9ae154990
--- /dev/null
+++ b/sdk-tests/sdk-ctoken-test/tests/test_ctoken_mint_to.rs
@@ -0,0 +1,340 @@
+// Tests for CTokenMintToCpi invoke() and invoke_signed()
+
+mod shared;
+
+use borsh::{BorshDeserialize, BorshSerialize};
+use light_client::rpc::Rpc;
+use light_ctoken_interface::state::CToken;
+use light_program_test::{LightProgramTest, ProgramTestConfig};
+use light_sdk_types::C_TOKEN_PROGRAM_ID;
+use native_ctoken_examples::{InstructionType, MintToData, ID, MINT_AUTHORITY_SEED};
+use shared::*;
+use solana_sdk::{
+    instruction::{AccountMeta, Instruction},
+    pubkey::Pubkey,
+    signer::Signer,
+};
+
+/// Test minting to CToken using CTokenMintToCpi::invoke()
+#[tokio::test]
+async fn test_ctoken_mint_to_invoke() {
+    let config = ProgramTestConfig::new_v2(true, Some(vec![("native_ctoken_examples", ID)]));
+    let mut rpc = LightProgramTest::new(config).await.unwrap();
+    let payer = rpc.get_payer().insecure_clone();
+
+    // Create a decompressed mint with an ATA for the payer with 0 tokens
+    let (mint_pda, _compression_address, ata_pubkeys) =
+        setup_create_compressed_mint_with_freeze_authority(
+            &mut rpc,
+            &payer,
+            payer.pubkey(), // mint authority is payer
+            None,
+            9,
+            vec![(0, payer.pubkey())], // Start with 0 tokens
+        )
+        .await;
+
+    let ata = ata_pubkeys[0];
+    let mint_amount = 500u64;
+
+    // Get initial state
+    let ata_account_before = rpc.get_account(ata).await.unwrap().unwrap();
+    let ctoken_before = CToken::deserialize(&mut &ata_account_before.data[..]).unwrap();
+
+    // Build mint instruction via wrapper program
+    let mut instruction_data = vec![InstructionType::CTokenMintToInvoke as u8];
+    let mint_data = MintToData {
+        amount: mint_amount,
+    };
+    mint_data.serialize(&mut instruction_data).unwrap();
+
+    let ctoken_program = Pubkey::from(C_TOKEN_PROGRAM_ID);
+    let system_program = Pubkey::default();
+    let instruction = Instruction {
+        program_id: ID,
+        accounts: vec![
+            AccountMeta::new(mint_pda, false),                // cmint
+            AccountMeta::new(ata, false),                     // destination
+            AccountMeta::new(payer.pubkey(), true), // authority (signer, writable for top-up)
+            AccountMeta::new_readonly(system_program, false), // system_program
+            AccountMeta::new_readonly(ctoken_program, false), // ctoken_program
+        ],
+        data: instruction_data,
+    };
+
+    // Execute the mint instruction
+    rpc.create_and_send_transaction(&[instruction], &payer.pubkey(), &[&payer])
+        .await
+        .unwrap();
+
+    // Verify with single assert_eq
+    let ata_account_after = rpc.get_account(ata).await.unwrap().unwrap();
+    let ctoken_after = CToken::deserialize(&mut &ata_account_after.data[..]).unwrap();
+
+    let mut expected_ctoken = ctoken_before;
+    expected_ctoken.amount = 500; // 0 + 500
+
+    assert_eq!(
+        ctoken_after, expected_ctoken,
+        "CToken should match expected state after mint"
+    );
+}
+
+/// Test minting to CToken with PDA authority using CTokenMintToCpi::invoke_signed()
+///
+/// This test:
+/// 1. Creates a compressed mint with PDA authority via wrapper program (discriminator 14)
+/// 2. Decompresses the mint (permissionless)
+/// 3. Creates an ATA
+/// 4. Mints tokens using PDA authority via invoke_signed
+#[tokio::test]
+async fn test_ctoken_mint_to_invoke_signed() {
+    use light_client::indexer::Indexer;
+    use light_ctoken_interface::{
+        instructions::mint_action::CompressedMintWithContext, state::CompressedMint,
+    };
+    use light_ctoken_sdk::ctoken::CreateAssociatedCTokenAccount;
+    use native_ctoken_examples::{
+        CreateCmintData, DecompressCmintData, InstructionType as WrapperInstructionType,
+        MINT_SIGNER_SEED,
+    };
+
+    let config = ProgramTestConfig::new_v2(true, Some(vec![("native_ctoken_examples", ID)]));
+    let mut rpc = LightProgramTest::new(config).await.unwrap();
+    let payer = rpc.get_payer().insecure_clone();
+
+    // Derive the PDAs from our wrapper program
+    let (mint_signer_pda, _) = Pubkey::find_program_address(&[MINT_SIGNER_SEED], &ID);
+    let (pda_mint_authority, _) = Pubkey::find_program_address(&[MINT_AUTHORITY_SEED], &ID);
+
+    let decimals = 9u8;
+    let address_tree = rpc.get_address_tree_v2();
+    let output_queue = rpc.get_random_state_tree_info().unwrap().queue;
+
+    // Derive compression address using the PDA mint_signer
+    let compression_address = light_ctoken_sdk::ctoken::derive_cmint_compressed_address(
+        &mint_signer_pda,
+        &address_tree.tree,
+    );
+
+    let mint_pda = light_ctoken_sdk::ctoken::find_cmint_address(&mint_signer_pda).0;
+
+    // Step 1: Create compressed mint with PDA authority using wrapper program (discriminator 14)
+    {
+        let rpc_result = rpc
+            .get_validity_proof(
+                vec![],
+                vec![light_client::indexer::AddressWithTree {
+                    address: compression_address,
+                    tree: address_tree.tree,
+                }],
+                None,
+            )
+            .await
+            .unwrap()
+            .value;
+
+        let compressed_token_program_id =
+            Pubkey::new_from_array(light_ctoken_interface::CTOKEN_PROGRAM_ID);
+        let default_pubkeys = light_ctoken_sdk::utils::CTokenDefaultAccounts::default();
+
+        let create_cmint_data = CreateCmintData {
+            decimals,
+            address_merkle_tree_root_index: rpc_result.addresses[0].root_index,
+            mint_authority: pda_mint_authority,
+            proof: rpc_result.proof.0.unwrap(),
+            compression_address,
+            mint: mint_pda,
+            freeze_authority: None,
+            extensions: None,
+        };
+        // Discriminator 14 = CreateCmintWithPdaAuthority
+        let wrapper_instruction_data =
+            [vec![14u8], create_cmint_data.try_to_vec().unwrap()].concat();
+
+        let wrapper_accounts = vec![
+            AccountMeta::new_readonly(compressed_token_program_id, false),
+            AccountMeta::new_readonly(default_pubkeys.light_system_program, false),
+            AccountMeta::new_readonly(mint_signer_pda, false),
+            AccountMeta::new(pda_mint_authority, false),
+            AccountMeta::new(payer.pubkey(), true),
+            AccountMeta::new_readonly(default_pubkeys.cpi_authority_pda, false),
+            AccountMeta::new_readonly(default_pubkeys.registered_program_pda, false),
+            AccountMeta::new_readonly(default_pubkeys.account_compression_authority, false),
+            AccountMeta::new_readonly(default_pubkeys.account_compression_program, false),
+            AccountMeta::new_readonly(default_pubkeys.system_program, false),
+            AccountMeta::new(output_queue, false),
+            AccountMeta::new(address_tree.tree, false),
+        ];
+
+        let create_mint_ix = Instruction {
+            program_id: ID,
+            accounts: wrapper_accounts,
+            data: wrapper_instruction_data,
+        };
+
+        rpc.create_and_send_transaction(&[create_mint_ix], &payer.pubkey(), &[&payer])
+            .await
+            .unwrap();
+    }
+
+    // Step 2: Decompress the mint via wrapper program (PDA authority requires CPI)
+    {
+        let compressed_mint_account = rpc
+            .get_compressed_account(compression_address, None)
+            .await
+            .unwrap()
+            .value
+            .expect("Compressed mint should exist");
+
+        let compressed_mint = CompressedMint::deserialize(
+            &mut compressed_mint_account
+                .data
+                .as_ref()
+                .unwrap()
+                .data
+                .as_slice(),
+        )
+        .unwrap();
+
+        let rpc_result = rpc
+            .get_validity_proof(vec![compressed_mint_account.hash], vec![], None)
+            .await
+            .unwrap()
+            .value;
+
+        let compressed_mint_with_context = CompressedMintWithContext {
+            address: compression_address,
+            leaf_index: compressed_mint_account.leaf_index,
+            prove_by_index: true,
+            root_index: rpc_result.accounts[0]
+                .root_index
+                .root_index()
+                .unwrap_or_default(),
+            mint: Some(compressed_mint.try_into().unwrap()),
+        };
+
+        let default_pubkeys = light_ctoken_sdk::utils::CTokenDefaultAccounts::default();
+        let compressible_config = light_ctoken_sdk::ctoken::config_pda();
+        let rent_sponsor = light_ctoken_sdk::ctoken::rent_sponsor_pda();
+
+        let decompress_data = DecompressCmintData {
+            compressed_mint_with_context,
+            proof: rpc_result.proof,
+            rent_payment: 16,
+            write_top_up: 766,
+        };
+
+        // Discriminator 33 = DecompressCmintInvokeSigned
+        let wrapper_instruction_data = [
+            vec![WrapperInstructionType::DecompressCmintInvokeSigned as u8],
+            decompress_data.try_to_vec().unwrap(),
+        ]
+        .concat();
+
+        // Account order matches process_decompress_cmint_invoke_signed:
+        // 0: mint_seed (readonly)
+        // 1: authority (PDA, readonly - program signs)
+        // 2: payer (signer, writable)
+        // 3: cmint (writable)
+        // 4: compressible_config (readonly)
+        // 5: rent_sponsor (writable)
+        // 6: state_tree (writable)
+        // 7: input_queue (writable)
+        // 8: output_queue (writable)
+        // 9: light_system_program (readonly)
+        // 10: cpi_authority_pda (readonly)
+        // 11: registered_program_pda (readonly)
+        // 12: account_compression_authority (readonly)
+        // 13: account_compression_program (readonly)
+        // 14: system_program (readonly)
+        // 15: ctoken_program (readonly) - required for CPI
+        let ctoken_program_id = Pubkey::new_from_array(light_ctoken_interface::CTOKEN_PROGRAM_ID);
+        let wrapper_accounts = vec![
+            AccountMeta::new_readonly(mint_signer_pda, false),
+            AccountMeta::new_readonly(pda_mint_authority, false),
+            AccountMeta::new(payer.pubkey(), true),
+            AccountMeta::new(mint_pda, false),
+            AccountMeta::new_readonly(compressible_config, false),
+            AccountMeta::new(rent_sponsor, false),
+            AccountMeta::new(compressed_mint_account.tree_info.tree, false),
+            AccountMeta::new(compressed_mint_account.tree_info.queue, false),
+            AccountMeta::new(output_queue, false),
+            AccountMeta::new_readonly(default_pubkeys.light_system_program, false),
+            AccountMeta::new_readonly(default_pubkeys.cpi_authority_pda, false),
+            AccountMeta::new_readonly(default_pubkeys.registered_program_pda, false),
+            AccountMeta::new_readonly(default_pubkeys.account_compression_authority, false),
+            AccountMeta::new_readonly(default_pubkeys.account_compression_program, false),
+            AccountMeta::new_readonly(default_pubkeys.system_program, false),
+            AccountMeta::new_readonly(ctoken_program_id, false),
+        ];
+
+        let decompress_ix = Instruction {
+            program_id: ID,
+            accounts: wrapper_accounts,
+            data: wrapper_instruction_data,
+        };
+
+        rpc.create_and_send_transaction(&[decompress_ix], &payer.pubkey(), &[&payer])
+            .await
+            .unwrap();
+    }
+
+    // Step 3: Create ATA for payer
+    let ata = {
+        let (ata_address, _) =
+            light_ctoken_sdk::ctoken::derive_ctoken_ata(&payer.pubkey(), &mint_pda);
+        let create_ata =
+            CreateAssociatedCTokenAccount::new(payer.pubkey(), payer.pubkey(), mint_pda);
+        let ata_instruction = create_ata.instruction().unwrap();
+
+        rpc.create_and_send_transaction(&[ata_instruction], &payer.pubkey(), &[&payer])
+            .await
+            .unwrap();
+
+        ata_address
+    };
+
+    let mint_amount = 1000u64;
+
+    // Get initial state
+    let ata_account_before = rpc.get_account(ata).await.unwrap().unwrap();
+    let ctoken_before = CToken::deserialize(&mut &ata_account_before.data[..]).unwrap();
+
+    // Step 4: Mint tokens using PDA authority via invoke_signed
+    let mut instruction_data = vec![InstructionType::CTokenMintToInvokeSigned as u8];
+    let mint_data = MintToData {
+        amount: mint_amount,
+    };
+    mint_data.serialize(&mut instruction_data).unwrap();
+
+    let ctoken_program = Pubkey::from(C_TOKEN_PROGRAM_ID);
+    let system_program = Pubkey::default();
+    let instruction = Instruction {
+        program_id: ID,
+        accounts: vec![
+            AccountMeta::new(mint_pda, false),                // cmint
+            AccountMeta::new(ata, false),                     // destination
+            AccountMeta::new(pda_mint_authority, false), // PDA authority (program signs, writable for top-up)
+            AccountMeta::new_readonly(system_program, false), // system_program
+            AccountMeta::new_readonly(ctoken_program, false), // ctoken_program
+        ],
+        data: instruction_data,
+    };
+
+    rpc.create_and_send_transaction(&[instruction], &payer.pubkey(), &[&payer])
+        .await
+        .unwrap();
+
+    // Verify with single assert_eq
+    let ata_account_after = rpc.get_account(ata).await.unwrap().unwrap();
+    let ctoken_after = CToken::deserialize(&mut &ata_account_after.data[..]).unwrap();
+
+    let mut expected_ctoken = ctoken_before;
+    expected_ctoken.amount = 1000; // 0 + 1000
+
+    assert_eq!(
+        ctoken_after, expected_ctoken,
+        "CToken should match expected state after mint"
+    );
+}
diff --git a/sdk-tests/sdk-ctoken-test/tests/test_decompress_cmint.rs b/sdk-tests/sdk-ctoken-test/tests/test_decompress_cmint.rs
new file mode 100644
index 0000000000..7dcae53446
--- /dev/null
+++ b/sdk-tests/sdk-ctoken-test/tests/test_decompress_cmint.rs
@@ -0,0 +1,712 @@
+// Tests for DecompressCMint SDK instruction
+
+mod shared;
+
+use borsh::BorshDeserialize;
+use light_client::{indexer::Indexer, rpc::Rpc};
+use light_compressible::compression_info::CompressionInfo;
+use light_ctoken_interface::{
+    instructions::mint_action::CompressedMintWithContext, state::CompressedMint,
+};
+use light_ctoken_sdk::ctoken::{find_cmint_address, DecompressCMint};
+use light_program_test::{LightProgramTest, ProgramTestConfig};
+use solana_sdk::{pubkey::Pubkey, signature::Keypair, signer::Signer};
+
+/// Test decompressing a compressed mint to CMint account
+#[tokio::test]
+async fn test_decompress_cmint() {
+    let config = ProgramTestConfig::new_v2(true, None);
+    let mut rpc = LightProgramTest::new(config).await.unwrap();
+    let payer = rpc.get_payer().insecure_clone();
+
+    let mint_authority = payer.pubkey();
+    let decimals = 9u8;
+
+    // Create a compressed mint (returns mint_seed keypair)
+    let (mint_pda, compression_address, _, mint_seed) =
+        shared::setup_create_compressed_mint(&mut rpc, &payer, mint_authority, decimals, vec![])
+            .await;
+
+    // Verify CMint account does NOT exist on-chain yet
+    let cmint_account_before = rpc.get_account(mint_pda).await.unwrap();
+    assert!(
+        cmint_account_before.is_none(),
+        "CMint should not exist before decompression"
+    );
+
+    // Verify compressed mint exists
+    let compressed_account = rpc
+        .get_compressed_account(compression_address, None)
+        .await
+        .unwrap()
+        .value
+        .expect("Compressed mint should exist");
+
+    // Get validity proof for decompression
+    let rpc_result = rpc
+        .get_validity_proof(vec![compressed_account.hash], vec![], None)
+        .await
+        .unwrap()
+        .value;
+
+    // Deserialize the compressed mint to build context
+    let compressed_mint =
+        CompressedMint::deserialize(&mut compressed_account.data.as_ref().unwrap().data.as_slice())
+            .unwrap();
+
+    let compressed_mint_with_context = CompressedMintWithContext {
+        address: compression_address,
+        leaf_index: compressed_account.leaf_index,
+        prove_by_index: true,
+        root_index: rpc_result.accounts[0]
+            .root_index
+            .root_index()
+            .unwrap_or_default(),
+        mint: Some(compressed_mint.clone().try_into().unwrap()),
+    };
+
+    let output_queue = rpc.get_random_state_tree_info().unwrap().queue;
+
+    // Build and execute DecompressCMint instruction
+    let decompress_ix = DecompressCMint {
+        mint_seed_pubkey: mint_seed.pubkey(),
+        payer: payer.pubkey(),
+        authority: mint_authority,
+        state_tree: compressed_account.tree_info.tree,
+        input_queue: compressed_account.tree_info.queue,
+        output_queue,
+        compressed_mint_with_context,
+        proof: rpc_result.proof,
+        rent_payment: 16,
+        write_top_up: 766,
+    }
+    .instruction()
+    .unwrap();
+
+    rpc.create_and_send_transaction(&[decompress_ix], &payer.pubkey(), &[&payer])
+        .await
+        .unwrap();
+
+    // Verify CMint account now exists on-chain
+    let cmint_account_after = rpc.get_account(mint_pda).await.unwrap();
+    assert!(
+        cmint_account_after.is_some(),
+        "CMint should exist after decompression"
+    );
+
+    // Verify CMint state with single assert_eq
+    let cmint_account = cmint_account_after.unwrap();
+    let cmint = CompressedMint::deserialize(&mut &cmint_account.data[..]).unwrap();
+
+    // Verify compression info is set (non-default) when decompressed
+    assert_ne!(
+        cmint.compression,
+        CompressionInfo::default(),
+        "CMint compression info should be set when decompressed"
+    );
+
+    // Build expected CMint from original compressed mint, updating fields changed by decompression
+    let mut expected_cmint = compressed_mint.clone();
+    expected_cmint.metadata.cmint_decompressed = true;
+    expected_cmint.compression = cmint.compression;
+
+    assert_eq!(cmint, expected_cmint, "CMint should match expected state");
+}
+
+/// Test decompressing a compressed mint with freeze_authority
+#[tokio::test]
+async fn test_decompress_cmint_with_freeze_authority() {
+    let config = ProgramTestConfig::new_v2(true, None);
+    let mut rpc = LightProgramTest::new(config).await.unwrap();
+    let payer = rpc.get_payer().insecure_clone();
+
+    let mint_authority = payer.pubkey();
+    let freeze_authority = Keypair::new();
+    let decimals = 6u8;
+
+    // Create a compressed mint with freeze_authority
+    let (mint_pda, compression_address, mint_seed) =
+        setup_create_compressed_mint_with_freeze_authority_only(
+            &mut rpc,
+            &payer,
+            mint_authority,
+            Some(freeze_authority.pubkey()),
+            decimals,
+        )
+        .await;
+
+    // Verify CMint account does NOT exist on-chain yet
+    let cmint_account_before = rpc.get_account(mint_pda).await.unwrap();
+    assert!(
+        cmint_account_before.is_none(),
+        "CMint should not exist before decompression"
+    );
+
+    // Get compressed mint account
+    let compressed_account = rpc
+        .get_compressed_account(compression_address, None)
+        .await
+        .unwrap()
+        .value
+        .expect("Compressed mint should exist");
+
+    // Get validity proof for decompression
+    let rpc_result = rpc
+        .get_validity_proof(vec![compressed_account.hash], vec![], None)
+        .await
+        .unwrap()
+        .value;
+
+    // Deserialize the compressed mint
+    let compressed_mint =
+        CompressedMint::deserialize(&mut compressed_account.data.as_ref().unwrap().data.as_slice())
+            .unwrap();
+
+    let compressed_mint_with_context = CompressedMintWithContext {
+        address: compression_address,
+        leaf_index: compressed_account.leaf_index,
+        prove_by_index: true,
+        root_index: rpc_result.accounts[0]
+            .root_index
+            .root_index()
+            .unwrap_or_default(),
+        mint: Some(compressed_mint.clone().try_into().unwrap()),
+    };
+
+    let output_queue = rpc.get_random_state_tree_info().unwrap().queue;
+
+    // Build and execute DecompressCMint instruction
+    let decompress_ix = DecompressCMint {
+        mint_seed_pubkey: mint_seed.pubkey(),
+        payer: payer.pubkey(),
+        authority: mint_authority,
+        state_tree: compressed_account.tree_info.tree,
+        input_queue: compressed_account.tree_info.queue,
+        output_queue,
+        compressed_mint_with_context,
+        proof: rpc_result.proof,
+        rent_payment: 16,
+        write_top_up: 766,
+    }
+    .instruction()
+    .unwrap();
+
+    rpc.create_and_send_transaction(&[decompress_ix], &payer.pubkey(), &[&payer])
+        .await
+        .unwrap();
+
+    // Verify CMint state with single assert_eq
+    let cmint_account = rpc
+        .get_account(mint_pda)
+        .await
+        .unwrap()
+        .expect("CMint should exist after decompression");
+    let cmint = CompressedMint::deserialize(&mut &cmint_account.data[..]).unwrap();
+
+    // Verify compression info is set (non-default) when decompressed
+    assert_ne!(
+        cmint.compression,
+        CompressionInfo::default(),
+        "CMint compression info should be set when decompressed"
+    );
+
+    // Build expected CMint from original compressed mint, updating fields changed by decompression
+    let mut expected_cmint = compressed_mint.clone();
+    expected_cmint.metadata.cmint_decompressed = true;
+    expected_cmint.compression = cmint.compression;
+
+    assert_eq!(cmint, expected_cmint, "CMint should match expected state");
+}
+
+/// Helper function: Creates a compressed mint with optional freeze_authority
+/// but does NOT decompress it (unlike setup_create_compressed_mint_with_freeze_authority)
+/// Returns (mint_pda, compression_address, mint_seed_keypair)
+async fn setup_create_compressed_mint_with_freeze_authority_only(
+    rpc: &mut (impl Rpc + Indexer),
+    payer: &Keypair,
+    mint_authority: Pubkey,
+    freeze_authority: Option<Pubkey>,
+    decimals: u8,
+) -> (Pubkey, [u8; 32], Keypair) {
+    use light_ctoken_sdk::ctoken::{CreateCMint, CreateCMintParams};
+
+    let mint_seed = Keypair::new();
+    let address_tree = rpc.get_address_tree_v2();
+    let output_queue = rpc.get_random_state_tree_info().unwrap().queue;
+
+    // Derive compression address using SDK helpers
+    let compression_address = light_ctoken_sdk::ctoken::derive_cmint_compressed_address(
+        &mint_seed.pubkey(),
+        &address_tree.tree,
+    );
+
+    let mint = find_cmint_address(&mint_seed.pubkey()).0;
+
+    // Get validity proof for the address
+    let rpc_result = rpc
+        .get_validity_proof(
+            vec![],
+            vec![light_client::indexer::AddressWithTree {
+                address: compression_address,
+                tree: address_tree.tree,
+            }],
+            None,
+        )
+        .await
+        .unwrap()
+        .value;
+
+    // Build params for the SDK
+    let params = CreateCMintParams {
+        decimals,
+        address_merkle_tree_root_index: rpc_result.addresses[0].root_index,
+        mint_authority,
+        proof: rpc_result.proof.0.unwrap(),
+        compression_address,
+        mint,
+        freeze_authority,
+        extensions: None,
+    };
+
+    // Create instruction directly using SDK
+    let create_cmint_builder = CreateCMint::new(
+        params,
+        mint_seed.pubkey(),
+        payer.pubkey(),
+        address_tree.tree,
+        output_queue,
+    );
+    let instruction = create_cmint_builder.instruction().unwrap();
+
+    // Send transaction
+    rpc.create_and_send_transaction(&[instruction], &payer.pubkey(), &[payer, &mint_seed])
+        .await
+        .unwrap();
+
+    // Verify the compressed mint was created
+    let compressed_account = rpc
+        .get_compressed_account(compression_address, None)
+        .await
+        .unwrap()
+        .value;
+
+    assert!(
+        compressed_account.is_some(),
+        "Compressed mint should exist after setup"
+    );
+
+    (mint, compression_address, mint_seed)
+}
+
+/// Test decompressing a compressed mint with TokenMetadata extension
+#[tokio::test]
+async fn test_decompress_cmint_with_token_metadata() {
+    use light_ctoken_interface::instructions::extensions::{
+        ExtensionInstructionData, TokenMetadataInstructionData,
+    };
+
+    let config = ProgramTestConfig::new_v2(true, None);
+    let mut rpc = LightProgramTest::new(config).await.unwrap();
+    let payer = rpc.get_payer().insecure_clone();
+
+    let mint_authority = payer.pubkey();
+    let update_authority = Keypair::new();
+    let decimals = 9u8;
+
+    // Create TokenMetadata extension
+    let token_metadata = TokenMetadataInstructionData {
+        update_authority: Some(update_authority.pubkey().to_bytes().into()),
+        name: b"Test Token".to_vec(),
+        symbol: b"TEST".to_vec(),
+        uri: b"https://example.com/token.json".to_vec(),
+        additional_metadata: None,
+    };
+    let extensions = vec![ExtensionInstructionData::TokenMetadata(token_metadata)];
+
+    // Create a compressed mint with TokenMetadata extension
+    let (mint_pda, compression_address, mint_seed) = setup_create_compressed_mint_with_extensions(
+        &mut rpc,
+        &payer,
+        mint_authority,
+        None,
+        decimals,
+        extensions,
+    )
+    .await;
+
+    // Verify CMint account does NOT exist on-chain yet
+    let cmint_account_before = rpc.get_account(mint_pda).await.unwrap();
+    assert!(
+        cmint_account_before.is_none(),
+        "CMint should not exist before decompression"
+    );
+
+    // Get compressed mint account
+    let compressed_account = rpc
+        .get_compressed_account(compression_address, None)
+        .await
+        .unwrap()
+        .value
+        .expect("Compressed mint should exist");
+
+    // Get validity proof for decompression
+    let rpc_result = rpc
+        .get_validity_proof(vec![compressed_account.hash], vec![], None)
+        .await
+        .unwrap()
+        .value;
+
+    // Deserialize the compressed mint
+    let compressed_mint =
+        CompressedMint::deserialize(&mut compressed_account.data.as_ref().unwrap().data.as_slice())
+            .unwrap();
+
+    let compressed_mint_with_context = CompressedMintWithContext {
+        address: compression_address,
+        leaf_index: compressed_account.leaf_index,
+        prove_by_index: true,
+        root_index: rpc_result.accounts[0]
+            .root_index
+            .root_index()
+            .unwrap_or_default(),
+        mint: Some(compressed_mint.clone().try_into().unwrap()),
+    };
+
+    let output_queue = rpc.get_random_state_tree_info().unwrap().queue;
+
+    // Build and execute DecompressCMint instruction
+    let decompress_ix = DecompressCMint {
+        mint_seed_pubkey: mint_seed.pubkey(),
+        payer: payer.pubkey(),
+        authority: mint_authority,
+        state_tree: compressed_account.tree_info.tree,
+        input_queue: compressed_account.tree_info.queue,
+        output_queue,
+        compressed_mint_with_context,
+        proof: rpc_result.proof,
+        rent_payment: 16,
+        write_top_up: 766,
+    }
+    .instruction()
+    .unwrap();
+
+    rpc.create_and_send_transaction(&[decompress_ix], &payer.pubkey(), &[&payer])
+        .await
+        .unwrap();
+
+    // Verify CMint state with single assert_eq
+    let cmint_account = rpc
+        .get_account(mint_pda)
+        .await
+        .unwrap()
+        .expect("CMint should exist after decompression");
+    let cmint = CompressedMint::deserialize(&mut &cmint_account.data[..]).unwrap();
+
+    // Verify compression info is set (non-default) when decompressed
+    assert_ne!(
+        cmint.compression,
+        CompressionInfo::default(),
+        "CMint compression info should be set when decompressed"
+    );
+
+    // Verify TokenMetadata extension is preserved
+    assert!(
+        cmint.extensions.is_some(),
+        "CMint should have extensions with TokenMetadata"
+    );
+
+    // Build expected CMint from original compressed mint, updating fields changed by decompression
+    let mut expected_cmint = compressed_mint.clone();
+    expected_cmint.metadata.cmint_decompressed = true;
+    expected_cmint.compression = cmint.compression;
+    // Extensions should preserve original TokenMetadata
+
+    assert_eq!(cmint, expected_cmint, "CMint should match expected state");
+}
+
+/// Helper function: Creates a compressed mint with extensions
+/// but does NOT decompress it
+/// Returns (mint_pda, compression_address, mint_seed_keypair)
+async fn setup_create_compressed_mint_with_extensions(
+    rpc: &mut (impl Rpc + Indexer),
+    payer: &Keypair,
+    mint_authority: Pubkey,
+    freeze_authority: Option<Pubkey>,
+    decimals: u8,
+    extensions: Vec<light_ctoken_interface::instructions::extensions::ExtensionInstructionData>,
+) -> (Pubkey, [u8; 32], Keypair) {
+    use light_ctoken_sdk::ctoken::{CreateCMint, CreateCMintParams};
+
+    let mint_seed = Keypair::new();
+    let address_tree = rpc.get_address_tree_v2();
+    let output_queue = rpc.get_random_state_tree_info().unwrap().queue;
+
+    // Derive compression address using SDK helpers
+    let compression_address = light_ctoken_sdk::ctoken::derive_cmint_compressed_address(
+        &mint_seed.pubkey(),
+        &address_tree.tree,
+    );
+
+    let mint = find_cmint_address(&mint_seed.pubkey()).0;
+
+    // Get validity proof for the address
+    let rpc_result = rpc
+        .get_validity_proof(
+            vec![],
+            vec![light_client::indexer::AddressWithTree {
+                address: compression_address,
+                tree: address_tree.tree,
+            }],
+            None,
+        )
+        .await
+        .unwrap()
+        .value;
+
+    // Build params for the SDK
+    let params = CreateCMintParams {
+        decimals,
+        address_merkle_tree_root_index: rpc_result.addresses[0].root_index,
+        mint_authority,
+        proof: rpc_result.proof.0.unwrap(),
+        compression_address,
+        mint,
+        freeze_authority,
+        extensions: Some(extensions),
+    };
+
+    // Create instruction directly using SDK
+    let create_cmint_builder = CreateCMint::new(
+        params,
+        mint_seed.pubkey(),
+        payer.pubkey(),
+        address_tree.tree,
+        output_queue,
+    );
+    let instruction = create_cmint_builder.instruction().unwrap();
+
+    // Send transaction
+    rpc.create_and_send_transaction(&[instruction], &payer.pubkey(), &[payer, &mint_seed])
+        .await
+        .unwrap();
+
+    // Verify the compressed mint was created
+    let compressed_account = rpc
+        .get_compressed_account(compression_address, None)
+        .await
+        .unwrap()
+        .value;
+
+    assert!(
+        compressed_account.is_some(),
+        "Compressed mint should exist after setup"
+    );
+
+    (mint, compression_address, mint_seed)
+}
+
+/// Test decompressing a compressed mint via CPI with PDA authority using invoke_signed
+#[tokio::test]
+async fn test_decompress_cmint_cpi_invoke_signed() {
+    use borsh::BorshSerialize;
+    use native_ctoken_examples::{
+        CreateCmintData, DecompressCmintData, InstructionType, ID, MINT_AUTHORITY_SEED,
+        MINT_SIGNER_SEED,
+    };
+    use solana_sdk::instruction::{AccountMeta, Instruction};
+
+    let config = ProgramTestConfig::new_v2(true, Some(vec![("native_ctoken_examples", ID)]));
+    let mut rpc = LightProgramTest::new(config).await.unwrap();
+    let payer = rpc.get_payer().insecure_clone();
+
+    // Derive the PDAs from our wrapper program
+    let (mint_signer_pda, _) = Pubkey::find_program_address(&[MINT_SIGNER_SEED], &ID);
+    let (pda_mint_authority, _) = Pubkey::find_program_address(&[MINT_AUTHORITY_SEED], &ID);
+
+    let decimals = 9u8;
+    let address_tree = rpc.get_address_tree_v2();
+    let output_queue = rpc.get_random_state_tree_info().unwrap().queue;
+
+    // Derive compression address using the PDA mint_signer
+    let compression_address = light_ctoken_sdk::ctoken::derive_cmint_compressed_address(
+        &mint_signer_pda,
+        &address_tree.tree,
+    );
+
+    let mint_pda = find_cmint_address(&mint_signer_pda).0;
+
+    // Step 1: Create compressed mint with PDA authority using wrapper program (discriminator 14)
+    {
+        let rpc_result = rpc
+            .get_validity_proof(
+                vec![],
+                vec![light_client::indexer::AddressWithTree {
+                    address: compression_address,
+                    tree: address_tree.tree,
+                }],
+                None,
+            )
+            .await
+            .unwrap()
+            .value;
+
+        let compressed_token_program_id =
+            Pubkey::new_from_array(light_ctoken_interface::CTOKEN_PROGRAM_ID);
+        let default_pubkeys = light_ctoken_sdk::utils::CTokenDefaultAccounts::default();
+
+        let create_cmint_data = CreateCmintData {
+            decimals,
+            address_merkle_tree_root_index: rpc_result.addresses[0].root_index,
+            mint_authority: pda_mint_authority,
+            proof: rpc_result.proof.0.unwrap(),
+            compression_address,
+            mint: mint_pda,
+            freeze_authority: None,
+            extensions: None,
+        };
+        // Discriminator 14 = CreateCmintWithPdaAuthority
+        let wrapper_instruction_data =
+            [vec![14u8], create_cmint_data.try_to_vec().unwrap()].concat();
+
+        let wrapper_accounts = vec![
+            AccountMeta::new_readonly(compressed_token_program_id, false),
+            AccountMeta::new_readonly(default_pubkeys.light_system_program, false),
+            AccountMeta::new_readonly(mint_signer_pda, false),
+            AccountMeta::new(pda_mint_authority, false),
+            AccountMeta::new(payer.pubkey(), true),
+            AccountMeta::new_readonly(default_pubkeys.cpi_authority_pda, false),
+            AccountMeta::new_readonly(default_pubkeys.registered_program_pda, false),
+            AccountMeta::new_readonly(default_pubkeys.account_compression_authority, false),
+            AccountMeta::new_readonly(default_pubkeys.account_compression_program, false),
+            AccountMeta::new_readonly(default_pubkeys.system_program, false),
+            AccountMeta::new(output_queue, false),
+            AccountMeta::new(address_tree.tree, false),
+        ];
+
+        let create_mint_ix = Instruction {
+            program_id: ID,
+            accounts: wrapper_accounts,
+            data: wrapper_instruction_data,
+        };
+
+        rpc.create_and_send_transaction(&[create_mint_ix], &payer.pubkey(), &[&payer])
+            .await
+            .unwrap();
+    }
+
+    // Verify CMint account does NOT exist on-chain yet
+    let cmint_account_before = rpc.get_account(mint_pda).await.unwrap();
+    assert!(
+        cmint_account_before.is_none(),
+        "CMint should not exist before decompression"
+    );
+
+    // Step 2: Decompress the mint via wrapper program (PDA authority requires CPI)
+    let compressed_mint = {
+        let compressed_mint_account = rpc
+            .get_compressed_account(compression_address, None)
+            .await
+            .unwrap()
+            .value
+            .expect("Compressed mint should exist");
+
+        let compressed_mint = CompressedMint::deserialize(
+            &mut compressed_mint_account
+                .data
+                .as_ref()
+                .unwrap()
+                .data
+                .as_slice(),
+        )
+        .unwrap();
+
+        let rpc_result = rpc
+            .get_validity_proof(vec![compressed_mint_account.hash], vec![], None)
+            .await
+            .unwrap()
+            .value;
+
+        let compressed_mint_with_context = CompressedMintWithContext {
+            address: compression_address,
+            leaf_index: compressed_mint_account.leaf_index,
+            prove_by_index: true,
+            root_index: rpc_result.accounts[0]
+                .root_index
+                .root_index()
+                .unwrap_or_default(),
+            mint: Some(compressed_mint.clone().try_into().unwrap()),
+        };
+
+        let default_pubkeys = light_ctoken_sdk::utils::CTokenDefaultAccounts::default();
+        let compressible_config = light_ctoken_sdk::ctoken::config_pda();
+        let rent_sponsor = light_ctoken_sdk::ctoken::rent_sponsor_pda();
+
+        let decompress_data = DecompressCmintData {
+            compressed_mint_with_context,
+            proof: rpc_result.proof,
+            rent_payment: 16,
+            write_top_up: 766,
+        };
+
+        // Discriminator 33 = DecompressCmintInvokeSigned
+        let wrapper_instruction_data = [
+            vec![InstructionType::DecompressCmintInvokeSigned as u8],
+            decompress_data.try_to_vec().unwrap(),
+        ]
+        .concat();
+
+        let ctoken_program_id = Pubkey::new_from_array(light_ctoken_interface::CTOKEN_PROGRAM_ID);
+        let wrapper_accounts = vec![
+            AccountMeta::new_readonly(mint_signer_pda, false),
+            AccountMeta::new_readonly(pda_mint_authority, false),
+            AccountMeta::new(payer.pubkey(), true),
+            AccountMeta::new(mint_pda, false),
+            AccountMeta::new_readonly(compressible_config, false),
+            AccountMeta::new(rent_sponsor, false),
+            AccountMeta::new(compressed_mint_account.tree_info.tree, false),
+            AccountMeta::new(compressed_mint_account.tree_info.queue, false),
+            AccountMeta::new(output_queue, false),
+            AccountMeta::new_readonly(default_pubkeys.light_system_program, false),
+            AccountMeta::new_readonly(default_pubkeys.cpi_authority_pda, false),
+            AccountMeta::new_readonly(default_pubkeys.registered_program_pda, false),
+            AccountMeta::new_readonly(default_pubkeys.account_compression_authority, false),
+            AccountMeta::new_readonly(default_pubkeys.account_compression_program, false),
+            AccountMeta::new_readonly(default_pubkeys.system_program, false),
+            AccountMeta::new_readonly(ctoken_program_id, false),
+        ];
+
+        let decompress_ix = Instruction {
+            program_id: ID,
+            accounts: wrapper_accounts,
+            data: wrapper_instruction_data,
+        };
+
+        rpc.create_and_send_transaction(&[decompress_ix], &payer.pubkey(), &[&payer])
+            .await
+            .unwrap();
+
+        compressed_mint
+    };
+
+    // Verify CMint state with single assert_eq
+    let cmint_account = rpc
+        .get_account(mint_pda)
+        .await
+        .unwrap()
+        .expect("CMint should exist after decompression");
+    let cmint = CompressedMint::deserialize(&mut &cmint_account.data[..]).unwrap();
+
+    // Verify compression info is set (non-default) when decompressed
+    assert_ne!(
+        cmint.compression,
+        CompressionInfo::default(),
+        "CMint compression info should be set when decompressed"
+    );
+
+    // Build expected CMint from original compressed mint, updating fields changed by decompression
+    let mut expected_cmint = compressed_mint.clone();
+    expected_cmint.metadata.cmint_decompressed = true;
+    expected_cmint.compression = cmint.compression;
+
+    assert_eq!(cmint, expected_cmint, "CMint should match expected state");
+}
diff --git a/sdk-tests/sdk-ctoken-test/tests/test_freeze_thaw.rs b/sdk-tests/sdk-ctoken-test/tests/test_freeze_thaw.rs
new file mode 100644
index 0000000000..ebf07236e7
--- /dev/null
+++ b/sdk-tests/sdk-ctoken-test/tests/test_freeze_thaw.rs
@@ -0,0 +1,304 @@
+// Tests for FreezeCTokenCpi and ThawCTokenCpi invoke() and invoke_signed()
+
+mod shared;
+
+use borsh::BorshDeserialize;
+use light_client::rpc::Rpc;
+use light_ctoken_interface::state::{AccountState, CToken};
+use light_program_test::{LightProgramTest, ProgramTestConfig};
+use light_sdk_types::C_TOKEN_PROGRAM_ID;
+use native_ctoken_examples::{InstructionType, FREEZE_AUTHORITY_SEED, ID};
+use shared::*;
+use solana_sdk::{
+    instruction::{AccountMeta, Instruction},
+    pubkey::Pubkey,
+    signature::Keypair,
+    signer::Signer,
+};
+
+/// Test freezing a CToken account using FreezeCTokenCpi::invoke()
+#[tokio::test]
+async fn test_freeze_invoke() {
+    let config = ProgramTestConfig::new_v2(true, Some(vec![("native_ctoken_examples", ID)]));
+    let mut rpc = LightProgramTest::new(config).await.unwrap();
+    let payer = rpc.get_payer().insecure_clone();
+
+    let freeze_authority = Keypair::new();
+
+    // Create a compressed mint with freeze_authority and an ATA for the payer with 1000 tokens
+    let (mint_pda, _compression_address, ata_pubkeys) =
+        setup_create_compressed_mint_with_freeze_authority(
+            &mut rpc,
+            &payer,
+            payer.pubkey(),
+            Some(freeze_authority.pubkey()),
+            9,
+            vec![(1000, payer.pubkey())],
+        )
+        .await;
+
+    let ata = ata_pubkeys[0];
+
+    // Verify account is initially unfrozen
+    let ata_account_before = rpc.get_account(ata).await.unwrap().unwrap();
+    let ctoken_before = CToken::deserialize(&mut &ata_account_before.data[..]).unwrap();
+    assert_eq!(
+        ctoken_before.state,
+        AccountState::Initialized,
+        "Account should be initialized (unfrozen) before freeze"
+    );
+
+    // Build freeze instruction via wrapper program
+    let instruction_data = vec![InstructionType::FreezeInvoke as u8];
+
+    let ctoken_program = Pubkey::from(C_TOKEN_PROGRAM_ID);
+    let instruction = Instruction {
+        program_id: ID,
+        accounts: vec![
+            AccountMeta::new(ata, false),               // token_account
+            AccountMeta::new_readonly(mint_pda, false), // mint
+            AccountMeta::new_readonly(freeze_authority.pubkey(), true), // freeze_authority (signer)
+            AccountMeta::new_readonly(ctoken_program, false), // ctoken_program
+        ],
+        data: instruction_data,
+    };
+
+    // Execute the freeze instruction
+    rpc.create_and_send_transaction(
+        &[instruction],
+        &payer.pubkey(),
+        &[&payer, &freeze_authority],
+    )
+    .await
+    .unwrap();
+
+    // Verify the account is now frozen
+    let ata_account_after = rpc.get_account(ata).await.unwrap().unwrap();
+    let ctoken_after = CToken::deserialize(&mut &ata_account_after.data[..]).unwrap();
+
+    assert_eq!(
+        ctoken_after.state,
+        AccountState::Frozen,
+        "Account should be frozen after freeze"
+    );
+}
+
+/// Test freezing a CToken account with PDA freeze authority using FreezeCTokenCpi::invoke_signed()
+#[tokio::test]
+async fn test_freeze_invoke_signed() {
+    let config = ProgramTestConfig::new_v2(true, Some(vec![("native_ctoken_examples", ID)]));
+    let mut rpc = LightProgramTest::new(config).await.unwrap();
+    let payer = rpc.get_payer().insecure_clone();
+
+    // Derive the PDA that will be the freeze authority
+    let (pda_freeze_authority, _bump) = Pubkey::find_program_address(&[FREEZE_AUTHORITY_SEED], &ID);
+
+    // Create a compressed mint with PDA freeze_authority and an ATA for the payer with 1000 tokens
+    let (mint_pda, _compression_address, ata_pubkeys) =
+        setup_create_compressed_mint_with_freeze_authority(
+            &mut rpc,
+            &payer,
+            payer.pubkey(),
+            Some(pda_freeze_authority),
+            9,
+            vec![(1000, payer.pubkey())],
+        )
+        .await;
+
+    let ata = ata_pubkeys[0];
+
+    // Build freeze instruction via wrapper program using invoke_signed
+    let instruction_data = vec![InstructionType::FreezeInvokeSigned as u8];
+
+    let ctoken_program = Pubkey::from(C_TOKEN_PROGRAM_ID);
+    let instruction = Instruction {
+        program_id: ID,
+        accounts: vec![
+            AccountMeta::new(ata, false),                           // token_account
+            AccountMeta::new_readonly(mint_pda, false),             // mint
+            AccountMeta::new_readonly(pda_freeze_authority, false), // PDA freeze_authority (program signs)
+            AccountMeta::new_readonly(ctoken_program, false),       // ctoken_program
+        ],
+        data: instruction_data,
+    };
+
+    // Execute the freeze instruction
+    rpc.create_and_send_transaction(&[instruction], &payer.pubkey(), &[&payer])
+        .await
+        .unwrap();
+
+    // Verify the account is now frozen
+    let ata_account_after = rpc.get_account(ata).await.unwrap().unwrap();
+    let ctoken_after = CToken::deserialize(&mut &ata_account_after.data[..]).unwrap();
+
+    assert_eq!(
+        ctoken_after.state,
+        AccountState::Frozen,
+        "Account should be frozen after freeze"
+    );
+}
+
+/// Test thawing a frozen CToken account using ThawCTokenCpi::invoke()
+#[tokio::test]
+async fn test_thaw_invoke() {
+    let config = ProgramTestConfig::new_v2(true, Some(vec![("native_ctoken_examples", ID)]));
+    let mut rpc = LightProgramTest::new(config).await.unwrap();
+    let payer = rpc.get_payer().insecure_clone();
+
+    let freeze_authority = Keypair::new();
+    let ctoken_program = Pubkey::from(C_TOKEN_PROGRAM_ID);
+
+    // Create a compressed mint with freeze_authority and an ATA for the payer with 1000 tokens
+    let (mint_pda, _compression_address, ata_pubkeys) =
+        setup_create_compressed_mint_with_freeze_authority(
+            &mut rpc,
+            &payer,
+            payer.pubkey(),
+            Some(freeze_authority.pubkey()),
+            9,
+            vec![(1000, payer.pubkey())],
+        )
+        .await;
+
+    let ata = ata_pubkeys[0];
+
+    // First freeze the account
+    let freeze_instruction_data = vec![InstructionType::FreezeInvoke as u8];
+    let freeze_instruction = Instruction {
+        program_id: ID,
+        accounts: vec![
+            AccountMeta::new(ata, false),
+            AccountMeta::new_readonly(mint_pda, false),
+            AccountMeta::new_readonly(freeze_authority.pubkey(), true),
+            AccountMeta::new_readonly(ctoken_program, false),
+        ],
+        data: freeze_instruction_data,
+    };
+
+    rpc.create_and_send_transaction(
+        &[freeze_instruction],
+        &payer.pubkey(),
+        &[&payer, &freeze_authority],
+    )
+    .await
+    .unwrap();
+
+    // Verify account is frozen
+    let ata_account_after_freeze = rpc.get_account(ata).await.unwrap().unwrap();
+    let ctoken_after_freeze = CToken::deserialize(&mut &ata_account_after_freeze.data[..]).unwrap();
+    assert_eq!(
+        ctoken_after_freeze.state,
+        AccountState::Frozen,
+        "Account should be frozen"
+    );
+
+    // Now thaw the account
+    let thaw_instruction_data = vec![InstructionType::ThawInvoke as u8];
+    let thaw_instruction = Instruction {
+        program_id: ID,
+        accounts: vec![
+            AccountMeta::new(ata, false),               // token_account
+            AccountMeta::new_readonly(mint_pda, false), // mint
+            AccountMeta::new_readonly(freeze_authority.pubkey(), true), // freeze_authority (signer)
+            AccountMeta::new_readonly(ctoken_program, false), // ctoken_program
+        ],
+        data: thaw_instruction_data,
+    };
+
+    rpc.create_and_send_transaction(
+        &[thaw_instruction],
+        &payer.pubkey(),
+        &[&payer, &freeze_authority],
+    )
+    .await
+    .unwrap();
+
+    // Verify the account is now thawed (initialized)
+    let ata_account_after_thaw = rpc.get_account(ata).await.unwrap().unwrap();
+    let ctoken_after_thaw = CToken::deserialize(&mut &ata_account_after_thaw.data[..]).unwrap();
+
+    assert_eq!(
+        ctoken_after_thaw.state,
+        AccountState::Initialized,
+        "Account should be initialized (thawed) after thaw"
+    );
+}
+
+/// Test thawing a frozen CToken account with PDA freeze authority using ThawCTokenCpi::invoke_signed()
+#[tokio::test]
+async fn test_thaw_invoke_signed() {
+    let config = ProgramTestConfig::new_v2(true, Some(vec![("native_ctoken_examples", ID)]));
+    let mut rpc = LightProgramTest::new(config).await.unwrap();
+    let payer = rpc.get_payer().insecure_clone();
+
+    // Derive the PDA that will be the freeze authority
+    let (pda_freeze_authority, _bump) = Pubkey::find_program_address(&[FREEZE_AUTHORITY_SEED], &ID);
+    let ctoken_program = Pubkey::from(C_TOKEN_PROGRAM_ID);
+
+    // Create a compressed mint with PDA freeze_authority and an ATA for the payer with 1000 tokens
+    let (mint_pda, _compression_address, ata_pubkeys) =
+        setup_create_compressed_mint_with_freeze_authority(
+            &mut rpc,
+            &payer,
+            payer.pubkey(),
+            Some(pda_freeze_authority),
+            9,
+            vec![(1000, payer.pubkey())],
+        )
+        .await;
+
+    let ata = ata_pubkeys[0];
+
+    // First freeze the account using invoke_signed
+    let freeze_instruction_data = vec![InstructionType::FreezeInvokeSigned as u8];
+    let freeze_instruction = Instruction {
+        program_id: ID,
+        accounts: vec![
+            AccountMeta::new(ata, false),
+            AccountMeta::new_readonly(mint_pda, false),
+            AccountMeta::new_readonly(pda_freeze_authority, false),
+            AccountMeta::new_readonly(ctoken_program, false),
+        ],
+        data: freeze_instruction_data,
+    };
+
+    rpc.create_and_send_transaction(&[freeze_instruction], &payer.pubkey(), &[&payer])
+        .await
+        .unwrap();
+
+    // Verify account is frozen
+    let ata_account_after_freeze = rpc.get_account(ata).await.unwrap().unwrap();
+    let ctoken_after_freeze = CToken::deserialize(&mut &ata_account_after_freeze.data[..]).unwrap();
+    assert_eq!(
+        ctoken_after_freeze.state,
+        AccountState::Frozen,
+        "Account should be frozen"
+    );
+
+    // Now thaw the account using invoke_signed
+    let thaw_instruction_data = vec![InstructionType::ThawInvokeSigned as u8];
+    let thaw_instruction = Instruction {
+        program_id: ID,
+        accounts: vec![
+            AccountMeta::new(ata, false),                           // token_account
+            AccountMeta::new_readonly(mint_pda, false),             // mint
+            AccountMeta::new_readonly(pda_freeze_authority, false), // PDA freeze_authority (program signs)
+            AccountMeta::new_readonly(ctoken_program, false),       // ctoken_program
+        ],
+        data: thaw_instruction_data,
+    };
+
+    rpc.create_and_send_transaction(&[thaw_instruction], &payer.pubkey(), &[&payer])
+        .await
+        .unwrap();
+
+    // Verify the account is now thawed (initialized)
+    let ata_account_after_thaw = rpc.get_account(ata).await.unwrap().unwrap();
+    let ctoken_after_thaw = CToken::deserialize(&mut &ata_account_after_thaw.data[..]).unwrap();
+
+    assert_eq!(
+        ctoken_after_thaw.state,
+        AccountState::Initialized,
+        "Account should be initialized (thawed) after thaw"
+    );
+}
diff --git a/sdk-tests/sdk-ctoken-test/tests/test_mint_to_ctoken.rs b/sdk-tests/sdk-ctoken-test/tests/test_mint_to_ctoken.rs
index 2dc52dd4e7..59260973eb 100644
--- a/sdk-tests/sdk-ctoken-test/tests/test_mint_to_ctoken.rs
+++ b/sdk-tests/sdk-ctoken-test/tests/test_mint_to_ctoken.rs
@@ -34,7 +34,7 @@ async fn test_mint_to_ctoken() {
     let mint_authority = payer.pubkey();
 
     // Setup: Create compressed mint directly (not via wrapper program)
-    let (mint_pda, compression_address, _) =
+    let (mint_pda, compression_address, _, _mint_seed) =
         setup_create_compressed_mint(&mut rpc, &payer, mint_authority, 9, vec![]).await;
 
     let ctoken_account = Keypair::new();
diff --git a/sdk-tests/sdk-ctoken-test/tests/test_transfer.rs b/sdk-tests/sdk-ctoken-test/tests/test_transfer.rs
index 9132108771..738f5ac425 100644
--- a/sdk-tests/sdk-ctoken-test/tests/test_transfer.rs
+++ b/sdk-tests/sdk-ctoken-test/tests/test_transfer.rs
@@ -24,7 +24,7 @@ async fn test_ctoken_transfer_invoke() {
     let source_owner = payer.pubkey();
     let dest_owner = Pubkey::new_unique();
 
-    let (_mint_pda, _compression_address, ata_pubkeys) = setup_create_compressed_mint(
+    let (_mint_pda, _compression_address, ata_pubkeys, _mint_seed) = setup_create_compressed_mint(
         &mut rpc,
         &payer,
         payer.pubkey(),
@@ -81,7 +81,7 @@ async fn test_ctoken_transfer_invoke_signed() {
     let (pda_owner, _bump) = Pubkey::find_program_address(&[TOKEN_ACCOUNT_SEED], &ID);
     let dest_owner = payer.pubkey();
 
-    let (_mint_pda, _compression_address, ata_pubkeys) = setup_create_compressed_mint(
+    let (_mint_pda, _compression_address, ata_pubkeys, _mint_seed) = setup_create_compressed_mint(
         &mut rpc,
         &payer,
         payer.pubkey(),
diff --git a/sdk-tests/sdk-ctoken-test/tests/test_transfer_checked.rs b/sdk-tests/sdk-ctoken-test/tests/test_transfer_checked.rs
new file mode 100644
index 0000000000..6b379c0fa0
--- /dev/null
+++ b/sdk-tests/sdk-ctoken-test/tests/test_transfer_checked.rs
@@ -0,0 +1,338 @@
+// Tests for TransferCTokenCheckedCpi with different mint types
+
+mod shared;
+use anchor_spl::token::{spl_token, Mint};
+use borsh::{BorshDeserialize, BorshSerialize};
+use light_client::rpc::Rpc;
+use light_ctoken_interface::state::CToken;
+use light_ctoken_sdk::{
+    ctoken::{derive_ctoken_ata, CreateAssociatedCTokenAccount, TransferSplToCtoken},
+    spl_interface::{find_spl_interface_pda_with_index, CreateSplInterfacePda},
+};
+use light_program_test::{LightProgramTest, ProgramTestConfig};
+use light_test_utils::{
+    mint_2022::{create_mint_22_with_extensions, create_token_22_account, mint_spl_tokens_22},
+    spl::{create_token_account, mint_spl_tokens},
+};
+use native_ctoken_examples::{InstructionType, TransferCheckedData, ID};
+use shared::*;
+use solana_sdk::{
+    instruction::{AccountMeta, Instruction},
+    pubkey::Pubkey,
+    signature::Keypair,
+    signer::Signer,
+};
+
+/// Test transfer_checked with SPL Token mint
+#[tokio::test]
+async fn test_ctoken_transfer_checked_spl_mint() {
+    let config = ProgramTestConfig::new_v2(true, Some(vec![("native_ctoken_examples", ID)]));
+    let mut rpc = LightProgramTest::new(config).await.unwrap();
+    let payer = rpc.get_payer().insecure_clone();
+
+    let decimals = 9u8;
+
+    // Create SPL mint
+    let mint_keypair = Keypair::new();
+    let mint = mint_keypair.pubkey();
+
+    let mint_rent = rpc
+        .get_minimum_balance_for_rent_exemption(Mint::LEN)
+        .await
+        .unwrap();
+
+    let create_mint_account_ix = solana_sdk::system_instruction::create_account(
+        &payer.pubkey(),
+        &mint,
+        mint_rent,
+        Mint::LEN as u64,
+        &spl_token::ID,
+    );
+
+    let initialize_mint_ix = spl_token::instruction::initialize_mint(
+        &spl_token::ID,
+        &mint,
+        &payer.pubkey(),
+        Some(&payer.pubkey()),
+        decimals,
+    )
+    .unwrap();
+
+    rpc.create_and_send_transaction(
+        &[create_mint_account_ix, initialize_mint_ix],
+        &payer.pubkey(),
+        &[&payer, &mint_keypair],
+    )
+    .await
+    .unwrap();
+
+    // Create token pool for SPL interface
+    let create_pool_ix =
+        CreateSplInterfacePda::new(payer.pubkey(), mint, anchor_spl::token::ID, false)
+            .instruction();
+
+    rpc.create_and_send_transaction(&[create_pool_ix], &payer.pubkey(), &[&payer])
+        .await
+        .unwrap();
+
+    // Create SPL token account and mint tokens
+    let spl_token_account_keypair = Keypair::new();
+    create_token_account(&mut rpc, &mint, &spl_token_account_keypair, &payer)
+        .await
+        .unwrap();
+    mint_spl_tokens(
+        &mut rpc,
+        &mint,
+        &spl_token_account_keypair.pubkey(),
+        &payer.pubkey(),
+        &payer,
+        1000,
+        false,
+    )
+    .await
+    .unwrap();
+
+    // Create cToken ATAs for source and destination
+    let source_owner = payer.pubkey();
+    let dest_owner = Pubkey::new_unique();
+
+    let (source_ata, _) = derive_ctoken_ata(&source_owner, &mint);
+    let (dest_ata, _) = derive_ctoken_ata(&dest_owner, &mint);
+
+    let create_source_ata = CreateAssociatedCTokenAccount::new(payer.pubkey(), source_owner, mint)
+        .instruction()
+        .unwrap();
+    let create_dest_ata = CreateAssociatedCTokenAccount::new(payer.pubkey(), dest_owner, mint)
+        .instruction()
+        .unwrap();
+
+    rpc.create_and_send_transaction(
+        &[create_source_ata, create_dest_ata],
+        &payer.pubkey(),
+        &[&payer],
+    )
+    .await
+    .unwrap();
+
+    // Transfer SPL tokens to source cToken ATA
+    let (spl_interface_pda, spl_interface_pda_bump) =
+        find_spl_interface_pda_with_index(&mint, 0, false);
+    let transfer_to_ctoken = TransferSplToCtoken {
+        amount: 1000,
+        spl_interface_pda_bump,
+        decimals,
+        source_spl_token_account: spl_token_account_keypair.pubkey(),
+        destination_ctoken_account: source_ata,
+        authority: payer.pubkey(),
+        mint,
+        payer: payer.pubkey(),
+        spl_interface_pda,
+        spl_token_program: anchor_spl::token::ID,
+    }
+    .instruction()
+    .unwrap();
+
+    rpc.create_and_send_transaction(&[transfer_to_ctoken], &payer.pubkey(), &[&payer])
+        .await
+        .unwrap();
+
+    // Execute transfer_checked via wrapper program
+    let transfer_data = TransferCheckedData {
+        amount: 500,
+        decimals,
+    };
+    let mut instruction_data = vec![InstructionType::CTokenTransferCheckedInvoke as u8];
+    transfer_data.serialize(&mut instruction_data).unwrap();
+
+    let ctoken_program = light_ctoken_sdk::ctoken::CTOKEN_PROGRAM_ID;
+    let instruction = Instruction {
+        program_id: ID,
+        accounts: vec![
+            AccountMeta::new(source_ata, false),
+            AccountMeta::new_readonly(mint, false),
+            AccountMeta::new(dest_ata, false),
+            AccountMeta::new_readonly(source_owner, true),
+            AccountMeta::new_readonly(ctoken_program, false),
+        ],
+        data: instruction_data,
+    };
+
+    rpc.create_and_send_transaction(&[instruction], &payer.pubkey(), &[&payer])
+        .await
+        .unwrap();
+
+    // Verify balances
+    let source_data = rpc.get_account(source_ata).await.unwrap().unwrap();
+    let source_state = CToken::deserialize(&mut &source_data.data[..]).unwrap();
+    assert_eq!(source_state.amount, 500);
+
+    let dest_data = rpc.get_account(dest_ata).await.unwrap().unwrap();
+    let dest_state = CToken::deserialize(&mut &dest_data.data[..]).unwrap();
+    assert_eq!(dest_state.amount, 500);
+}
+
+/// Test transfer_checked with Token-2022 mint
+#[tokio::test]
+async fn test_ctoken_transfer_checked_t22_mint() {
+    let config = ProgramTestConfig::new_v2(true, Some(vec![("native_ctoken_examples", ID)]));
+    let mut rpc = LightProgramTest::new(config).await.unwrap();
+    let payer = rpc.get_payer().insecure_clone();
+
+    let decimals = 2u8;
+
+    // Create Token-2022 mint with extensions
+    let (mint_keypair, _extension_config) =
+        create_mint_22_with_extensions(&mut rpc, &payer, decimals).await;
+    let mint = mint_keypair.pubkey();
+
+    // Create T22 token account and mint tokens
+    let t22_token_account = create_token_22_account(&mut rpc, &payer, &mint, &payer.pubkey()).await;
+    mint_spl_tokens_22(&mut rpc, &payer, &mint, &t22_token_account, 1000).await;
+
+    // Create cToken ATAs for source and destination with compression_only for T22 restricted extensions
+    let source_owner = payer.pubkey();
+    let dest_owner = Pubkey::new_unique();
+
+    let (source_ata, _) = derive_ctoken_ata(&source_owner, &mint);
+    let (dest_ata, _) = derive_ctoken_ata(&dest_owner, &mint);
+
+    use light_ctoken_sdk::ctoken::CompressibleParams;
+    let compressible_params = CompressibleParams {
+        compression_only: true,
+        ..Default::default()
+    };
+
+    let create_source_ata = CreateAssociatedCTokenAccount::new(payer.pubkey(), source_owner, mint)
+        .with_compressible(compressible_params.clone())
+        .instruction()
+        .unwrap();
+    let create_dest_ata = CreateAssociatedCTokenAccount::new(payer.pubkey(), dest_owner, mint)
+        .with_compressible(compressible_params)
+        .instruction()
+        .unwrap();
+
+    rpc.create_and_send_transaction(
+        &[create_source_ata, create_dest_ata],
+        &payer.pubkey(),
+        &[&payer],
+    )
+    .await
+    .unwrap();
+
+    // Transfer T22 tokens to source cToken ATA (use restricted=true for mints with restricted extensions)
+    let (spl_interface_pda, spl_interface_pda_bump) =
+        find_spl_interface_pda_with_index(&mint, 0, true);
+    let transfer_to_ctoken = TransferSplToCtoken {
+        amount: 1000,
+        spl_interface_pda_bump,
+        decimals,
+        source_spl_token_account: t22_token_account,
+        destination_ctoken_account: source_ata,
+        authority: payer.pubkey(),
+        mint,
+        payer: payer.pubkey(),
+        spl_interface_pda,
+        spl_token_program: spl_token_2022::ID,
+    }
+    .instruction()
+    .unwrap();
+
+    rpc.create_and_send_transaction(&[transfer_to_ctoken], &payer.pubkey(), &[&payer])
+        .await
+        .unwrap();
+
+    // Execute transfer_checked via wrapper program
+    let transfer_data = TransferCheckedData {
+        amount: 500,
+        decimals,
+    };
+    let mut instruction_data = vec![InstructionType::CTokenTransferCheckedInvoke as u8];
+    transfer_data.serialize(&mut instruction_data).unwrap();
+
+    let ctoken_program = light_ctoken_sdk::ctoken::CTOKEN_PROGRAM_ID;
+    let instruction = Instruction {
+        program_id: ID,
+        accounts: vec![
+            AccountMeta::new(source_ata, false),
+            AccountMeta::new_readonly(mint, false),
+            AccountMeta::new(dest_ata, false),
+            AccountMeta::new_readonly(source_owner, true),
+            AccountMeta::new_readonly(ctoken_program, false),
+        ],
+        data: instruction_data,
+    };
+
+    rpc.create_and_send_transaction(&[instruction], &payer.pubkey(), &[&payer])
+        .await
+        .unwrap();
+
+    // Verify balances
+    let source_data = rpc.get_account(source_ata).await.unwrap().unwrap();
+    let source_state = CToken::deserialize(&mut &source_data.data[..]).unwrap();
+    assert_eq!(source_state.amount, 500);
+
+    let dest_data = rpc.get_account(dest_ata).await.unwrap().unwrap();
+    let dest_state = CToken::deserialize(&mut &dest_data.data[..]).unwrap();
+    assert_eq!(dest_state.amount, 500);
+}
+
+/// Test transfer_checked with decompressed CMint
+#[tokio::test]
+async fn test_ctoken_transfer_checked_cmint() {
+    let config = ProgramTestConfig::new_v2(true, Some(vec![("native_ctoken_examples", ID)]));
+    let mut rpc = LightProgramTest::new(config).await.unwrap();
+    let payer = rpc.get_payer().insecure_clone();
+
+    let decimals = 9u8;
+    let source_owner = payer.pubkey();
+    let dest_owner = Pubkey::new_unique();
+
+    // Create compressed mint and decompress it, then create ATAs with tokens
+    let (mint, _compression_address, ata_pubkeys) =
+        setup_create_compressed_mint_with_freeze_authority(
+            &mut rpc,
+            &payer,
+            payer.pubkey(),
+            None, // no freeze authority needed for transfer
+            decimals,
+            vec![(1000, source_owner), (0, dest_owner)],
+        )
+        .await;
+
+    let source_ata = ata_pubkeys[0];
+    let dest_ata = ata_pubkeys[1];
+
+    // Execute transfer_checked via wrapper program
+    let transfer_data = TransferCheckedData {
+        amount: 500,
+        decimals,
+    };
+    let mut instruction_data = vec![InstructionType::CTokenTransferCheckedInvoke as u8];
+    transfer_data.serialize(&mut instruction_data).unwrap();
+
+    let ctoken_program = light_ctoken_sdk::ctoken::CTOKEN_PROGRAM_ID;
+    let instruction = Instruction {
+        program_id: ID,
+        accounts: vec![
+            AccountMeta::new(source_ata, false),
+            AccountMeta::new_readonly(mint, false),
+            AccountMeta::new(dest_ata, false),
+            AccountMeta::new_readonly(source_owner, true),
+            AccountMeta::new_readonly(ctoken_program, false),
+        ],
+        data: instruction_data,
+    };
+
+    rpc.create_and_send_transaction(&[instruction], &payer.pubkey(), &[&payer])
+        .await
+        .unwrap();
+
+    // Verify balances
+    let source_data = rpc.get_account(source_ata).await.unwrap().unwrap();
+    let source_state = CToken::deserialize(&mut &source_data.data[..]).unwrap();
+    assert_eq!(source_state.amount, 500);
+
+    let dest_data = rpc.get_account(dest_ata).await.unwrap().unwrap();
+    let dest_state = CToken::deserialize(&mut &dest_data.data[..]).unwrap();
+    assert_eq!(dest_state.amount, 500);
+}
diff --git a/sdk-tests/sdk-ctoken-test/tests/test_transfer_interface.rs b/sdk-tests/sdk-ctoken-test/tests/test_transfer_interface.rs
index 3a1ca1a3d9..f06eaf203e 100644
--- a/sdk-tests/sdk-ctoken-test/tests/test_transfer_interface.rs
+++ b/sdk-tests/sdk-ctoken-test/tests/test_transfer_interface.rs
@@ -5,12 +5,14 @@ mod shared;
 use borsh::BorshSerialize;
 use light_client::rpc::Rpc;
 use light_ctoken_sdk::{
-    ctoken::{derive_ctoken_ata, CreateAssociatedCTokenAccount},
+    ctoken::{derive_ctoken_ata, CompressibleParams, CreateAssociatedCTokenAccount},
     spl_interface::find_spl_interface_pda_with_index,
 };
 use light_ctoken_types::CPI_AUTHORITY_PDA;
 use light_program_test::{LightProgramTest, ProgramTestConfig};
-use light_test_utils::spl::{create_mint_helper, create_token_2022_account, mint_spl_tokens};
+use light_test_utils::spl::{
+    create_mint_helper, create_token_2022_account, mint_spl_tokens, CREATE_MINT_HELPER_DECIMALS,
+};
 use native_ctoken_examples::{TransferInterfaceData, ID, TRANSFER_INTERFACE_AUTHORITY_SEED};
 use solana_sdk::{
     instruction::{AccountMeta, Instruction},
@@ -75,7 +77,8 @@ async fn test_transfer_interface_spl_to_ctoken_invoke() {
     let ctoken_account = derive_ctoken_ata(&recipient.pubkey(), &mint).0;
 
     // Get token pool PDA
-    let (spl_interface_pda, spl_interface_pda_bump) = find_spl_interface_pda_with_index(&mint, 0);
+    let (spl_interface_pda, spl_interface_pda_bump) =
+        find_spl_interface_pda_with_index(&mint, 0, false);
     let compressed_token_program_id =
         Pubkey::new_from_array(light_ctoken_interface::CTOKEN_PROGRAM_ID);
     let cpi_authority_pda = Pubkey::new_from_array(CPI_AUTHORITY_PDA);
@@ -84,6 +87,7 @@ async fn test_transfer_interface_spl_to_ctoken_invoke() {
     let data = TransferInterfaceData {
         amount: transfer_amount,
         spl_interface_pda_bump: Some(spl_interface_pda_bump),
+        decimals: CREATE_MINT_HELPER_DECIMALS,
     };
     // Discriminator 19 = TransferInterfaceInvoke
     let wrapper_instruction_data = [vec![19u8], data.try_to_vec().unwrap()].concat();
@@ -95,6 +99,7 @@ async fn test_transfer_interface_spl_to_ctoken_invoke() {
         AccountMeta::new_readonly(sender.pubkey(), true),            // authority (signer)
         AccountMeta::new(payer.pubkey(), true),                      // payer
         AccountMeta::new_readonly(cpi_authority_pda, false), // compressed_token_program_authority
+        AccountMeta::new_readonly(solana_sdk::system_program::ID, false), // system_program
         AccountMeta::new_readonly(mint, false),              // mint (for SPL bridge)
         AccountMeta::new(spl_interface_pda, false),          // spl_interface_pda
         AccountMeta::new_readonly(anchor_spl::token::ID, false), // spl_token_program
@@ -181,7 +186,8 @@ async fn test_transfer_interface_ctoken_to_spl_invoke() {
     .await
     .unwrap();
 
-    let (spl_interface_pda, spl_interface_pda_bump) = find_spl_interface_pda_with_index(&mint, 0);
+    let (spl_interface_pda, spl_interface_pda_bump) =
+        find_spl_interface_pda_with_index(&mint, 0, false);
     let compressed_token_program_id =
         Pubkey::new_from_array(light_ctoken_interface::CTOKEN_PROGRAM_ID);
     let cpi_authority_pda = Pubkey::new_from_array(CPI_AUTHORITY_PDA);
@@ -191,6 +197,7 @@ async fn test_transfer_interface_ctoken_to_spl_invoke() {
         let data = TransferInterfaceData {
             amount,
             spl_interface_pda_bump: Some(spl_interface_pda_bump),
+            decimals: CREATE_MINT_HELPER_DECIMALS,
         };
         let wrapper_instruction_data = [vec![19u8], data.try_to_vec().unwrap()].concat();
         let wrapper_accounts = vec![
@@ -200,6 +207,7 @@ async fn test_transfer_interface_ctoken_to_spl_invoke() {
             AccountMeta::new_readonly(owner.pubkey(), true),
             AccountMeta::new(payer.pubkey(), true),
             AccountMeta::new_readonly(cpi_authority_pda, false),
+            AccountMeta::new_readonly(solana_sdk::system_program::ID, false),
             AccountMeta::new_readonly(mint, false),
             AccountMeta::new(spl_interface_pda, false),
             AccountMeta::new_readonly(anchor_spl::token::ID, false),
@@ -218,6 +226,7 @@ async fn test_transfer_interface_ctoken_to_spl_invoke() {
     let data = TransferInterfaceData {
         amount: transfer_amount,
         spl_interface_pda_bump: Some(spl_interface_pda_bump),
+        decimals: CREATE_MINT_HELPER_DECIMALS,
     };
     let wrapper_instruction_data = [vec![19u8], data.try_to_vec().unwrap()].concat();
 
@@ -228,6 +237,7 @@ async fn test_transfer_interface_ctoken_to_spl_invoke() {
         AccountMeta::new_readonly(owner.pubkey(), true), // authority
         AccountMeta::new(payer.pubkey(), true),  // payer
         AccountMeta::new_readonly(cpi_authority_pda, false),
+        AccountMeta::new_readonly(solana_sdk::system_program::ID, false),
         AccountMeta::new_readonly(mint, false),
         AccountMeta::new(spl_interface_pda, false),
         AccountMeta::new_readonly(anchor_spl::token::ID, false),
@@ -321,7 +331,8 @@ async fn test_transfer_interface_ctoken_to_ctoken_invoke() {
     .await
     .unwrap();
 
-    let (spl_interface_pda, spl_interface_pda_bump) = find_spl_interface_pda_with_index(&mint, 0);
+    let (spl_interface_pda, spl_interface_pda_bump) =
+        find_spl_interface_pda_with_index(&mint, 0, false);
     let compressed_token_program_id =
         Pubkey::new_from_array(light_ctoken_interface::CTOKEN_PROGRAM_ID);
     let cpi_authority_pda = Pubkey::new_from_array(CPI_AUTHORITY_PDA);
@@ -331,6 +342,7 @@ async fn test_transfer_interface_ctoken_to_ctoken_invoke() {
         let data = TransferInterfaceData {
             amount,
             spl_interface_pda_bump: Some(spl_interface_pda_bump),
+            decimals: CREATE_MINT_HELPER_DECIMALS,
         };
         let wrapper_instruction_data = [vec![19u8], data.try_to_vec().unwrap()].concat();
         let wrapper_accounts = vec![
@@ -340,6 +352,7 @@ async fn test_transfer_interface_ctoken_to_ctoken_invoke() {
             AccountMeta::new_readonly(sender.pubkey(), true),
             AccountMeta::new(payer.pubkey(), true),
             AccountMeta::new_readonly(cpi_authority_pda, false),
+            AccountMeta::new_readonly(solana_sdk::system_program::ID, false),
             AccountMeta::new_readonly(mint, false),
             AccountMeta::new(spl_interface_pda, false),
             AccountMeta::new_readonly(anchor_spl::token::ID, false),
@@ -358,10 +371,11 @@ async fn test_transfer_interface_ctoken_to_ctoken_invoke() {
     let data = TransferInterfaceData {
         amount: transfer_amount,
         spl_interface_pda_bump: None, // Not needed for CToken->CToken
+        decimals: CREATE_MINT_HELPER_DECIMALS,
     };
     let wrapper_instruction_data = [vec![19u8], data.try_to_vec().unwrap()].concat();
 
-    // For CToken->CToken, we only need 6 accounts (no SPL bridge)
+    // For CToken->CToken, we need 7 accounts (no SPL bridge, but system_program is required)
     let wrapper_accounts = vec![
         AccountMeta::new_readonly(compressed_token_program_id, false),
         AccountMeta::new(sender_ctoken, false), // source (CToken)
@@ -369,6 +383,7 @@ async fn test_transfer_interface_ctoken_to_ctoken_invoke() {
         AccountMeta::new_readonly(sender.pubkey(), true), // authority
         AccountMeta::new(payer.pubkey(), true), // payer
         AccountMeta::new_readonly(cpi_authority_pda, false),
+        AccountMeta::new_readonly(solana_sdk::system_program::ID, false), // system_program
     ];
 
     let instruction = Instruction {
@@ -464,7 +479,8 @@ async fn test_transfer_interface_spl_to_ctoken_invoke_signed() {
         .unwrap();
     let ctoken_account = derive_ctoken_ata(&recipient.pubkey(), &mint).0;
 
-    let (spl_interface_pda, spl_interface_pda_bump) = find_spl_interface_pda_with_index(&mint, 0);
+    let (spl_interface_pda, spl_interface_pda_bump) =
+        find_spl_interface_pda_with_index(&mint, 0, false);
     let compressed_token_program_id =
         Pubkey::new_from_array(light_ctoken_interface::CTOKEN_PROGRAM_ID);
     let cpi_authority_pda = Pubkey::new_from_array(CPI_AUTHORITY_PDA);
@@ -472,6 +488,7 @@ async fn test_transfer_interface_spl_to_ctoken_invoke_signed() {
     let data = TransferInterfaceData {
         amount: transfer_amount,
         spl_interface_pda_bump: Some(spl_interface_pda_bump),
+        decimals: CREATE_MINT_HELPER_DECIMALS,
     };
     // Discriminator 20 = TransferInterfaceInvokeSigned
     let wrapper_instruction_data = [vec![20u8], data.try_to_vec().unwrap()].concat();
@@ -483,6 +500,7 @@ async fn test_transfer_interface_spl_to_ctoken_invoke_signed() {
         AccountMeta::new_readonly(authority_pda, false), // authority (PDA, not signer)
         AccountMeta::new(payer.pubkey(), true), // payer
         AccountMeta::new_readonly(cpi_authority_pda, false), // compressed_token_program_authority
+        AccountMeta::new_readonly(solana_sdk::system_program::ID, false), // system_program
         AccountMeta::new_readonly(mint, false),
         AccountMeta::new(spl_interface_pda, false),
         AccountMeta::new_readonly(anchor_spl::token::ID, false),
@@ -558,7 +576,7 @@ async fn test_transfer_interface_ctoken_to_spl_invoke_signed() {
         owner: authority_pda,
         mint,
         associated_token_account: ctoken_account,
-        compressible: None,
+        compressible: CompressibleParams::default(),
     }
     .instruction()
     .unwrap();
@@ -587,7 +605,8 @@ async fn test_transfer_interface_ctoken_to_spl_invoke_signed() {
     .await
     .unwrap();
 
-    let (spl_interface_pda, spl_interface_pda_bump) = find_spl_interface_pda_with_index(&mint, 0);
+    let (spl_interface_pda, spl_interface_pda_bump) =
+        find_spl_interface_pda_with_index(&mint, 0, false);
     let compressed_token_program_id =
         Pubkey::new_from_array(light_ctoken_interface::CTOKEN_PROGRAM_ID);
     let cpi_authority_pda = Pubkey::new_from_array(CPI_AUTHORITY_PDA);
@@ -597,6 +616,7 @@ async fn test_transfer_interface_ctoken_to_spl_invoke_signed() {
         let data = TransferInterfaceData {
             amount,
             spl_interface_pda_bump: Some(spl_interface_pda_bump),
+            decimals: CREATE_MINT_HELPER_DECIMALS,
         };
         let wrapper_instruction_data = [vec![19u8], data.try_to_vec().unwrap()].concat();
         let wrapper_accounts = vec![
@@ -606,6 +626,7 @@ async fn test_transfer_interface_ctoken_to_spl_invoke_signed() {
             AccountMeta::new_readonly(temp_owner.pubkey(), true),
             AccountMeta::new(payer.pubkey(), true),
             AccountMeta::new_readonly(cpi_authority_pda, false),
+            AccountMeta::new_readonly(solana_sdk::system_program::ID, false),
             AccountMeta::new_readonly(mint, false),
             AccountMeta::new(spl_interface_pda, false),
             AccountMeta::new_readonly(anchor_spl::token::ID, false),
@@ -624,6 +645,7 @@ async fn test_transfer_interface_ctoken_to_spl_invoke_signed() {
     let data = TransferInterfaceData {
         amount: transfer_amount,
         spl_interface_pda_bump: Some(spl_interface_pda_bump),
+        decimals: CREATE_MINT_HELPER_DECIMALS,
     };
     // Discriminator 20 = TransferInterfaceInvokeSigned
     let wrapper_instruction_data = [vec![20u8], data.try_to_vec().unwrap()].concat();
@@ -635,6 +657,7 @@ async fn test_transfer_interface_ctoken_to_spl_invoke_signed() {
         AccountMeta::new_readonly(authority_pda, false), // authority (PDA)
         AccountMeta::new(payer.pubkey(), true),  // payer
         AccountMeta::new_readonly(cpi_authority_pda, false),
+        AccountMeta::new_readonly(solana_sdk::system_program::ID, false),
         AccountMeta::new_readonly(mint, false),
         AccountMeta::new(spl_interface_pda, false),
         AccountMeta::new_readonly(anchor_spl::token::ID, false),
@@ -698,7 +721,7 @@ async fn test_transfer_interface_ctoken_to_ctoken_invoke_signed() {
         owner: authority_pda,
         mint,
         associated_token_account: source_ctoken,
-        compressible: None,
+        compressible: CompressibleParams::default(),
     }
     .instruction()
     .unwrap();
@@ -740,7 +763,8 @@ async fn test_transfer_interface_ctoken_to_ctoken_invoke_signed() {
     .await
     .unwrap();
 
-    let (spl_interface_pda, spl_interface_pda_bump) = find_spl_interface_pda_with_index(&mint, 0);
+    let (spl_interface_pda, spl_interface_pda_bump) =
+        find_spl_interface_pda_with_index(&mint, 0, false);
     let compressed_token_program_id =
         Pubkey::new_from_array(light_ctoken_interface::CTOKEN_PROGRAM_ID);
     let cpi_authority_pda = Pubkey::new_from_array(CPI_AUTHORITY_PDA);
@@ -750,6 +774,7 @@ async fn test_transfer_interface_ctoken_to_ctoken_invoke_signed() {
         let data = TransferInterfaceData {
             amount,
             spl_interface_pda_bump: Some(spl_interface_pda_bump),
+            decimals: CREATE_MINT_HELPER_DECIMALS,
         };
         let wrapper_instruction_data = [vec![19u8], data.try_to_vec().unwrap()].concat();
         let wrapper_accounts = vec![
@@ -759,6 +784,7 @@ async fn test_transfer_interface_ctoken_to_ctoken_invoke_signed() {
             AccountMeta::new_readonly(temp_owner.pubkey(), true),
             AccountMeta::new(payer.pubkey(), true),
             AccountMeta::new_readonly(cpi_authority_pda, false),
+            AccountMeta::new_readonly(solana_sdk::system_program::ID, false),
             AccountMeta::new_readonly(mint, false),
             AccountMeta::new(spl_interface_pda, false),
             AccountMeta::new_readonly(anchor_spl::token::ID, false),
@@ -777,6 +803,7 @@ async fn test_transfer_interface_ctoken_to_ctoken_invoke_signed() {
     let data = TransferInterfaceData {
         amount: transfer_amount,
         spl_interface_pda_bump: None, // Not needed for CToken->CToken
+        decimals: CREATE_MINT_HELPER_DECIMALS,
     };
     // Discriminator 20 = TransferInterfaceInvokeSigned
     let wrapper_instruction_data = [vec![20u8], data.try_to_vec().unwrap()].concat();
@@ -789,6 +816,7 @@ async fn test_transfer_interface_ctoken_to_ctoken_invoke_signed() {
         AccountMeta::new_readonly(authority_pda, false), // authority (PDA)
         AccountMeta::new(payer.pubkey(), true), // payer
         AccountMeta::new_readonly(cpi_authority_pda, false),
+        AccountMeta::new_readonly(solana_sdk::system_program::ID, false),
     ];
 
     let instruction = Instruction {
diff --git a/sdk-tests/sdk-ctoken-test/tests/test_transfer_spl_ctoken.rs b/sdk-tests/sdk-ctoken-test/tests/test_transfer_spl_ctoken.rs
index 152540122f..cfd65618cf 100644
--- a/sdk-tests/sdk-ctoken-test/tests/test_transfer_spl_ctoken.rs
+++ b/sdk-tests/sdk-ctoken-test/tests/test_transfer_spl_ctoken.rs
@@ -5,12 +5,14 @@ mod shared;
 use borsh::BorshSerialize;
 use light_client::rpc::Rpc;
 use light_ctoken_sdk::{
-    ctoken::{derive_ctoken_ata, CreateAssociatedCTokenAccount},
+    ctoken::{derive_ctoken_ata, CompressibleParams, CreateAssociatedCTokenAccount},
     spl_interface::find_spl_interface_pda_with_index,
 };
 use light_ctoken_types::CPI_AUTHORITY_PDA;
 use light_program_test::{LightProgramTest, ProgramTestConfig};
-use light_test_utils::spl::{create_mint_helper, create_token_2022_account, mint_spl_tokens};
+use light_test_utils::spl::{
+    create_mint_helper, create_token_2022_account, mint_spl_tokens, CREATE_MINT_HELPER_DECIMALS,
+};
 use native_ctoken_examples::{
     TransferCTokenToSplData, TransferSplToCtokenData, ID, TRANSFER_AUTHORITY_SEED,
 };
@@ -86,7 +88,8 @@ async fn test_spl_to_ctoken_invoke() {
     assert_eq!(initial_spl_balance, amount);
 
     // Get token pool PDA
-    let (spl_interface_pda, spl_interface_pda_bump) = find_spl_interface_pda_with_index(&mint, 0);
+    let (spl_interface_pda, spl_interface_pda_bump) =
+        find_spl_interface_pda_with_index(&mint, 0, false);
     let compressed_token_program_id =
         Pubkey::new_from_array(light_ctoken_interface::CTOKEN_PROGRAM_ID);
     let cpi_authority_pda = Pubkey::new_from_array(CPI_AUTHORITY_PDA);
@@ -95,6 +98,7 @@ async fn test_spl_to_ctoken_invoke() {
     let data = TransferSplToCtokenData {
         amount: transfer_amount,
         spl_interface_pda_bump,
+        decimals: CREATE_MINT_HELPER_DECIMALS,
     };
     // Discriminator 15 = SplToCtokenInvoke
     let wrapper_instruction_data = [vec![15u8], data.try_to_vec().unwrap()].concat();
@@ -109,6 +113,7 @@ async fn test_spl_to_ctoken_invoke() {
     // - accounts[6]: spl_interface_pda
     // - accounts[7]: spl_token_program
     // - accounts[8]: compressed_token_program_authority
+    // - accounts[9]: system_program
     let wrapper_accounts = vec![
         AccountMeta::new_readonly(compressed_token_program_id, false),
         AccountMeta::new(spl_token_account_keypair.pubkey(), false),
@@ -119,6 +124,7 @@ async fn test_spl_to_ctoken_invoke() {
         AccountMeta::new(spl_interface_pda, false),
         AccountMeta::new_readonly(anchor_spl::token::ID, false),
         AccountMeta::new_readonly(cpi_authority_pda, false),
+        AccountMeta::new_readonly(solana_sdk::system_program::ID, false),
     ];
 
     let instruction = Instruction {
@@ -209,7 +215,8 @@ async fn test_ctoken_to_spl_invoke() {
     .unwrap();
 
     // Transfer from temp SPL to ctoken to fund it
-    let (spl_interface_pda, spl_interface_pda_bump) = find_spl_interface_pda_with_index(&mint, 0);
+    let (spl_interface_pda, spl_interface_pda_bump) =
+        find_spl_interface_pda_with_index(&mint, 0, false);
     let compressed_token_program_id =
         Pubkey::new_from_array(light_ctoken_interface::CTOKEN_PROGRAM_ID);
     let cpi_authority_pda = Pubkey::new_from_array(CPI_AUTHORITY_PDA);
@@ -218,6 +225,7 @@ async fn test_ctoken_to_spl_invoke() {
         let data = TransferSplToCtokenData {
             amount,
             spl_interface_pda_bump,
+            decimals: CREATE_MINT_HELPER_DECIMALS,
         };
         let wrapper_instruction_data = [vec![15u8], data.try_to_vec().unwrap()].concat();
         let wrapper_accounts = vec![
@@ -230,6 +238,7 @@ async fn test_ctoken_to_spl_invoke() {
             AccountMeta::new(spl_interface_pda, false),
             AccountMeta::new_readonly(anchor_spl::token::ID, false),
             AccountMeta::new_readonly(cpi_authority_pda, false),
+            AccountMeta::new_readonly(solana_sdk::system_program::ID, false),
         ];
 
         let instruction = Instruction {
@@ -254,6 +263,7 @@ async fn test_ctoken_to_spl_invoke() {
     let data = TransferCTokenToSplData {
         amount: transfer_amount,
         spl_interface_pda_bump,
+        decimals: CREATE_MINT_HELPER_DECIMALS,
     };
     // Discriminator 17 = CtokenToSplInvoke
     let wrapper_instruction_data = [vec![17u8], data.try_to_vec().unwrap()].concat();
@@ -378,7 +388,8 @@ async fn test_spl_to_ctoken_invoke_signed() {
     let ctoken_account = derive_ctoken_ata(&recipient.pubkey(), &mint).0;
 
     // Get SPL interface PDA
-    let (spl_interface_pda, spl_interface_pda_bump) = find_spl_interface_pda_with_index(&mint, 0);
+    let (spl_interface_pda, spl_interface_pda_bump) =
+        find_spl_interface_pda_with_index(&mint, 0, false);
     let compressed_token_program_id =
         Pubkey::new_from_array(light_ctoken_interface::CTOKEN_PROGRAM_ID);
     let cpi_authority_pda = Pubkey::new_from_array(CPI_AUTHORITY_PDA);
@@ -387,6 +398,7 @@ async fn test_spl_to_ctoken_invoke_signed() {
     let data = TransferSplToCtokenData {
         amount: transfer_amount,
         spl_interface_pda_bump,
+        decimals: CREATE_MINT_HELPER_DECIMALS,
     };
     // Discriminator 16 = SplToCtokenInvokeSigned
     let wrapper_instruction_data = [vec![16u8], data.try_to_vec().unwrap()].concat();
@@ -401,6 +413,7 @@ async fn test_spl_to_ctoken_invoke_signed() {
         AccountMeta::new(spl_interface_pda, false),
         AccountMeta::new_readonly(anchor_spl::token::ID, false),
         AccountMeta::new_readonly(cpi_authority_pda, false),
+        AccountMeta::new_readonly(solana_sdk::system_program::ID, false),
     ];
 
     let instruction = Instruction {
@@ -471,7 +484,6 @@ async fn test_ctoken_to_spl_invoke_signed() {
     .unwrap();
 
     // Create ctoken ATA owned by the PDA
-    // We need to use a non-compressible ATA so it can be owned by a PDA
     let (ctoken_account, bump) = derive_ctoken_ata(&authority_pda, &mint);
     let instruction = CreateAssociatedCTokenAccount {
         idempotent: false,
@@ -480,7 +492,7 @@ async fn test_ctoken_to_spl_invoke_signed() {
         owner: authority_pda,
         mint,
         associated_token_account: ctoken_account,
-        compressible: None, // Non-compressible so PDA can own it
+        compressible: CompressibleParams::default(),
     }
     .instruction()
     .unwrap();
@@ -516,7 +528,8 @@ async fn test_ctoken_to_spl_invoke_signed() {
     .unwrap();
 
     // Transfer from temp SPL to ctoken to fund it
-    let (spl_interface_pda, spl_interface_pda_bump) = find_spl_interface_pda_with_index(&mint, 0);
+    let (spl_interface_pda, spl_interface_pda_bump) =
+        find_spl_interface_pda_with_index(&mint, 0, false);
     let compressed_token_program_id =
         Pubkey::new_from_array(light_ctoken_interface::CTOKEN_PROGRAM_ID);
     let cpi_authority_pda = Pubkey::new_from_array(CPI_AUTHORITY_PDA);
@@ -525,6 +538,7 @@ async fn test_ctoken_to_spl_invoke_signed() {
         let data = TransferSplToCtokenData {
             amount,
             spl_interface_pda_bump,
+            decimals: CREATE_MINT_HELPER_DECIMALS,
         };
         let wrapper_instruction_data = [vec![15u8], data.try_to_vec().unwrap()].concat();
         let wrapper_accounts = vec![
@@ -537,6 +551,7 @@ async fn test_ctoken_to_spl_invoke_signed() {
             AccountMeta::new(spl_interface_pda, false),
             AccountMeta::new_readonly(anchor_spl::token::ID, false),
             AccountMeta::new_readonly(cpi_authority_pda, false),
+            AccountMeta::new_readonly(solana_sdk::system_program::ID, false),
         ];
 
         let instruction = Instruction {
@@ -561,6 +576,7 @@ async fn test_ctoken_to_spl_invoke_signed() {
     let data = TransferCTokenToSplData {
         amount: transfer_amount,
         spl_interface_pda_bump,
+        decimals: CREATE_MINT_HELPER_DECIMALS,
     };
     // Discriminator 18 = CtokenToSplInvokeSigned
     let wrapper_instruction_data = [vec![18u8], data.try_to_vec().unwrap()].concat();
diff --git a/sdk-tests/sdk-token-test/src/lib.rs b/sdk-tests/sdk-token-test/src/lib.rs
index 57c02809d9..b7cf1c7b51 100644
--- a/sdk-tests/sdk-token-test/src/lib.rs
+++ b/sdk-tests/sdk-token-test/src/lib.rs
@@ -107,6 +107,7 @@ pub mod sdk_token_test {
         source_index: u8,
         authority_index: u8,
         close_recipient_index: u8,
+        rent_sponsor_index: u8,
         system_accounts_offset: u8,
     ) -> Result<()> {
         process_compress_full_and_close(
@@ -116,6 +117,7 @@ pub mod sdk_token_test {
             source_index,
             authority_index,
             close_recipient_index,
+            rent_sponsor_index,
             system_accounts_offset,
         )
     }
diff --git a/sdk-tests/sdk-token-test/src/process_compress_full_and_close.rs b/sdk-tests/sdk-token-test/src/process_compress_full_and_close.rs
index adcfa61113..be78c62b65 100644
--- a/sdk-tests/sdk-token-test/src/process_compress_full_and_close.rs
+++ b/sdk-tests/sdk-token-test/src/process_compress_full_and_close.rs
@@ -21,6 +21,7 @@ pub fn process_compress_full_and_close<'info>(
     source_index: u8,
     authority_index: u8,
     close_recipient_index: u8,
+    rent_sponsor_index: u8,
     system_accounts_offset: u8,
 ) -> Result<()> {
     // Parse CPI accounts (following four_transfer2 pattern)
@@ -39,6 +40,9 @@ pub fn process_compress_full_and_close<'info>(
     let close_recipient_info = cpi_accounts
         .get_tree_account_info(close_recipient_index as usize)
         .unwrap();
+    let rent_sponsor_info = cpi_accounts
+        .get_tree_account_info(rent_sponsor_index as usize)
+        .unwrap();
     // Create CTokenAccount2 for compression (following four_transfer2 pattern)
     let mut token_account_compress = CTokenAccount2::new_empty(recipient_index, mint_index);
 
@@ -88,14 +92,13 @@ pub fn process_compress_full_and_close<'info>(
 
     let compressed_token_program_id =
         Pubkey::new_from_array(light_ctoken_interface::CTOKEN_PROGRAM_ID);
-    // Create close instruction without rent_sponsor for non-compressible accounts
-    let close_instruction = CloseCTokenAccount {
-        token_program: compressed_token_program_id,
-        account: *token_account_info.key,
-        destination: *close_recipient_info.key,
-        owner: *ctx.accounts.signer.key,
-        rent_sponsor: None,
-    }
+    // Create close instruction with rent_sponsor for compressible accounts
+    let close_instruction = CloseCTokenAccount::new(
+        compressed_token_program_id,
+        *token_account_info.key,
+        *close_recipient_info.key,
+        *ctx.accounts.signer.key,
+    )
     .instruction()?;
 
     invoke(
@@ -104,6 +107,7 @@ pub fn process_compress_full_and_close<'info>(
             token_account_info.clone(),
             close_recipient_info.clone(),
             ctx.accounts.signer.to_account_info(),
+            rent_sponsor_info.clone(),
         ],
     )?;
     Ok(())
diff --git a/sdk-tests/sdk-token-test/src/process_create_ctoken_with_compress_to_pubkey.rs b/sdk-tests/sdk-token-test/src/process_create_ctoken_with_compress_to_pubkey.rs
index 2d0e13e6ee..5bbf2fe45f 100644
--- a/sdk-tests/sdk-token-test/src/process_create_ctoken_with_compress_to_pubkey.rs
+++ b/sdk-tests/sdk-token-test/src/process_create_ctoken_with_compress_to_pubkey.rs
@@ -1,5 +1,5 @@
 use anchor_lang::{prelude::*, solana_program::program::invoke_signed};
-use light_ctoken_interface::instructions::extensions::compressible::CompressToPubkey;
+use light_ctoken_interface::instructions::create_ctoken_account::CompressToPubkey;
 use light_ctoken_sdk::ctoken::{CompressibleParams, CreateCTokenAccount};
 
 use crate::Generic;
@@ -27,6 +27,7 @@ pub fn process_create_ctoken_with_compress_to_pubkey<'info>(
         lamports_per_write: None,
         compress_to_account_pubkey: Some(compress_to_pubkey),
         token_account_version: light_ctoken_interface::state::TokenDataVersion::ShaFlat,
+        compression_only: false,
     };
 
     let instruction = CreateCTokenAccount::new(
diff --git a/sdk-tests/sdk-token-test/src/process_four_transfer2.rs b/sdk-tests/sdk-token-test/src/process_four_transfer2.rs
index 2d8adc394a..41f9ef5133 100644
--- a/sdk-tests/sdk-token-test/src/process_four_transfer2.rs
+++ b/sdk-tests/sdk-token-test/src/process_four_transfer2.rs
@@ -240,6 +240,7 @@ pub fn process_four_transfer2<'info>(
                 transfer_recipient3,
             ],
             output_queue: output_tree_index,
+            in_tlv: None,
         };
         let instruction = create_transfer2_instruction(inputs).map_err(ProgramError::from)?;
 
diff --git a/sdk-tests/sdk-token-test/tests/decompress_full_cpi.rs b/sdk-tests/sdk-token-test/tests/decompress_full_cpi.rs
index 3c1cc454a1..ba64fc7bb7 100644
--- a/sdk-tests/sdk-token-test/tests/decompress_full_cpi.rs
+++ b/sdk-tests/sdk-token-test/tests/decompress_full_cpi.rs
@@ -83,6 +83,7 @@ async fn setup_decompress_full_test(num_inputs: usize) -> (LightProgramTest, Tes
             lamports_per_write: None,
             compress_to_account_pubkey: None,
             token_account_version: light_ctoken_interface::state::TokenDataVersion::ShaFlat,
+            compression_only: false,
         };
 
         let create_token_account_ix =
@@ -189,7 +190,8 @@ async fn test_decompress_full_cpi() {
             use light_zero_copy::traits::ZeroCopyAt;
             let (dest_token, _) = CToken::zero_copy_at(&dest_account.data).unwrap();
             assert_eq!(
-                *dest_token.amount, 0,
+                u64::from(dest_token.amount),
+                0,
                 "Destination should be empty initially"
             );
         }
@@ -243,6 +245,7 @@ async fn test_decompress_full_cpi() {
                     tree_info,
                     dest_pubkey,
                     &mut remaining_accounts,
+                    None, // No TLV extensions
                     version,
                 )
             })
@@ -288,7 +291,8 @@ async fn test_decompress_full_cpi() {
             use light_zero_copy::traits::ZeroCopyAt;
             let (dest_token_after, _) = CToken::zero_copy_at(&dest_account_after.data).unwrap();
             assert_eq!(
-                *dest_token_after.amount, ctx.compressed_amount_per_account,
+                u64::from(dest_token_after.amount),
+                ctx.compressed_amount_per_account,
                 "Each destination should have its decompressed amount"
             );
         }
@@ -333,7 +337,8 @@ async fn test_decompress_full_cpi_with_context() {
             use light_zero_copy::traits::ZeroCopyAt;
             let (dest_token_before, _) = CToken::zero_copy_at(&dest_account_before.data).unwrap();
             assert_eq!(
-                *dest_token_before.amount, 0,
+                u64::from(dest_token_before.amount),
+                0,
                 "Destination should be empty initially"
             );
         }
@@ -447,6 +452,7 @@ async fn test_decompress_full_cpi_with_context() {
                     tree_info,
                     dest_pubkey,
                     &mut remaining_accounts,
+                    None, // No TLV extensions
                     version,
                 )
             })
@@ -514,7 +520,8 @@ async fn test_decompress_full_cpi_with_context() {
             use light_zero_copy::traits::ZeroCopyAt;
             let (dest_token_after, _) = CToken::zero_copy_at(&dest_account_after.data).unwrap();
             assert_eq!(
-                *dest_token_after.amount, ctx.compressed_amount_per_account,
+                u64::from(dest_token_after.amount),
+                ctx.compressed_amount_per_account,
                 "Each destination should have received its decompressed amount"
             );
         }
diff --git a/sdk-tests/sdk-token-test/tests/pda_ctoken.rs b/sdk-tests/sdk-token-test/tests/pda_ctoken.rs
index 3525d2e05f..ad0ca1daba 100644
--- a/sdk-tests/sdk-token-test/tests/pda_ctoken.rs
+++ b/sdk-tests/sdk-token-test/tests/pda_ctoken.rs
@@ -213,6 +213,7 @@ pub async fn create_mint(
         lamports_per_write: Some(1000),
         compress_to_account_pubkey: None,
         token_account_version: light_ctoken_interface::state::TokenDataVersion::ShaFlat,
+        compression_only: false,
     };
 
     let create_ata_instruction =
diff --git a/sdk-tests/sdk-token-test/tests/test.rs b/sdk-tests/sdk-token-test/tests/test.rs
index 9ecff1ba77..2eb917d7d3 100644
--- a/sdk-tests/sdk-token-test/tests/test.rs
+++ b/sdk-tests/sdk-token-test/tests/test.rs
@@ -289,7 +289,7 @@ async fn compress_spl_tokens(
     token_account: Pubkey,
 ) -> Result<Signature, RpcError> {
     let mut remaining_accounts = PackedAccounts::default();
-    let spl_interface_pda = get_spl_interface_pda(&mint);
+    let spl_interface_pda = get_spl_interface_pda(&mint, false);
     let config = TokenAccountsMetaConfig::compress_client(
         spl_interface_pda,
         token_account,
@@ -394,7 +394,7 @@ async fn decompress_compressed_tokens(
     decompress_token_account: Pubkey,
 ) -> Result<Signature, RpcError> {
     let mut remaining_accounts = PackedAccounts::default();
-    let spl_interface_pda = get_spl_interface_pda(&compressed_account.token.mint);
+    let spl_interface_pda = get_spl_interface_pda(&compressed_account.token.mint, false);
     let config = TokenAccountsMetaConfig::decompress_client(
         spl_interface_pda,
         decompress_token_account,
@@ -582,7 +582,7 @@ async fn batch_compress_spl_tokens(
     remaining_accounts.add_pre_accounts_signer_mut(payer.pubkey());
     let spl_interface_index = 0;
     let (spl_interface_pda, spl_interface_bump) =
-        find_spl_interface_pda_with_index(&mint, spl_interface_index);
+        find_spl_interface_pda_with_index(&mint, spl_interface_index, false);
     println!("spl_interface_pda {:?}", spl_interface_pda);
     // Use batch compress account metas
     let config = BatchCompressMetaConfig::new_client(
diff --git a/sdk-tests/sdk-token-test/tests/test_4_invocations.rs b/sdk-tests/sdk-token-test/tests/test_4_invocations.rs
index c3f413d5cd..5c0e3fab9a 100644
--- a/sdk-tests/sdk-token-test/tests/test_4_invocations.rs
+++ b/sdk-tests/sdk-token-test/tests/test_4_invocations.rs
@@ -262,7 +262,7 @@ async fn compress_spl_tokens(
     token_account: Pubkey,
 ) -> Result<Signature, RpcError> {
     let mut remaining_accounts = PackedAccounts::default();
-    let spl_interface_pda = get_spl_interface_pda(&mint);
+    let spl_interface_pda = get_spl_interface_pda(&mint, false);
     let config = TokenAccountsMetaConfig::compress_client(
         spl_interface_pda,
         token_account,
@@ -430,7 +430,7 @@ async fn test_four_invokes_instruction(
 ) -> Result<(), RpcError> {
     let default_pubkeys = CTokenDefaultAccounts::default();
     let mut remaining_accounts = PackedAccounts::default();
-    let spl_interface_pda1 = get_spl_interface_pda(&mint1);
+    let spl_interface_pda1 = get_spl_interface_pda(&mint1, false);
     // Remaining accounts 0
     remaining_accounts.add_pre_accounts_meta(AccountMeta::new(compression_token_account, false));
     // Remaining accounts 1
diff --git a/sdk-tests/sdk-token-test/tests/test_4_transfer2.rs b/sdk-tests/sdk-token-test/tests/test_4_transfer2.rs
index af7608c848..01be945744 100644
--- a/sdk-tests/sdk-token-test/tests/test_4_transfer2.rs
+++ b/sdk-tests/sdk-token-test/tests/test_4_transfer2.rs
@@ -4,7 +4,7 @@ use light_ctoken_interface::{
         mint_action::{CompressedMintWithContext, Recipient},
         transfer2::MultiInputTokenDataWithContext,
     },
-    state::{BaseMint, CompressedMintMetadata},
+    state::{BaseMint, CompressedMintMetadata, ACCOUNT_TYPE_MINT},
     COMPRESSED_MINT_SEED,
 };
 use light_ctoken_sdk::{
@@ -127,6 +127,7 @@ async fn create_compressed_mints_and_tokens(
             decompress_amount,
             token_account1_pubkey,
             payer.pubkey(),
+            9,
         )
         .await
         .unwrap();
@@ -241,6 +242,9 @@ async fn mint_compressed_tokens(
             mint: mint_pda.into(),
             cmint_decompressed: false,
         },
+        reserved: [0u8; 49],
+        account_type: ACCOUNT_TYPE_MINT,
+        compression: Default::default(),
         extensions: None,
     };
 
diff --git a/sdk-tests/sdk-token-test/tests/test_compress_full_and_close.rs b/sdk-tests/sdk-token-test/tests/test_compress_full_and_close.rs
index b4ffa6cf21..02f2f1fdc9 100644
--- a/sdk-tests/sdk-token-test/tests/test_compress_full_and_close.rs
+++ b/sdk-tests/sdk-token-test/tests/test_compress_full_and_close.rs
@@ -4,7 +4,9 @@ use anchor_lang::{
 };
 use light_ctoken_interface::{
     instructions::mint_action::{CompressedMintWithContext, Recipient},
-    state::{BaseMint, CompressedMint, CompressedMintMetadata},
+    state::{
+        BaseMint, CompressedMint, CompressedMintMetadata, TokenDataVersion, ACCOUNT_TYPE_MINT,
+    },
     COMPRESSED_MINT_SEED, CTOKEN_PROGRAM_ID,
 };
 use light_ctoken_sdk::{
@@ -12,7 +14,10 @@ use light_ctoken_sdk::{
         create_compressed_mint::{create_compressed_mint, CreateCompressedMintInputs},
         mint_to_compressed::{create_mint_to_compressed_instruction, MintToCompressedInputs},
     },
-    ctoken::{derive_ctoken_ata, CreateAssociatedCTokenAccount},
+    ctoken::{
+        config_pda, derive_ctoken_ata, rent_sponsor_pda, CompressibleParams,
+        CreateAssociatedCTokenAccount,
+    },
 };
 use light_program_test::{Indexer, LightProgramTest, ProgramTestConfig, Rpc};
 use light_sdk::instruction::{PackedAccounts, SystemAccountMetaConfig};
@@ -128,6 +133,9 @@ async fn test_compress_full_and_close() {
             mint: mint_pda.into(),
             cmint_decompressed: false,
         },
+        reserved: [0u8; 49],
+        account_type: ACCOUNT_TYPE_MINT,
+        compression: Default::default(),
         extensions: None,
     };
 
@@ -169,18 +177,25 @@ async fn test_compress_full_and_close() {
 
     println!("✅ Minted {} compressed tokens to recipient", mint_amount);
 
-    // Step 4: Create associated token account for decompression
+    // Step 4: Create compressible associated token account for decompression
     let (ctoken_ata_pubkey, bump) = derive_ctoken_ata(&recipient, &mint_pda);
-    // Create a non-compressible token account by setting compressible to None
-    let create_ata_instruction = CreateAssociatedCTokenAccount {
-        idempotent: false,
+    let compressible_params = CompressibleParams {
+        token_account_version: TokenDataVersion::ShaFlat,
+        pre_pay_num_epochs: 2,
+        lamports_per_write: Some(1000),
+        compress_to_account_pubkey: None,
+        compressible_config: config_pda(),
+        rent_sponsor: rent_sponsor_pda(),
+        compression_only: false,
+    };
+    let create_ata_instruction = CreateAssociatedCTokenAccount::new_with_bump(
+        payer.pubkey(),
+        recipient,
+        mint_pda,
+        ctoken_ata_pubkey,
         bump,
-        payer: payer.pubkey(),
-        owner: recipient,
-        mint: mint_pda,
-        associated_token_account: ctoken_ata_pubkey,
-        compressible: None,
-    }
+    )
+    .with_compressible(compressible_params)
     .instruction()
     .unwrap();
 
@@ -214,6 +229,7 @@ async fn test_compress_full_and_close() {
         decompress_amount,
         ctoken_ata_pubkey,
         payer.pubkey(),
+        9,
     )
     .await
     .unwrap();
@@ -274,6 +290,7 @@ async fn test_compress_full_and_close() {
     let source_index = remaining_accounts.insert_or_get(ctoken_ata_pubkey); // Token account to compress
     let authority_index = remaining_accounts.insert_or_get(recipient_keypair.pubkey()); // Authority
     let close_recipient_index = remaining_accounts.insert_or_get(close_recipient_pubkey); // Close recipient
+    let rent_sponsor_index = remaining_accounts.insert_or_get(rent_sponsor_pda()); // Rent sponsor
 
     // Get remaining accounts and create instruction
     let (account_metas, system_accounts_offset, _packed_accounts_offset) =
@@ -285,6 +302,7 @@ async fn test_compress_full_and_close() {
         source_index,
         authority_index,
         close_recipient_index,
+        rent_sponsor_index,
         system_accounts_offset: system_accounts_offset as u8,
     };
     rpc.airdrop_lamports(&recipient_keypair.pubkey(), 1_000_000_000)
diff --git a/sdk-tests/sdk-token-test/tests/test_deposit.rs b/sdk-tests/sdk-token-test/tests/test_deposit.rs
index 8084dc363e..b35cc25510 100644
--- a/sdk-tests/sdk-token-test/tests/test_deposit.rs
+++ b/sdk-tests/sdk-token-test/tests/test_deposit.rs
@@ -448,7 +448,7 @@ async fn batch_compress_spl_tokens(
     remaining_accounts.add_pre_accounts_signer_mut(payer.pubkey());
     let spl_interface_index = 0;
     let (spl_interface_pda, spl_interface_bump) =
-        find_spl_interface_pda_with_index(&mint, spl_interface_index);
+        find_spl_interface_pda_with_index(&mint, spl_interface_index, false);
     println!("spl_interface_pda {:?}", spl_interface_pda);
 
     // Use batch compress account metas