diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
new file mode 100644
index 00000000..158e4a92
--- /dev/null
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,27 @@
+name: CI
+
+on:
+    push:
+        branches: [main]
+    pull_request:
+        branches: [main]
+
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Set up Rust
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          components: rustfmt, clippy
+      - name: Run formatting check
+        run: cargo fmt --check
+      - name: Install solc
+        run: sudo apt-get update && sudo apt-get install -y solc
+      - name: Run clippy
+        run: cargo clippy --workspace --all-targets --all-features -- -D warnings
+      - name: Run tests
+        run: cargo test -p cargo-pvm-contract
diff --git a/Cargo.lock b/Cargo.lock
index 1cb324d3..093ae968 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -79,20 +79,133 @@ version = "1.0.100"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a23eb6b1614318a8071c9b2521f36b424b2c83db5eb3a0fead4a6c0809af6e61"
 
+[[package]]
+name = "askama"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b79091df18a97caea757e28cd2d5fda49c6cd4bd01ddffd7ff01ace0c0ad2c28"
+dependencies = [
+ "askama_derive",
+ "askama_escape",
+ "humansize",
+ "num-traits",
+ "percent-encoding",
+]
+
+[[package]]
+name = "askama_derive"
+version = "0.12.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "19fe8d6cb13c4714962c072ea496f3392015f0989b1a2847bb4b2d9effd71d83"
+dependencies = [
+ "askama_parser",
+ "basic-toml",
+ "mime",
+ "mime_guess",
+ "proc-macro2",
+ "quote",
+ "serde",
+ "syn",
+]
+
+[[package]]
+name = "askama_escape"
+version = "0.10.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "619743e34b5ba4e9703bba34deac3427c72507c7159f5fd030aea8cac0cfe341"
+
+[[package]]
+name = "askama_parser"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "acb1161c6b64d1c3d83108213c2a2533a342ac225aabd0bda218278c2ddb00c0"
+dependencies = [
+ "nom",
+]
+
+[[package]]
+name = "assert_cmd"
+version = "2.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c5bcfa8749ac45dd12cb11055aeeb6b27a3895560d60d71e3c23bf979e60514"
+dependencies = [
+ "anstyle",
+ "bstr",
+ "libc",
+ "predicates",
+ "predicates-core",
+ "predicates-tree",
+ "wait-timeout",
+]
+
+[[package]]
+name = "autocfg"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
+
+[[package]]
+name = "basic-toml"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba62675e8242a4c4e806d12f11d136e626e6c8361d6b829310732241652a178a"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
 [[package]]
 name = "bitflags"
 version = "2.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "812e12b5285cc515a9c72a5c1d3b6d46a19dac5acfef5265968c166106e31dd3"
 
+[[package]]
+name = "bstr"
+version = "1.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "63044e1ae8e69f3b5a92c736ca6269b8d12fa7efe39bf34ddb06d102cf0e2cab"
+dependencies = [
+ "memchr",
+ "regex-automata",
+ "serde",
+]
+
+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+
 [[package]]
 name = "cargo-pvm-contract"
-version = "0.1.0"
+version = "0.2.0"
 dependencies = [
  "anyhow",
+ "askama",
+ "assert_cmd",
  "clap",
  "env_logger",
  "include_dir",
+ "inquire",
+ "log",
+ "predicates",
+ "serde",
+ "serde_json",
+ "tempfile",
+ "tiny-keccak",
+]
+
+[[package]]
+name = "cargo-pvm-contract-builder"
+version = "0.2.0"
+dependencies = [
+ "anyhow",
  "log",
  "polkavm-linker",
  "toml_edit",
@@ -106,9 +219,9 @@ checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
 
 [[package]]
 name = "clap"
-version = "4.5.53"
+version = "4.5.54"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c9e340e012a1bf4935f5282ed1436d1489548e8f72308207ea5df0e23d2d03f8"
+checksum = "c6e6ff9dcd79cff5cd969a17a545d79e84ab086e444102a591e288a8aa3ce394"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -116,9 +229,9 @@ dependencies = [
 
 [[package]]
 name = "clap_builder"
-version = "4.5.53"
+version = "4.5.54"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d76b5d13eaa18c901fd2f7fca939fefe3a0727a953561fefdf3b2922b8569d00"
+checksum = "fa42cf4d2b7a41bc8f663a7cab4031ebafa1bf3875705bfaf8466dc60ab52c00"
 dependencies = [
  "anstream",
  "anstyle",
@@ -140,9 +253,9 @@ dependencies = [
 
 [[package]]
 name = "clap_lex"
-version = "0.7.6"
+version = "0.7.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1d728cc89cf3aee9ff92b05e62b19ee65a02b5702cff7d5a377e32c6ae29d8d"
+checksum = "c3e64b0cc0439b12df2fa678eae89a1c56a529fd067a9115f7827f1fffd22b32"
 
 [[package]]
 name = "colorchoice"
@@ -150,6 +263,43 @@ version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b05b61dc5112cbb17e4b6cd61790d9845d13888356391624cbe7e41efeac1e75"
 
+[[package]]
+name = "crossterm"
+version = "0.25.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e64e6c0fbe2c17357405f7c758c1ef960fce08bdfb2c03d88d2a18d7e09c4b67"
+dependencies = [
+ "bitflags 1.3.2",
+ "crossterm_winapi",
+ "libc",
+ "mio",
+ "parking_lot",
+ "signal-hook",
+ "signal-hook-mio",
+ "winapi",
+]
+
+[[package]]
+name = "crossterm_winapi"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "acdd7c62a3665c7f6830a51635d9ac9b23ed385797f70a83bb8bafe9c572ab2b"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "crunchy"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5"
+
+[[package]]
+name = "difflib"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6184e33543162437515c2e2b48714794e37845ec9851711914eec9d308f6ebe8"
+
 [[package]]
 name = "dirs"
 version = "5.0.1"
@@ -171,6 +321,12 @@ dependencies = [
  "windows-sys 0.48.0",
 ]
 
+[[package]]
+name = "dyn-clone"
+version = "1.0.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d0881ea181b1df73ff77ffaaf9c7544ecc11e82fba9b5f27b262a3c73a332555"
+
 [[package]]
 name = "env_filter"
 version = "0.1.4"
@@ -200,23 +356,78 @@ version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
 
+[[package]]
+name = "errno"
+version = "0.3.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
+dependencies = [
+ "libc",
+ "windows-sys 0.61.2",
+]
+
 [[package]]
 name = "fallible-iterator"
 version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2acce4a10f12dc2fb14a218589d4f1f62ef011b2d0cc4b3cb1bba8e94da14649"
 
+[[package]]
+name = "fastrand"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
+
+[[package]]
+name = "float-cmp"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b09cf3155332e944990140d967ff5eceb70df778b34f77d8075db46e4704e6d8"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "fuzzy-matcher"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "54614a3312934d066701a80f20f15fa3b56d67ac7722b39eea5b4c9dd1d66c94"
+dependencies = [
+ "thread_local",
+]
+
+[[package]]
+name = "fxhash"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c31b6d751ae2c7f11320402d34e41349dd1016f8d5d45e48c4312bc8625af50c"
+dependencies = [
+ "byteorder",
+]
+
 [[package]]
 name = "getrandom"
-version = "0.2.16"
+version = "0.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "335ff9f135e4384c8150d6f27c6daed433577f86b4750418338c01a1a2528592"
+checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0"
 dependencies = [
  "cfg-if",
  "libc",
  "wasi",
 ]
 
+[[package]]
+name = "getrandom"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi",
+ "wasip2",
+]
+
 [[package]]
 name = "gimli"
 version = "0.31.1"
@@ -254,6 +465,15 @@ version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 
+[[package]]
+name = "humansize"
+version = "2.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6cb51c9a029ddc91b07a787f1d86b53ccfa49b0e86688c946ebe8d3555685dd7"
+dependencies = [
+ "libm",
+]
+
 [[package]]
 name = "include_dir"
 version = "0.7.4"
@@ -275,25 +495,48 @@ dependencies = [
 
 [[package]]
 name = "indexmap"
-version = "2.12.1"
+version = "2.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ad4bb2b565bca0645f4d68c5c9af97fba094e9791da685bf83cb5f3ce74acf2"
+checksum = "7714e70437a7dc3ac8eb7e6f8df75fd8eb422675fc7678aff7364301092b1017"
 dependencies = [
  "equivalent",
  "hashbrown 0.16.1",
 ]
 
+[[package]]
+name = "inquire"
+version = "0.7.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fddf93031af70e75410a2511ec04d49e758ed2f26dad3404a934e0fb45cc12a"
+dependencies = [
+ "bitflags 2.10.0",
+ "crossterm",
+ "dyn-clone",
+ "fuzzy-matcher",
+ "fxhash",
+ "newline-converter",
+ "once_cell",
+ "unicode-segmentation",
+ "unicode-width",
+]
+
 [[package]]
 name = "is_terminal_polyfill"
 version = "1.70.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a6cb138bb79a146c1bd460005623e142ef0181e3d0219cb493e02f7d08a35695"
 
+[[package]]
+name = "itoa"
+version = "1.0.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2"
+
 [[package]]
 name = "jiff"
-version = "0.2.16"
+version = "0.2.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49cce2b81f2098e7e3efc35bc2e0a6b7abec9d34128283d7a26fa8f32a6dbb35"
+checksum = "e67e8da4c49d6d9909fe03361f9b620f58898859f5c7aded68351e85e71ecf50"
 dependencies = [
  "jiff-static",
  "log",
@@ -304,9 +547,9 @@ dependencies = [
 
 [[package]]
 name = "jiff-static"
-version = "0.2.16"
+version = "0.2.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "980af8b43c3ad5d8d349ace167ec8170839f753a42d233ba19e08afe1850fa69"
+checksum = "e0c84ee7f197eca9a86c6fd6cb771e55eb991632f15f2bc3ca6ec838929e6e78"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -315,20 +558,41 @@ dependencies = [
 
 [[package]]
 name = "libc"
-version = "0.2.178"
+version = "0.2.180"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "37c93d8daa9d8a012fd8ab92f088405fb202ea0b6ab73ee2482ae66af4f42091"
+checksum = "bcc35a38544a891a5f7c865aca548a982ccb3b8650a5b06d0fd33a10283c56fc"
+
+[[package]]
+name = "libm"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f9fbbcab51052fe104eb5e5d351cf728d30a5be1fe14d9be8a3b097481fb97de"
 
 [[package]]
 name = "libredox"
-version = "0.1.10"
+version = "0.1.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "416f7e718bdb06000964960ffa43b4335ad4012ae8b99060261aa4a8088d5ccb"
+checksum = "3d0b95e02c851351f877147b7deea7b1afb1df71b63aa5f8270716e0c5720616"
 dependencies = [
- "bitflags",
+ "bitflags 2.10.0",
  "libc",
 ]
 
+[[package]]
+name = "linux-raw-sys"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df1d3c3b53da64cf5760482273a98e575c651a67eec7f77df96b5b642de8f039"
+
+[[package]]
+name = "lock_api"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965"
+dependencies = [
+ "scopeguard",
+]
+
 [[package]]
 name = "log"
 version = "0.4.29"
@@ -341,6 +605,74 @@ version = "2.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f52b00d39961fc5b2736ea853c9cc86238e165017a493d1d5c8eac6bdc4cc273"
 
+[[package]]
+name = "mime"
+version = "0.3.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a"
+
+[[package]]
+name = "mime_guess"
+version = "2.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f7c44f8e672c00fe5308fa235f821cb4198414e1c77935c1ab6948d3fd78550e"
+dependencies = [
+ "mime",
+ "unicase",
+]
+
+[[package]]
+name = "minimal-lexical"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
+
+[[package]]
+name = "mio"
+version = "0.8.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4a650543ca06a924e8b371db273b2756685faae30f8487da1b56505a8f78b0c"
+dependencies = [
+ "libc",
+ "log",
+ "wasi",
+ "windows-sys 0.48.0",
+]
+
+[[package]]
+name = "newline-converter"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47b6b097ecb1cbfed438542d16e84fd7ad9b0c76c8a65b7f9039212a3d14dc7f"
+dependencies = [
+ "unicode-segmentation",
+]
+
+[[package]]
+name = "nom"
+version = "7.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a"
+dependencies = [
+ "memchr",
+ "minimal-lexical",
+]
+
+[[package]]
+name = "normalize-line-endings"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "61807f77802ff30975e01f4f071c8ba10c022052f98b3294119f3e615d13e5be"
+
+[[package]]
+name = "num-traits"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+dependencies = [
+ "autocfg",
+]
+
 [[package]]
 name = "object"
 version = "0.36.7"
@@ -368,6 +700,35 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d"
 
+[[package]]
+name = "parking_lot"
+version = "0.12.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93857453250e3077bd71ff98b6a65ea6621a19bb0f559a85248955ac12c45a1a"
+dependencies = [
+ "lock_api",
+ "parking_lot_core",
+]
+
+[[package]]
+name = "parking_lot_core"
+version = "0.9.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "redox_syscall",
+ "smallvec",
+ "windows-link",
+]
+
+[[package]]
+name = "percent-encoding"
+version = "2.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
+
 [[package]]
 name = "picosimd"
 version = "0.9.2"
@@ -401,9 +762,9 @@ dependencies = [
 
 [[package]]
 name = "portable-atomic"
-version = "1.11.1"
+version = "1.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f84267b20a16ea918e43c6a88433c2d54fa145c92a811b5b047ccbe153674483"
+checksum = "f89776e4d69bb58bc6993e99ffa1d11f228b839984854c7daeb5d37f87cbe950"
 
 [[package]]
 name = "portable-atomic-util"
@@ -414,31 +775,76 @@ dependencies = [
  "portable-atomic",
 ]
 
+[[package]]
+name = "predicates"
+version = "3.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a5d19ee57562043d37e82899fade9a22ebab7be9cef5026b07fda9cdd4293573"
+dependencies = [
+ "anstyle",
+ "difflib",
+ "float-cmp",
+ "normalize-line-endings",
+ "predicates-core",
+ "regex",
+]
+
+[[package]]
+name = "predicates-core"
+version = "1.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "727e462b119fe9c93fd0eb1429a5f7647394014cf3c04ab2c0350eeb09095ffa"
+
+[[package]]
+name = "predicates-tree"
+version = "1.0.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72dd2d6d381dfb73a193c7fca536518d7caee39fc8503f74e7dc0be0531b425c"
+dependencies = [
+ "predicates-core",
+ "termtree",
+]
+
 [[package]]
 name = "proc-macro2"
-version = "1.0.103"
+version = "1.0.105"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5ee95bc4ef87b8d5ba32e8b7714ccc834865276eab0aed5c9958d00ec45f49e8"
+checksum = "535d180e0ecab6268a3e718bb9fd44db66bbbc256257165fc699dadf70d16fe7"
 dependencies = [
  "unicode-ident",
 ]
 
 [[package]]
 name = "quote"
-version = "1.0.42"
+version = "1.0.43"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a338cc41d27e6cc6dce6cefc13a0729dfbb81c262b1f519331575dd80ef3067f"
+checksum = "dc74d9a594b72ae6656596548f56f667211f8a97b3d4c3d467150794690dc40a"
 dependencies = [
  "proc-macro2",
 ]
 
+[[package]]
+name = "r-efi"
+version = "5.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
+
+[[package]]
+name = "redox_syscall"
+version = "0.5.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d"
+dependencies = [
+ "bitflags 2.10.0",
+]
+
 [[package]]
 name = "redox_users"
 version = "0.4.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ba009ff324d1fc1b900bd1fdb31564febe58a8ccc8a6fdbb93b543d33b13ca43"
 dependencies = [
- "getrandom",
+ "getrandom 0.2.17",
  "libredox",
  "thiserror",
 ]
@@ -487,9 +893,9 @@ checksum = "7a2d987857b319362043e95f5353c0535c1f58eec5336fdfcf626430af7def58"
 
 [[package]]
 name = "rustc-demangle"
-version = "0.1.26"
+version = "0.1.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "56f7d92ca342cea22a06f2121d944b4fd82af56988c270852495420f961d4ace"
+checksum = "b50b8869d9fc858ce7266cce0194bd74df58b9d0e3f6df3a9fc8eb470d95c09d"
 
 [[package]]
 name = "rustc-hash"
@@ -497,6 +903,35 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
 
+[[package]]
+name = "rustix"
+version = "1.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "146c9e247ccc180c1f61615433868c99f3de3ae256a30a43b49f67c2d9171f34"
+dependencies = [
+ "bitflags 2.10.0",
+ "errno",
+ "libc",
+ "linux-raw-sys",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "scopeguard"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
+
+[[package]]
+name = "serde"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
+dependencies = [
+ "serde_core",
+ "serde_derive",
+]
+
 [[package]]
 name = "serde_core"
 version = "1.0.228"
@@ -517,6 +952,50 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "serde_json"
+version = "1.0.149"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "83fc039473c5595ace860d8c4fafa220ff474b3fc6bfdb4293327f1a37e94d86"
+dependencies = [
+ "itoa",
+ "memchr",
+ "serde",
+ "serde_core",
+ "zmij",
+]
+
+[[package]]
+name = "signal-hook"
+version = "0.3.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d881a16cf4426aa584979d30bd82cb33429027e42122b169753d6ef1085ed6e2"
+dependencies = [
+ "libc",
+ "signal-hook-registry",
+]
+
+[[package]]
+name = "signal-hook-mio"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b75a19a7a740b25bc7944bdee6172368f988763b744e3d4dfe753f6b4ece40cc"
+dependencies = [
+ "libc",
+ "mio",
+ "signal-hook",
+]
+
+[[package]]
+name = "signal-hook-registry"
+version = "1.4.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4db69cba1110affc0e9f7bcd48bbf87b3f4fc7c61fc9155afd4c469eb3d6c1b"
+dependencies = [
+ "errno",
+ "libc",
+]
+
 [[package]]
 name = "slice-group-by"
 version = "0.3.1"
@@ -543,15 +1022,34 @@ checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
 
 [[package]]
 name = "syn"
-version = "2.0.111"
+version = "2.0.114"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "390cc9a294ab71bdb1aa2e99d13be9c753cd2d7bd6560c77118597410c4d2e87"
+checksum = "d4d107df263a3013ef9b1879b0df87d706ff80f65a86ea879bd9c31f9b307c2a"
 dependencies = [
  "proc-macro2",
  "quote",
  "unicode-ident",
 ]
 
+[[package]]
+name = "tempfile"
+version = "3.24.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "655da9c7eb6305c55742045d5a8d2037996d61d8de95806335c7c86ce0f82e9c"
+dependencies = [
+ "fastrand",
+ "getrandom 0.3.4",
+ "once_cell",
+ "rustix",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "termtree"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f50febec83f5ee1df3015341d8bd429f2d1cc62bcba7ea2076759d315084683"
+
 [[package]]
 name = "thiserror"
 version = "1.0.69"
@@ -572,6 +1070,24 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "thread_local"
+version = "1.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f60246a4944f24f6e018aa17cdeffb7818b76356965d03b07d6a9886e8962185"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "tiny-keccak"
+version = "2.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2c9d3793400a45f954c52e73d068316d76b6f4e36977e3fcebb13a2721e80237"
+dependencies = [
+ "crunchy",
+]
+
 [[package]]
 name = "toml_datetime"
 version = "0.6.11"
@@ -596,12 +1112,30 @@ version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5d99f8c9a7727884afe522e9bd5edbfc91a3312b36a77b5fb8926e4c31a41801"
 
+[[package]]
+name = "unicase"
+version = "2.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dbc4bc3a9f746d862c45cb89d705aa10f187bb96c76001afab07a0d35ce60142"
+
 [[package]]
 name = "unicode-ident"
 version = "1.0.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9312f7c4f6ff9069b165498234ce8be658059c6728633667c526e27dc2cf1df5"
 
+[[package]]
+name = "unicode-segmentation"
+version = "1.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6ccf251212114b54433ec949fd6a7841275f9ada20dddd2f29e9ceea4501493"
+
+[[package]]
+name = "unicode-width"
+version = "0.1.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7dd6e30e90baa6f72411720665d41d89b9a3d039dc45b8faea1ddd07f617f6af"
+
 [[package]]
 name = "utf8parse"
 version = "0.2.2"
@@ -614,12 +1148,52 @@ version = "0.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
 
+[[package]]
+name = "wait-timeout"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09ac3b126d3914f9849036f826e054cbabdc8519970b8998ddaf3b5bd3c65f11"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "wasi"
 version = "0.11.1+wasi-snapshot-preview1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
 
+[[package]]
+name = "wasip2"
+version = "1.0.1+wasi-0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0562428422c63773dad2c345a1882263bbf4d65cf3f42e90921f787ef5ad58e7"
+dependencies = [
+ "wit-bindgen",
+]
+
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+
 [[package]]
 name = "windows-link"
 version = "0.2.1"
@@ -710,22 +1284,34 @@ dependencies = [
  "memchr",
 ]
 
+[[package]]
+name = "wit-bindgen"
+version = "0.46.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f17a85883d4e6d00e8a97c586de764dabcc06133f7f1d55dce5cdc070ad7fe59"
+
 [[package]]
 name = "zerocopy"
-version = "0.8.31"
+version = "0.8.33"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fd74ec98b9250adb3ca554bdde269adf631549f51d8a8f8f0a10b50f1cb298c3"
+checksum = "668f5168d10b9ee831de31933dc111a459c97ec93225beb307aed970d1372dfd"
 dependencies = [
  "zerocopy-derive",
 ]
 
 [[package]]
 name = "zerocopy-derive"
-version = "0.8.31"
+version = "0.8.33"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d8a8d209fdf45cf5138cbb5a506f6b52522a25afccc534d1475dad8e31105c6a"
+checksum = "2c7962b26b0a8685668b671ee4b54d007a67d4eaf05fda79ac0ecf41e32270f1"
 dependencies = [
  "proc-macro2",
  "quote",
  "syn",
 ]
+
+[[package]]
+name = "zmij"
+version = "1.0.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bd8f3f50b848df28f887acb68e41201b5aea6bc8a8dacc00fb40635ff9a72fea"
diff --git a/Cargo.toml b/Cargo.toml
index 3889960a..96c66e3c 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,28 +1,26 @@
-[package]
-name = "cargo-pvm-contract"
-description = "A Cargo subcommand to create and build PVM smart contracts."
-repository = "https://github.com/paritytech/cargo-pvm-contract"
-version = "0.1.0"
-edition = "2021"
-license = "MIT"
-publish = true
-include = [
-    "src/**",
-    "templates/**",
-    "Cargo.toml",
-    "Cargo.lock",
-    "README.md",
+[workspace]
+members = [
+    "crates/cargo-pvm-contract",
+    "crates/cargo-pvm-contract-builder",
 ]
+resolver = "2"
 
-[[bin]]
-name = "cargo-pvm-contract"
-path = "src/main.rs"
+[workspace.package]
+version = "0.2.0"
+edition = "2024"
+license = "MIT"
+repository = "https://github.com/paritytech/cargo-pvm-contract"
 
-[dependencies]
-polkavm-linker = "0.30.0"
+[workspace.dependencies]
 anyhow = "1.0"
+askama = "0.12"
 clap = { version = "4.5", features = ["derive"] }
+env_logger = "0.11"
 include_dir = "0.7"
 log = "0.4"
-env_logger = "0.11"
+polkavm-linker = "0.30.0"
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+tiny-keccak = { version = "2.0", features = ["keccak"] }
 toml_edit = "0.22"
+inquire = "0.7"
diff --git a/README.md b/README.md
index 20731499..e005bc70 100644
--- a/README.md
+++ b/README.md
@@ -17,60 +17,14 @@ cargo install --force --locked cargo-pvm-contract
 Once installed, you can use it as a cargo subcommand:
 
 ```bash
-cargo pvm-contract <COMMAND>
+cargo pvm-contract
 ```
 
-### Commands
-
-#### `init` - Initialize a new contract project
-
-Create a new contract project from a template:
-
-```bash
-cargo pvm-contract init <CONTRACT_NAME> [OPTIONS]
-```
-
-Options:
-- `<CONTRACT_NAME>` - Name of the contract project (required)
-- `-t, --template <TEMPLATE>` - Template to use (defaults to `pico-alloc`)
-
-Examples:
-
-Initialize with default pico-alloc template:
-
-```bash
-cargo pvm-contract init my-token
-cd my-token
-cargo pvm-contract build
-```
-
-Initialize with a specific template:
-
-```bash
-cargo pvm-contract init my-token --template pico-alloc
-```
-
-#### `build` - Build a contract to PolkaVM bytecode
-
-Build a contract binary to PolkaVM bytecode:
-
-```bash
-cargo pvm-contract build [BIN_NAME]
-```
-
-Options:
-- `[BIN_NAME]` - Name of the binary to build (optional, defaults to first binary in Cargo.toml)
-- `-o, --output <PATH>` - Output path for the PolkaVM bytecode (defaults to `./<bin_name>.polkavm`)
+This launches an interactive prompt to initialize a new contract project.
 
 Examples:
 
-Build the first binary defined in Cargo.toml:
-
-```bash
-cargo pvm-contract build
-```
-
-## Templates
+Initialize a new project with `cargo pvm-contract` and build it with `cargo build`:
+The PolkaVM bytecode will be written to `target/<bin>.<profile>.polkavm`.
 
-The tool includes contract templates to help you get started quickly. Templates are located in the `templates/` directory.
 
diff --git a/crates/cargo-pvm-contract-builder/Cargo.toml b/crates/cargo-pvm-contract-builder/Cargo.toml
new file mode 100644
index 00000000..a988748a
--- /dev/null
+++ b/crates/cargo-pvm-contract-builder/Cargo.toml
@@ -0,0 +1,14 @@
+[package]
+name = "cargo-pvm-contract-builder"
+description = "Build helper for PolkaVM contract bytecode."
+repository.workspace = true
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+publish = true
+
+[dependencies]
+anyhow = { workspace = true }
+log = { workspace = true }
+polkavm-linker = { workspace = true }
+toml_edit = { workspace = true }
diff --git a/crates/cargo-pvm-contract-builder/src/lib.rs b/crates/cargo-pvm-contract-builder/src/lib.rs
new file mode 100644
index 00000000..4cd5cd4b
--- /dev/null
+++ b/crates/cargo-pvm-contract-builder/src/lib.rs
@@ -0,0 +1,311 @@
+//! # PolkaVM Contract Builder
+//!
+//! A utility for building Rust projects as PolkaVM bytecode.
+//!
+//! ## Usage in `build.rs`
+//!
+//! ```no_run
+//! cargo_pvm_contract_builder::PvmBuilder::new().build();
+//! ```
+
+use anyhow::{Context, Result};
+use std::{
+    env, fs,
+    path::{Path, PathBuf},
+    process::Command,
+};
+
+/// Internal environment variable to prevent recursive builds.
+const INTERNAL_BUILD_ENV: &str = "CARGO_PVM_CONTRACT_INTERNAL";
+
+/// The builder for building a PolkaVM binary.
+pub struct PvmBuilder {
+    /// The path to the `Cargo.toml` of the project that should be built.
+    project_cargo_toml: PathBuf,
+    /// Specific binaries to build (None = all binaries).
+    bin_names: Option<Vec<String>>,
+}
+
+impl Default for PvmBuilder {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl PvmBuilder {
+    /// Create a new builder for the current project.
+    pub fn new() -> Self {
+        Self {
+            project_cargo_toml: get_manifest_dir().join("Cargo.toml"),
+            bin_names: None,
+        }
+    }
+
+    /// Build only the specified binary.
+    pub fn with_bin(mut self, name: impl Into<String>) -> Self {
+        self.bin_names = Some(vec![name.into()]);
+        self
+    }
+
+    /// Build only the specified binaries.
+    pub fn with_bins<I, S>(mut self, names: I) -> Self
+    where
+        I: IntoIterator<Item = S>,
+        S: Into<String>,
+    {
+        self.bin_names = Some(names.into_iter().map(Into::into).collect());
+        self
+    }
+
+    /// Build the PolkaVM binary.
+    pub fn build(self) {
+        // Check if we're in a recursive build
+        if env::var(INTERNAL_BUILD_ENV).is_ok() {
+            return;
+        }
+
+        if let Err(e) = build_project(&self.project_cargo_toml, self.bin_names) {
+            eprintln!("PolkaVM build failed: {e}");
+            std::process::exit(1);
+        }
+    }
+}
+
+/// Returns the manifest dir from the `CARGO_MANIFEST_DIR` env.
+fn get_manifest_dir() -> PathBuf {
+    env::var("CARGO_MANIFEST_DIR")
+        .expect("`CARGO_MANIFEST_DIR` is always set for `build.rs` files")
+        .into()
+}
+
+/// Detect the build profile from the environment.
+#[derive(Clone, Debug)]
+struct Profile {
+    name: String,
+}
+
+impl Profile {
+    fn detect() -> Self {
+        let name = env::var("PROFILE").unwrap_or_else(|_| "debug".to_string());
+        Self { name }
+    }
+
+    fn cargo_arg(&self) -> &str {
+        if self.name == "debug" {
+            "dev"
+        } else {
+            self.name.as_str()
+        }
+    }
+
+    fn directory(&self) -> &str {
+        self.name.as_str()
+    }
+}
+
+/// Get the workspace target directory.
+fn get_target_root() -> PathBuf {
+    let out_dir = PathBuf::from(env::var("OUT_DIR").expect("OUT_DIR is set"));
+
+    for ancestor in out_dir.ancestors() {
+        if ancestor.file_name().map(|n| n == "target").unwrap_or(false) {
+            return ancestor.to_path_buf();
+        }
+    }
+
+    out_dir
+}
+
+/// Get the build output directory.
+fn get_build_dir() -> PathBuf {
+    get_target_root().join("pvmbuild")
+}
+
+/// Get the list of binary targets from Cargo.toml.
+fn get_bin_targets(cargo_toml: &Path) -> Result<Vec<String>> {
+    let content = fs::read_to_string(cargo_toml)
+        .with_context(|| format!("Failed to read {}", cargo_toml.display()))?;
+
+    let doc: toml_edit::DocumentMut = content.parse().context("Failed to parse Cargo.toml")?;
+
+    let mut bins = Vec::new();
+
+    if let Some(bin_array) = doc.get("bin").and_then(|b| b.as_array_of_tables()) {
+        for bin in bin_array {
+            if let Some(name) = bin.get("name").and_then(|n| n.as_str()) {
+                bins.push(name.to_string());
+            }
+        }
+    }
+
+    if bins.is_empty()
+        && let Some(name) = doc
+            .get("package")
+            .and_then(|p| p.get("name"))
+            .and_then(|n| n.as_str())
+    {
+        bins.push(name.to_string());
+    }
+
+    Ok(bins)
+}
+
+/// Build the project.
+fn build_project(project_cargo_toml: &Path, bin_names: Option<Vec<String>>) -> Result<()> {
+    let profile = Profile::detect();
+    let build_dir = get_build_dir();
+    let target_root = get_target_root();
+
+    let bins_to_build = match bin_names {
+        Some(names) => names,
+        None => get_bin_targets(project_cargo_toml)?,
+    };
+
+    if bins_to_build.is_empty() {
+        anyhow::bail!("No binary targets found in Cargo.toml");
+    }
+
+    let target_dir = build_dir;
+    build_elf(project_cargo_toml, &target_dir, &profile, &bins_to_build)?;
+
+    // Link each ELF to PolkaVM
+    let elf_dir = target_dir
+        .join("riscv64emac-unknown-none-polkavm")
+        .join(profile.directory());
+
+    for bin in &bins_to_build {
+        let elf_path = elf_dir.join(bin);
+        if !elf_path.exists() {
+            anyhow::bail!("ELF binary not found at: {}", elf_path.display());
+        }
+
+        let output_path = target_root.join(format!("{}.{}.polkavm", bin, profile.directory()));
+        link_to_polkavm(&elf_path, &output_path)?;
+    }
+
+    Ok(())
+}
+
+/// Build the ELF binary using cargo.
+fn build_elf(
+    manifest_path: &Path,
+    target_dir: &Path,
+    profile: &Profile,
+    bins: &[String],
+) -> Result<()> {
+    let immediate_abort = check_immediate_abort_support()?;
+
+    let rustflags = if immediate_abort {
+        "-Zunstable-options -Cpanic=immediate-abort"
+    } else {
+        ""
+    };
+
+    let mut args = polkavm_linker::TargetJsonArgs::default();
+    args.is_64_bit = true;
+    let target_json = polkavm_linker::target_json_path(args)
+        .map_err(|e| anyhow::anyhow!("Failed to get target JSON: {e}"))?;
+
+    let cargo = env::var("CARGO").unwrap_or_else(|_| "cargo".to_string());
+    let work_dir = manifest_path.parent().context("Invalid manifest path")?;
+
+    let mut cmd = Command::new(&cargo);
+    cmd.current_dir(work_dir)
+        .env_remove("CARGO_ENCODED_RUSTFLAGS") // We set RUSTFLAGS, but cargo prefers this one
+        .env_remove("RUSTC") // Prevent host toolchain override from build.rs
+        .env("RUSTFLAGS", rustflags)
+        .env("CARGO_TARGET_DIR", target_dir)
+        // Disable strip during ELF build - it conflicts with --emit-relocs required by PolkaVM.
+        // Stripping is done later by polkavm_linker after processing relocations.
+        .env("CARGO_PROFILE_RELEASE_STRIP", "false")
+        .env("RUSTC_BOOTSTRAP", "1")
+        .env(INTERNAL_BUILD_ENV, "1")
+        .arg("build")
+        .arg("--manifest-path")
+        .arg(manifest_path)
+        .arg("--profile")
+        .arg(profile.cargo_arg())
+        .arg("--target")
+        .arg(&target_json)
+        .arg("-Zbuild-std=core,alloc");
+
+    if immediate_abort {
+        cmd.arg("-Zbuild-std-features=panic_immediate_abort");
+    }
+
+    for bin in bins {
+        cmd.arg("--bin").arg(bin);
+    }
+
+    eprintln!("Building PolkaVM binary with profile: {profile:?}");
+
+    let output = cmd.output().context("Failed to execute cargo build")?;
+
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        anyhow::bail!("Cargo build failed:\n{stderr}");
+    }
+
+    Ok(())
+}
+
+/// Check if rustc supports immediate abort (>= 1.92).
+fn check_immediate_abort_support() -> Result<bool> {
+    let output = Command::new("rustc")
+        .arg("--version")
+        .output()
+        .context("Failed to run rustc --version")?;
+
+    let version_str = String::from_utf8(output.stdout).context("Invalid rustc version output")?;
+
+    let version = version_str
+        .split_whitespace()
+        .nth(1)
+        .context("Unexpected rustc version format")?;
+
+    let mut parts = version.split('.');
+    let major: u32 = parts
+        .next()
+        .context("Missing major version")?
+        .parse()
+        .context("Invalid major version")?;
+    let minor: u32 = parts
+        .next()
+        .context("Missing minor version")?
+        .parse()
+        .context("Invalid minor version")?;
+
+    Ok(major > 1 || (major == 1 && minor >= 92))
+}
+
+/// Link an ELF binary to PolkaVM bytecode.
+fn link_to_polkavm(elf_path: &Path, output_path: &Path) -> Result<()> {
+    let elf_bytes = fs::read(elf_path)
+        .with_context(|| format!("Failed to read ELF from {}", elf_path.display()))?;
+
+    let mut config = polkavm_linker::Config::default();
+    config.set_strip(true);
+    config.set_optimize(true);
+
+    let linked = polkavm_linker::program_from_elf(
+        config,
+        polkavm_linker::TargetInstructionSet::ReviveV1,
+        &elf_bytes,
+    )
+    .map_err(|e| anyhow::anyhow!("Failed to link PolkaVM program: {e}"))?;
+
+    fs::write(output_path, &linked).with_context(|| {
+        format!(
+            "Failed to write PolkaVM bytecode to {}",
+            output_path.display()
+        )
+    })?;
+
+    eprintln!(
+        "Created PolkaVM binary: {} ({} bytes)",
+        output_path.display(),
+        linked.len()
+    );
+
+    Ok(())
+}
diff --git a/crates/cargo-pvm-contract/Cargo.toml b/crates/cargo-pvm-contract/Cargo.toml
new file mode 100644
index 00000000..4d073bf1
--- /dev/null
+++ b/crates/cargo-pvm-contract/Cargo.toml
@@ -0,0 +1,34 @@
+[package]
+name = "cargo-pvm-contract"
+description = "A Cargo subcommand to create and build PVM smart contracts."
+repository.workspace = true
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+publish = true
+include = [
+    "src/**",
+    "templates/**",
+    "Cargo.toml",
+]
+
+[[bin]]
+name = "cargo-pvm-contract"
+path = "src/main.rs"
+
+[dependencies]
+anyhow = { workspace = true }
+clap = { workspace = true }
+include_dir = { workspace = true }
+log = { workspace = true }
+env_logger = { workspace = true }
+serde = { workspace = true }
+serde_json = { workspace = true }
+inquire = { workspace = true }
+tiny-keccak = { workspace = true }
+askama = { workspace = true }
+
+[dev-dependencies]
+assert_cmd = "2.0"
+predicates = "3.1"
+tempfile = "3.10"
diff --git a/crates/cargo-pvm-contract/src/main.rs b/crates/cargo-pvm-contract/src/main.rs
new file mode 100644
index 00000000..0f7df917
--- /dev/null
+++ b/crates/cargo-pvm-contract/src/main.rs
@@ -0,0 +1,401 @@
+use anyhow::{Context, Result};
+use clap::{Parser, Subcommand, ValueEnum};
+use include_dir::{Dir, include_dir};
+use inquire::{Select, Text};
+use log::debug;
+use std::{
+    fs,
+    path::{Path, PathBuf},
+};
+
+mod scaffold;
+
+// Embed the templates directory into the binary
+static TEMPLATES_DIR: Dir = include_dir!("$CARGO_MANIFEST_DIR/templates");
+
+#[derive(Parser, Debug)]
+#[command(name = "cargo", bin_name = "cargo", author, version)]
+struct Cli {
+    #[command(subcommand)]
+    command: Commands,
+}
+
+#[derive(Subcommand, Debug)]
+enum Commands {
+    /// Initialize contract projects for PolkaVM
+    PvmContract(PvmContractArgs),
+}
+
+#[derive(Parser, Debug, Default)]
+struct PvmContractArgs {
+    #[arg(long, value_enum, requires = "non_interactive")]
+    init_type: Option<InitType>,
+    #[arg(long, requires = "non_interactive")]
+    example: Option<String>,
+    #[arg(long, value_enum, requires = "non_interactive")]
+    memory_model: Option<MemoryModel>,
+    #[arg(long, requires = "non_interactive")]
+    name: Option<String>,
+    #[arg(long, requires = "non_interactive")]
+    sol_file: Option<PathBuf>,
+    #[arg(long)]
+    non_interactive: bool,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, ValueEnum)]
+enum InitType {
+    SolidityFile,
+    Example,
+    Blank,
+}
+
+impl std::fmt::Display for InitType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            InitType::SolidityFile => write!(f, "From a Solidity interface file (.sol)"),
+            InitType::Example => write!(f, "From an example contract"),
+            InitType::Blank => write!(f, "Blank (empty contract)"),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, ValueEnum)]
+enum MemoryModel {
+    AllocWithAlloy,
+    NoAlloc,
+}
+
+impl std::fmt::Display for MemoryModel {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            MemoryModel::AllocWithAlloy => {
+                write!(f, "alloy-core + allocator (easier API, larger binary)")
+            }
+            MemoryModel::NoAlloc => write!(f, "No allocator (manual encoding, smaller binary)"),
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+struct ExampleContract {
+    name: String,
+    filename: String,
+}
+
+impl ExampleContract {
+    fn from_path(path: &Path) -> Option<Self> {
+        if path.extension().and_then(|ext| ext.to_str()) != Some("sol") {
+            return None;
+        }
+
+        let filename = path.file_name()?.to_str()?.to_string();
+        let name = path.file_stem()?.to_str()?.to_string();
+        Some(Self { name, filename })
+    }
+
+    fn matches(&self, query: &str) -> bool {
+        let query = query.trim().to_ascii_lowercase();
+        let name = self.name.to_ascii_lowercase();
+        let filename = self.filename.to_ascii_lowercase();
+        query == name || query == filename
+    }
+}
+
+impl std::fmt::Display for ExampleContract {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.name)
+    }
+}
+
+fn load_examples() -> Result<Vec<ExampleContract>> {
+    let examples_dir = TEMPLATES_DIR
+        .get_dir("examples")
+        .ok_or_else(|| anyhow::anyhow!("Examples directory not found in templates"))?;
+    let mut examples: Vec<ExampleContract> = examples_dir
+        .files()
+        .filter_map(|file| ExampleContract::from_path(file.path()))
+        .collect();
+
+    examples.sort_by(|left, right| left.name.cmp(&right.name));
+
+    if examples.is_empty() {
+        anyhow::bail!("No example contracts found in templates/examples");
+    }
+
+    Ok(examples)
+}
+
+fn find_example(examples: &[ExampleContract], query: &str) -> Result<ExampleContract> {
+    examples
+        .iter()
+        .find(|example| example.matches(query))
+        .cloned()
+        .ok_or_else(|| anyhow::anyhow!("Unknown example: {query}"))
+}
+
+fn main() -> Result<()> {
+    env_logger::init();
+
+    let Cli { command } = Cli::parse();
+    match command {
+        Commands::PvmContract(args) => init_command(args),
+    }
+}
+
+fn init_command(args: PvmContractArgs) -> Result<()> {
+    let builder_path = std::env::var("CARGO_PVM_CONTRACT_BUILDER_PATH")
+        .ok()
+        .filter(|value| !value.trim().is_empty())
+        .map(PathBuf::from);
+
+    if let Some(path) = builder_path.as_deref()
+        && !path.exists()
+    {
+        anyhow::bail!("Builder path does not exist: {}", path.display());
+    }
+
+    if args.non_interactive {
+        init_command_non_interactive(args, builder_path.as_deref())
+    } else {
+        init_command_interactive(builder_path.as_deref())
+    }
+}
+
+fn init_command_interactive(builder_path: Option<&std::path::Path>) -> Result<()> {
+    // First, prompt for initialization type
+    let init_types = vec![InitType::SolidityFile, InitType::Example, InitType::Blank];
+    let init_type = Select::new("How do you want to initialize the project?", init_types)
+        .prompt()
+        .context("Failed to get initialization type")?;
+
+    match init_type {
+        InitType::Blank => {
+            // Ask for name without prefill
+            let contract_name = Text::new("What is your contract name?")
+                .with_help_message("This will be the name of the project directory")
+                .prompt()
+                .context("Failed to get contract name")?;
+
+            if contract_name.is_empty() {
+                anyhow::bail!("Contract name cannot be empty");
+            }
+
+            check_dir_exists(&contract_name)?;
+            debug!("Initializing blank contract: {contract_name}");
+            scaffold::init_blank_contract(&contract_name, builder_path)
+        }
+        InitType::Example => {
+            let examples = load_examples()?;
+            let example = Select::new("Select an example:", examples)
+                .prompt()
+                .context("Failed to get example choice")?;
+
+            // Prompt for memory model
+            let memory_models = vec![MemoryModel::AllocWithAlloy, MemoryModel::NoAlloc];
+            let memory_model = Select::new("Which memory model do you want to use?", memory_models)
+                .prompt()
+                .context("Failed to get memory model choice")?;
+
+            // Ask for name with example name as default
+            let contract_name = Text::new("What is your contract name?")
+                .with_default(&example.name)
+                .with_help_message("This will be the name of the project directory")
+                .prompt()
+                .context("Failed to get contract name")?;
+
+            if contract_name.is_empty() {
+                anyhow::bail!("Contract name cannot be empty");
+            }
+
+            check_dir_exists(&contract_name)?;
+            debug!(
+                "Initializing from example: {} with memory model: {:?}",
+                example.filename, memory_model
+            );
+
+            init_from_example(&example, &contract_name, memory_model, builder_path)
+        }
+        InitType::SolidityFile => {
+            // Prompt for .sol file path
+            let sol_file = Text::new("Enter path to your .sol file:")
+                .with_help_message("Path to a Solidity interface file")
+                .prompt()
+                .context("Failed to get .sol file path")?;
+
+            if sol_file.is_empty() {
+                anyhow::bail!("Solidity file path cannot be empty");
+            }
+
+            // Verify file exists
+            let sol_path = PathBuf::from(&sol_file);
+            if !sol_path.exists() {
+                anyhow::bail!("Solidity file not found: {sol_file}");
+            }
+
+            // Extract default name from .sol filename
+            let default_name = sol_path
+                .file_stem()
+                .and_then(|s| s.to_str())
+                .unwrap_or("contract")
+                .to_string();
+
+            // Prompt for memory model
+            let memory_models = vec![MemoryModel::AllocWithAlloy, MemoryModel::NoAlloc];
+            let memory_model = Select::new("Which memory model do you want to use?", memory_models)
+                .prompt()
+                .context("Failed to get memory model choice")?;
+
+            // Ask for name with .sol filename as default
+            let contract_name = Text::new("What is your contract name?")
+                .with_default(&default_name)
+                .with_help_message("This will be the name of the project directory")
+                .prompt()
+                .context("Failed to get contract name")?;
+
+            if contract_name.is_empty() {
+                anyhow::bail!("Contract name cannot be empty");
+            }
+
+            check_dir_exists(&contract_name)?;
+            debug!(
+                "Initializing from Solidity file: {sol_file} with memory model: {:?}",
+                memory_model
+            );
+
+            let use_alloc = memory_model == MemoryModel::AllocWithAlloy;
+            scaffold::init_from_solidity_file(&sol_file, &contract_name, use_alloc, builder_path)
+        }
+    }
+}
+
+fn init_command_non_interactive(
+    args: PvmContractArgs,
+    builder_path: Option<&std::path::Path>,
+) -> Result<()> {
+    let init_type = args
+        .init_type
+        .ok_or_else(|| anyhow::anyhow!("--init-type is required with --non-interactive"))?;
+
+    match init_type {
+        InitType::Blank => {
+            let contract_name = args
+                .name
+                .filter(|name| !name.is_empty())
+                .ok_or_else(|| anyhow::anyhow!("--name is required for blank initialization"))?;
+
+            check_dir_exists(&contract_name)?;
+            debug!("Initializing blank contract: {contract_name}");
+            scaffold::init_blank_contract(&contract_name, builder_path)
+        }
+        InitType::Example => {
+            let examples = load_examples()?;
+            let example_name = args.example.ok_or_else(|| {
+                anyhow::anyhow!("--example is required for example initialization")
+            })?;
+            let example = find_example(&examples, &example_name)?;
+            let memory_model = args.memory_model.ok_or_else(|| {
+                anyhow::anyhow!("--memory-model is required for example initialization")
+            })?;
+            let contract_name = args.name.unwrap_or_else(|| example.name.clone());
+
+            if contract_name.is_empty() {
+                anyhow::bail!("Contract name cannot be empty");
+            }
+
+            check_dir_exists(&contract_name)?;
+            debug!(
+                "Initializing from example: {} with memory model: {:?}",
+                example.filename, memory_model
+            );
+
+            init_from_example(&example, &contract_name, memory_model, builder_path)
+        }
+        InitType::SolidityFile => {
+            let sol_path = args.sol_file.ok_or_else(|| {
+                anyhow::anyhow!("--sol-file is required for Solidity initialization")
+            })?;
+
+            if !sol_path.exists() {
+                anyhow::bail!("Solidity file not found: {}", sol_path.display());
+            }
+
+            let default_name = sol_path
+                .file_stem()
+                .and_then(|s| s.to_str())
+                .unwrap_or("contract")
+                .to_string();
+            let contract_name = args.name.unwrap_or(default_name);
+
+            if contract_name.is_empty() {
+                anyhow::bail!("Contract name cannot be empty");
+            }
+
+            let memory_model = args.memory_model.ok_or_else(|| {
+                anyhow::anyhow!("--memory-model is required for Solidity initialization")
+            })?;
+
+            check_dir_exists(&contract_name)?;
+            debug!(
+                "Initializing from Solidity file: {} with memory model: {:?}",
+                sol_path.display(),
+                memory_model
+            );
+
+            let sol_file = sol_path.to_str().ok_or_else(|| {
+                anyhow::anyhow!("Solidity file path is not valid UTF-8: {:?}", sol_path)
+            })?;
+            let use_alloc = memory_model == MemoryModel::AllocWithAlloy;
+            scaffold::init_from_solidity_file(sol_file, &contract_name, use_alloc, builder_path)
+        }
+    }
+}
+
+fn init_from_example(
+    example: &ExampleContract,
+    contract_name: &str,
+    memory_model: MemoryModel,
+    builder_path: Option<&std::path::Path>,
+) -> Result<()> {
+    // Get the embedded example .sol file
+    let example_path = format!("examples/{}", example.filename);
+    let example_file = TEMPLATES_DIR
+        .get_file(&example_path)
+        .ok_or_else(|| anyhow::anyhow!("Example file not found: {}", example_path))?;
+
+    // Write to a temporary file
+    let temp_dir = std::env::temp_dir();
+    let timestamp = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .context("Failed to read system time")?
+        .as_nanos();
+    let example_temp_dir = temp_dir.join(format!("cargo-pvm-contract-{timestamp}"));
+    fs::create_dir_all(&example_temp_dir).with_context(|| {
+        format!("Failed to create temporary directory for example: {example_temp_dir:?}")
+    })?;
+    let temp_sol_path = example_temp_dir.join(example.filename.as_str());
+    fs::write(&temp_sol_path, example_file.contents())
+        .with_context(|| format!("Failed to write temporary .sol file: {:?}", temp_sol_path))?;
+
+    let use_alloc = memory_model == MemoryModel::AllocWithAlloy;
+
+    // Use scaffold to initialize from the temp file
+    let result = scaffold::init_from_solidity_file(
+        temp_sol_path.to_str().unwrap(),
+        contract_name,
+        use_alloc,
+        builder_path,
+    );
+
+    // Clean up temp file
+    let _ = fs::remove_dir_all(&example_temp_dir);
+
+    result
+}
+
+fn check_dir_exists(contract_name: &str) -> Result<()> {
+    let target_dir = std::env::current_dir()?.join(contract_name);
+    if target_dir.exists() {
+        anyhow::bail!("Directory already exists: {target_dir:?}");
+    }
+    Ok(())
+}
diff --git a/crates/cargo-pvm-contract/src/scaffold.rs b/crates/cargo-pvm-contract/src/scaffold.rs
new file mode 100644
index 00000000..2ece8376
--- /dev/null
+++ b/crates/cargo-pvm-contract/src/scaffold.rs
@@ -0,0 +1,608 @@
+use anyhow::{Context, Result};
+use askama::Template;
+use serde::Deserialize;
+use std::io::Write;
+use std::{fs, path::PathBuf, process::Command};
+use tiny_keccak::{Hasher, Keccak};
+
+// ============================================================================
+// Askama Templates
+// ============================================================================
+
+#[derive(Template)]
+#[template(path = "scaffold/contract_alloc.rs.txt")]
+struct ContractAllocTemplate<'a> {
+    sol_file_name: &'a str,
+    functions: Vec<AllocFunctionInfo>,
+}
+
+#[derive(Template)]
+#[template(path = "scaffold/contract_no_alloc.rs.txt")]
+struct ContractNoAllocTemplate<'a> {
+    contract_name_upper: &'a str,
+    selectors: Vec<SelectorConst>,
+    events: Vec<EventConst>,
+    errors: Vec<ErrorConst>,
+    functions: Vec<NoAllocFunctionInfo>,
+}
+
+const BUILDER_VERSION: &str = env!("CARGO_PKG_VERSION");
+
+#[derive(Template)]
+#[template(path = "scaffold/cargo_toml.txt")]
+struct CargoTomlTemplate<'a> {
+    contract_name: &'a str,
+    use_alloc: bool,
+    builder_version: &'a str,
+    builder_path: Option<String>,
+}
+
+#[derive(Template)]
+#[template(path = "scaffold/contract_blank.rs.txt")]
+struct ContractBlankTemplate;
+
+#[derive(Template)]
+#[template(path = "scaffold/build.rs.txt")]
+struct BuildRsTemplate;
+
+// ============================================================================
+// Template Data Structures
+// ============================================================================
+
+struct AllocFunctionInfo {
+    name: String,
+    name_snake: String,
+    call_type: String,
+}
+
+struct SelectorConst {
+    const_name: String,
+    bytes_hex: String,
+    signature: String,
+}
+
+struct EventConst {
+    const_name: String,
+    bytes_hex: String,
+    signature: String,
+}
+
+struct ErrorConst {
+    const_name: String,
+    bytes_hex: String,
+    signature: String,
+}
+
+struct NoAllocFunctionInfo {
+    name: String,
+    selector_const: String,
+    min_call_data_len: usize,
+    params: Vec<ParamDecode>,
+}
+
+struct ParamDecode {
+    decode_line: String,
+}
+
+// ============================================================================
+// Solc Output Parsing Structures
+// ============================================================================
+
+#[derive(Debug, Deserialize)]
+struct SolcOutput {
+    contracts: std::collections::HashMap<String, std::collections::HashMap<String, ContractInfo>>,
+}
+
+#[derive(Debug, Deserialize)]
+struct ContractInfo {
+    metadata: String,
+}
+
+#[derive(Debug, Deserialize)]
+struct ContractMetadata {
+    output: MetadataOutput,
+}
+
+#[derive(Debug, Deserialize)]
+struct MetadataOutput {
+    abi: Vec<AbiItem>,
+}
+
+#[derive(Debug, Deserialize, Clone)]
+#[serde(tag = "type")]
+enum AbiItem {
+    #[serde(rename = "function")]
+    Function {
+        name: String,
+        inputs: Vec<AbiInput>,
+        #[allow(dead_code)]
+        outputs: Vec<AbiOutput>,
+        #[serde(rename = "stateMutability")]
+        #[allow(dead_code)]
+        state_mutability: String,
+    },
+    #[serde(rename = "event")]
+    Event { name: String, inputs: Vec<AbiInput> },
+    #[serde(rename = "error")]
+    Error { name: String, inputs: Vec<AbiInput> },
+    #[serde(rename = "constructor")]
+    Constructor {
+        #[allow(dead_code)]
+        inputs: Vec<AbiInput>,
+    },
+}
+
+#[derive(Debug, Deserialize, Clone)]
+struct AbiInput {
+    name: String,
+    #[serde(rename = "type")]
+    type_name: String,
+    #[allow(dead_code)]
+    indexed: Option<bool>,
+}
+
+#[derive(Debug, Deserialize, Clone)]
+#[allow(dead_code)]
+struct AbiOutput {
+    name: String,
+    #[serde(rename = "type")]
+    type_name: String,
+}
+
+// ============================================================================
+// Helper Functions
+// ============================================================================
+
+/// Compute the keccak256 hash of a string
+fn keccak256(input: &str) -> [u8; 32] {
+    let mut hasher = Keccak::v256();
+    let mut output = [0u8; 32];
+    hasher.update(input.as_bytes());
+    hasher.finalize(&mut output);
+    output
+}
+
+/// Compute the 4-byte function selector from a function signature
+fn compute_selector(signature: &str) -> [u8; 4] {
+    let hash = keccak256(signature);
+    [hash[0], hash[1], hash[2], hash[3]]
+}
+
+/// Build a function signature from name and input types
+fn build_function_signature(name: &str, inputs: &[AbiInput]) -> String {
+    let types: Vec<&str> = inputs.iter().map(|i| i.type_name.as_str()).collect();
+    format!("{}({})", name, types.join(","))
+}
+
+/// Format a byte array as Rust hex literal
+fn format_bytes_as_hex(bytes: &[u8]) -> String {
+    bytes
+        .iter()
+        .map(|b| format!("0x{:02x}", b))
+        .collect::<Vec<_>>()
+        .join(", ")
+}
+
+/// Format a 32-byte array with line breaks for readability
+fn format_bytes32_multiline(bytes: &[u8; 32]) -> String {
+    bytes
+        .chunks(8)
+        .map(|chunk| {
+            chunk
+                .iter()
+                .map(|b| format!("0x{:02x}", b))
+                .collect::<Vec<_>>()
+                .join(", ")
+        })
+        .collect::<Vec<_>>()
+        .join(",\n    ")
+}
+
+fn to_pascal_case(s: &str) -> String {
+    s.split(|c: char| !c.is_alphanumeric())
+        .filter(|s| !s.is_empty())
+        .map(|word| {
+            let mut chars = word.chars();
+            match chars.next() {
+                None => String::new(),
+                Some(first) => first.to_uppercase().chain(chars).collect(),
+            }
+        })
+        .collect()
+}
+
+fn to_snake_case(s: &str) -> String {
+    let mut result = String::new();
+    for (i, c) in s.chars().enumerate() {
+        if c.is_uppercase() && i > 0 {
+            result.push('_');
+        }
+        result.push(c.to_lowercase().next().unwrap());
+    }
+    result
+}
+
+fn to_screaming_snake_case(s: &str) -> String {
+    to_snake_case(s).to_uppercase()
+}
+
+// ============================================================================
+// Public API
+// ============================================================================
+
+pub fn init_blank_contract(
+    contract_name: &str,
+    builder_path: Option<&std::path::Path>,
+) -> Result<()> {
+    let target_dir = std::env::current_dir()?.join(contract_name);
+    if target_dir.exists() {
+        anyhow::bail!("Directory already exists: {target_dir:?}");
+    }
+
+    fs::create_dir(&target_dir)
+        .with_context(|| format!("Failed to create directory: {target_dir:?}"))?;
+
+    let cargo_config_dir = target_dir.join(".cargo");
+    fs::create_dir(&cargo_config_dir)?;
+    fs::write(
+        cargo_config_dir.join("config.toml"),
+        r#"[build]
+target = "riscv64imac-unknown-none-elf"
+"#,
+    )?;
+
+    fs::write(target_dir.join(".gitignore"), "/target\n*.polkavm\n")?;
+
+    fs::create_dir(target_dir.join("src"))?;
+    let lib_rs_content = generate_blank_contract()?;
+    fs::write(target_dir.join("src/lib.rs"), lib_rs_content)?;
+
+    let build_rs_content = generate_build_rs()?;
+    fs::write(target_dir.join("build.rs"), build_rs_content)?;
+
+    let cargo_toml_content = generate_cargo_toml(contract_name, false, builder_path)?;
+    fs::write(target_dir.join("Cargo.toml"), cargo_toml_content)?;
+
+    println!("Successfully initialized blank contract project: {target_dir:?}");
+    println!("\nNext steps:");
+    println!("  cd {contract_name}");
+    println!("  cargo build");
+    Ok(())
+}
+
+pub fn init_from_solidity_file(
+    sol_file: &str,
+    contract_name: &str,
+    use_alloc: bool,
+    builder_path: Option<&std::path::Path>,
+) -> Result<()> {
+    let sol_path = PathBuf::from(sol_file);
+    if !sol_path.exists() {
+        anyhow::bail!("Solidity file not found: {sol_file}");
+    }
+
+    // Get absolute path to .sol file
+    let sol_abs_path = sol_path
+        .canonicalize()
+        .with_context(|| format!("Failed to get absolute path for {sol_file}"))?;
+
+    let sol_file_name = sol_path
+        .file_name()
+        .and_then(|s| s.to_str())
+        .ok_or_else(|| anyhow::anyhow!("Invalid file name"))?;
+
+    log::debug!("Extracting metadata from {sol_file}");
+    let (metadata, actual_contract_name) = extract_solc_metadata(&sol_abs_path, sol_file_name)?;
+
+    // Create project directory
+    let target_dir = std::env::current_dir()?.join(contract_name);
+    if target_dir.exists() {
+        anyhow::bail!("Directory already exists: {target_dir:?}");
+    }
+    fs::create_dir(&target_dir)
+        .with_context(|| format!("Failed to create directory: {target_dir:?}"))?;
+
+    // Copy .sol file to project
+    let target_sol_path = target_dir.join(sol_file_name);
+    fs::copy(&sol_abs_path, &target_sol_path)
+        .with_context(|| format!("Failed to copy {sol_file} to {target_sol_path:?}"))?;
+
+    // Create .cargo directory and config
+    let cargo_config_dir = target_dir.join(".cargo");
+    fs::create_dir(&cargo_config_dir)?;
+    fs::write(
+        cargo_config_dir.join("config.toml"),
+        r#"[build]
+target = "riscv64imac-unknown-none-elf"
+"#,
+    )?;
+
+    // Create .gitignore
+    fs::write(target_dir.join(".gitignore"), "/target\n*.polkavm\n")?;
+
+    // Generate src/lib.rs
+    fs::create_dir(target_dir.join("src"))?;
+
+    let lib_rs_content = if use_alloc {
+        generate_rust_code_alloc(sol_file_name, &metadata, &actual_contract_name)?
+    } else {
+        generate_rust_code_no_alloc(&metadata, &actual_contract_name)?
+    };
+    fs::write(target_dir.join("src/lib.rs"), lib_rs_content)?;
+
+    let build_rs_content = generate_build_rs()?;
+    fs::write(target_dir.join("build.rs"), build_rs_content)?;
+
+    // Create Cargo.toml
+    let cargo_toml_content = generate_cargo_toml(contract_name, use_alloc, builder_path)?;
+    fs::write(target_dir.join("Cargo.toml"), cargo_toml_content)?;
+
+    println!("Successfully initialized contract project from {sol_file}: {target_dir:?}");
+    println!("\nNext steps:");
+    println!("  cd {contract_name}");
+    println!("  cargo build");
+    Ok(())
+}
+
+// ============================================================================
+// Internal Functions
+// ============================================================================
+
+fn extract_solc_metadata(
+    sol_abs_path: &PathBuf,
+    sol_file_name: &str,
+) -> Result<(ContractMetadata, String)> {
+    // Read the Solidity source code
+    let sol_content = fs::read_to_string(sol_abs_path)
+        .with_context(|| format!("Failed to read Solidity file: {sol_abs_path:?}"))?;
+
+    let solc_input = serde_json::json!({
+        "language": "Solidity",
+        "sources": {
+            sol_file_name: {
+                "content": sol_content
+            }
+        },
+        "settings": {
+            "outputSelection": {
+                "*": {
+                    "*": ["metadata"]
+                }
+            }
+        }
+    });
+
+    let solc_input_str = serde_json::to_string(&solc_input)?;
+
+    let mut child = Command::new("solc")
+        .arg("--standard-json")
+        .stdin(std::process::Stdio::piped())
+        .stdout(std::process::Stdio::piped())
+        .stderr(std::process::Stdio::piped())
+        .spawn()
+        .context("Failed to spawn solc. Make sure solc is installed and in PATH.")?;
+
+    child
+        .stdin
+        .as_mut()
+        .ok_or_else(|| anyhow::anyhow!("Failed to open stdin"))?
+        .write_all(solc_input_str.as_bytes())?;
+
+    let output_result = child
+        .wait_with_output()
+        .context("Failed to wait for solc")?;
+
+    if !output_result.status.success() {
+        let stderr = String::from_utf8_lossy(&output_result.stderr);
+        anyhow::bail!("solc failed: {stderr}");
+    }
+
+    log::debug!(
+        "solc stdout: {}",
+        String::from_utf8_lossy(&output_result.stdout)
+    );
+
+    let solc_output: SolcOutput =
+        serde_json::from_slice(&output_result.stdout).with_context(|| {
+            format!(
+                "Failed to parse solc output. Output was: {}",
+                String::from_utf8_lossy(&output_result.stdout)
+            )
+        })?;
+
+    // Extract metadata from the first contract
+    let contracts_for_file = solc_output
+        .contracts
+        .get(sol_file_name)
+        .ok_or_else(|| anyhow::anyhow!("No contract found in solc output"))?;
+
+    let (contract_name, contract_info) = contracts_for_file
+        .iter()
+        .next()
+        .ok_or_else(|| anyhow::anyhow!("No contract found in solc output"))?;
+
+    let metadata: ContractMetadata = serde_json::from_str(&contract_info.metadata)
+        .context("Failed to parse contract metadata")?;
+
+    Ok((metadata, contract_name.clone()))
+}
+
+fn generate_blank_contract() -> Result<String> {
+    ContractBlankTemplate
+        .render()
+        .context("Failed to render blank contract template")
+}
+
+fn generate_build_rs() -> Result<String> {
+    BuildRsTemplate
+        .render()
+        .context("Failed to render build.rs template")
+}
+
+fn generate_rust_code_alloc(
+    sol_file_name: &str,
+    metadata: &ContractMetadata,
+    contract_name: &str,
+) -> Result<String> {
+    let contract_name_pascal = to_pascal_case(contract_name);
+
+    let functions: Vec<AllocFunctionInfo> = metadata
+        .output
+        .abi
+        .iter()
+        .filter_map(|item| match item {
+            AbiItem::Function { name, .. } => Some(AllocFunctionInfo {
+                name: name.clone(),
+                name_snake: to_snake_case(name),
+                call_type: format!("{contract_name_pascal}::{name}Call"),
+            }),
+            _ => None,
+        })
+        .collect();
+
+    let template = ContractAllocTemplate {
+        sol_file_name,
+        functions,
+    };
+
+    template.render().context("Failed to render alloc template")
+}
+
+fn generate_rust_code_no_alloc(metadata: &ContractMetadata, contract_name: &str) -> Result<String> {
+    let contract_name_upper = contract_name.to_uppercase();
+
+    // Collect function selectors
+    let mut selectors = Vec::new();
+    let mut functions = Vec::new();
+
+    for item in &metadata.output.abi {
+        if let AbiItem::Function { name, inputs, .. } = item {
+            let signature = build_function_signature(name, inputs);
+            let selector = compute_selector(&signature);
+            let const_name = format!("{}_SELECTOR", to_screaming_snake_case(name));
+
+            selectors.push(SelectorConst {
+                const_name: const_name.clone(),
+                bytes_hex: format_bytes_as_hex(&selector),
+                signature: signature.clone(),
+            });
+
+            // Generate decode params
+            let mut params = Vec::new();
+            let mut offset = 4usize;
+
+            for (idx, input) in inputs.iter().enumerate() {
+                let param_name = if input.name.is_empty() {
+                    format!("param_{}", idx)
+                } else {
+                    to_snake_case(&input.name)
+                };
+
+                let decode_line = match input.type_name.as_str() {
+                    "address" => {
+                        format!(
+                            "let {param_name} = decode_address(&call_data[{offset}..{}]);",
+                            offset + 32
+                        )
+                    }
+                    "uint256" | "uint128" | "uint64" | "uint32" | "uint16" | "uint8" => {
+                        format!(
+                            "let {param_name} = decode_u128(&call_data[{offset}..{}]);",
+                            offset + 32
+                        )
+                    }
+                    "bool" => {
+                        format!("let {param_name} = call_data[{}] != 0;", offset + 31)
+                    }
+                    "bytes32" => {
+                        format!(
+                            "let {param_name}: [u8; 32] = call_data[{offset}..{}].try_into().unwrap();",
+                            offset + 32
+                        )
+                    }
+                    _ => {
+                        format!("// TODO: decode {param_name} of type {}", input.type_name)
+                    }
+                };
+
+                params.push(ParamDecode { decode_line });
+                offset += 32;
+            }
+
+            functions.push(NoAllocFunctionInfo {
+                name: name.clone(),
+                selector_const: const_name,
+                min_call_data_len: 4 + inputs.len() * 32,
+                params,
+            });
+        }
+    }
+
+    // Collect events
+    let events: Vec<EventConst> = metadata
+        .output
+        .abi
+        .iter()
+        .filter_map(|item| {
+            if let AbiItem::Event { name, inputs } = item {
+                let signature = build_function_signature(name, inputs);
+                let hash = keccak256(&signature);
+                Some(EventConst {
+                    const_name: format!("{}_EVENT_SIGNATURE", to_screaming_snake_case(name)),
+                    bytes_hex: format_bytes32_multiline(&hash),
+                    signature,
+                })
+            } else {
+                None
+            }
+        })
+        .collect();
+
+    // Collect errors
+    let errors: Vec<ErrorConst> = metadata
+        .output
+        .abi
+        .iter()
+        .filter_map(|item| {
+            if let AbiItem::Error { name, inputs } = item {
+                let signature = build_function_signature(name, inputs);
+                let selector = compute_selector(&signature);
+                Some(ErrorConst {
+                    const_name: format!("{}_ERROR", to_screaming_snake_case(name)),
+                    bytes_hex: format_bytes_as_hex(&selector),
+                    signature,
+                })
+            } else {
+                None
+            }
+        })
+        .collect();
+
+    let template = ContractNoAllocTemplate {
+        contract_name_upper: &contract_name_upper,
+        selectors,
+        events,
+        errors,
+        functions,
+    };
+
+    template
+        .render()
+        .context("Failed to render no-alloc template")
+}
+
+fn generate_cargo_toml(
+    contract_name: &str,
+    use_alloc: bool,
+    builder_path: Option<&std::path::Path>,
+) -> Result<String> {
+    let template = CargoTomlTemplate {
+        contract_name,
+        use_alloc,
+        builder_version: BUILDER_VERSION,
+        builder_path: builder_path.map(|path| path.display().to_string()),
+    };
+    template
+        .render()
+        .context("Failed to render Cargo.toml template")
+}
diff --git a/crates/cargo-pvm-contract/templates/examples/Fibonacci.sol b/crates/cargo-pvm-contract/templates/examples/Fibonacci.sol
new file mode 100644
index 00000000..8a52a358
--- /dev/null
+++ b/crates/cargo-pvm-contract/templates/examples/Fibonacci.sol
@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: Apache-2.0
+
+pragma solidity ^0.8.0;
+
+interface Fibonacci {
+    function fibonacci(uint32) external pure returns (uint32);
+}
+
diff --git a/templates/no-alloc/contract.sol b/crates/cargo-pvm-contract/templates/examples/MyToken.sol
similarity index 100%
rename from templates/no-alloc/contract.sol
rename to crates/cargo-pvm-contract/templates/examples/MyToken.sol
diff --git a/crates/cargo-pvm-contract/templates/scaffold/build.rs.txt b/crates/cargo-pvm-contract/templates/scaffold/build.rs.txt
new file mode 100644
index 00000000..39b81193
--- /dev/null
+++ b/crates/cargo-pvm-contract/templates/scaffold/build.rs.txt
@@ -0,0 +1,4 @@
+fn main() {
+    cargo_pvm_contract_builder::PvmBuilder::new().build();
+}
+
diff --git a/crates/cargo-pvm-contract/templates/scaffold/cargo_toml.txt b/crates/cargo-pvm-contract/templates/scaffold/cargo_toml.txt
new file mode 100644
index 00000000..6b54d3b4
--- /dev/null
+++ b/crates/cargo-pvm-contract/templates/scaffold/cargo_toml.txt
@@ -0,0 +1,34 @@
+[package]
+name = "{{ contract_name }}"
+version = "0.1.0"
+edition = "2024"
+build = "build.rs"
+
+[[bin]]
+name = "{{ contract_name }}"
+path = "src/lib.rs"
+
+[dependencies]
+{% if use_alloc -%}
+alloy-core = { version = "0.8", default-features = false, features = ["sol-types"] }
+{% endif -%}
+pallet-revive-uapi = { version = "0.10", default-features = false }
+{% if use_alloc -%}
+picoalloc = { version = "5", default-features = false }
+{% endif -%}
+polkavm-derive = { version = "0.30.0" }
+
+[build-dependencies]
+{% if let Some(path) = builder_path -%}
+cargo-pvm-contract-builder = { path = "{{ path }}" }
+{% else -%}
+cargo-pvm-contract-builder = "{{ builder_version }}"
+{% endif %}
+
+[profile.release]
+codegen-units = 1
+lto = true
+opt-level = "z"
+panic = "abort"
+strip = true
+overflow-checks = false
diff --git a/crates/cargo-pvm-contract/templates/scaffold/contract_alloc.rs.txt b/crates/cargo-pvm-contract/templates/scaffold/contract_alloc.rs.txt
new file mode 100644
index 00000000..cfc26893
--- /dev/null
+++ b/crates/cargo-pvm-contract/templates/scaffold/contract_alloc.rs.txt
@@ -0,0 +1,60 @@
+#![no_main]
+#![no_std]
+
+use alloy_core::{
+    primitives::{Address, U256},
+    sol,
+    sol_types::{SolCall, SolError, SolEvent},
+};
+use pallet_revive_uapi::{HostFn, HostFnImpl as api, ReturnFlags, StorageFlags};
+
+extern crate alloc;
+use alloc::vec;
+
+sol!("{{ sol_file_name }}");
+
+#[global_allocator]
+static mut ALLOC: picoalloc::Mutex<picoalloc::Allocator<picoalloc::ArrayPointer<1024>>> = {
+    static mut ARRAY: picoalloc::Array<1024> = picoalloc::Array([0u8; 1024]);
+
+    picoalloc::Mutex::new(picoalloc::Allocator::new(unsafe {
+        picoalloc::ArrayPointer::new(&raw mut ARRAY)
+    }))
+};
+
+#[panic_handler]
+fn panic(_info: &core::panic::PanicInfo) -> ! {
+    // Safety: The unimp instruction is guaranteed to trap
+    unsafe {
+        core::arch::asm!("unimp");
+        core::hint::unreachable_unchecked();
+    }
+}
+
+/// This is the constructor which is called once per contract.
+#[no_mangle]
+#[polkavm_derive::polkavm_export]
+pub extern "C" fn deploy() {}
+
+/// This is the regular entry point when the contract is called.
+#[no_mangle]
+#[polkavm_derive::polkavm_export]
+pub extern "C" fn call() {
+    let call_data_len = api::call_data_size();
+    let mut call_data = vec![0u8; call_data_len as usize];
+    api::call_data_copy(&mut call_data, 0);
+
+    let selector: [u8; 4] = call_data[0..4].try_into().unwrap();
+
+    match selector {
+{% for func in functions %}
+        {{ func.call_type }}::SELECTOR => {
+            let _{{ func.name_snake }}_call = {{ func.call_type }}::abi_decode(&call_data, true)
+                .expect("Failed to decode {{ func.name }} call");
+
+            todo!()
+        }
+{% endfor %}
+        _ => panic!("Unknown function selector"),
+    }
+}
diff --git a/templates/blank/src/contract.rs b/crates/cargo-pvm-contract/templates/scaffold/contract_blank.rs.txt
similarity index 100%
rename from templates/blank/src/contract.rs
rename to crates/cargo-pvm-contract/templates/scaffold/contract_blank.rs.txt
diff --git a/crates/cargo-pvm-contract/templates/scaffold/contract_no_alloc.rs.txt b/crates/cargo-pvm-contract/templates/scaffold/contract_no_alloc.rs.txt
new file mode 100644
index 00000000..9f9adee8
--- /dev/null
+++ b/crates/cargo-pvm-contract/templates/scaffold/contract_no_alloc.rs.txt
@@ -0,0 +1,119 @@
+#![no_main]
+#![no_std]
+
+use pallet_revive_uapi::{HostFn, HostFnImpl as api, ReturnFlags, StorageFlags};
+
+// ============================================================================
+// {{ contract_name_upper }} CONTRACT - Generated from Solidity ABI
+// ============================================================================
+
+// Function selectors
+{% for sel in selectors %}
+const {{ sel.const_name }}: [u8; 4] = [{{ sel.bytes_hex }}]; // {{ sel.signature }}
+{% endfor %}
+
+// Event signatures
+{% for evt in events %}
+const {{ evt.const_name }}: [u8; 32] = [
+    {{ evt.bytes_hex }}
+]; // {{ evt.signature }}
+
+{% endfor %}
+// Error selectors
+{% for err in errors %}
+const {{ err.const_name }}: [u8; 4] = [{{ err.bytes_hex }}]; // {{ err.signature }}
+{% endfor %}
+
+#[panic_handler]
+fn panic(_info: &core::panic::PanicInfo) -> ! {
+    // Safety: The unimp instruction is guaranteed to trap
+    unsafe {
+        core::arch::asm!("unimp");
+        core::hint::unreachable_unchecked();
+    }
+}
+
+// ============================================================================
+// ABI Decoding Helpers
+// ============================================================================
+
+/// Decode address from ABI-encoded data (32 bytes, address is in the last 20 bytes)
+#[inline]
+fn decode_address(data: &[u8]) -> [u8; 20] {
+    let mut addr = [0u8; 20];
+    addr.copy_from_slice(&data[12..32]);
+    addr
+}
+
+/// Decode u128 from ABI-encoded data (32 bytes, takes lower 16 bytes)
+#[inline]
+fn decode_u128(data: &[u8]) -> u128 {
+    u128::from_be_bytes(data[16..32].try_into().unwrap())
+}
+
+/// Convert u128 to 32-byte word (big-endian, left-padded)
+#[inline]
+fn to_word(v: u128) -> [u8; 32] {
+    let mut out = [0u8; 32];
+    out[16..].copy_from_slice(&v.to_be_bytes());
+    out
+}
+
+// ============================================================================
+// Storage Helpers
+// ============================================================================
+
+/// Get the caller's address
+#[inline]
+fn get_caller() -> [u8; 20] {
+    let mut caller = [0u8; 20];
+    api::caller(&mut caller);
+    caller
+}
+
+// ============================================================================
+// Contract Entry Points
+// ============================================================================
+
+/// This is the constructor which is called once per contract.
+#[no_mangle]
+#[polkavm_derive::polkavm_export]
+pub extern "C" fn deploy() {}
+
+/// This is the regular entry point when the contract is called.
+#[no_mangle]
+#[polkavm_derive::polkavm_export]
+pub extern "C" fn call() {
+    let call_data_len = api::call_data_size() as usize;
+
+    // Fixed buffer for call data
+    let mut call_data = [0u8; 256];
+    if call_data_len > call_data.len() {
+        panic!("Call data too large");
+    }
+
+    api::call_data_copy(&mut call_data[..call_data_len], 0);
+
+    if call_data_len < 4 {
+        panic!("Call data too short");
+    }
+
+    let selector: [u8; 4] = call_data[0..4].try_into().unwrap();
+
+    match selector {
+{% for func in functions %}
+        {{ func.selector_const }} => {
+            if call_data_len < {{ func.min_call_data_len }} {
+                panic!("Invalid {{ func.name }} call data");
+            }
+{% for param in func.params %}
+            {{ param.decode_line }}
+{% endfor %}
+
+            // TODO: Implement {{ func.name }} logic
+            todo!()
+        }
+{% endfor %}
+        _ => panic!("Unknown function selector"),
+    }
+}
diff --git a/crates/cargo-pvm-contract/tests/test_cmd.rs b/crates/cargo-pvm-contract/tests/test_cmd.rs
new file mode 100644
index 00000000..ff66aeb5
--- /dev/null
+++ b/crates/cargo-pvm-contract/tests/test_cmd.rs
@@ -0,0 +1,71 @@
+use assert_cmd::Command;
+use std::path::{Path, PathBuf};
+use tempfile::TempDir;
+
+fn cargo_path() -> PathBuf {
+    std::env::var("CARGO")
+        .map(PathBuf::from)
+        .unwrap_or_else(|_| PathBuf::from("cargo"))
+}
+
+fn scaffold_example(temp_dir: &TempDir, name: &str, memory_model: &str) -> PathBuf {
+    let builder_path = Path::new(env!("CARGO_MANIFEST_DIR")).join("../cargo-pvm-contract-builder");
+    let project_dir = temp_dir.path().join(name);
+    let mut cmd = Command::new(assert_cmd::cargo::cargo_bin!("cargo-pvm-contract"));
+    cmd.current_dir(temp_dir.path())
+        .env("CARGO_PVM_CONTRACT_BUILDER_PATH", builder_path)
+        .arg("pvm-contract")
+        .arg("--non-interactive")
+        .arg("--init-type")
+        .arg("example")
+        .arg("--example")
+        .arg("my-token")
+        .arg("--memory-model")
+        .arg(memory_model)
+        .arg("--name")
+        .arg(name)
+        .assert()
+        .success();
+
+    project_dir
+}
+
+fn build_scaffolded_project(project_dir: &Path) {
+    let status = std::process::Command::new(cargo_path())
+        .current_dir(project_dir)
+        .arg("build")
+        .status()
+        .expect("run cargo build");
+
+    assert!(status.success(), "cargo build failed");
+}
+
+#[test]
+fn scaffold_mytoken_alloc() {
+    let temp_dir = TempDir::new().expect("temp dir");
+    let project_dir = scaffold_example(&temp_dir, "mytoken-alloc", "alloc-with-alloy");
+
+    let cargo_toml =
+        std::fs::read_to_string(project_dir.join("Cargo.toml")).expect("Cargo.toml exists");
+
+    assert!(cargo_toml.contains("alloy-core"));
+    assert!(cargo_toml.contains("picoalloc"));
+    assert!(cargo_toml.contains("pallet-revive-uapi"));
+
+    build_scaffolded_project(&project_dir);
+}
+
+#[test]
+fn scaffold_mytoken_no_alloc() {
+    let temp_dir = TempDir::new().expect("temp dir");
+    let project_dir = scaffold_example(&temp_dir, "mytoken-no-alloc", "no-alloc");
+
+    let cargo_toml =
+        std::fs::read_to_string(project_dir.join("Cargo.toml")).expect("Cargo.toml exists");
+
+    assert!(!cargo_toml.contains("alloy-core"));
+    assert!(!cargo_toml.contains("picoalloc"));
+    assert!(cargo_toml.contains("pallet-revive-uapi"));
+
+    build_scaffolded_project(&project_dir);
+}
diff --git a/next-prompt.txt b/next-prompt.txt
new file mode 100644
index 00000000..82f2398f
--- /dev/null
+++ b/next-prompt.txt
@@ -0,0 +1,13 @@
+Let's now do one more thing.
+Let's get rid of the build command
+instead we will create a cargo-pvm-contract-builder crate that will build the contract for us
+and we will generate the contracts with a build.rs file that reference it.
+
+this way user can simply run 
+
+cargo pvm-contract  to generate their contract (instead of calling cargo pvm-contract init)
+
+and they can just do 
+
+
+cargo build to build their contract to PVM like any regular crate
diff --git a/src/main.rs b/src/main.rs
deleted file mode 100644
index be6c8d7d..00000000
--- a/src/main.rs
+++ /dev/null
@@ -1,307 +0,0 @@
-use anyhow::{Context, Result};
-use clap::{Parser, Subcommand};
-use include_dir::{include_dir, Dir};
-use log::debug;
-use std::io::Write;
-use std::{fs, path::PathBuf, process::Command};
-
-// Embed the templates directory into the binary
-static TEMPLATES_DIR: Dir = include_dir!("$CARGO_MANIFEST_DIR/templates");
-
-/// Build contracts to PolkaVM bytecode
-#[derive(Parser, Debug)]
-#[command(name = "cargo")]
-#[command(bin_name = "cargo")]
-enum CargoCli {
-    PvmContract(PvmContractArgs),
-}
-
-#[derive(Parser, Debug)]
-#[command(author, version, about, long_about = None)]
-struct PvmContractArgs {
-    #[command(subcommand)]
-    command: Commands,
-}
-
-#[derive(Subcommand, Debug)]
-enum Commands {
-    /// Build a contract to PolkaVM bytecode
-    Build {
-        /// Name of the binary to build (defaults to first binary in Cargo.toml)
-        #[arg(short, long)]
-        bin_name: Option<String>,
-
-        /// Output path for the PolkaVM bytecode (defaults to ./<bin_name>.polkavm)
-        #[arg(short, long)]
-        output: Option<PathBuf>,
-    },
-    /// Initialize a new contract project from template
-    Init {
-        /// Name of the contract
-        #[arg(value_name = "CONTRACT_NAME")]
-        name: String,
-
-        /// Template to use (defaults to pico-alloc)
-        #[arg(short, long, default_value = "pico-alloc")]
-        template: String,
-    },
-}
-
-fn main() -> Result<()> {
-    env_logger::init();
-
-    let CargoCli::PvmContract(args) = CargoCli::parse();
-
-    match args.command {
-        Commands::Build { bin_name, output } => build_command(bin_name, output),
-        Commands::Init { name, template } => init_command(name, template),
-    }
-}
-
-fn build_command(bin_name: Option<String>, output: Option<PathBuf>) -> Result<()> {
-    let current_dir = std::env::current_dir().context("Failed to get current directory")?;
-    let manifest_path = find_manifest(&current_dir)?
-        .context("Could not find Cargo.toml in current directory or parent directories")?;
-
-    debug!("Found Cargo.toml at: {}", manifest_path.display());
-
-    let cargo_toml_content = fs::read_to_string(&manifest_path)
-        .with_context(|| format!("Failed to read Cargo.toml at {manifest_path:?}"))?;
-
-    let doc = cargo_toml_content
-        .parse::<toml_edit::DocumentMut>()
-        .context("Failed to parse Cargo.toml")?;
-
-    let bin_name = if let Some(name) = bin_name {
-        debug!("Using specified binary name: {name}");
-        name
-    } else {
-        let first_bin_name = doc
-            .get("bin")
-            .and_then(|b| b.as_array_of_tables())
-            .and_then(|arr| arr.get(0))
-            .and_then(|bin| bin.get("name"))
-            .and_then(|name| name.as_str())
-            .context("No [[bin]] section found in Cargo.toml. Please specify a binary name.")?;
-
-        debug!("Using first binary from Cargo.toml: {first_bin_name}");
-        first_bin_name.to_string()
-    };
-
-    let work_dir = manifest_path.parent().unwrap();
-    let build_dir = work_dir.join("target");
-    let elf_path = build_contract(&manifest_path, &build_dir, &bin_name)?;
-    let output_path = output.unwrap_or_else(|| PathBuf::from(format!("./{bin_name}.polkavm")));
-    link_to_polkavm(&elf_path, &output_path)?;
-
-    println!("Successfully built contract: {output_path:?}");
-    Ok(())
-}
-
-fn init_command(name: String, template: String) -> Result<()> {
-    debug!("Initializing new contract project: {name} with template: {template}");
-
-    // Get the template from embedded templates
-    let template_dir = TEMPLATES_DIR.get_dir(&template).ok_or_else(|| {
-        anyhow::anyhow!(
-            "Template '{template}' not found. Available templates: {}",
-            TEMPLATES_DIR
-                .dirs()
-                .map(|d| d.path().file_name().unwrap().to_string_lossy())
-                .collect::<Vec<_>>()
-                .join(", ")
-        )
-    })?;
-
-    let target_dir = std::env::current_dir()?.join(&name);
-    if target_dir.exists() {
-        anyhow::bail!("Directory already exists: {target_dir:?}");
-    }
-
-    // Create target directory
-    fs::create_dir(&target_dir)
-        .with_context(|| format!("Failed to create directory: {target_dir:?}"))?;
-
-    // Copy template files from embedded directory
-    copy_embedded_template(template_dir, &target_dir, &name)?;
-
-    println!("Successfully initialized contract project: {target_dir:?}");
-    println!("\nNext steps:");
-    println!("  cd {name}");
-    println!("  cargo pvm-contract build");
-    Ok(())
-}
-
-fn copy_embedded_template(
-    template_dir: &Dir,
-    target_dir: &PathBuf,
-    project_name: &str,
-) -> Result<()> {
-    use std::io::Write;
-
-    extract_embedded_dir(template_dir, target_dir)?;
-    log::debug!("Extracted template files to {template_dir:?}");
-
-    let cargo_toml_path = template_dir.path().join("_Cargo.toml");
-    let cargo_toml_file = template_dir
-        .get_file(&cargo_toml_path)
-        .ok_or_else(|| anyhow::anyhow!("Template missing _Cargo.toml at {cargo_toml_path:?}"))?;
-
-    let cargo_toml_content = std::str::from_utf8(cargo_toml_file.contents())
-        .context("Invalid UTF-8 in template Cargo.toml")?;
-
-    let mut doc = cargo_toml_content
-        .parse::<toml_edit::DocumentMut>()
-        .context("Failed to parse template Cargo.toml")?;
-
-    // Update the package name
-    doc["package"]["name"] = toml_edit::value(project_name);
-
-    let updated_cargo_toml = doc.to_string();
-    let cargo_toml_path = target_dir.join("Cargo.toml");
-
-    debug!("Creating Cargo.toml at {cargo_toml_path:?}");
-    let mut file = fs::File::create(&cargo_toml_path)
-        .with_context(|| format!("Failed to create Cargo.toml at {cargo_toml_path:?}"))?;
-    file.write_all(updated_cargo_toml.as_bytes())
-        .context("Failed to write Cargo.toml")?;
-
-    Ok(())
-}
-
-fn extract_embedded_dir(embedded_dir: &Dir, target_dir: &PathBuf) -> Result<()> {
-    extract_embedded_dir_impl(embedded_dir, target_dir, embedded_dir.path())
-}
-
-fn extract_embedded_dir_impl(
-    embedded_dir: &Dir,
-    target_dir: &PathBuf,
-    base_path: &std::path::Path,
-) -> Result<()> {
-    for file in embedded_dir.files() {
-        let relative_path = file
-            .path()
-            .strip_prefix(base_path)
-            .context("Failed to strip template prefix from file path")?;
-
-        // Skip _Cargo.toml as it's handled separately in copy_embedded_template
-        if relative_path.file_name().and_then(|n| n.to_str()) == Some("_Cargo.toml") {
-            continue;
-        }
-
-        let file_path = target_dir.join(relative_path);
-        debug!("Extracting file: {relative_path:?}");
-
-        // Create parent directories if needed
-        if let Some(parent) = file_path.parent() {
-            fs::create_dir_all(parent)
-                .with_context(|| format!("Failed to create directory: {parent:?}"))?;
-        }
-
-        // Write file contents
-        let mut output_file = fs::File::create(&file_path)
-            .with_context(|| format!("Failed to create file: {file_path:?}"))?;
-        output_file
-            .write_all(file.contents())
-            .with_context(|| format!("Failed to write file: {file_path:?}"))?;
-    }
-
-    // Recursively extract subdirectories
-    for subdir in embedded_dir.dirs() {
-        let relative_path = subdir
-            .path()
-            .strip_prefix(base_path)
-            .context("Failed to strip template prefix from directory path")?;
-
-        debug!("Extracting directory: {relative_path:?}");
-        extract_embedded_dir_impl(subdir, target_dir, base_path)?;
-    }
-
-    Ok(())
-}
-
-fn find_manifest(start_dir: &std::path::Path) -> Result<Option<PathBuf>> {
-    let mut current = start_dir.canonicalize()?;
-    loop {
-        let manifest = current.join("Cargo.toml");
-        if manifest.exists() {
-            return Ok(Some(manifest));
-        }
-
-        match current.parent() {
-            Some(parent) => current = parent.to_path_buf(),
-            None => return Ok(None),
-        }
-    }
-}
-
-fn build_contract(manifest_path: &PathBuf, build_dir: &PathBuf, bin_name: &str) -> Result<PathBuf> {
-    debug!("Building RISC-V ELF binary for binary: {bin_name}");
-
-    let mut args = polkavm_linker::TargetJsonArgs::default();
-    args.is_64_bit = true;
-
-    let target_json = polkavm_linker::target_json_path(args).map_err(|e| anyhow::anyhow!(e))?;
-
-    let work_dir = manifest_path.parent().unwrap();
-
-    let mut build_command = Command::new("cargo");
-    build_command
-        .current_dir(work_dir)
-        .env("RUSTC_BOOTSTRAP", "1")
-        .args(["build", "--release", "--manifest-path"])
-        .arg(manifest_path)
-        .args([
-            "-Zbuild-std=core,alloc",
-            "-Zbuild-std-features=panic_immediate_abort",
-            "--bin",
-            bin_name,
-            "--target",
-            &target_json.to_string_lossy(),
-        ]);
-
-    debug!("Running: {build_command:?}");
-    let mut child = build_command
-        .spawn()
-        .context("Failed to execute cargo build")?;
-
-    let status = child.wait().context("Failed to wait for cargo build")?;
-
-    if !status.success() {
-        anyhow::bail!("Failed to build binary {bin_name}");
-    }
-
-    let elf_path = build_dir
-        .join("riscv64emac-unknown-none-polkavm/release")
-        .join(bin_name);
-
-    if !elf_path.exists() {
-        anyhow::bail!("ELF binary was not generated at: {elf_path:?}");
-    }
-
-    Ok(elf_path)
-}
-
-fn link_to_polkavm(elf_path: &PathBuf, output_path: &PathBuf) -> Result<()> {
-    debug!("Linking to PolkaVM bytecode...");
-
-    let mut config = polkavm_linker::Config::default();
-    config.set_strip(true);
-    config.set_optimize(true);
-
-    let elf_bytes =
-        fs::read(elf_path).with_context(|| format!("Failed to read ELF from {elf_path:?}"))?;
-
-    let linked = polkavm_linker::program_from_elf(
-        config,
-        polkavm_linker::TargetInstructionSet::ReviveV1,
-        &elf_bytes,
-    )
-    .map_err(|err| anyhow::anyhow!("Failed to link PolkaVM program: {err:?}"))?;
-
-    fs::write(output_path, &linked)
-        .with_context(|| format!("Failed to write PolkaVM bytecode to {output_path:?}"))?;
-
-    debug!("Wrote {} bytes to {output_path:?}", linked.len());
-    Ok(())
-}
diff --git a/templates/blank/.cargo/config.toml b/templates/blank/.cargo/config.toml
deleted file mode 100644
index 8ae662cf..00000000
--- a/templates/blank/.cargo/config.toml
+++ /dev/null
@@ -1,7 +0,0 @@
-# Use a standard rust riscv64 target for cargo check and rust-anaylser
-# cargo pvm will use  `polkavm_linker::TargetJsonArgs::default()`
-[build]
-target = "riscv64imac-unknown-none-elf"
-
-
-
diff --git a/templates/blank/.gitignore b/templates/blank/.gitignore
deleted file mode 100644
index 2dbb5ecd..00000000
--- a/templates/blank/.gitignore
+++ /dev/null
@@ -1,2 +0,0 @@
-/target
-/*.polkavm
diff --git a/templates/blank/_Cargo.toml b/templates/blank/_Cargo.toml
deleted file mode 100644
index ec5a1d14..00000000
--- a/templates/blank/_Cargo.toml
+++ /dev/null
@@ -1,22 +0,0 @@
-[package]
-name = "rust-contract-template"
-version = "0.1.0"
-edition = "2021"
-publish = false
-
-[[bin]]
-name = "contract"
-path = "src/contract.rs"
-
-[profile.release]
-opt-level = 3
-lto = true
-codegen-units = 1
-
-[dependencies]
-polkavm-derive = { version = "0.30.0" }
-pallet-revive-uapi = { version = "0.9.0", default-features = false }
-
-
-
-
diff --git a/templates/no-alloc/.cargo/config.toml b/templates/no-alloc/.cargo/config.toml
deleted file mode 100644
index 8ae662cf..00000000
--- a/templates/no-alloc/.cargo/config.toml
+++ /dev/null
@@ -1,7 +0,0 @@
-# Use a standard rust riscv64 target for cargo check and rust-anaylser
-# cargo pvm will use  `polkavm_linker::TargetJsonArgs::default()`
-[build]
-target = "riscv64imac-unknown-none-elf"
-
-
-
diff --git a/templates/no-alloc/.gitignore b/templates/no-alloc/.gitignore
deleted file mode 100644
index 2dbb5ecd..00000000
--- a/templates/no-alloc/.gitignore
+++ /dev/null
@@ -1,2 +0,0 @@
-/target
-/*.polkavm
diff --git a/templates/no-alloc/_Cargo.toml b/templates/no-alloc/_Cargo.toml
deleted file mode 100644
index 33e0552d..00000000
--- a/templates/no-alloc/_Cargo.toml
+++ /dev/null
@@ -1,23 +0,0 @@
-[package]
-name = "rust-contract-template"
-version = "0.1.0"
-edition = "2021"
-publish = false
-
-[[bin]]
-name = "contract"
-path = "src/contract.rs"
-
-[profile.release]
-opt-level = 3
-lto = true
-codegen-units = 1
-
-[dependencies]
-polkavm-derive = { version = "0.30.0" }
-picoalloc = "5.2.0"
-pallet-revive-uapi = { version = "0.9.0", default-features = false }
-
-
-
-
diff --git a/templates/no-alloc/src/contract.rs b/templates/no-alloc/src/contract.rs
deleted file mode 100644
index 378762b0..00000000
--- a/templates/no-alloc/src/contract.rs
+++ /dev/null
@@ -1,211 +0,0 @@
-#![no_main]
-#![no_std]
-
-use pallet_revive_uapi::{HostFn, HostFnImpl as api, ReturnFlags, StorageFlags};
-//
-// Function selectors
-const TRANSFER_SELECTOR: [u8; 4] = [0xa9, 0x05, 0x9c, 0xbb]; // transfer(address,uint256)
-const MINT_SELECTOR: [u8; 4] = [0x40, 0xc1, 0x0f, 0x19]; // mint(address,uint256)
-
-// Event signature hash for Transfer(address,address,uint256)
-const TRANSFER_EVENT_SIGNATURE: [u8; 32] = [
-    0xdd, 0xf2, 0x52, 0xad, 0x1b, 0xe2, 0xc8, 0x9b, 0x69, 0xc2, 0xb0, 0x68, 0xfc, 0x37, 0x8d, 0xaa,
-    0x95, 0x2b, 0xa7, 0xf1, 0x63, 0xc4, 0xa1, 0x16, 0x28, 0xf5, 0x5a, 0x4d, 0xf5, 0x23, 0xb3, 0xef,
-];
-
-// Error selector for InsufficientBalance()
-const INSUFFICIENT_BALANCE_ERROR: [u8; 4] = [0xf4, 0xd6, 0x78, 0xb8];
-
-#[panic_handler]
-fn panic(_info: &core::panic::PanicInfo) -> ! {
-    // Safety: The unimp instruction is guaranteed to trap
-    unsafe {
-        core::arch::asm!("unimp");
-        core::hint::unreachable_unchecked();
-    }
-}
-
-/// Storage key for totalSupply (slot 0)
-#[inline]
-fn total_supply_key() -> [u8; 32] {
-    [0u8; 32] // Slot 0
-}
-
-/// Helper function to compute storage key for balances[address]
-/// Storage slot for balances mapping is 1 (totalSupply is at slot 0)
-/// Follows Solidity convention: keccak256(leftPad32(key) ++ leftPad32(slot))
-fn balance_key(addr: &[u8; 20]) -> [u8; 32] {
-    let mut input = [0u8; 64]; // 32 bytes (padded address) + 32 bytes (slot)
-
-    // First 32 bytes: address left-padded to 32 bytes (12 zeros + 20 address bytes)
-    input[12..32].copy_from_slice(addr);
-
-    // Last 32 bytes: slot 1 for balances mapping (slot 0 is totalSupply)
-    input[63] = 1;
-
-    let mut key = [0u8; 32];
-    api::hash_keccak_256(&input, &mut key);
-    key
-}
-
-/// Get totalSupply from storage
-fn get_total_supply() -> u128 {
-    let key = total_supply_key();
-    let mut supply_bytes = [0u8; 16];
-    let mut supply_slice = &mut supply_bytes[..];
-
-    match api::get_storage(StorageFlags::empty(), &key, &mut supply_slice) {
-        Ok(_) => u128::from_be_bytes(supply_bytes),
-        Err(_) => 0u128,
-    }
-}
-
-// #[inline(always)]
-fn to_word(v: u128) -> [u8; 32] {
-    let mut out = [0u8; 32];
-    out[16..].copy_from_slice(&v.to_be_bytes());
-    out
-}
-
-/// Set totalSupply in storage
-#[inline]
-fn set_total_supply(amount: u128) {
-    let key = total_supply_key();
-    let bytes = amount.to_be_bytes();
-    api::set_storage(StorageFlags::empty(), &key, &bytes);
-}
-
-/// Get the balance for a given address from storage
-#[inline]
-fn get_balance(addr: &[u8; 20]) -> u128 {
-    let key = balance_key(addr);
-    let mut balance_bytes = [0u8; 16];
-    let mut balance_slice = &mut balance_bytes[..];
-
-    match api::get_storage(StorageFlags::empty(), &key, &mut balance_slice) {
-        Ok(_) => u128::from_be_bytes(balance_bytes),
-        Err(_) => 0u128,
-    }
-}
-
-/// Set the balance for a given address in storage
-#[inline]
-fn set_balance(addr: &[u8; 20], amount: u128) {
-    let key = balance_key(addr);
-    let bytes = amount.to_be_bytes();
-    api::set_storage(StorageFlags::empty(), &key, &bytes);
-}
-
-/// Emit a Transfer event
-#[inline]
-fn emit_transfer(from: &[u8; 20], to: &[u8; 20], value: u128) {
-    let mut from_topic = [0u8; 32];
-    from_topic[12..32].copy_from_slice(from);
-
-    let mut to_topic = [0u8; 32];
-    to_topic[12..32].copy_from_slice(to);
-
-    let topics = [TRANSFER_EVENT_SIGNATURE, from_topic, to_topic];
-    let data = to_word(value);
-    api::deposit_event(&topics, &data);
-}
-
-/// Revert with an InsufficientBalance error
-#[inline]
-fn revert_insufficient_balance() -> ! {
-    api::return_value(ReturnFlags::REVERT, &INSUFFICIENT_BALANCE_ERROR);
-}
-
-/// Get the caller's address
-#[inline]
-fn get_caller() -> [u8; 20] {
-    let mut caller = [0u8; 20];
-    api::caller(&mut caller);
-    caller
-}
-
-/// Decode address from ABI-encoded data (32 bytes, address is in the last 20 bytes)
-#[inline]
-fn decode_address(data: &[u8]) -> [u8; 20] {
-    let mut addr = [0u8; 20];
-    addr.copy_from_slice(&data[12..32]);
-    addr
-}
-
-/// Decode u128 from ABI-encoded data (32 bytes)
-#[inline]
-fn decode_u128(data: &[u8]) -> u128 {
-    u128::from_be_bytes(data[16..32].try_into().unwrap())
-}
-
-/// This is the constructor which is called once per contract.
-#[no_mangle]
-#[polkavm_derive::polkavm_export]
-pub extern "C" fn deploy() {}
-
-/// This is the regular entry point when the contract is called.
-#[no_mangle]
-#[polkavm_derive::polkavm_export]
-pub extern "C" fn call() {
-    let call_data_len = api::call_data_size() as usize;
-
-    // Fixed buffer for call data
-    let mut call_data = [0u8; 256];
-    if call_data_len > call_data.len() {
-        panic!("Call data too large");
-    }
-
-    api::call_data_copy(&mut call_data[..call_data_len], 0);
-
-    if call_data_len < 4 {
-        panic!("Call data too short");
-    }
-
-    let selector: [u8; 4] = call_data[0..4].try_into().unwrap();
-
-    match selector {
-        TRANSFER_SELECTOR => {
-            // ABI encoding: selector(4) + address(32) + uint256(32)
-            if call_data_len < 68 {
-                panic!("Invalid transfer call data");
-            }
-
-            let to = decode_address(&call_data[4..36]);
-            let amount = decode_u128(&call_data[36..68]);
-
-            let caller = get_caller();
-            let sender_balance = get_balance(&caller);
-
-            if sender_balance < amount {
-                revert_insufficient_balance();
-            }
-
-            let new_sender_balance = sender_balance - amount;
-            let recipient_balance = get_balance(&to);
-            let new_recipient_balance = recipient_balance + amount;
-
-            set_balance(&caller, new_sender_balance);
-            set_balance(&to, new_recipient_balance);
-            emit_transfer(&caller, &to, amount);
-        }
-        MINT_SELECTOR => {
-            // ABI encoding: selector(4) + address(32) + uint256(32)
-            if call_data_len < 68 {
-                panic!("Invalid mint call data");
-            }
-
-            let to = decode_address(&call_data[4..36]);
-            let amount = decode_u128(&call_data[36..68]);
-
-            let new_recipient_balance = get_balance(&to).saturating_add(amount);
-            set_balance(&to, new_recipient_balance);
-
-            let new_supply = get_total_supply().saturating_add(amount);
-            set_total_supply(new_supply);
-
-            let zero_address = [0u8; 20];
-            emit_transfer(&zero_address, &to, amount);
-        }
-        _ => panic!("Unknown function selector"),
-    }
-}
diff --git a/templates/pico-alloc/.cargo/config.toml b/templates/pico-alloc/.cargo/config.toml
deleted file mode 100644
index 8ae662cf..00000000
--- a/templates/pico-alloc/.cargo/config.toml
+++ /dev/null
@@ -1,7 +0,0 @@
-# Use a standard rust riscv64 target for cargo check and rust-anaylser
-# cargo pvm will use  `polkavm_linker::TargetJsonArgs::default()`
-[build]
-target = "riscv64imac-unknown-none-elf"
-
-
-
diff --git a/templates/pico-alloc/.gitignore b/templates/pico-alloc/.gitignore
deleted file mode 100644
index 2dbb5ecd..00000000
--- a/templates/pico-alloc/.gitignore
+++ /dev/null
@@ -1,2 +0,0 @@
-/target
-/*.polkavm
diff --git a/templates/pico-alloc/_Cargo.toml b/templates/pico-alloc/_Cargo.toml
deleted file mode 100644
index 8c108d9c..00000000
--- a/templates/pico-alloc/_Cargo.toml
+++ /dev/null
@@ -1,24 +0,0 @@
-[package]
-name = "rust-contract-template"
-version = "0.1.0"
-edition = "2021"
-publish = false
-
-[[bin]]
-name = "contract"
-path = "src/contract.rs"
-
-[profile.release]
-opt-level = 3
-lto = true
-codegen-units = 1
-
-[dependencies]
-polkavm-derive = { version = "0.30.0" }
-alloy-core = { version = "0.8.0", default-features = false, features = ["sol-types"] }
-picoalloc = "5.2.0"
-pallet-revive-uapi = { version = "0.9.0", default-features = false }
-
-
-
-
diff --git a/templates/pico-alloc/contract.sol b/templates/pico-alloc/contract.sol
deleted file mode 100644
index 3f90238f..00000000
--- a/templates/pico-alloc/contract.sol
+++ /dev/null
@@ -1,13 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.27;
-
-interface MyToken {
-    event Transfer(address indexed from, address indexed to, uint256 value);
-    error InsufficientBalance();
-
-    function totalSupply() external view returns (uint256);
-    function balanceOf(address account) external view returns (uint256);
-
-    function transfer(address to, uint256 amount) external;
-    function mint(address to, uint256 amount) external;
-}
diff --git a/templates/pico-alloc/src/contract.rs b/templates/pico-alloc/src/contract.rs
deleted file mode 100644
index d2565483..00000000
--- a/templates/pico-alloc/src/contract.rs
+++ /dev/null
@@ -1,176 +0,0 @@
-#![no_main]
-#![no_std]
-
-use alloy_core::{
-    primitives::{Address, U256},
-    sol,
-    sol_types::{SolCall, SolError, SolEvent},
-};
-use pallet_revive_uapi::{HostFn, HostFnImpl as api, ReturnFlags, StorageFlags};
-
-extern crate alloc;
-use alloc::vec;
-
-sol!("contract.sol");
-use crate::MyToken::transferCall;
-
-#[global_allocator]
-static mut ALLOC: picoalloc::Mutex<picoalloc::Allocator<picoalloc::ArrayPointer<1024>>> = {
-    static mut ARRAY: picoalloc::Array<1024> = picoalloc::Array([0u8; 1024]);
-
-    picoalloc::Mutex::new(picoalloc::Allocator::new(unsafe {
-        picoalloc::ArrayPointer::new(&raw mut ARRAY)
-    }))
-};
-
-#[panic_handler]
-fn panic(_info: &core::panic::PanicInfo) -> ! {
-    // Safety: The unimp instruction is guaranteed to trap
-    unsafe {
-        core::arch::asm!("unimp");
-        core::hint::unreachable_unchecked();
-    }
-}
-
-/// Storage key for totalSupply (slot 0)
-#[inline]
-fn total_supply_key() -> [u8; 32] {
-    [0u8; 32] // Slot 0
-}
-
-/// Helper function to compute storage key for balances[address]
-/// Storage slot for balances mapping is 1 (totalSupply is at slot 0)
-/// Follows Solidity convention: keccak256(leftPad32(key) ++ leftPad32(slot))
-fn balance_key(addr: &[u8; 20]) -> [u8; 32] {
-    let mut input = [0u8; 64]; // 32 bytes (padded address) + 32 bytes (slot)
-
-    // First 32 bytes: address left-padded to 32 bytes (12 zeros + 20 address bytes)
-    input[12..32].copy_from_slice(addr);
-
-    // Last 32 bytes: slot 1 for balances mapping (slot 0 is totalSupply)
-    input[63] = 1;
-
-    let mut key = [0u8; 32];
-    api::hash_keccak_256(&input, &mut key);
-    key
-}
-
-/// Get totalSupply from storage
-fn get_total_supply() -> U256 {
-    let key = total_supply_key();
-    let mut supply_bytes = vec![0u8; 32];
-    let mut supply_output = supply_bytes.as_mut_slice();
-
-    match api::get_storage(StorageFlags::empty(), &key, &mut supply_output) {
-        Ok(_) => U256::from_be_bytes::<32>(supply_output[0..32].try_into().unwrap()),
-        Err(_) => U256::ZERO,
-    }
-}
-
-/// Set totalSupply in storage
-#[inline]
-fn set_total_supply(amount: U256) {
-    let key = total_supply_key();
-    api::set_storage(StorageFlags::empty(), &key, &amount.to_be_bytes::<32>());
-}
-
-/// Get the balance for a given address from storage
-#[inline]
-fn get_balance(addr: &[u8; 20]) -> U256 {
-    let key = balance_key(addr);
-    let mut balance_bytes = vec![0u8; 32];
-    let mut balance_output = balance_bytes.as_mut_slice();
-
-    match api::get_storage(StorageFlags::empty(), &key, &mut balance_output) {
-        Ok(_) => U256::from_be_bytes::<32>(balance_output[0..32].try_into().unwrap()),
-        Err(_) => U256::ZERO,
-    }
-}
-
-/// Set the balance for a given address in storage
-#[inline]
-fn set_balance(addr: &[u8; 20], amount: U256) {
-    let key = balance_key(addr);
-    api::set_storage(StorageFlags::empty(), &key, &amount.to_be_bytes::<32>());
-}
-
-/// Emit a Transfer event
-#[inline]
-fn emit_transfer(from: Address, to: Address, value: U256) {
-    let event = MyToken::Transfer { from, to, value };
-    let topics = [
-        MyToken::Transfer::SIGNATURE_HASH.0,
-        event.from.into_word().0,
-        event.to.into_word().0,
-    ];
-    let data = event.value.to_be_bytes::<32>();
-    api::deposit_event(&topics, &data);
-}
-
-/// Revert with an InsufficientBalance error
-#[inline]
-fn revert_insufficient_balance() -> ! {
-    let error = MyToken::InsufficientBalance {};
-    let encoded_error = <MyToken::InsufficientBalance as SolError>::abi_encode(&error);
-    api::return_value(ReturnFlags::REVERT, &encoded_error);
-}
-
-/// Get the caller's address
-#[inline]
-fn get_caller() -> [u8; 20] {
-    let mut caller = [0u8; 20];
-    api::caller(&mut caller);
-    caller
-}
-
-/// This is the constructor which is called once per contract.
-#[no_mangle]
-#[polkavm_derive::polkavm_export]
-pub extern "C" fn deploy() {}
-
-/// This is the regular entry point when the contract is called.
-#[no_mangle]
-#[polkavm_derive::polkavm_export]
-pub extern "C" fn call() {
-    let call_data_len = api::call_data_size();
-    let mut call_data = vec![0u8; call_data_len as usize];
-    api::call_data_copy(&mut call_data, 0);
-
-    let selector: [u8; 4] = call_data[0..4].try_into().unwrap();
-
-    match selector {
-        MyToken::transferCall::SELECTOR => {
-            let transferCall { to, amount } = MyToken::transferCall::abi_decode(&call_data, true)
-                .expect("Failed to decode transfer call");
-
-            let caller = get_caller();
-            let sender_balance = get_balance(&caller);
-
-            if sender_balance < amount {
-                revert_insufficient_balance();
-            }
-
-            let new_sender_balance = sender_balance - amount;
-
-            let recipient_balance = get_balance(&to.into_array());
-            let new_recipient_balance = recipient_balance + amount;
-
-            set_balance(&caller, new_sender_balance);
-            set_balance(&to.into_array(), new_recipient_balance);
-            emit_transfer(Address::from(caller), to, amount);
-        }
-        MyToken::mintCall::SELECTOR => {
-            let MyToken::mintCall { to, amount } = MyToken::mintCall::abi_decode(&call_data, true)
-                .expect("Failed to decode mint call");
-
-            let new_recipient_balance = get_balance(&to.into_array()).saturating_add(amount);
-            set_balance(&to.0 .0, new_recipient_balance);
-
-            let new_supply = get_total_supply().saturating_add(amount);
-            set_total_supply(new_supply);
-
-            emit_transfer(Address::ZERO, to, amount);
-        }
-        _ => panic!("Unknown function selector"),
-    }
-}