From 4e79f81c6e9016b2992c8459c28f7a1aefb5c75d Mon Sep 17 00:00:00 2001
From: Dustin Brickwood <dustinbrickwood204@gmail.com>
Date: Fri, 5 Apr 2024 15:12:46 -0500
Subject: [PATCH] feat: Add initial draft of dev onbaording material * Hello
 zkSync * Contract factories * Testing * Upgrades * Paymaster - wip

---
 app.config.ts                                 |  30 +-
 components/content/ContentSwitcher.vue        |   6 +-
 content/10.quick-start/1.index.md             |  52 +++
 content/10.quick-start/2.deploy_factory.md    |  68 +++
 content/10.quick-start/3.testing.md           |  60 +++
 content/10.quick-start/4.upgrading.md         |  61 +++
 content/10.quick-start/5.paymaster.md         |  85 ++++
 content/10.quick-start/6.smart-account.md     | 155 +++++++
 .../_foundry_deploy_contract_factory.md       | 163 +++++++
 .../_hardhat_deploy_contract_factory.md       | 221 +++++++++
 content/10.quick-start/_dir.yml               |   2 +
 .../_index/_foundry_deploy_contract.md        | 174 +++++++
 .../_index/_hardhat_deploy_contract.md        | 202 +++++++++
 .../_paymasters/_approval_paymaster_flow.md   |  22 +
 .../_general_paymaster_flow copy.md           |   0
 .../_paymasters/_general_paymaster_flow.md    |  22 +
 .../_testing/_foundry_contract_testing.md     | 215 +++++++++
 .../_testing/_hardhat_contract_testing.md     | 263 +++++++++++
 .../_foundry_beacon_contract_upgradability.md |   5 +
 .../_hardhat_beacon_contract_upgradability.md | 429 ++++++++++++++++++
 .../_beacon_proxy_contract_upgradability.md   |  32 ++
 ...ndry_transparent_contract_upgradability.md |   5 +
 ...dhat_transparent_contract_upgradability.md | 410 +++++++++++++++++
 ...ransparent_proxy_contract_upgradability.md |  35 ++
 .../_foundry_uups_contract_upgradability.md   |   5 +
 .../_hardhat_uups_contract_upgradability.md   | 410 +++++++++++++++++
 .../_uups_contract_upgradability.md           |  33 ++
 .../30.documentation-styleguide.md            |  10 +-
 .../_partials/_compile-solidity-contracts.md  |  28 ++
 content/_partials/_deploy-contract.md         |  19 +
 .../_environment-setup-with-foundry.md        |  43 ++
 .../_environment-setup-with-zksync-cli.md     |  47 ++
 content/_partials/_setting-up-your-wallet.md  |  40 ++
 content/_partials/setting-up-your-wallet.md   |  54 ---
 content/index.yml                             |   2 +-
 cspell-config/cspell-blockchain.txt           |   7 +
 cspell-config/cspell-dev.txt                  |  15 +
 cspell-config/cspell-zksync.txt               |   5 +
 nuxt.config.ts                                |  10 +-
 package.json                                  |   1 +
 40 files changed, 3365 insertions(+), 81 deletions(-)
 create mode 100644 content/10.quick-start/1.index.md
 create mode 100644 content/10.quick-start/2.deploy_factory.md
 create mode 100644 content/10.quick-start/3.testing.md
 create mode 100644 content/10.quick-start/4.upgrading.md
 create mode 100644 content/10.quick-start/5.paymaster.md
 create mode 100644 content/10.quick-start/6.smart-account.md
 create mode 100644 content/10.quick-start/_deploy_factory/_foundry_deploy_contract_factory.md
 create mode 100644 content/10.quick-start/_deploy_factory/_hardhat_deploy_contract_factory.md
 create mode 100644 content/10.quick-start/_dir.yml
 create mode 100644 content/10.quick-start/_index/_foundry_deploy_contract.md
 create mode 100644 content/10.quick-start/_index/_hardhat_deploy_contract.md
 create mode 100644 content/10.quick-start/_paymasters/_approval_paymaster_flow.md
 create mode 100644 content/10.quick-start/_paymasters/_general_paymaster_flow copy.md
 create mode 100644 content/10.quick-start/_paymasters/_general_paymaster_flow.md
 create mode 100644 content/10.quick-start/_testing/_foundry_contract_testing.md
 create mode 100644 content/10.quick-start/_testing/_hardhat_contract_testing.md
 create mode 100644 content/10.quick-start/_upgrading/_beacon/_foundry_beacon_contract_upgradability.md
 create mode 100644 content/10.quick-start/_upgrading/_beacon/_hardhat_beacon_contract_upgradability.md
 create mode 100644 content/10.quick-start/_upgrading/_beacon_proxy_contract_upgradability.md
 create mode 100644 content/10.quick-start/_upgrading/_transparent/_foundry_transparent_contract_upgradability.md
 create mode 100644 content/10.quick-start/_upgrading/_transparent/_hardhat_transparent_contract_upgradability.md
 create mode 100644 content/10.quick-start/_upgrading/_transparent_proxy_contract_upgradability.md
 create mode 100644 content/10.quick-start/_upgrading/_uups/_foundry_uups_contract_upgradability.md
 create mode 100644 content/10.quick-start/_upgrading/_uups/_hardhat_uups_contract_upgradability.md
 create mode 100644 content/10.quick-start/_upgrading/_uups_contract_upgradability.md
 create mode 100644 content/_partials/_compile-solidity-contracts.md
 create mode 100644 content/_partials/_deploy-contract.md
 create mode 100644 content/_partials/_environment-setup-with-foundry.md
 create mode 100644 content/_partials/_environment-setup-with-zksync-cli.md
 create mode 100644 content/_partials/_setting-up-your-wallet.md
 delete mode 100644 content/_partials/setting-up-your-wallet.md

diff --git a/app.config.ts b/app.config.ts
index 38d99c76..79fc0f17 100644
--- a/app.config.ts
+++ b/app.config.ts
@@ -102,24 +102,18 @@ export default defineAppConfig({
       edit: 'https://github.com/matter-labs/zksync-docs/edit/staging/content',
       feedback: 'https://github.com/matter-labs/zksync-docs/issues/new?labels=documentation',
       links: [
-        // {
-        //   icon: 'i-heroicons-star',
-        //   label: 'Star on GitHub',
-        //   to: 'https://github.com/nuxt/ui',
-        //   target: '_blank',
-        // },
-        // {
-        //   icon: 'i-heroicons-book-open',
-        //   label: 'Nuxt UI Pro docs',
-        //   to: 'https://ui.nuxt.com/pro/guide',
-        //   target: '_blank',
-        // },
-        // {
-        //   icon: 'i-simple-icons-nuxtdotjs',
-        //   label: 'Purchase a license',
-        //   to: 'https://ui.nuxt.com/pro/purchase',
-        //   target: '_blank',
-        // },
+        {
+          icon: 'i-heroicons-chat-bubble-oval-left-ellipsis-16-solid',
+          label: 'Chat on Discord',
+          to: 'https://join.zksync.dev/',
+          target: '_blank',
+        },
+        {
+          icon: 'i-heroicons-user-group-20-solid',
+          label: 'Developer Forum',
+          to: 'https://github.com/zkSync-Community-Hub/zkync-developers/discussions',
+          target: '_blank',
+        },
       ],
     },
   },
diff --git a/components/content/ContentSwitcher.vue b/components/content/ContentSwitcher.vue
index 21dd8de6..6e23d6c3 100644
--- a/components/content/ContentSwitcher.vue
+++ b/components/content/ContentSwitcher.vue
@@ -2,13 +2,15 @@
 defineProps<{
   items: ContentSwitcherItem[];
 }>();
-
 const selectedIndex = ref(0);
 
 function onTabChange(index: number) {
   selectedIndex.value = index;
 }
 const route = useRoute();
+// This splits the path into segments and takes the first one
+// TODO: This is a temporary solution, we need to find a better way to get the base path
+const basePath = route.path.split('/')[1];
 </script>
 
 <template>
@@ -25,7 +27,7 @@ const route = useRoute();
     >
       <ContentQuery
         v-slot="{ data }"
-        :path="$route.path"
+        :path="basePath"
         find="one"
         :where="{ _partial: true, _path: { $icontains: item.partial } }"
       >
diff --git a/content/10.quick-start/1.index.md b/content/10.quick-start/1.index.md
new file mode 100644
index 00000000..b40e7df6
--- /dev/null
+++ b/content/10.quick-start/1.index.md
@@ -0,0 +1,52 @@
+---
+title: Hello zkSync!
+description: Learn to deploy smart contracts efficiently in the zkSync environment.
+---
+
+Welcome to the Quickstart Guide for deploying smart contracts on zkSync! In this guide, we'll walk you through the process
+of creating and deploying a simple smart contract that creates a crowdfunding campaign for Zeek.
+
+:check-icon Initializing a new project with a scaffolding tool.
+
+:check-icon Crafting a smart contract to fund Zeek's latest adventure.
+
+:check-icon Deploying the contract on the zkSync Era using your choice of Hardhat or Foundry.
+
+Let's dive in and start your developer journey on zkSync!
+
+## Framework selection
+
+Select the framework you want to get started using zkSync Era with.
+
+::content-switcher
+---
+items: [{
+  label: 'Hardhat',
+  partial: '_index/_hardhat_deploy_contract'
+}, {
+  label: 'Foundry',
+  partial: '_index/_foundry_deploy_contract'
+}]
+---
+::
+
+## Takeaways
+
+- **EVM Compatibility:** zkSync is EVM compatible and you can write smart contracts in Solidity or Vyper.
+- **Development Tools:** zkSync supports your favorite development toolkit Hardhat and Foundry.
+- **Custom Compilation:** Contracts deployed to zkSync are compiled using `zksolc` or `zkvyper` as
+they generate a special bytecode for zkSync's ZKEVM.
+
+## Next steps
+
+Having successfully deployed your first contract on zkSync, you're well on your way to becoming
+a proficient zkSync developer. To expand your expertise:
+
+- **Explore Contract Factories:** Enhance your project by building a contract factory
+for the `CrowdfundingCampaign` contract in the next guide. This will allow you to efficiently
+manage multiple crowdfunding campaigns, each with its own unique parameters.
+- **Dive Deeper into zkSync Features:** Investigate advanced zkSync features such as account abstraction,
+and paymasters.
+- **Join the Community:** Engage with the zkSync developer community through forums,
+Discord channels, Dev Discussions, or GitHub repositories. Share your experiences, ask questions,
+and collaborate on projects.
diff --git a/content/10.quick-start/2.deploy_factory.md b/content/10.quick-start/2.deploy_factory.md
new file mode 100644
index 00000000..6621a9e6
--- /dev/null
+++ b/content/10.quick-start/2.deploy_factory.md
@@ -0,0 +1,68 @@
+---
+title: Contract Factories
+description: Learn to deploy contract factories in the zkSync environment.
+---
+
+Welcome back to the Quickstart Series on becoming proficient with zkSync development!
+This second installment advances from your introductory exploration of smart contract
+deployment to dive into the utility of contract factories. Through this guide,
+you'll learn how to streamline the deployment of multiple crowdfunding campaigns
+using a single contract factory, leveraging the foundational `CrowdfundingCampaign`
+contract in the first guide.
+
+:check-icon Advancing your zkSync development journey with contract factories.
+
+:check-icon Constructing a contract factory to create multiple crowdfunding campaigns for Zeek.
+
+:check-icon Seamlessly deploying your contract factory on zkSync Era, using either Hardhat or Foundry.
+
+Let's explore the efficiency and scalability that contract factories bring.
+
+### What is a contract factory?
+
+A contract factory is a design pattern that allows for the creation of multiple
+contract instances from a single "factory" contract. It's essentially a contract
+that creates other contracts, streamlining and organizing the deployment of
+numerous similar contracts efficiently.
+
+## Framework selection
+
+Select the framework you want to get started using zkSync Era with.
+
+::content-switcher
+---
+items: [{
+  label: 'Hardhat',
+  partial: '_deploy_factory/_hardhat_deploy_contract_factory'
+}, {
+  label: 'Foundry',
+  partial: '_deploy_factory/_foundry_deploy_contract_factory'
+}]
+---
+::
+
+## Takeaways
+
+- **Contract Factories:** Utilizing contract factories significantly streamlines
+the deployment process, allowing for the creation of multiple instances of a
+contract, like the `CrowdfundingCampaign`, with varied parameters.
+- **Scalability and Management:** Contract factories offer a scalable solution to manage
+numerous contract instances, enhancing project organization and efficiency.
+- **Event-Driven Insights:** The `CampaignCreated` event in the factory contract provides
+a transparent mechanism to track each crowdfunding campaign's deployment, useful for
+off-chain monitoring and interaction.
+
+## Next steps
+
+With the contract factory in your zkSync development arsenal, you're set to elevate
+your smart contract projects. Here's how you can further your journey:
+
+- **Contract Testing:** Progress to the next guide focused on testing your contracts.
+Ensuring the reliability and security of your `CrowdfundingCampaign` through
+comprehensive tests is critical.
+- **Advanced zkSync Integrations:** Explore deeper into zkSync's ecosystem by
+implementing features like account abstraction and paymasters to enhance user
+experience and contract flexibility.
+- **Community Engagement and Contribution:** Join the vibrant zkSync community.
+Participate in forums, Discord, or GitHub discussions. Sharing insights, asking queries,
+and contributing can enrich the ecosystem and your understanding of zkSync.
diff --git a/content/10.quick-start/3.testing.md b/content/10.quick-start/3.testing.md
new file mode 100644
index 00000000..f8df6cae
--- /dev/null
+++ b/content/10.quick-start/3.testing.md
@@ -0,0 +1,60 @@
+---
+title: Testing
+description: Learn to test smart contracts efficiently in the zkSync environment.
+---
+
+Welcome back to our Quickstart Series, your fast-track to zkSync development! In this
+third guide, we transition from deploying and managing contracts to the critical phase
+of testing. This guide will walk you through the steps to ensure your `CrowdfundingCampaign`
+contracts, introduced in our first guide and efficiently deployed through contract factories
+in the second, work flawlessly.
+
+:check-icon Elevating your zkSync toolkit with robust contract testing techniques.
+
+:check-icon Crafting comprehensive tests for your `CrowdfundingCampaign` to ensure reliability and security.
+
+:check-icon Using Hardhat or Foundry to write and run tests, ensuring your campaigns are ready.
+
+Dive into the world of smart contract testing and solidify the foundation of your zkSync projects.
+
+## Framework selection
+
+Select the framework you want to get started using zkSync Era with.
+
+::content-switcher
+---
+items: [{
+  label: 'Hardhat',
+  partial: '_testing/_hardhat_contract_testing'
+}, {
+  label: 'Foundry',
+  partial: '_testing/_foundry_contract_testing'
+}]
+---
+::
+
+## Takeaways
+
+- **Testing**: Understanding contract testing is important for ensuring the reliability and security of your smart contracts
+on zkSync. Proper testing safeguards against unforeseen errors and vulnerabilities.
+- **Comprehensive Coverage**: Achieving comprehensive test coverage, including both positive and negative testing
+scenarios, is essential for a robust smart contract. This guide emphasized the `contribute` method,
+but testing should encompass all aspects of your contract.
+- **Tooling Efficiency**: Leveraging Hardhat or Foundry for testing provides a streamlined and efficient workflow.
+These tools offer powerful features and plugins, like `@nomicfoundation/hardhat-chai-matchers`,
+that enhance the testing process.
+
+## Next Steps
+
+With a solid foundation in contract testing, you're well-equipped to advance your zkSync
+development journey. Consider the following steps to further your expertise:
+
+- **Upgradeability**: Delve into the next guide focusing on contract upgradability.
+Learning to make your contracts upgradeable will enable you to update and improve your smart contracts
+over time without losing state or funds.
+- **Advanced zkSync Integrations:** Explore deeper into zkSync's ecosystem by
+implementing features like account abstraction and paymasters to enhance user
+experience and contract flexibility.
+- **Community Engagement and Contribution:** Join the vibrant zkSync community.
+Participate in forums, Discord, or GitHub discussions. Sharing insights, asking queries,
+and contributing can enrich the ecosystem and your understanding of zkSync.
diff --git a/content/10.quick-start/4.upgrading.md b/content/10.quick-start/4.upgrading.md
new file mode 100644
index 00000000..90edbf30
--- /dev/null
+++ b/content/10.quick-start/4.upgrading.md
@@ -0,0 +1,61 @@
+---
+title: Upgradability
+description: Learn to make smart contracts upgradeable within the zkSync ecosystem.
+---
+
+Welcome back to our Quickstart Series, the express lane to zkSync development!
+In this fourth installment, we embark on a journey through contract upgradability,
+an important aspect for maintaining and enhancing smart contracts over time. This guide will
+lead you through the strategies and practices for making the `CrowdfundingCampaign` contract,
+introduced in the first guide and brought to life in subsequent guides, **upgradeable**.
+
+:check-icon Harnessing advanced techniques for contract upgradability in zkSync.
+
+:check-icon Implementing upgradeable patterns for the `CrowdfundingCampaign` to ensure long-term adaptability and improvement.
+
+:check-icon Leveraging tools and best practices in zkSync to facilitate seamless contract upgrades.
+
+Begin to understand smart contract evolution and empower your zkSync applications with the
+flexibility of upgradability.
+
+### Select preferred upgrade mechanism
+
+::content-switcher
+---
+items: [{
+  label: 'Transparent',
+  partial: '_upgrading/_transparent_proxy_contract_upgradability'
+}, {
+  label: 'Beacon',
+  partial: '_upgrading/_beacon_proxy_contract_upgradability'
+},
+ {
+  label: 'UUPS',
+  partial: '_upgrading/_uups_contract_upgradability'
+},]
+---
+::
+
+## Takeaways and Next Steps
+
+### Takeaways
+
+- **Upgradability:** The guide highlights the critical aspect of smart contract upgradability, introducing techniques
+for using transparent, beacon, and UUPS proxies.
+This ensures your contracts remain adaptable, allowing for seamless updates to business logic or enhancements in efficiency.
+
+- **Flexibility:** Emphasizing flexibility, the guide demonstrates how upgradable
+contracts maintain continuity of state and fund security, even as underlying
+functionalities evolve. This approach provides a resilient framework for your dApps to grow and adapt over time.
+
+### Next Steps
+
+- **Exploring Paymasters:** Dive into the next guide focused on using paymasters
+with your smart contracts. Paymasters abstract gas payments in transactions,
+offering new models for transaction fee management and enhancing user experience in dApps.
+- **Advanced zkSync Integrations:** Explore deeper into zkSync's ecosystem by
+implementing features like account abstraction and paymasters to enhance user
+experience and contract flexibility.
+- **Community Engagement and Contribution:** Join the vibrant zkSync community.
+Participate in forums, Discord, or GitHub discussions. Sharing insights, asking queries,
+and contributing can enrich the ecosystem and your understanding of zkSync.
diff --git a/content/10.quick-start/5.paymaster.md b/content/10.quick-start/5.paymaster.md
new file mode 100644
index 00000000..63f28dfb
--- /dev/null
+++ b/content/10.quick-start/5.paymaster.md
@@ -0,0 +1,85 @@
+---
+title: Paymaster
+description: Learn how to write and customize your documentation.
+---
+
+WWelcome back to our Quickstart Series on mastering zkSync development! In this guide, we move beyond the basics
+of smart contract deployment and the creation of contract factories to explore the innovative concept of paymasters
+in the zkSync ecosystem. This guide will illuminate the power of paymasters to revolutionize transaction
+fee management and enhance user experiences within your dApps.
+
+:check-icon Delving deeper into zkSync development with the introduction of paymasters.
+
+:check-icon Learning how paymasters can cover transaction fees for your dApp users, enhancing accessibility and user experience.
+
+:check-icon Discovering the flexibility of fee payment with paymasters, including the ability to pay
+fees in ERC20 tokens on zkSync Era, using Hardhat or Foundry.
+
+Embark on this journey to understand how paymasters can add a new layer of functionality and user-friendliness
+to your decentralized applications.
+
+### What are Paymasters?
+
+Paymasters in the zkSync ecosystem represent a groundbreaking approach to handling transaction fees.
+They are special accounts designed to subsidize transaction costs for other accounts, potentially making
+certain transactions free for end-users. This feature is particularly useful for dApp developers looking
+to improve their platform's accessibility and user experience by covering transaction fees on behalf of their users.
+
+### Built-in Paymaster Flows
+
+Paymasters can operate under various flows, some of which may require user interaction, such as setting allowances
+for token swaps. These flows enable paymasters to support a wide range of use cases, from simple fee subsidies
+to more complex scenarios involving ERC20 token exchanges for transaction fees.
+
+- **General Paymaster Flow:** This default flow requires no preliminary actions from users, allowing paymasters
+to interpret transaction data as needed to cover fees.
+  
+- **Approval-Based Paymaster Flow:** For operations requiring user permissions, such as token allowances,
+this flow provides a structured approach. It ensures that user tokens can be seamlessly exchanged for transaction
+fees, subject to user-approved limits.
+
+As we delve into paymasters, remember that while they offer enhanced flexibility for fee management, their
+implementation should always prioritize security and user trust. This guide aims to equip you with the knowledge
+to effectively incorporate paymasters into your zkSync projects, paving the way for more user-friendly and accessible dApps.
+
+## Framework selection
+
+Select the framework you want to get started using zkSync Era with.
+
+::content-switcher
+---
+items: [{
+  label: 'Hardhat',
+  partial: '_deploy_factory/_hardhat_deploy_contract_factory'
+}, {
+  label: 'Foundry',
+  partial: '_deploy_factory/_foundry_deploy_contract_factory'
+}]
+---
+::
+
+## Takeaways
+
+- **Contract Factories:** Utilizing contract factories significantly streamlines
+the deployment process, allowing for the creation of multiple instances of a
+contract, like the `CrowdfundingCampaign`, with varied parameters.
+- **Scalability and Management:** Contract factories offer a scalable solution to manage
+numerous contract instances, enhancing project organization and efficiency.
+- **Event-Driven Insights:** The `CampaignCreated` event in the factory contract provides
+a transparent mechanism to track each crowdfunding campaign's deployment, useful for
+off-chain monitoring and interaction.
+
+## Next steps
+
+With the contract factory in your zkSync development arsenal, you're set to elevate
+your smart contract projects. Here's how you can further your journey:
+
+- **Contract Testing:** Progress to the next guide focused on testing your contracts.
+Ensuring the reliability and security of your `CrowdfundingCampaign` through
+comprehensive tests is critical.
+- **Advanced zkSync Integrations:** Explore deeper into zkSync's ecosystem by
+implementing features like account abstraction and paymasters to enhance user
+experience and contract flexibility.
+- **Community Engagement and Contribution:** Join the vibrant zkSync community.
+Participate in forums, Discord, or GitHub discussions. Sharing insights, asking queries,
+and contributing can enrich the ecosystem and your understanding of zkSync.
diff --git a/content/10.quick-start/6.smart-account.md b/content/10.quick-start/6.smart-account.md
new file mode 100644
index 00000000..ff479b8a
--- /dev/null
+++ b/content/10.quick-start/6.smart-account.md
@@ -0,0 +1,155 @@
+---
+title: Smart Account
+description: Learn how to write and customize your documentation.
+---
+
+This is only a basic example of what you can achieve with [Nuxt UI Pro](https://ui.nuxt.com/pro/guide), you can tweak it
+to match your needs. The template uses several Nuxt modules underneath like [`@nuxt/content`](https://content.nuxt.com)
+for the content, [`@nuxtjs/fontaine`](https://github.com/nuxt-modules/fontaine) and
+[`@nuxtjs/google-fonts`](https://github.com/nuxt-modules/google-fonts) to change the font and
+[`nuxt-og-image`](https://nuxtseo.com/og-image/getting-started/installation) for social previews.
+
+## ::callout
+
+icon: i-heroicons-light-bulb target: \_blank to: [nuxt guide](https://ui.nuxt.com/pro/guide/usage#structure)
+
+---
+
+Learn more on how to customize and structure a Nuxt UI Pro app! ::
+
+## Writing content
+
+You can just start writing `.md` or `.yml` files in the [`content/`](https://content.nuxt.com/usage/content-directory)
+directory to have your pages updated. The navigation will be automatically generated in the left aside and in the mobile
+menu. You will also be able to go through your content with full-text search.
+
+::callout{icon="i-heroicons-light-bulb"} This template relies on a
+[catch-all route](https://nuxt.com/docs/guide/directory-structure/pages#catch-all-route) but you can achieve the same
+thing with the [document-driven mode](https://content.nuxt.com/document-driven/introduction). ::
+
+## App Configuration
+
+In addition to `@nuxt/ui-pro` configuration through the `app.config.ts`, this template lets you customize the `Header`,
+`Footer` and the `Table of contents` components.
+
+### Header
+
+```ts [app.config.ts]
+export default defineAppConfig({
+  header: {
+    // Logo configuration
+    logo: {
+      // Light mode
+      light: {
+        src: '',
+        alt: '',
+        class: '',
+      },
+      // Dark mode
+      dark: {
+        src: '',
+        alt: '',
+        class: '',
+      },
+    },
+    // Show or hide the search bar
+    search: true,
+    // Show or hide the color mode button
+    colorMode: true,
+    // Customize links
+    links: [
+      {
+        icon: 'i-simple-icons-github',
+        to: 'https://github.com/nuxt-ui-pro/docs',
+        target: '_blank',
+        'aria-label': 'Docs template on GitHub',
+      },
+    ],
+  },
+});
+```
+
+### Footer
+
+```ts [app.config.ts]
+export default defineAppConfig({
+  footer: {
+    // Update bottom left credits
+    credits: 'Copyright © 2023',
+    // Show or hide the color mode button
+    colorMode: false,
+    // Customize links
+    links: [
+      {
+        icon: 'i-simple-icons-nuxtdotjs',
+        to: 'https://nuxt.com',
+        target: '_blank',
+        'aria-label': 'Nuxt Website',
+      },
+      {
+        icon: 'i-simple-icons-discord',
+        to: 'https://discord.com/invite/ps2h6QT',
+        target: '_blank',
+        'aria-label': 'Nuxt UI on Discord',
+      },
+      {
+        icon: 'i-simple-icons-x',
+        to: 'https://x.com/nuxt_js',
+        target: '_blank',
+        'aria-label': 'Nuxt on X',
+      },
+      {
+        icon: 'i-simple-icons-github',
+        to: 'https://github.com/nuxt/ui',
+        target: '_blank',
+        'aria-label': 'Nuxt UI on GitHub',
+      },
+    ],
+  },
+});
+```
+
+### Table of contents
+
+```ts [app.config.ts]
+export default defineAppConfig({
+  toc: {
+    // Title of the main table of contents
+    title: 'Table of Contents',
+    // Bottom TOC configuration
+    bottom: {
+      // Title of the bottom table of contents
+      title: 'Community',
+      // URL of your repository content folder
+      edit: '',
+      // Customize links
+      links: [
+        {
+          icon: 'i-heroicons-star',
+          label: 'Star on GitHub',
+          to: 'https://github.com/nuxt/ui',
+          target: '_blank',
+        },
+        {
+          icon: 'i-heroicons-book-open',
+          label: 'Nuxt UI Pro docs',
+          to: 'https://ui.nuxt.com/pro/guide',
+          target: '_blank',
+        },
+        {
+          icon: 'i-simple-icons-nuxtdotjs',
+          label: 'Purchase a license',
+          to: 'https://ui.nuxt.com/pro/purchase',
+          target: '_blank',
+        },
+      ],
+    },
+  },
+});
+```
+
+icon: i-heroicons-light-bulb target: \_blank to: [app-config](https://nuxt.studio/docs/developers/app-config)
+
+---
+
+A dedicated interface is provided to edit those configurations on Nuxt Studio. ::
diff --git a/content/10.quick-start/_deploy_factory/_foundry_deploy_contract_factory.md b/content/10.quick-start/_deploy_factory/_foundry_deploy_contract_factory.md
new file mode 100644
index 00000000..fb87cea9
--- /dev/null
+++ b/content/10.quick-start/_deploy_factory/_foundry_deploy_contract_factory.md
@@ -0,0 +1,163 @@
+---
+title: Foundry | Deploy Contract Factory
+---
+
+`foundry-zksync` is a specialized fork of Foundry, tailored for zkSync.
+It extends Foundry's capabilities for Ethereum app development to support zkSync,
+allowing for the compilation, deployment, testing, and interaction with smart contracts on zkSync.
+
+::callout{icon="i-heroicons-information-circle-16-solid" color="amber"}
+`foundry-zksync` is still in an alpha stage, so some features might not be fully supported
+yet and may not work as fully intended. It is open-sourced and contributions are welcomed.
+::
+
+<!-- TODO: @dutterbutter 
+Need to update to include prerequisite of Foundry installation
+This should be a simple curl request but needs to be setup by devops  -->
+## Step 1: Setting up environment
+:display-partial{path = "/_partials/_environment-setup-with-foundry"}
+
+## Step 2: Set up wallet
+
+Deploying contracts on the zkSync Sepolia testnet requires having testnet ETH.
+If you're working within the local development environment,
+you can utilize pre-configured rich wallets and skip this step.
+For testnet deployments, follow these steps to secure your funds:
+
+:display-partial{path = "/_partials/_setting-up-your-wallet"}
+
+## Step 3: Deploying contract with factory
+
+With our environment and wallet configured, we're set to review the `CrowdfundingFactory.sol`
+contract that is provided during the initialization step in the `/src` directory.
+The `CrowdfundingFactory.sol`contract will be used to deploy multiple instances of
+the `CrowdfundingCampaign.sol` contract from the previous guide.
+
+```solidity
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+// Crowdfunding campaign contract
+import "./CrowdfundingCampaign.sol";
+
+// Factory contract to create and manage crowdfunding campaigns
+contract CrowdfundingFactory {
+    CrowdfundingCampaign[] public campaigns;
+
+    event CampaignCreated(address campaignAddress, uint256 fundingGoal);
+
+    function createCampaign(uint256 fundingGoal) public {
+        CrowdfundingCampaign newCampaign = new CrowdfundingCampaign(fundingGoal);
+        campaigns.push(newCampaign);
+
+        emit CampaignCreated(address(newCampaign), fundingGoal);
+    }
+
+    function getCampaigns() public view returns (CrowdfundingCampaign[] memory) {
+        return campaigns;
+    }
+}
+```
+
+The `CrowdfundingFactory` contract automates the creation and oversight of
+`CrowdfundingCampaign` contracts, each with its distinct funding goals, it features:
+
+- **Campaign Creation**: Utilizes the `createCampaign` method to initiate a new
+`CrowdfundingCampaign` contract. This function takes a `fundingGoal` as an argument,
+deploys a new campaign contract with this goal, and tracks the created campaign in the
+`campaigns` array.
+- **Campaign Tracking**: The `getCampaigns` method offers a view into all the campaigns
+created by the factory, allowing for easy access and management of multiple crowdfunding
+initiatives.
+
+This contract factory approach streamlines the deployment of crowdfunding campaigns,
+making it efficient to launch and manage multiple campaigns concurrently.
+
+### Compile contract
+
+Smart contracts deployed to zkSync must be compiled using our custom compiler.
+For this particular guide we are making use of `zksolc`.
+
+To compile the contracts in the project, run the following command:
+
+```bash
+forge build --zksync
+```
+
+#### Expected Output
+
+Upon successful compilation, you'll receive output detailing the
+`zksolc` and `solc` versions used during compiling and the number
+of Solidity files compiled.
+
+```bash
+[⠒] Compiling...
+[⠃] Compiling 22 files with 0.8.20
+[⠊] Solc 0.8.20 finished in 736.48ms
+Compiler run successful!
+Compiling contracts for zkSync Era with zksolc v1.4.0
+```
+
+The compiled zkEVM artifacts will be located in the `/zkout` folder, and the solc
+artifacts will be located in the `/out` folder.
+
+### Deploy
+
+This section outlines the steps to deploy the `CrowdfundingCampaign` contract using
+our new `CrowdfundingFactory`.
+
+Let's start by deploying the `CrowdfundingFactory` contract. Execute the following
+command:
+
+```bash
+forge create src/CrowdfundFactory.sol:CrowdfundingFactory --factory-deps src/CrowdfundingCampaign.sol:CrowdfundingCampaign --rpc-url zkSyncSepoliaTestnet --chain 300 --private-key <YOUR-PRIVATE-KEY> --zksync
+# To deploy the contract on local in-memory node:
+# forge script script/DeployFactory.s.sol:DeployFactoryAndCreateCampaign --rpc-url inMemoryNode --broadcast --zksync
+```
+
+#### Expected output
+
+Upon a successfull deployment you'll receive details of the deploying address, the contract address,
+and the transaction hash, like so:
+
+```bash
+Deployer: 0x89E0Ff69Cc520b55C9F7Bcd3EAC17e81d9bB8dc2
+Deployed to: 0x607545Fd35ef49d7445555ddFa22938fD4Efb219
+Transaction hash: 0x94e7a97bb64c2bacffbd2a47f3c10021a80156d11082c079046a426c99518d28
+```
+
+Using the `CrowdfundingFactory` contract address let's deploy our `CrowdfundingCampaign`:
+
+```bash
+cast send 0x607545Fd35ef49d7445555ddFa22938fD4Efb219 "createCampaign(uint256)" "1" --rpc-url zkSyncSepoliaTestnet --chain 300 --private-key <YOUR-PRIVATE-KEY>
+# To use the contract factory on local in-memory node:
+# cast send 0x607545Fd35ef49d7445555ddFa22938fD4Efb219 "createCampaign(uint256)" "1" --rpc-url inMemoryNode --chain 260 --private-key <YOUR-PRIVATE-KEY>
+```
+
+#### Expected output
+
+Upon a successfull deployment you'll receive details of the transaction, including the
+contract address of our crowdfunding campaign:
+
+```bash
+blockHash               0x7f8dfcd365b4ba5ac690e94aedb5fdb2bdb5ef12b2ff68672ab58c7a89738161
+blockNumber             1576375
+contractAddress         0x95f83473b88B5599cdB273F976fB3DC66DEA1c1D
+...
+...
+```
+
+**Key Components:**
+
+**Deployment Workflow:**
+
+- Initiates by deploying the `CrowdfundingFactory` through `forge create --zksync`.
+- Using the factory's deployed address to form a `factoryContract` instance,
+facilitating access to the factory's functionalities.
+
+**Initiating Campaigns:**
+
+- Executes the `factoryContract`'s `createCampaign` function to create and deploy a new
+crowdfunding campaign, with the specified funding target.
+
+🌟 Brilliant! Your contract factory and its first crowdfunding campaign are now operational.
diff --git a/content/10.quick-start/_deploy_factory/_hardhat_deploy_contract_factory.md b/content/10.quick-start/_deploy_factory/_hardhat_deploy_contract_factory.md
new file mode 100644
index 00000000..6c140837
--- /dev/null
+++ b/content/10.quick-start/_deploy_factory/_hardhat_deploy_contract_factory.md
@@ -0,0 +1,221 @@
+---
+title: Hardhat | Deploy Contract Factory
+---
+
+Hardhat is an Ethereum development environment, designed for easy smart contract
+development in Solidity. zkSync provides its own plugins which makes working with
+contracts on zkSync simple and efficient.
+
+## Step 1: Setting up environment
+:display-partial{path = "/_partials/_environment-setup-with-zksync-cli"}
+
+## Step 2: Set up wallet
+
+Deploying contracts on the zkSync Sepolia testnet requires having testnet ETH.
+If you're working within the local development environment,
+you can utilize pre-configured rich wallets and skip this step.
+For testnet deployments, follow these steps to secure your funds:
+
+:display-partial{path = "/_partials/_setting-up-your-wallet"}
+
+## Step 3: Deploying contract with factory
+
+With our environment and wallet configured, we're set to review the `CrowdfundingFactory.sol`
+contract that is provided during the initialization step in the `/contracts` directory.
+The `CrowdfundingFactory.sol`contract will be used to deploy multiple instances of
+the `CrowdfundingCampaign.sol` contract from the previous guide.
+
+```solidity
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+// Crowdfunding campaign contract
+import "./CrowdfundingCampaign.sol";
+
+// Factory contract to create and manage crowdfunding campaigns
+contract CrowdfundingFactory {
+    CrowdfundingCampaign[] public campaigns;
+
+    event CampaignCreated(address campaignAddress, uint256 fundingGoal);
+
+    function createCampaign(uint256 fundingGoal) public {
+        CrowdfundingCampaign newCampaign = new CrowdfundingCampaign(fundingGoal);
+        campaigns.push(newCampaign);
+
+        emit CampaignCreated(address(newCampaign), fundingGoal);
+    }
+
+    function getCampaigns() public view returns (CrowdfundingCampaign[] memory) {
+        return campaigns;
+    }
+}
+```
+
+The `CrowdfundingFactory` contract automates the creation and oversight of
+`CrowdfundingCampaign` contracts, each with its distinct funding goals, it features:
+
+- **Campaign Creation**: Utilizes the `createCampaign` method to initiate a new
+`CrowdfundingCampaign` contract. This function takes a `fundingGoal` as an argument,
+deploys a new campaign contract with this goal, and tracks the created campaign in the
+`campaigns` array.
+- **Campaign Tracking**: The `getCampaigns` method offers a view into all the campaigns
+created by the factory, allowing for easy access and management of multiple crowdfunding
+initiatives.
+
+This contract factory approach streamlines the deployment of crowdfunding campaigns,
+making it efficient to launch and manage multiple campaigns concurrently.
+
+### Compile contract
+
+Smart contracts deployed to zkSync must be compiled using our custom compiler.
+For this particular guide we are making use of `zksolc`.
+
+To compile the contracts in the project, run the following command:
+
+::code-group
+
+```bash [yarn]
+yarn compile
+```
+
+```bash [pnpm]
+pnpm run compile
+```
+
+```bash [npm]
+npm run compile
+```
+
+```bash [bun]
+bun run compile
+```
+
+::
+
+#### Expected Output
+
+Upon successful compilation, you'll receive output detailing the
+`zksolc` and `solc` versions used during compiling and the number
+of Solidity files compiled.
+
+```bash
+Compiling contracts for zkSync Era with zksolc v1.4.0 and solc v0.8.17
+Compiling 2 Solidity file
+Successfully compiled 2 Solidity file
+```
+
+The compiled artifacts will be located in the `/artifacts-zk` folder.
+
+### Deploy
+
+This section outlines the steps to deploy the `CrowdfundingCampaign` contract
+using our new `CrowdfundingFactory`.
+
+The deployment script is located at `/deploy/deployUsingFactory.ts`.
+
+```typescript
+import { deployContract, getWallet } from "./utils";
+import { ethers } from "ethers";
+import { HardhatRuntimeEnvironment } from "hardhat/types";
+
+export default async function (hre: HardhatRuntimeEnvironment) {
+  const contractArtifactName = "CrowdfundingFactory";
+  const constructorArguments = [];
+  const crowdfundingFactory = await deployContract(contractArtifactName, constructorArguments);
+
+  console.log(`🏭 CrowdfundingFactory address: ${crowdfundingFactory.target}`);
+  
+  const contractArtifact = await hre.artifacts.readArtifact("CrowdfundingFactory");
+  const factoryContract = new ethers.Contract(
+    crowdfundingFactory.target,
+    contractArtifact.abi,
+    getWallet()
+  );
+
+  // Define funding goal for the campaign, e.g., 0.1 ether
+  const fundingGoalInWei = ethers.parseEther('0.1').toString();
+
+  // Use the factory to create a new CrowdfundingCampaign
+  const createTx = await factoryContract.createCampaign(fundingGoalInWei);
+  await createTx.wait();
+
+  // Retrieve the address of the newly created CrowdfundingCampaign
+  const campaigns = await factoryContract.getCampaigns();
+  const newCampaignAddress = campaigns[campaigns.length - 1];
+
+  console.log(`🚀 New CrowdfundingCampaign deployed at: ${newCampaignAddress}`);
+  console.log('✅ Deployment and campaign creation complete!');
+}
+```
+
+**Key Components:**
+
+**Deployment Workflow:**
+
+- Initiates by deploying the `CrowdfundingFactory` through `deployContract`.
+- Using the factory's deployed address to form a `factoryContract` instance,
+facilitating access to the factory's functionalities.
+
+**Initiating Campaigns:**
+
+- Executes the `factoryContract`'s `createCampaign` function to create and deploy a new
+crowdfunding campaign, with the specified funding target.
+
+#### Deploy factory
+
+Execute the deployment command corresponding to your package manager. The default command
+deploys to the configured network in your Hardhat setup. For local deployment, append
+`--network inMemoryNode` to deploy to the local in-memory node running.
+
+::code-group
+
+```bash [yarn]
+yarn hardhat deploy-zksync --script deployUsingFactory.ts
+# To deploy the contract on local in-memory node:
+# yarn hardhat deploy-zksync --script deployUsingFactory.ts --network inMemoryNode
+```
+
+```bash [pnpm]
+pnpm run hardhat deploy-zksync --script deployUsingFactory.ts
+# To deploy the contract on local in-memory node:
+# pnpm run hardhat deploy-zksync --script deployUsingFactory.ts --network inMemoryNode
+```
+
+```bash [npm]
+npm run hardhat deploy-zksync --script deployUsingFactory.ts
+# To deploy the contract on local in-memory node:
+# npm run hardhat deploy-zksync --script deployUsingFactory.ts --network inMemoryNode
+```
+
+```bash [bun]
+bun run hardhat deploy-zksync --script deployUsingFactory.ts
+# To deploy the contract on local in-memory node:
+# bun run hardhat deploy-zksync --script deployUsingFactory.ts --network inMemoryNode
+```
+
+::
+
+#### Expected Output
+
+Upon successful deployment, you'll receive output detailing the deployment process,
+including the contract address, source, and encoded constructor arguments:
+
+```bash
+Starting deployment process of "CrowdfundingFactory"...
+Estimated deployment cost: 0.0002500236 ETH
+
+"CrowdfundingFactory" was successfully deployed:
+ - Contract address: 0xD084EF36f8F5353f70498cD84cb8D2B844C120a8
+ - Contract source: contracts/CrowdfundFactory.sol:CrowdfundingFactory
+ - Encoded constructor arguments: 0x
+
+Requesting contract verification...
+Your verification ID is: 10097
+Contract successfully verified on zkSync block explorer!
+🏭 CrowdfundingFactory address: 0xD084EF36f8F5353f70498cD84cb8D2B844C120a8
+🚀 New CrowdfundingCampaign deployed at: 0x060B748eC3512795E94045c406CFd5877DD84e4D
+✅ Deployment and campaign creation complete!
+```
+
+🌟 Brilliant! Your contract factory and its first crowdfunding campaign are now
+operational.
diff --git a/content/10.quick-start/_dir.yml b/content/10.quick-start/_dir.yml
new file mode 100644
index 00000000..f29ef524
--- /dev/null
+++ b/content/10.quick-start/_dir.yml
@@ -0,0 +1,2 @@
+title: Quickstart
+layout: docs
diff --git a/content/10.quick-start/_index/_foundry_deploy_contract.md b/content/10.quick-start/_index/_foundry_deploy_contract.md
new file mode 100644
index 00000000..631a7dea
--- /dev/null
+++ b/content/10.quick-start/_index/_foundry_deploy_contract.md
@@ -0,0 +1,174 @@
+---
+title: Foundry | Deploy Contract
+---
+
+`foundry-zksync` is a specialized fork of Foundry, tailored for zkSync.
+It extends Foundry's capabilities for Ethereum app development to support zkSync,
+allowing for the compilation, deployment, testing, and interaction with smart contracts on zkSync.
+
+::callout{icon="i-heroicons-information-circle-16-solid" color="amber"}
+`foundry-zksync` is still in an alpha stage, so some features might not be fully supported
+yet and may not work as fully intended. It is open-sourced and contributions are welcomed.
+::
+
+<!-- TODO: @dutterbutter 
+Need to update to include prerequisite of Foundry installation
+This should be a simple curl request but needs to be setup by devops  -->
+## Step 1: Setting up environment
+:display-partial{path = "/_partials/_environment-setup-with-foundry"}
+
+## Step 2: Set up wallet
+
+Deploying contracts on the zkSync Sepolia testnet requires having testnet ETH.
+If you're working within the local development environment,
+you can utilize pre-configured rich wallets and skip this step.
+For testnet deployments, follow these steps to secure your funds:
+
+:display-partial{path = "/_partials/_setting-up-your-wallet"}
+
+## Step 3: Deploying your first contract
+
+With our environment and wallet configured, we're set to deploy our first contract. This guide
+introduces a crowdfunding campaign contract aimed at supporting Zeek's inventive ventures
+Let's start by reviewing the starter contract in the `src/` directory.
+
+```solidity
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+contract CrowdfundingCampaign {
+    address public owner;
+    uint256 public fundingGoal;
+    uint256 public totalFundsRaised;
+    mapping(address => uint256) public contributions;
+
+    event ContributionReceived(address contributor, uint256 amount);
+    event GoalReached(uint256 totalFundsRaised);
+
+    constructor(uint256 _fundingGoal) {
+        owner = msg.sender;
+        fundingGoal = _fundingGoal;
+    }
+
+    function contribute() public payable {
+        require(msg.value > 0, "Contribution must be greater than 0");
+        contributions[msg.sender] += msg.value;
+        totalFundsRaised += msg.value;
+
+        emit ContributionReceived(msg.sender, msg.value);
+
+        if (totalFundsRaised >= fundingGoal) {
+            emit GoalReached(totalFundsRaised);
+        }
+    }
+
+    function withdrawFunds() public {
+        require(msg.sender == owner, "Only the owner can withdraw funds");
+        require(totalFundsRaised >= fundingGoal, "Funding goal not reached");
+
+        uint256 amount = address(this).balance;
+        totalFundsRaised = 0;
+
+        (bool success, ) = payable(owner).call{value: amount}("");
+        require(success, "Transfer failed.");
+    }
+
+    function getTotalFundsRaised() public view returns (uint256) {
+        return totalFundsRaised;
+    }
+
+    function getFundingGoal() public view returns (uint256) {
+        return fundingGoal;
+    }
+}
+```
+
+The `CrowdfundingCampaign` contract is designed for project crowdfunding.
+Owned and deployed with a set funding goal, it features:
+
+- A constructor to initialize the campaign's funding target.
+- The `contribute` method to log funds, triggering `ContributionReceived` and `GoalReached` events.
+- The `withdrawFunds` method, allowing the owner to collect accumulated funds post-goal achievement.
+
+### Compile contract
+
+Smart contracts deployed to zkSync must be compiled using our custom compiler.
+For this particular guide we are making use of `zksolc`.
+
+To compile the contracts in the project, run the following command:
+
+```bash
+forge build --zksync
+```
+
+#### Expected Output
+
+Upon successful compilation, you'll receive output detailing the
+`zksolc` and `solc` versions used during compiling and the number
+of Solidity files compiled.
+
+```bash
+[⠒] Compiling...
+[⠃] Compiling 2 files with 0.8.20
+[⠊] Solc 0.8.20 finished in 736.48ms
+Compiler run successful!
+Compiling contracts for zkSync Era with zksolc v1.4.0
+```
+
+The compiled zkEVM artifacts will be located in the `/zkout` folder, and the solc artifacts will be
+located in the `/out` folder.
+
+### Deploy
+
+This section outlines the steps to deploy the `CrowdfundingCampaign` contract.
+The deployment script is located at `/script/Deploy.s.sol`.
+
+```solidity
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.13;
+
+import "forge-std/Script.sol";
+import "../src/Crowdfund.sol";
+
+contract DeployCrowdfundContract is Script {
+    function run() external {
+        uint256 deployerPrivateKey = vm.envUint("WALLET_PRIVATE_KEY");
+        vm.startBroadcast(deployerPrivateKey);
+
+        uint256 fundingGoalInWei = 0.02 ether;
+        new CrowdfundingCampaign(fundingGoalInWei);
+
+        vm.stopBroadcast();
+    }
+}
+```
+
+**Key Components:**
+
+- **contractArtifactName:** Identifies the `CrowdfundingCampaign` contract for deployment.
+- **constructorArguments:** Sets initialization parameters for the contract.
+
+#### Deploy contract
+
+Execute the deployment command.
+
+```bash
+forge script script/Deploy.s.sol:DeployCrowdfundContract --rpc-url zkSyncSepoliaTestnet --broadcast --zksync
+# To deploy the contract on local in-memory node:
+# forge script script/Deploy.s.sol:DeployCrowdfundContract --rpc-url inMemoryNode --broadcast --zksync
+```
+
+#### Expected Output
+
+Upon successful deployment, you'll receive output detailing the deployment process,
+including the contract address, transaction hash, and block number deployed to:
+
+```bash
+...
+✅  [Success]Hash: 0x69f5f1f0f5b3fa12ed2fbab4d6bb6edc02bbfff2f8c414d8171cc8295250296c
+Contract Address: 0xB0C0d3d02c270b6ABe4862EA90bBa1Af192314a8
+Block: 1491370
+Paid: 0.0001168854 ETH (1168854 gas * 0.1 gwei)
+```
+
+🥳 Congratulations! Your smart contract is now deployed. 🚀
diff --git a/content/10.quick-start/_index/_hardhat_deploy_contract.md b/content/10.quick-start/_index/_hardhat_deploy_contract.md
new file mode 100644
index 00000000..c1af302f
--- /dev/null
+++ b/content/10.quick-start/_index/_hardhat_deploy_contract.md
@@ -0,0 +1,202 @@
+---
+title: Hardhat | Deploy Contract
+---
+
+Hardhat is an Ethereum development environment, designed for easy smart contract development in Solidity.
+zkSync provides its own plugins which makes working with contracts on zkSync simple and efficient.
+
+## Step 1: Setting up environment
+:display-partial{path = "/_partials/_environment-setup-with-zksync-cli"}
+
+## Step 2: Set up wallet
+
+Deploying contracts on the zkSync Sepolia testnet requires having testnet ETH.
+If you're working within the local development environment,
+you can utilize pre-configured rich wallets and skip this step.
+For testnet deployments, follow these steps to secure your funds:
+
+:display-partial{path = "/_partials/_setting-up-your-wallet"}
+
+## Step 3: Deploying your first contract
+
+With our environment and wallet configured, we're set to deploy our first contract. This guide
+introduces a crowdfunding campaign contract aimed at supporting Zeek's inventive ventures
+Let's start by reviewing the starter contract in the `contracts/` directory.
+
+```solidity
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+contract CrowdfundingCampaign {
+    address public owner;
+    uint256 public fundingGoal;
+    uint256 public totalFundsRaised;
+    mapping(address => uint256) public contributions;
+
+    event ContributionReceived(address contributor, uint256 amount);
+    event GoalReached(uint256 totalFundsRaised);
+
+    constructor(uint256 _fundingGoal) {
+        owner = msg.sender;
+        fundingGoal = _fundingGoal;
+    }
+
+    function contribute() public payable {
+        require(msg.value > 0, "Contribution must be greater than 0");
+        contributions[msg.sender] += msg.value;
+        totalFundsRaised += msg.value;
+
+        emit ContributionReceived(msg.sender, msg.value);
+
+        if (totalFundsRaised >= fundingGoal) {
+            emit GoalReached(totalFundsRaised);
+        }
+    }
+
+    function withdrawFunds() public {
+        require(msg.sender == owner, "Only the owner can withdraw funds");
+        require(totalFundsRaised >= fundingGoal, "Funding goal not reached");
+
+        uint256 amount = address(this).balance;
+        totalFundsRaised = 0;
+
+        (bool success, ) = payable(owner).call{value: amount}("");
+        require(success, "Transfer failed.");
+    }
+
+    function getTotalFundsRaised() public view returns (uint256) {
+        return totalFundsRaised;
+    }
+
+    function getFundingGoal() public view returns (uint256) {
+        return fundingGoal;
+    }
+}
+```
+
+The `CrowdfundingCampaign` contract is designed for project crowdfunding.
+Owned and deployed with a set funding goal, it features:
+
+- A constructor to initialize the campaign's funding target.
+- The `contribute` method to log funds, triggering `ContributionReceived` and `GoalReached` events.
+- The `withdrawFunds` method, allowing the owner to collect accumulated funds post-goal achievement.
+
+### Compile contract
+
+Smart contracts deployed to zkSync must be compiled using our custom compiler.
+For this particular guide we are making use of `zksolc`.
+
+To compile the contracts in the project, run the following command:
+
+::code-group
+
+```bash [yarn]
+yarn compile
+```
+
+```bash [pnpm]
+pnpm run compile
+```
+
+```bash [npm]
+npm run compile
+```
+
+```bash [bun]
+bun run compile
+```
+
+::
+
+#### Expected Output
+
+Upon successful compilation, you'll receive output detailing the
+`zksolc` and `solc` versions used during compiling and the number
+of Solidity files compiled.
+
+```bash
+Compiling contracts for zkSync Era with zksolc v1.4.0 and solc v0.8.17
+Compiling 1 Solidity file
+Successfully compiled 1 Solidity file
+```
+
+The compiled artifacts will be located in the `/artifacts-zk` folder.
+
+### Deploy
+
+This section outlines the steps to deploy the `CrowdfundingCampaign` contract.
+The deployment script is located at `/deploy/deploy.ts`.
+
+```typescript
+import { deployContract } from "./utils";
+import { ethers } from "ethers";
+
+// An example of a basic deploy script
+// It will deploy a CrowdfundingCampaign contract to selected network
+// `parseEther` converts ether to wei, and `.toString()` ensures serialization compatibility.
+export default async function () {
+  const contractArtifactName = "CrowdfundingCampaign";
+  const constructorArguments = [ethers.parseEther('.02').toString()];
+  await deployContract(contractArtifactName, constructorArguments);
+}
+```
+
+**Key Components:**
+
+- **contractArtifactName:** Identifies the `CrowdfundingCampaign` contract for deployment.
+- **constructorArguments:** Sets initialization parameters for the contract. In this case,
+the fundraising goal, converted from ether to `wei` to match Solidity's `uint256` type.
+
+#### Deploy contract
+Execute the deployment command corresponding to your package manager. The default command
+deploys to the configured network in your Hardhat setup. For local deployment, append
+`--network inMemoryNode` to deploy to the local in-memory node running.
+
+::code-group
+
+```bash [yarn]
+yarn hardhat deploy-zksync --script deploy.ts
+# To deploy the contract on local in-memory node:
+# yarn hardhat deploy-zksync --script deploy.ts --network inMemoryNode
+```
+
+```bash [pnpm]
+pnpm run hardhat deploy-zksync --script deploy.ts
+# To deploy the contract on local in-memory node:
+# pnpm run hardhat deploy-zksync --script deploy.ts --network inMemoryNode
+```
+
+```bash [npm]
+npm run hardhat deploy-zksync --script deploy.ts
+# To deploy the contract on local in-memory node:
+# npm run hardhat deploy-zksync --script deploy.ts --network inMemoryNode
+```
+
+```bash [bun]
+bun run hardhat deploy-zksync --script deploy.ts
+# To deploy the contract on local in-memory node:
+# bun run hardhat deploy-zksync --script deploy.ts --network inMemoryNode
+```
+
+::
+
+#### Expected Output
+
+Upon successful deployment, you'll receive output detailing the deployment process,
+including the contract address, source, and encoded constructor arguments:
+
+```bash
+Starting deployment process of "CrowdfundingCampaign"...
+Estimated deployment cost: 0.000501 ETH
+
+"CrowdfundingCampaign" was successfully deployed:
+ - Contract address: 0x4E3404F21b29d069539e15f8f9E712CeAE39d90C
+ - Contract source: contracts/Crowdfund.sol:CrowdfundingCampaign
+ - Encoded constructor arguments: 0x00000000000000000000000000000000000000000000000000470de4df820000
+
+Requesting contract verification...
+Your verification ID is: 10067
+Contract successfully verified on zkSync block explorer!
+```
+
+🥳 Congratulations! Your smart contract is now deployed. 🚀
diff --git a/content/10.quick-start/_paymasters/_approval_paymaster_flow.md b/content/10.quick-start/_paymasters/_approval_paymaster_flow.md
new file mode 100644
index 00000000..6597b458
--- /dev/null
+++ b/content/10.quick-start/_paymasters/_approval_paymaster_flow.md
@@ -0,0 +1,22 @@
+---
+title: Approval Paymaster
+description: Learn to deploy contract factories in the zkSync environment.
+---
+
+## Step 1: Setting up environment
+:display-partial{path = "/_partials/_environment-setup-with-zksync-cli"}
+
+## Step 2: Set up wallet
+
+Deploying contracts on the zkSync Sepolia testnet requires having testnet ETH.
+If you're working within the local development environment,
+you can utilize pre-configured rich wallets and skip this step.
+For testnet deployments, follow these steps to secure your funds:
+
+:display-partial{path = "/_partials/_environment-setup-with-zksync-cli"}
+
+## Step 3: Understanding ApprovalPaymaster contract
+
+## Step 4: Deploying ApprovalPaymaster contract
+
+## Step 5: Interacting with ApprovalPaymaster contract
diff --git a/content/10.quick-start/_paymasters/_general_paymaster_flow copy.md b/content/10.quick-start/_paymasters/_general_paymaster_flow copy.md
new file mode 100644
index 00000000..e69de29b
diff --git a/content/10.quick-start/_paymasters/_general_paymaster_flow.md b/content/10.quick-start/_paymasters/_general_paymaster_flow.md
new file mode 100644
index 00000000..086363f6
--- /dev/null
+++ b/content/10.quick-start/_paymasters/_general_paymaster_flow.md
@@ -0,0 +1,22 @@
+---
+title: General Paymaster
+description: Learn to deploy contract factories in the zkSync environment.
+---
+
+## Step 1: Setting up environment
+:display-partial{path = "/_partials/_environment-setup-with-zksync-cli"}
+
+## Step 2: Set up wallet
+
+Deploying contracts on the zkSync Sepolia testnet requires having testnet ETH.
+If you're working within the local development environment,
+you can utilize pre-configured rich wallets and skip this step.
+For testnet deployments, follow these steps to secure your funds:
+
+:display-partial{path = "/_partials/_environment-setup-with-zksync-cli"}
+
+## Step 3: Understanding GeneralPaymaster contract
+
+## Step 4: Deploying GeneralPaymaster contract
+
+## Step 5: Interacting with GeneralPaymaster contract
diff --git a/content/10.quick-start/_testing/_foundry_contract_testing.md b/content/10.quick-start/_testing/_foundry_contract_testing.md
new file mode 100644
index 00000000..6d006d7d
--- /dev/null
+++ b/content/10.quick-start/_testing/_foundry_contract_testing.md
@@ -0,0 +1,215 @@
+---
+title: Hardhat | Contract Testing
+---
+
+`foundry-zksync` is a specialized fork of Foundry, tailored for zkSync.
+It extends Foundry's capabilities for Ethereum app development to support zkSync,
+allowing for the compilation, deployment, testing, and interaction with smart contracts on zkSync.
+
+::callout{icon="i-heroicons-information-circle-16-solid" color="amber"}
+`foundry-zksync` is still in an alpha stage, so some features might not be fully supported
+yet and may not work as fully intended. It is open-sourced and contributions are welcomed.
+::
+
+## Step 1: Environment Configuration
+:display-partial{path = "/_partials/_environment-setup-with-foundry"}
+
+## Step 2: Testing `CrowdfundingCampaign` contract
+
+Now that our setup is complete, it's time to focus on the core of this
+guide - testing our `CrowdfundingCampaign.sol` contract. Here's a quick
+refresher on its structure:
+
+```solidity
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+contract CrowdfundingCampaign {
+    address public owner;
+    uint256 public fundingGoal;
+    uint256 public totalFundsRaised;
+    mapping(address => uint256) public contributions;
+
+    event ContributionReceived(address contributor, uint256 amount);
+    event GoalReached(uint256 totalFundsRaised);
+
+    constructor(uint256 _fundingGoal) {
+        owner = msg.sender;
+        fundingGoal = _fundingGoal;
+    }
+
+    function contribute() public payable {
+        require(msg.value > 0, "Contribution must be greater than 0");
+        contributions[msg.sender] += msg.value;
+        totalFundsRaised += msg.value;
+
+        emit ContributionReceived(msg.sender, msg.value);
+
+        if (totalFundsRaised >= fundingGoal) {
+            emit GoalReached(totalFundsRaised);
+        }
+    }
+
+    function withdrawFunds() public {
+        require(msg.sender == owner, "Only the owner can withdraw funds");
+        require(totalFundsRaised >= fundingGoal, "Funding goal not reached");
+
+        uint256 amount = address(this).balance;
+        totalFundsRaised = 0;
+
+        (bool success, ) = payable(owner).call{value: amount}("");
+        require(success, "Transfer failed.");
+    }
+
+    function getTotalFundsRaised() public view returns (uint256) {
+        return totalFundsRaised;
+    }
+
+    function getFundingGoal() public view returns (uint256) {
+        return fundingGoal;
+    }
+}
+```
+
+Thorough testing involves scrutinizing every function and aspect of our contract,
+including potential failure scenarios. In this guide, we'll focus in on the `contribute`
+method to ensure it's tested.
+
+As a challenge to hone your testing skills further,
+consider devising additional tests for the `withdrawFunds`, `getTotalFundsRaised`,
+and `getFundingGoal` methods, expanding your test coverage and reinforcing the
+reliability of the contract.
+
+### Compile contract
+
+Smart contracts deployed to zkSync must be compiled using our custom compiler.
+For this particular guide we are making use of `zksolc`.
+
+To compile the contracts in the project, run the following command:
+
+```bash
+forge build --zksync
+```
+
+#### Expected Output
+
+Upon successful compilation, you'll receive output detailing the
+`zksolc` and `solc` versions used during compiling and the number
+of Solidity files compiled.
+
+```bash
+[⠒] Compiling...
+[⠃] Compiling 22 files with 0.8.20
+[⠊] Solc 0.8.20 finished in 736.48ms
+Compiler run successful!
+Compiling contracts for zkSync Era with zksolc v1.4.0
+```
+
+The compiled zkEVM artifacts will be located in the `/zkout` folder, and the solc artifacts will be
+located in the `/out` folder.
+
+### Testing
+
+This section describes the testing `CrowdfundingCampaign.sol` contract. Let's
+start by reviewing the tests for `CrowdfundingCampaign.sol` contract provided
+during the initialization step in the `/test` directory, specifically the
+`CrowdfundingCampaign.t.sol` file.
+
+```solidity
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "forge-std/Test.sol";
+import "forge-std/console.sol";
+import "../src/CrowdfundingCampaign.sol";
+
+contract CrowdfundingCampaignTest is Test {
+    CrowdfundingCampaign campaign;
+    event GoalReached(uint256 totalFundsRaised);
+    address owner;
+    address addr1;
+    address addr2;
+
+    function setUp() public {
+        owner = address(this);
+        
+        addr1 = vm.addr(1);
+        addr2 = vm.addr(2);
+
+        campaign = new CrowdfundingCampaign(1 ether);
+        console.log("CrowdfundingCampaign deployed at: %s", address(campaign));
+    }
+
+    function test_RejectZeroContributions() public {
+        vm.expectRevert("Contribution must be greater than 0");
+        campaign.contribute{value: 0}();
+    }
+
+    function test_AggregateContributions() public {
+        uint256 initialTotal = campaign.getTotalFundsRaised();
+
+        vm.prank(addr1);
+        vm.deal(addr1, 2 ether);
+        campaign.contribute{value: 0.5 ether}();
+
+        vm.prank(addr2);
+        vm.deal(addr2, 2 ether);
+        campaign.contribute{value: 0.3 ether}();
+
+        assertEq(campaign.getTotalFundsRaised(), initialTotal + 0.8 ether);
+    }
+
+    function test_EmitGoalReachedWhenFundingGoalMet() public {    
+        vm.prank(addr1);
+        vm.deal(addr1, 2 ether);
+        vm.expectEmit(true, true, false, true);
+        emit GoalReached(1 ether);
+        campaign.contribute{value: 1 ether}();        
+    }
+}
+
+```
+
+**Testing Workflow:**
+
+- **Environment Setup**: Leverages Foundry's `Test` contract and setup functions
+to prepare the test environment, ensuring a fresh state for each test case.
+- **Deployment and Address Simulation**: Deploys the `CrowdfundingCampaign` contract
+within the test setup and simulates addresses using Foundry's `vm.addr()` function for
+various test actors.
+
+**`contribute` Method Tests:**
+
+- **Zero Contribution Validation**: Asserts that the contract rejects contribution
+attempts with zero value, testing the contract's input validation logic.
+- **Contribution Aggregation**: Confirms the contract's ability to correctly tally
+contributions from various addresses, ensuring accurate tracking of the total funds raised.
+- **Event Emission Upon Goal Achievement**: Utilizes Foundry's `vm.expectEmit` to
+anticipate the `GoalReached` event when the funding goal is met, validating the
+contract's event logic and state transitions.
+
+#### Execute tests
+
+Execute the test command:
+
+```bash
+forge test --zksync
+```
+
+#### Expected Output
+
+Upon completion, the test suite will provide a summary of all executed tests,
+indicating their success or failure:
+
+```bash
+Ran 3 tests for test/CrowdfundingCampaign.t.sol:CrowdfundingCampaignTest
+[PASS] test_AggregateContributions() (gas: 29204)
+[PASS] test_EmitGoalReachedWhenFundingGoalMet() (gas: 18862)
+[PASS] test_RejectZeroContributions() (gas: 8148)
+Suite result: ok. 3 passed; 0 failed; 0 skipped; finished in 44.03ms (43.94ms CPU time)
+
+Ran 1 test suite in 48.11ms (44.03ms CPU time): 3 tests passed, 0 failed, 0 skipped (3 total tests)
+```
+
+🎉 Congratulations! The `contribute` method of the `CrowdfundingCampaign` contract
+has been thoroughly tested and is ready for action.
diff --git a/content/10.quick-start/_testing/_hardhat_contract_testing.md b/content/10.quick-start/_testing/_hardhat_contract_testing.md
new file mode 100644
index 00000000..ff442e3e
--- /dev/null
+++ b/content/10.quick-start/_testing/_hardhat_contract_testing.md
@@ -0,0 +1,263 @@
+---
+title: Hardhat | Contract Testing
+---
+
+Hardhat is an Ethereum development environment, designed for easy smart contract development in Solidity.
+zkSync provides its own plugins which makes working with contracts on zkSync simple and efficient.
+
+## Step 1: Environment Configuration
+While setting up a local development environment was previously optional, testing contracts requires
+a more structured setup. We'll use `hardhat-zksync` to run tests against an In-memory node,
+which operates seamlessly within a separate process for an optimized testing workflow.
+Kickstart the project setup for this guide with the following command:
+
+<!-- TODO: consult with Danil about best approach here with zkSync-cli usage -->
+```sh
+npx zksync-cli@latest —template zksync-quickstart
+```
+
+Within the `hardhat.config.ts`, you'll observe the `zksync` flag set to `true` under the
+`hardhat` network, indicating the integration with zkSync's testing environment.
+
+```ts
+ hardhat: {
+      zksync: true,
+    },
+```
+
+To use the In-memory node for testing, ensure the `hardhat` network is selected with
+the `zksync` flag enabled. This setup initiates the node alongside your tests and ensures
+it terminates once testing is complete. The node's port allocation starts at the default
+`8011`, facilitating smooth and isolated test execution.
+
+Secondly within the `hardhat.config.ts`, you'll observe the importing of
+`@nomicfoundation/hardhat-chai-matchers`. This plugin provides Hardhat with an extended
+suite of assertion methods tailored for contract testing, significantly improving the testing
+toolkit available for your project.
+
+```typescript
+import "@nomicfoundation/hardhat-chai-matchers";
+```
+
+## Step 2: Test Wallet Configuration
+
+For testing purposes, we have the luxury of using pre-configured, well-funded wallets.
+Throughout this testing guide, we will leverage the following pre-configured wallet,
+eliminating the need for manual funding or setup:
+
+| Account Address                              | Private Key                                                          |
+| -------------------------------------------- | -------------------------------------------------------------------- |
+| `0x36615Cf349d7F6344891B1e7CA7C72883F5dc049` | `0x7726827caac94a7f9e1b160f7ea819f172f7b6f9d2a97f992c38edeab82d4110` |
+
+This streamlined approach allows us to focus on writing and running effective tests.
+
+## Step 3: Testing `CrowdfundingCampaign` contract
+
+Now that our setup is complete, it's time to focus on the core of this
+guide - testing our `CrowdfundingCampaign.sol` contract. Here's a quick
+refresher on its structure:
+
+```solidity
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+contract CrowdfundingCampaign {
+    address public owner;
+    uint256 public fundingGoal;
+    uint256 public totalFundsRaised;
+    mapping(address => uint256) public contributions;
+
+    event ContributionReceived(address contributor, uint256 amount);
+    event GoalReached(uint256 totalFundsRaised);
+
+    constructor(uint256 _fundingGoal) {
+        owner = msg.sender;
+        fundingGoal = _fundingGoal;
+    }
+
+    function contribute() public payable {
+        require(msg.value > 0, "Contribution must be greater than 0");
+        contributions[msg.sender] += msg.value;
+        totalFundsRaised += msg.value;
+
+        emit ContributionReceived(msg.sender, msg.value);
+
+        if (totalFundsRaised >= fundingGoal) {
+            emit GoalReached(totalFundsRaised);
+        }
+    }
+
+    function withdrawFunds() public {
+        require(msg.sender == owner, "Only the owner can withdraw funds");
+        require(totalFundsRaised >= fundingGoal, "Funding goal not reached");
+
+        uint256 amount = address(this).balance;
+        totalFundsRaised = 0;
+
+        (bool success, ) = payable(owner).call{value: amount}("");
+        require(success, "Transfer failed.");
+    }
+
+    function getTotalFundsRaised() public view returns (uint256) {
+        return totalFundsRaised;
+    }
+
+    function getFundingGoal() public view returns (uint256) {
+        return fundingGoal;
+    }
+}
+```
+
+Thorough testing involves scrutinizing every function and aspect of our contract,
+including potential failure scenarios. In this guide, we'll focus in on the `contribute`
+method to ensure it's tested.
+
+As a challenge to hone your testing skills further,
+consider devising additional tests for the `withdrawFunds`, `getTotalFundsRaised`,
+and `getFundingGoal` methods, expanding your test coverage and reinforcing the
+reliability of the contract.
+
+### Compile contract
+
+Smart contracts deployed to zkSync must be compiled using our custom compiler.
+For this particular guide we are making use of `zksolc`.
+
+To compile the contracts in the project, run the following command:
+
+::code-group
+
+```bash [yarn]
+yarn compile
+```
+
+```bash [pnpm]
+pnpm run compile
+```
+
+```bash [npm]
+npm run compile
+```
+
+```bash [bun]
+bun run compile
+```
+
+::
+
+#### Expected Output
+
+Upon successful compilation, you'll receive output detailing the
+`zksolc` and `solc` versions used during compiling and the number
+of Solidity files compiled.
+
+```bash
+Compiling contracts for zkSync Era with zksolc v1.4.0 and solc v0.8.17
+Compiling 2 Solidity file
+Successfully compiled 2 Solidity file
+```
+
+The compiled artifacts will be located in the `/artifacts-zk` folder.
+
+### Testing
+
+This section describes testing `CrowdfundingCampaign.sol` contract. Let's
+start by reviewing the tests for `CrowdfundingCampaign.sol` contract provided
+during the initialization step in the `/tests` directory, specifically the
+`crowdFunding.test.ts` file.
+
+```typescript
+import { expect } from "chai";
+import { ethers } from "hardhat";
+import { getWallet, LOCAL_RICH_WALLETS, deployContract } from "../deploy/utils";
+
+describe("CrowdfundingCampaign", function () {
+  let campaign;
+  let owner, addr1, addr2;
+
+  beforeEach(async function () {
+    owner = getWallet(LOCAL_RICH_WALLETS[0].privateKey);
+    addr1 = getWallet(LOCAL_RICH_WALLETS[1].privateKey);
+    addr2 = getWallet(LOCAL_RICH_WALLETS[2].privateKey);
+    const fundingGoalInWei = ethers.parseEther('1').toString();
+    campaign = await deployContract("CrowdfundingCampaign", [fundingGoalInWei], { wallet: owner, silent: true });
+  });
+
+  describe("Contribute", function () {
+    it("should reject contributions of 0", async function () {
+      await expect(campaign.connect(addr1).contribute({ value: ethers.parseEther("0") })).to.be.revertedWith("Contribution must be greater than 0");
+    });
+
+    it("should aggregate contributions in totalFundsRaised", async function () {
+      await campaign.connect(addr1).contribute({ value: ethers.parseEther("0.5") });
+      await campaign.connect(addr2).contribute({ value: ethers.parseEther("0.3") });
+      expect(await campaign.getTotalFundsRaised()).to.equal(ethers.parseEther("0.8"));
+    });
+
+    it("should emit GoalReached event when funding goal is met", async function () {
+      await expect(campaign.connect(addr1).contribute({ value: ethers.parseEther("1") }))
+        .to.emit(campaign, "GoalReached")
+        .withArgs(ethers.parseEther("1"));
+    });
+  });
+});
+```
+
+**Key Components:**
+
+**Testing Workflow:**
+
+- **Initialization**: Each test case initializes with fresh contract instances and predefined
+rich wallet accounts to simulate various contributors and the contract owner.
+- **Deployment**: The `CrowdfundingCampaign` contract is deployed using the `deployContract`
+utility, setting a specific funding goal for each test scenario.
+
+**`contribute` Method Tests:**
+
+- **Zero Contributions**: Verifies that the contract correctly rejects contribution attempts with
+zero value, ensuring the integrity of the contribution process.
+- **Funds Aggregation**: Tests the contract's ability to accurately aggregate contributions from
+multiple addresses and update the `totalFundsRaised` accordingly.
+- **Goal Achievement**: Checks for the `GoalReached` event emission upon meeting the funding goal,
+confirming the contract's responsiveness to achieving its set target.
+
+#### Execute tests
+Execute the test command corresponding to your package manager:
+
+::code-group
+
+```bash [yarn]
+yarn hardhat test --network hardhat
+```
+
+```bash [pnpm]
+pnpm run hardhat test --network hardhat
+```
+
+```bash [npm]
+npm run hardhat test --network hardhat
+```
+
+```bash [bun]
+bun run hardhat test --network hardhat
+```
+
+::
+
+#### Expected Output
+
+Upon completion, the test suite will provide a summary of all executed tests,
+indicating their success or failure:
+
+```bash
+  CrowdfundingCampaign
+    Contribute
+      ✔ should reject contributions of 0 (45ms)
+      ✔ should aggregate contributions in totalFundsRaised (213ms)
+      ✔ should emit GoalReached event when funding goal is met (113ms)
+
+
+  3 passing (1s)
+```
+
+🎉 Congratulations! The `contribute` method of the `CrowdfundingCampaign` contract
+has been thoroughly tested and is ready for action.
diff --git a/content/10.quick-start/_upgrading/_beacon/_foundry_beacon_contract_upgradability.md b/content/10.quick-start/_upgrading/_beacon/_foundry_beacon_contract_upgradability.md
new file mode 100644
index 00000000..6876ce71
--- /dev/null
+++ b/content/10.quick-start/_upgrading/_beacon/_foundry_beacon_contract_upgradability.md
@@ -0,0 +1,5 @@
+---
+title: Foundry | Contract Upgrade
+---
+
+Coming soon!
diff --git a/content/10.quick-start/_upgrading/_beacon/_hardhat_beacon_contract_upgradability.md b/content/10.quick-start/_upgrading/_beacon/_hardhat_beacon_contract_upgradability.md
new file mode 100644
index 00000000..dbb7863c
--- /dev/null
+++ b/content/10.quick-start/_upgrading/_beacon/_hardhat_beacon_contract_upgradability.md
@@ -0,0 +1,429 @@
+---
+title: Hardhat | Contract Upgrading
+---
+
+Hardhat is an Ethereum development environment, designed for easy smart contract development in Solidity.
+zkSync provides its own plugins which makes working with contracts on zkSync simple and efficient.
+
+## Step 1: Setting up environment
+:display-partial{path = "/_partials/_environment-setup-with-zksync-cli"}
+
+## Step 2: Set up wallet
+
+Deploying contracts on the zkSync Sepolia testnet requires having testnet ETH.
+If you're working within the local development environment,
+you can utilize pre-configured rich wallets and skip this step.
+For testnet deployments, follow these steps to secure your funds:
+
+:display-partial{path = "/_partials/_setting-up-your-wallet"}
+
+## Step 3: Adapting `CrowdfundingCampaign.sol` contract for upgradability
+
+To adapt our `CrowdfundingCampaign.sol` contract for upgradability, we are
+transitioning to a proxy pattern. This approach separates the
+contract's logic (which can be upgraded) from its persistent state
+(stored in the proxy).
+
+### Refactoring for Proxy Compatibility
+
+We're refactoring the contract to initialize state variables through an
+`initialize` function instead of the constructor, in line with the
+proxy pattern.
+
+**Updated Contract Structure:**
+
+```solidity
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "@openzeppelin/contracts/proxy/utils/Initializable.sol";
+
+contract CrowdfundingCampaign is Initializable {
+    address public owner;
+    uint256 public fundingGoal;
+    mapping(address => uint256) public contributions;
+
+    event ContributionReceived(address contributor, uint256 amount);
+    event GoalReached(uint256 totalFundsRaised);
+
+    // Remove constructor in favour of initialize method
+    function initialize(uint256 _fundingGoal) public initializer {
+        owner = msg.sender;
+        fundingGoal = _fundingGoal;
+    }
+
+    function contribute() public payable {
+        // contribution logic remains the same
+    }
+
+    function withdrawFunds() public {
+        // withdrawFunds logic remains the same
+    }
+
+    function getTotalFundsRaised() public view returns (uint256) {
+        // getTotalFundsRaised remains the same
+    }
+
+    function getFundingGoal() public view returns (uint256) {
+        // getFundingGoal remains the same
+    }
+}
+```
+
+**Key Modifications:**
+
+- **Initializable**: Inherits from OpenZeppelin's `Initializable` to ensure the `initialize` function
+can only be called once, similar to a constructor.
+- **Initialize Function**: Replaces the constructor for setting initial state, facilitating upgrades
+through new logic contracts.
+- **Transparent Proxy Pattern**: Utilizes a proxy contract to delegate calls to this logic contract,
+allowing for future upgrades without losing the contract's state.
+
+This restructuring prepares the `CrowdfundingCampaign` contract for upgradeability.
+
+## Step 4: Deploy the `CrowdfundingCampaign` contract
+
+This initial deployment sets the stage for future upgrades, enabling us
+to iterate on the contract's functionality without starting from scratch.
+As modifications have been made to the contract to support upgradability,
+a fresh compilation is necessary to reflect these changes in the deployment artifact.
+
+To compile the contracts in the project, run the following command:
+
+::code-group
+
+```bash [yarn]
+yarn compile
+```
+
+```bash [pnpm]
+pnpm run compile
+```
+
+```bash [npm]
+npm run compile
+```
+
+```bash [bun]
+bun run compile
+```
+
+::
+
+#### Expected Output
+
+Upon successful compilation, you'll receive output detailing the
+`zksolc` and `solc` versions used during compiling and the number
+of Solidity files compiled.
+
+```bash
+Compiling contracts for zkSync Era with zksolc v1.4.0 and solc v0.8.17
+Compiling 1 Solidity file
+Successfully compiled 1 Solidity file
+```
+
+The compiled artifacts will be located in the `/artifacts-zk` folder.
+
+### Deploy
+
+This guide details the process for deploying the upgraded `CrowdfundingCampaign`
+contract, now enhanced with upgradability features.
+You'll find the necessary deployment script at `/deploy/deployBeaconProxy.ts`.
+
+```typescript
+import { getWallet } from "./utils";
+import { Deployer } from '@matterlabs/hardhat-zksync';
+import { ethers } from "ethers";
+import { HardhatRuntimeEnvironment } from "hardhat/types";
+
+export default async function (hre: HardhatRuntimeEnvironment) {
+    const wallet = getWallet();
+    const deployer = new Deployer(hre, wallet);
+
+    const contractArtifact = await deployer.loadArtifact("CrowdfundingCampaign");
+    const fundingGoalInWei = ethers.parseEther('0.1').toString();
+
+    const beacon = await hre.zkUpgrades.deployBeacon(
+        getWallet(),
+        contractArtifact
+    );
+    await beacon.waitForDeployment();
+
+    const crowdfunding = await hre.zkUpgrades.deployBeaconProxy(deployer.zkWallet, 
+        await beacon.getAddress(), contractArtifact, [fundingGoalInWei]);
+    await crowdfunding.waitForDeployment();
+}
+```
+
+**Key Components:**
+
+- **`deployBeacon` Method:** Initiates the deployment of a beacon contract,
+which acts as a central point for managing future upgrades of the `CrowdfundingCampaign`
+contract. The beacon's address is a critical component as it links the deployed proxy
+to the actual contract logic.
+
+- **`deployBeaconProxy` Method:** This step involves deploying the beacon proxy,
+which serves as the user-facing contract instance. It references the beacon for its logic,
+allowing for seamless upgrades without altering the proxy's address.
+The `fundingGoalInWei parameter`, converted from ether to wei, is passed during
+this step to initialize the contract with a funding goal.
+
+#### Deploy contract
+Execute the deployment command corresponding to your package manager. The default command
+deploys to the configured network in your Hardhat setup. For local deployment, append
+`--network inMemoryNode` to deploy to the local in-memory node running.
+
+::code-group
+
+```bash [yarn]
+yarn hardhat deploy-zksync --script deployBeaconProxy.ts
+# To deploy the contract on local in-memory node:
+# yarn hardhat deploy-zksync --script deployBeaconProxy.ts --network inMemoryNode
+```
+
+```bash [pnpm]
+pnpm run hardhat deploy-zksync --script deployBeaconProxy.ts
+# To deploy the contract on local in-memory node:
+# pnpm run hardhat deploy-zksync --script deployBeaconProxy.ts --network inMemoryNode
+```
+
+```bash [npm]
+npm run hardhat deploy-zksync --script deployBeaconProxy.ts
+# To deploy the contract on local in-memory node:
+# npm run hardhat deploy-zksync --script deployBeaconProxy.ts --network inMemoryNode
+```
+
+```bash [bun]
+bun run hardhat deploy-zksync --script deployBeaconProxy.ts
+# To deploy the contract on local in-memory node:
+# bun run hardhat deploy-zksync --script deployBeaconProxy.ts --network inMemoryNode
+```
+
+::
+
+#### Expected Output
+
+Upon successful deployment, you'll receive output detailing the deployment process,
+including the contract addresses of the implementation
+contract, the admin contract, and the beacon
+proxy contract.
+
+```bash
+Beacon impl deployed at 0xE3F814fa915A75bA47230537726C99f6517Da58e
+Beacon deployed at:  0x26410Bebf5Df7398DCBC5f00e9EBBa0Ddf471C72
+Beacon proxy deployed at:  0xD58FA9Fb362Abf69cFc68A3545fD227165DAc167
+```
+
+## Step 5: Upgrading the `CrowdfundingCampaign` Contract
+
+With our initial setup deployed, we're ready to upgrade our `CrowdfundingCampaign.sol`
+contract by incorporating a deadline for contributions. This addition not only brings
+a new layer of functionality but also introduces the concept of time-based conditions
+through a `modifier`.
+
+**Current Contract Overview:**
+
+The existing version of our contract allows for open-ended contributions towards a
+funding goal, without any time constraints.
+
+**Proposed Upgrade:**
+
+We're introducing a `deadline` variable, initialized at contract deployment, to establish a
+clear timeframe for accepting contributions. The `withinDeadline` modifier will then enforce
+this constraint, ensuring contributions are made within the allowed period.
+
+**Enhanced Contract:**
+
+The upgraded contract, `CrowdfundingCampaignV2.sol`, located in the `/contracts` directory,
+incorporates these changes:
+
+- **Deadline Variable:** A new state variable deadline defines the campaign's end time,
+enhancing the contract with time-based logic.
+
+- **Initialization Logic:** An additional initialization method, `initializeV2`, sets the deadline
+based on a duration provided during the upgrade. This function ensures that the upgrade is
+backward-compatible and maintains the contract's integrity.
+
+- **Contribution Logic with Deadline:** The `contribute` method now includes a `withinDeadline` modifier,
+ensuring all contributions are made within the set timeframe.
+
+- **Deadline Enforcement:** The `withinDeadline` modifier checks the current time against the deadline,
+safeguarding the contract from late contributions.
+
+**Deadline Extension Capability:**
+
+To provide flexibility, a new function allows the owner to extend the deadline,
+offering adaptability to changing campaign needs.
+
+```solidity
+function extendDeadline(uint256 _newDuration) public {
+    require(msg.sender == owner, "Only the owner can extend the deadline");
+    deadline = block.timestamp + _newDuration;
+}
+```
+
+This upgrade not only introduces the element of time to the campaign but also
+exemplifies the use of `modifiers` for enforcing contract conditions.
+
+### Compile contract
+
+:display-partial{path = "/_partials/_compile-solidity-contracts"}
+
+#### Expected Output
+
+Upon successful compilation, you'll receive output detailing the
+`zksolc` and `solc` versions used during compiling and the number
+of Solidity files compiled.
+
+```bash
+Compiling contracts for zkSync Era with zksolc v1.4.0 and solc v0.8.17
+Compiling 2 Solidity file
+Successfully compiled 2 Solidity file
+```
+
+The compiled artifacts will be located in the `/artifacts-zk` folder.
+
+### Upgrading to `CrowdfundingCampaignV2`
+
+This section describes the initiating the upgrade to `CrowdfundingCampaignV2.sol` contract. Let's
+start by reviewing the `upgradeBeaconCrowdfundingCampaign.ts` script in the `deploy/upgrade-scripts` directory:
+
+```typescript
+import { getWallet } from "../utils";
+import { Deployer } from '@matterlabs/hardhat-zksync';
+import { HardhatRuntimeEnvironment } from "hardhat/types";
+import * as zk from 'zksync-ethers';
+import { Contract } from 'ethers';
+
+export default async function (hre: HardhatRuntimeEnvironment) {
+    const wallet = getWallet();
+    const deployer = new Deployer(hre, wallet);
+
+    // Placeholder for the deployed beacon address
+    const beaconAddress = 'YOUR_BEACON_ADDRESS_HERE';
+    
+    const contractV2Artifact = await deployer.loadArtifact('CrowdfundingCampaignV2');
+
+    // Upgrade the proxy to V2
+    await hre.zkUpgrades.upgradeBeacon(deployer.zkWallet, beaconAddress, contractV2Artifact);
+
+    console.log('Successfully upgraded crowdfundingCampaign to crowdfundingCampaignV2');
+
+    const attachTo = new zk.ContractFactory<any[], Contract>(
+        crowdfundingCampaignV2.abi,
+        crowdfundingCampaignV2.bytecode,
+        deployer.zkWallet,
+        deployer.deploymentType,
+    );
+    
+    // Placeholder for the deployed beacon proxy address
+    const proxyAddress = 'YOUR_PROXY_ADDRESS_HERE';
+
+    const upgradedContract  = attachTo.attach(proxyAddress);
+
+    upgradedContract.connect(deployer.zkWallet);
+    // wait some time before the next call
+    await new Promise((resolve) => setTimeout(resolve, 2000));
+
+    // Initialize V2 with a new campaign duration
+    const durationInSeconds = 30 * 24 * 60 * 60; // For example, setting a 30-day duration
+    const initTx = await upgradedContract.initializeV2(durationInSeconds);
+    const receipt = await initTx.wait();
+
+   console.log(`CrowdfundingCampaignV2 initialized. Transaction Hash: ${receipt.hash}`);
+}
+```
+
+Ensure to replace `YOUR_BEACON_ADDRESS_HERE` with the address of your deployed beacon and
+`YOUR_PROXY_ADDRESS_HERE` with the actual address of your
+deployed Beacon Proxy from the previous deployment step.
+
+**Key Components:**
+
+- **`upgradeBeacon`**: This method from the `hre.zkUpgrades` module is used to update the beacon contract
+with the new version of the contract logic, `CrowdfundingCampaignV2`.
+It ensures that all proxies pointing to this beacon will now execute the updated contract code.
+- **`initializeV2`:** This method is specifically called post-upgrade to initialize or reconfigure any new state
+variables or logic introduced in the `CrowdfundingCampaignV2`.
+Here, it's used to set a new campaign duration, seamlessly
+integrating new functionalities while retaining the existing contract state and funds.
+
+#### Upgrade contract
+Execute the test command corresponding to your package manager:
+
+::code-group
+
+```bash [yarn]
+yarn hardhat deploy-zksync --script upgrade-scripts/upgradeBeaconCrowdfundingCampaign.ts
+```
+
+```bash [pnpm]
+pnpm run hardhat deploy-zksync --script upgrade-scripts/upgradeBeaconCrowdfundingCampaign.ts
+```
+
+```bash [npm]
+npm run hardhat deploy-zksync --script upgrade-scripts/upgradeBeaconCrowdfundingCampaign.ts
+```
+
+```bash [bun]
+bun run hardhat deploy-zksync --script upgrade-scripts/upgradeBeaconCrowdfundingCampaign.ts
+```
+
+::
+
+#### Expected Output
+
+Upon successful deployment, you'll receive output detailing the upgrade process,
+including the new beacon address, and transaction hash:
+
+```bash
+New beacon impl deployed at 0x58BD5adb462CF087E5838d53aE38A3Fe0EAf7A31
+Successfully upgraded crowdfundingCampaign to crowdfundingCampaignV2 0x26410Bebf5Df7398DCBC5f00e9EBBa0Ddf471C72
+CrowdfundingCampaignV2 initialized! 0x5f3131c77fcac19390f5f644a3ad1f0e7719dee4b4b5b4746c992de00db743f7
+Fundraising goal: 100000000000000000
+```
+
+## Step 6: Verify upgradable contracts
+
+For the verification of our upgradable contracts, it's essential to utilize the proxy address that was specified in our
+upgrade script.
+
+To proceed with verification, execute the following command:
+
+::code-group
+
+```bash [yarn]
+yarn hardhat verify <BEACON-PROXY-ADDRESS>
+```
+
+```bash [pnpm]
+pnpm run hardhat verify <BEACON-PROXY-ADDRESS>
+```
+
+```bash [npm]
+npm run hardhat verify <BEACON-PROXY-ADDRESS>
+```
+
+```bash [bun]
+bun run hardhat verify <BEACON-PROXY-ADDRESS>
+```
+
+::
+
+#### Expected Output
+
+Upon successful verification, you'll receive output detailing the verification process:
+
+```bash
+Verifying implementation: 0x58BD5adb462CF087E5838d53aE38A3Fe0EAf7A31
+Your verification ID is: 10547
+Contract successfully verified on zkSync block explorer!
+Verifying beacon: 0x26410Bebf5Df7398DCBC5f00e9EBBa0Ddf471C72
+Your verification ID is: 10548
+Contract successfully verified on zkSync block explorer!
+Verifying beacon proxy: 0xD58FA9Fb362Abf69cFc68A3545fD227165DAc167
+Your verification ID is: 10549
+Contract successfully verified on zkSync block explorer!
+```
+
+🎉 Congratulations! The `CrowdfundingCampaignV2` contract has been upgraded and verified!
diff --git a/content/10.quick-start/_upgrading/_beacon_proxy_contract_upgradability.md b/content/10.quick-start/_upgrading/_beacon_proxy_contract_upgradability.md
new file mode 100644
index 00000000..b10318f1
--- /dev/null
+++ b/content/10.quick-start/_upgrading/_beacon_proxy_contract_upgradability.md
@@ -0,0 +1,32 @@
+---
+title: Beacon Proxy Contract Upgradeability
+---
+
+### What is a beacon proxy upgradeable contract?
+Beacon Proxy Upgradeable Contracts leverage a beacon to manage upgrades, allowing
+for centralized logic updates across multiple proxies. The structure includes:
+
+1. **Beacon Contract**: Acts as the central point holding the address of the current logic contract.
+It enables updating the logic for all associated proxies through a single transaction.
+2. **Proxy Contracts**: These lightweight contracts delegate calls to the logic contract address
+provided by the beacon, maintaining their own state and balance.
+3. **Logic Contract**: Contains the executable business logic, which can be updated by changing
+the beacon's reference without altering individual proxies.
+4. **Admin Address**: Authorized to update the logic contract address in the beacon, ensuring controlled and secure upgrades.
+
+This arrangement allows multiple proxy contracts to be upgraded simultaneously by updating
+the logic contract address in the beacon, streamlining the upgrade process. It preserves
+the state and balance of each proxy contract, offering an efficient way to roll out new
+features or fixes while maintaining a uniform interface for users.
+
+::content-switcher
+---
+items: [{
+  label: 'Hardhat',
+  partial: '_upgrading/_beacon/_hardhat_beacon_contract_upgradability'
+}, {
+  label: 'Foundry',
+  partial: '_upgrading/_beacon/_foundry_beacon_contract_upgradability'
+}]
+---
+::
diff --git a/content/10.quick-start/_upgrading/_transparent/_foundry_transparent_contract_upgradability.md b/content/10.quick-start/_upgrading/_transparent/_foundry_transparent_contract_upgradability.md
new file mode 100644
index 00000000..6876ce71
--- /dev/null
+++ b/content/10.quick-start/_upgrading/_transparent/_foundry_transparent_contract_upgradability.md
@@ -0,0 +1,5 @@
+---
+title: Foundry | Contract Upgrade
+---
+
+Coming soon!
diff --git a/content/10.quick-start/_upgrading/_transparent/_hardhat_transparent_contract_upgradability.md b/content/10.quick-start/_upgrading/_transparent/_hardhat_transparent_contract_upgradability.md
new file mode 100644
index 00000000..5408954c
--- /dev/null
+++ b/content/10.quick-start/_upgrading/_transparent/_hardhat_transparent_contract_upgradability.md
@@ -0,0 +1,410 @@
+---
+title: Hardhat | Contract Upgrading
+---
+
+Hardhat is an Ethereum development environment, designed for easy smart contract development in Solidity.
+zkSync provides its own plugins which makes working with contracts on zkSync simple and efficient.
+
+## Step 1: Setting up environment
+:display-partial{path = "/_partials/_environment-setup-with-zksync-cli"}
+
+## Step 2: Set up wallet
+
+Deploying contracts on the zkSync Sepolia testnet requires having testnet ETH.
+If you're working within the local development environment,
+you can utilize pre-configured rich wallets and skip this step.
+For testnet deployments, follow these steps to secure your funds:
+
+:display-partial{path = "/_partials/_environment-setup-with-zksync-cli"}
+
+## Step 3: Adapting `CrowdfundingCampaign.sol` contract for upgradability
+
+To adapt our `CrowdfundingCampaign.sol` contract for upgradability, we're
+transitioning to a proxy pattern. This approach separates the
+contract's logic (which can be upgraded) from its persistent state
+(stored in the proxy).
+
+### Refactoring for Proxy Compatibility
+
+In the `contracts/` directory you'll observe the refactored the contract
+which initializes state variables through an
+`initialize` function instead of the constructor, in line with the
+Transparent Proxy pattern.
+
+**Updated Contract Structure:**
+
+```solidity
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "@openzeppelin/contracts/proxy/utils/Initializable.sol";
+
+contract CrowdfundingCampaign is Initializable {
+    address public owner;
+    uint256 public fundingGoal;
+    mapping(address => uint256) public contributions;
+
+    event ContributionReceived(address contributor, uint256 amount);
+    event GoalReached(uint256 totalFundsRaised);
+
+    // Remove constructor in favour of initialize method
+    function initialize(uint256 _fundingGoal) public initializer {
+        owner = msg.sender;
+        fundingGoal = _fundingGoal;
+    }
+
+    function contribute() public payable {
+        // contribution logic remains the same
+    }
+
+    function withdrawFunds() public {
+        // withdrawFunds logic remains the same
+    }
+
+    function getTotalFundsRaised() public view returns (uint256) {
+        // getTotalFundsRaised remains the same
+    }
+
+    function getFundingGoal() public view returns (uint256) {
+        // getFundingGoal remains the same
+    }
+}
+```
+
+**Key Modifications:**
+
+- **Initializable**: Inherits from OpenZeppelin's `Initializable` to ensure the `initialize` function
+can only be called once, similar to a constructor.
+- **Initialize Function**: Replaces the constructor for setting initial state, facilitating upgrades
+through new logic contracts.
+- **Transparent Proxy Pattern**: Utilizes a proxy contract to delegate calls to this logic contract,
+allowing for future upgrades without losing the contract's state.
+
+This restructuring prepares the `CrowdfundingCampaign` contract for upgradability.
+
+## Step 4: Deploy the `CrowdfundingCampaign` contract
+
+Now that the `CrowdfundingCampaign` contract is adapted for contract upgradability, let's proceed to deploy
+the contract so we may upgrade it in later steps. Since we've made changes to our contract we will
+need to re-compile.
+
+To compile the contracts in the project, run the following command:
+
+::code-group
+
+```bash [yarn]
+yarn compile
+```
+
+```bash [pnpm]
+pnpm run compile
+```
+
+```bash [npm]
+npm run compile
+```
+
+```bash [bun]
+bun run compile
+```
+
+::
+
+#### Expected Output
+
+Upon successful compilation, you'll receive output detailing the
+`zksolc` and `solc` versions used during compiling and the number
+of Solidity files compiled.
+
+```bash
+Compiling contracts for zkSync Era with zksolc v1.4.0 and solc v0.8.17
+Compiling 1 Solidity file
+Successfully compiled 1 Solidity file
+```
+
+The compiled artifacts will be located in the `/artifacts-zk` folder.
+
+### Deploy
+
+This section outlines the steps to deploy the `CrowdfundingCampaign` contract that we recently updated for upgradability.
+The deployment script is located at `/deploy/deployTransparentProxy.ts`.
+
+```typescript
+import { getWallet } from "./utils";
+import { Deployer } from '@matterlabs/hardhat-zksync';
+import { ethers } from "ethers";
+import { HardhatRuntimeEnvironment } from "hardhat/types";
+
+export default async function (hre: HardhatRuntimeEnvironment) {
+    const wallet = getWallet();
+    const deployer = new Deployer(hre, wallet);
+
+    const contractArtifact = await deployer.loadArtifact("CrowdfundingCampaign");
+    const fundingGoalInWei = ethers.parseEther('0.1').toString();
+    // Deploy the contract using a transparent proxy
+    const crowdfunding = await hre.zkUpgrades.deployProxy(
+        getWallet(),
+        contractArtifact,
+        [fundingGoalInWei],
+        { initializer: 'initialize' }
+    );
+
+    await crowdfunding.waitForDeployment();
+}
+```
+
+**Key Components:**
+
+- **`hre.zkUpgrades.deployProxy`**: The method call to deploy the `CrowdfundingCampaign`
+contract via a transparent proxy, leveraging Hardhat's runtime environment for zkSync upgrades.
+This ensures the deployed contract can be upgraded in the future without losing its state or funds.
+- **`initializer`**: Specifies the initialization method of the contract, `initialize` in this case,
+which is required for setting up the proxy's state upon deployment.
+
+#### Deploy contract
+Execute the deployment command corresponding to your package manager. The default command
+deploys to the configured network in your Hardhat setup. For local deployment, append
+`--network inMemoryNode` to deploy to the local in-memory node running.
+
+::code-group
+
+```bash [yarn]
+yarn hardhat deploy-zksync --script deployTransparentProxy.ts
+# To deploy the contract on local in-memory node:
+# yarn hardhat deploy-zksync --script deployTransparentProxy.ts --network inMemoryNode
+```
+
+```bash [pnpm]
+pnpm run hardhat deploy-zksync --script deployTransparentProxy.ts
+# To deploy the contract on local in-memory node:
+# pnpm run hardhat deploy-zksync --script deployTransparentProxy.ts --network inMemoryNode
+```
+
+```bash [npm]
+npm run hardhat deploy-zksync --script deployTransparentProxy.ts
+# To deploy the contract on local in-memory node:
+# npm run hardhat deploy-zksync --script deployTransparentProxy.ts --network inMemoryNode
+```
+
+```bash [bun]
+bun run hardhat deploy-zksync --script deployTransparentProxy.ts
+# To deploy the contract on local in-memory node:
+# bun run hardhat deploy-zksync --script deployTransparentProxy.ts --network inMemoryNode
+```
+
+::
+
+#### Expected Output
+
+Upon successful deployment, you'll receive output detailing the deployment process,
+including the contract addresses of the implementation
+contract, the admin contract, and the transparent
+proxy contract.
+
+```bash
+Implementation contract was deployed to 0xE3F814fa915A75bA47230537726C99f6517Da58e
+Admin was deployed to 0x05198D9f93cBDfa3e332776019115512d8e0c809
+Transparent proxy was deployed to 0x68E8533acE01019CB8D07Eca822369D5De71b74D
+```
+
+## Step 5: Upgrading the `CrowdfundingCampaign` Contract
+
+With our initial setup deployed, we're ready to upgrade our `CrowdfundingCampaign.sol`
+contract by incorporating a deadline for contributions. This addition not only brings
+a new layer of functionality but also introduces the concept of time-based conditions
+through a `modifier`.
+
+**Current Contract Overview:**
+
+The existing version of our contract allows for open-ended contributions towards a
+funding goal, without any time constraints.
+
+**Proposed Upgrade:**
+
+We're introducing a `deadline` variable, initialized at contract deployment, to establish a
+clear timeframe for accepting contributions. The `withinDeadline` modifier will then enforce
+this constraint, ensuring contributions are made within the allowed period.
+
+**Enhanced Contract:**
+
+The upgraded contract, `CrowdfundingCampaignV2.sol`, located in the `/contracts` directory,
+incorporates these changes:
+
+- **Deadline Variable:** A new state variable deadline defines the campaign's end time,
+enhancing the contract with time-based logic.
+
+- **Initialization Logic:** An additional initialization method, `initializeV2`, sets the deadline
+based on a duration provided during the upgrade. This function ensures that the upgrade is
+backward-compatible and maintains the contract's integrity.
+
+- **Contribution Logic with Deadline:** The `contribute` method now includes a `withinDeadline` modifier,
+ensuring all contributions are made within the set timeframe.
+
+- **Deadline Enforcement:** The `withinDeadline` modifier checks the current time against the deadline,
+safeguarding the contract from late contributions.
+
+**Deadline Extension Capability:**
+
+To provide flexibility, a new function allows the owner to extend the deadline,
+offering adaptability to changing campaign needs.
+
+```solidity
+function extendDeadline(uint256 _newDuration) public {
+    require(msg.sender == owner, "Only the owner can extend the deadline");
+    deadline = block.timestamp + _newDuration;
+}
+```
+
+This upgrade not only introduces the element of time to the campaign but also
+exemplifies the use of `modifiers` for enforcing contract conditions.
+
+### Compile contract
+:display-partial{path = "/_partials/_compile-solidity-contracts"}
+
+#### Expected Output
+
+Upon successful compilation, you'll receive output detailing the
+`zksolc` and `solc` versions used during compiling and the number
+of Solidity files compiled.
+
+```bash
+Compiling contracts for zkSync Era with zksolc v1.4.0 and solc v0.8.17
+Compiling 2 Solidity file
+Successfully compiled 2 Solidity file
+```
+
+The compiled artifacts will be located in the `/artifacts-zk` folder.
+
+### Upgrading to `CrowdfundingCampaignV2`
+
+This section guides you through upgrading the `CrowdfundingCampaign` contract
+to its second version, `CrowdfundingCampaignV2`. Review the `upgradeCrowdfundingCampaign.ts`
+script located within the `deploy/upgrade-scripts` directory to begin.
+
+```typescript
+import { getWallet } from "../utils";
+import { Deployer } from '@matterlabs/hardhat-zksync';
+import { HardhatRuntimeEnvironment } from "hardhat/types";
+
+export default async function (hre: HardhatRuntimeEnvironment) {
+    const wallet = getWallet();
+    const deployer = new Deployer(hre, wallet);
+    
+    // Placeholder for the deployed proxy address
+    const proxyAddress = 'YOUR_PROXY_ADDRESS_HERE';
+    
+    const contractV2Artifact = await deployer.loadArtifact('CrowdfundingCampaignV2');
+
+    // Upgrade the proxy to V2
+    const upgradedContract = await hre.zkUpgrades.upgradeProxy(deployer.zkWallet, proxyAddress, contractV2Artifact);
+
+    console.log('Successfully upgraded crowdfundingCampaign to crowdfundingCampaignV2');
+
+    upgradedContract.connect(deployer.zkWallet);
+    // wait some time before the next call
+    await new Promise((resolve) => setTimeout(resolve, 2000));
+    
+    // Initialize V2 with a new campaign duration
+    const durationInSeconds = 30 * 24 * 60 * 60; // For example, setting a 30-day duration
+    const initTx = await upgradedContract.initializeV2(durationInSeconds);
+    const receipt = await initTx.wait();
+
+    console.log(`CrowdfundingCampaignV2 initialized. Transaction Hash: ${receipt.hash}`);
+}
+```
+
+Ensure to replace `YOUR_PROXY_ADDRESS_HERE` with the actual address of your
+deployed Transparent Proxy from the previous deployment step.
+
+**Key Components:**
+
+- **`upgradeProxy`:** A critical method from the `hre.zkUpgrades` module that
+performs the contract upgrade. It takes the wallet, the proxy address, and the
+new contract artifact as arguments to transition the proxy to use the `CrowdfundingCampaignV2` logic.
+
+- **`initializeV2`:** Post-upgrade, this function is invoked to initialize the new
+variables or logic introduced in `CrowdfundingCampaignV2`. In this example,
+it sets a new campaign duration, illustrating how contract upgrades can add
+functionalities without losing the existing state or funds.
+
+#### Upgrade contract
+Execute the test command corresponding to your package manager:
+
+::code-group
+
+```bash [yarn]
+yarn hardhat deploy-zksync --script upgrade-scripts/upgradeCrowdfundingCampaign.ts
+```
+
+```bash [pnpm]
+pnpm run hardhat deploy-zksync --script upgrade-scripts/upgradeCrowdfundingCampaign.ts
+```
+
+```bash [npm]
+npm run hardhat deploy-zksync --script upgrade-scripts/upgradeCrowdfundingCampaign.ts
+```
+
+```bash [bun]
+bun run hardhat deploy-zksync --script upgrade-scripts/upgradeCrowdfundingCampaign.ts
+```
+
+::
+
+#### Expected Output
+
+Upon successful deployment, you'll receive output detailing the upgrade process,
+including the contract address, and transaction hash:
+
+```bash
+Contract successfully upgraded to 0x58BD5adb462CF087E5838d53aE38A3Fe0EAf7A31 with tx 0xe30c017c52376507ab55bb51bc27eb300832dc46b8b9ac14549d2f9014cee97e
+Successfully upgraded crowdfundingCampaign to crowdfundingCampaignV2
+CrowdfundingCampaignV2 initialized! 0x5adfe360187195d98d3603a82a20ffe7304cd4dec030d1bdf456fa1690879668
+Fundraising goal: 100000000000000000
+```
+
+## Step 6: Verify upgradable contracts
+
+For the verification of our upgradable contracts, it's essential to utilize the proxy address that was specified in our
+upgrade script.
+
+To proceed with verification, execute the following command:
+
+::code-group
+
+```bash [yarn]
+yarn hardhat verify <PROXY-ADDRESS>
+```
+
+```bash [pnpm]
+pnpm run hardhat verify <PROXY-ADDRESS>
+```
+
+```bash [npm]
+npm run hardhat verify <PROXY-ADDRESS>
+```
+
+```bash [bun]
+bun run hardhat verify <PROXY-ADDRESS>
+```
+
+::
+
+Ensure to replace <PROXY_ADDRESS> with the actual proxy address from your deployment.
+
+#### Expected Output
+
+Upon successful verification, you'll receive output detailing the verification process:
+
+```bash
+Verifying implementation: 0x58BD5adb462CF087E5838d53aE38A3Fe0EAf7A31
+Your verification ID is: 10543
+Contract successfully verified on zkSync block explorer!
+Verifying proxy: 0x68E8533acE01019CB8D07Eca822369D5De71b74D
+Your verification ID is: 10544
+Contract successfully verified on zkSync block explorer!
+Verifying proxy admin: 0x05198D9f93cBDfa3e332776019115512d8e0c809
+Your verification ID is: 10545
+Contract successfully verified on zkSync block explorer!
+```
+
+🎉 Congratulations! The `CrowdfundingCampaignV2` contract has been upgraded and verified!
diff --git a/content/10.quick-start/_upgrading/_transparent_proxy_contract_upgradability.md b/content/10.quick-start/_upgrading/_transparent_proxy_contract_upgradability.md
new file mode 100644
index 00000000..70ac46e4
--- /dev/null
+++ b/content/10.quick-start/_upgrading/_transparent_proxy_contract_upgradability.md
@@ -0,0 +1,35 @@
+---
+title: Transparent Upgradeable Proxy Contract
+---
+
+### What is a transparent upgradeable proxy contract?
+Transparent upgradeable contracts utilize the proxy pattern to facilitate post-deployment
+logic updates while preventing accidental function collisions. They consist of:
+
+1. **Proxy Contract**: Manages storage, balance, and delegates calls to the logic contract,
+except for those by the admin, ensuring clear separation between user and administrative interactions.
+2. **Logic Contract**: Houses the actual business logic, upgradeable by swapping out for new versions.
+3. **Admin Address**: Holds the rights to upgrade the logic contract, with its commands executed
+exclusively by the proxy to prevent unintended logic execution.
+
+This setup ensures only non-administrative calls reach the logic contract, allowing
+for safe and seamless upgrades. By switching the logic contract to a newer version
+while keeping the original proxy intact, the contract's state and balance are preserved.
+This facilitates improvements or bug fixes without changing the proxy, maintaining a
+consistent user interface.
+
+## Framework selection
+
+Select the framework you want to get started using zkSync Era with.
+
+::content-switcher
+---
+items: [{
+  label: 'Hardhat',
+  partial: '_upgrading/_transparent/_hardhat_transparent_contract_upgradability'
+}, {
+  label: 'Foundry',
+  partial: '_upgrading/_transparent/_foundry_transparent_contract_upgradability'
+}]
+---
+::
diff --git a/content/10.quick-start/_upgrading/_uups/_foundry_uups_contract_upgradability.md b/content/10.quick-start/_upgrading/_uups/_foundry_uups_contract_upgradability.md
new file mode 100644
index 00000000..6876ce71
--- /dev/null
+++ b/content/10.quick-start/_upgrading/_uups/_foundry_uups_contract_upgradability.md
@@ -0,0 +1,5 @@
+---
+title: Foundry | Contract Upgrade
+---
+
+Coming soon!
diff --git a/content/10.quick-start/_upgrading/_uups/_hardhat_uups_contract_upgradability.md b/content/10.quick-start/_upgrading/_uups/_hardhat_uups_contract_upgradability.md
new file mode 100644
index 00000000..a4d84ad3
--- /dev/null
+++ b/content/10.quick-start/_upgrading/_uups/_hardhat_uups_contract_upgradability.md
@@ -0,0 +1,410 @@
+---
+title: Hardhat | Contract Upgrading
+---
+
+Hardhat is an Ethereum development environment, designed for easy smart contract development in Solidity.
+zkSync provides its own plugins which makes working with contracts on zkSync simple and efficient.
+
+## Step 1: Setting up environment
+:display-partial{path = "/_partials/_environment-setup-with-zksync-cli"}
+
+## Step 2: Set up wallet
+
+Deploying contracts on the zkSync Sepolia testnet requires having testnet ETH.
+If you're working within the local development environment,
+you can utilize pre-configured rich wallets and skip this step.
+For testnet deployments, follow these steps to secure your funds:
+
+:display-partial{path = "/_partials/_setting-up-your-wallet"}
+
+## Step 3: Adapting `CrowdfundingCampaign.sol` for UUPS Upgradability
+
+To align the `CrowdfundingCampaign.sol` contract with UUPS (Universal Upgradeable Proxy Standard) upgradability,
+we're integrating OpenZeppelin's UUPSUpgradeable contracts. This method offers a more secure and gas-efficient
+approach to contract upgrades by embedding the upgrade logic within the contract itself.
+
+### Refactoring for UUPS Compatibility
+
+We've refactored the contract to support UUPS upgradability, ensuring the contract's logic
+is upgradeable while maintaining a persistent state. This is achieved by utilizing initializer
+functions and the UUPS upgrade mechanism.
+
+**UUPS-Enabled Contract Structure:**
+
+```solidity
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+// Import UUPS from OpenZeppelin
+import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
+
+contract CrowdfundingCampaign_UUPS is Initializable, UUPSUpgradeable, OwnableUpgradeable {
+    uint256 public fundingGoal;
+    uint256 public totalFundsRaised;
+    mapping(address => uint256) public contributions;
+
+    event ContributionReceived(address contributor, uint256 amount);
+    event GoalReached(uint256 totalFundsRaised);
+
+    // Initializer function, replaces constructor for upgradeable contracts
+    function initialize(uint256 _fundingGoal) public initializer {
+        __Ownable_init(); // Initialize ownership to the deployer
+        __UUPSUpgradeable_init(); // Initialize UUPS upgradeability
+
+        fundingGoal = _fundingGoal;
+    }
+
+    function contribute() public payable {
+        // Contribution logic remains the same
+    }
+
+    function withdrawFunds() public onlyOwner {
+        // WithdrawFunds logic remains the same
+    }
+
+    function getTotalFundsRaised() public view returns (uint256) {
+        // getTotalFundsRaised remains the same
+    }
+
+    function getFundingGoal() public view returns (uint256) {
+        // getFundingGoal remains the same
+    }
+
+    // Ensure only the owner can upgrade the contract
+    function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}
+}
+```
+
+**Key Adaptations:**
+
+- **Initializable & UUPSUpgradeable**: The contract inherits from `Initializable` and `UUPSUpgradeable`,
+ensuring initialization follows the proxy pattern and enabling the UUPS upgrade mechanism.
+- **OwnableUpgradeable**: Utilizes `OwnableUpgradeable` to manage ownership through an initializer,
+important for secure upgrade authorization.
+- **_authorizeUpgrade**: A safeguard function ensuring only the contract owner can perform upgrades,
+reinforcing the contract's security.
+
+By adopting the UUPS pattern, the `CrowdfundingCampaign_UUPS` contract becomes efficiently upgradeable,
+offering enhanced security and reduced gas costs, setting a solid foundation for future enhancements.
+
+## Step 4: Deploy the `CrowdfundingCampaign` contract
+
+Now that the `CrowdfundingCampaign_UUPS` contract is adapted for contract upgradability, let's proceed to deploy
+the contract so we may upgrade it in later steps. Since we've made changes to our contract we will
+need to re-compile.
+
+To compile the contracts in the project, run the following command:
+
+::code-group
+
+```bash [yarn]
+yarn compile
+```
+
+```bash [pnpm]
+pnpm run compile
+```
+
+```bash [npm]
+npm run compile
+```
+
+```bash [bun]
+bun run compile
+```
+
+::
+
+#### Expected Output
+
+Upon successful compilation, you'll receive output detailing the
+`zksolc` and `solc` versions used during compiling and the number
+of Solidity files compiled.
+
+```bash
+Compiling contracts for zkSync Era with zksolc v1.4.0 and solc v0.8.17
+Compiling 1 Solidity file
+Successfully compiled 1 Solidity file
+```
+
+The compiled artifacts will be located in the `/artifacts-zk` folder.
+
+### Deploy
+
+This section outlines the steps to deploy the `CrowdfundingCampaign_UUPS` contract that we recently updated for
+UUPS upgradability. The deployment script is located at `/deploy/deployUUPS.ts`.
+
+```typescript
+import { getWallet } from "./utils";
+import { Deployer } from '@matterlabs/hardhat-zksync';
+import { ethers } from "ethers";
+import { HardhatRuntimeEnvironment } from "hardhat/types";
+
+export default async function (hre: HardhatRuntimeEnvironment) {
+    const wallet = getWallet();
+    const deployer = new Deployer(hre, wallet);
+
+    const contractArtifact = await deployer.loadArtifact("CrowdfundingCampaign_UUPS");
+    const fundingGoalInWei = ethers.parseEther('0.1').toString();
+
+    const crowdfunding = await hre.zkUpgrades.deployProxy(
+        getWallet(),
+        contractArtifact,
+        [fundingGoalInWei],
+        { initializer: 'initialize' }
+    );
+
+    await crowdfunding.waitForDeployment();
+}
+```
+
+**Key Components:**
+
+- **`deployProxy` Method:** This method is responsible for deploying the `CrowdfundingCampaign`
+contract as a UUPS upgradeable contract. It initializes the contract with the specified parameters,
+such as the `fundingGoalInWei`, ensuring that the contract is ready for immediate use after deployment.
+The use of the UUPS pattern provides a secure and efficient mechanism for future upgrades.
+
+- **`initializer` Option:** Specifies the initialization method of the contract, in this case, `initialize`.
+This is used for setting up the initial state of the contract upon deployment, particularly important
+for upgradeable contracts where constructor usage is not possible.
+
+#### Deploy contract
+Execute the deployment command corresponding to your package manager. The default command
+deploys to the configured network in your Hardhat setup. For local deployment, append
+`--network inMemoryNode` to deploy to the local in-memory node running.
+
+::code-group
+
+```bash [yarn]
+yarn hardhat deploy-zksync --script deployUUPS.ts
+# To deploy the contract on local in-memory node:
+# yarn hardhat deploy-zksync --script deployUUPS.ts --network inMemoryNode
+```
+
+```bash [pnpm]
+pnpm run hardhat deploy-zksync --script deployUUPS.ts
+# To deploy the contract on local in-memory node:
+# pnpm run hardhat deploy-zksync --script deployUUPS.ts --network inMemoryNode
+```
+
+```bash [npm]
+npm run hardhat deploy-zksync --script deployUUPS.ts
+# To deploy the contract on local in-memory node:
+# npm run hardhat deploy-zksync --script deployUUPS.ts --network inMemoryNode
+```
+
+```bash [bun]
+bun run hardhat deploy-zksync --script deployUUPS.ts
+# To deploy the contract on local in-memory node:
+# bun run hardhat deploy-zksync --script deployUUPS.ts --network inMemoryNode
+```
+
+::
+
+#### Expected Output
+
+Upon successful deployment, you'll receive output detailing the deployment process,
+including the contract addresses of the implementation
+contract, the admin contract, and the transparent
+proxy contract.
+
+```bash
+Implementation contract was deployed to 0xF0De77041F3cF6D9C905A10ce59858b17E57E3B9
+UUPS proxy was deployed to 0x56882194aAe8E4B6d18cD84e4D7B0F807e0100Cb
+```
+
+## Step 5: Upgrading the `CrowdfundingCampaign_UUPS` Contract
+
+With our initial setup deployed, we're ready to upgrade our `CrowdfundingCampaign_UUPS.sol`
+contract by incorporating a deadline for contributions. This addition not only brings
+a new layer of functionality but also introduces the concept of time-based conditions
+through a `modifier`.
+
+**Current Contract Overview:**
+
+The existing version of our contract allows for open-ended contributions towards a
+funding goal, without any time constraints.
+
+**Proposed Upgrade:**
+
+We're introducing a `deadline` variable, initialized at contract deployment, to establish a
+clear timeframe for accepting contributions. The `withinDeadline` modifier will then enforce
+this constraint, ensuring contributions are made within the allowed period.
+
+**Enhanced Contract:**
+
+The upgraded contract, `CrowdfundingCampaignV2_UUPS.sol`, located in the `/contracts` directory,
+incorporates these changes:
+
+- **Deadline Variable:** A new state variable deadline defines the campaign's end time,
+enhancing the contract with time-based logic.
+
+- **Initialization Logic:** An additional initialization method, `initializeV2`, sets the deadline
+based on a duration provided during the upgrade. This function ensures that the upgrade is
+backward-compatible and maintains the contract's integrity.
+
+- **Contribution Logic with Deadline:** The `contribute` method now includes a `withinDeadline` modifier,
+ensuring all contributions are made within the set timeframe.
+
+- **Deadline Enforcement:** The `withinDeadline` modifier checks the current time against the deadline,
+safeguarding the contract from late contributions.
+
+**Deadline Extension Capability:**
+
+To provide flexibility, a new function allows the owner to extend the deadline,
+offering adaptability to changing campaign needs.
+
+```solidity
+function extendDeadline(uint256 _newDuration) public {
+    require(msg.sender == owner, "Only the owner can extend the deadline");
+    deadline = block.timestamp + _newDuration;
+}
+```
+
+This upgrade not only introduces the element of time to the campaign but also
+exemplifies the use of `modifiers` for enforcing contract conditions.
+
+### Compile contract
+
+:display-partial{path = "/_partials/_compile-solidity-contracts"}
+
+#### Expected Output
+
+Upon successful compilation, you'll receive output detailing the
+`zksolc` and `solc` versions used during compiling and the number
+of Solidity files compiled.
+
+```bash
+Compiling contracts for zkSync Era with zksolc v1.4.0 and solc v0.8.17
+Compiling 2 Solidity file
+Successfully compiled 2 Solidity file
+```
+
+The compiled artifacts will be located in the `/artifacts-zk` folder.
+
+### Upgrading to `CrowdfundingCampaignV2_UUPS`
+
+This section describes the initiating the upgrade to `CrowdfundingCampaignV2_UUPS.sol` contract.
+Let's start by reviewing the `upgradeUUPSCrowdfundingCampaign.ts` script in the
+`deploy/upgrade-scripts` directory:
+
+```typescript
+import { getWallet } from "../utils";
+import { Deployer } from '@matterlabs/hardhat-zksync';
+import { HardhatRuntimeEnvironment } from "hardhat/types";
+
+export default async function (hre: HardhatRuntimeEnvironment) {
+    const wallet = getWallet();
+    const deployer = new Deployer(hre, wallet);
+
+    // Placeholder for the deployed proxy address
+    const proxyAddress = 'YOUR_PROXY_ADDRESS_HERE';
+    
+    // Upgrade the proxy to V2
+    const contractV2Artifact = await deployer.loadArtifact('CrowdfundingCampaignV2_UUPS');
+    const upgradedContract = await hre.zkUpgrades.upgradeProxy(deployer.zkWallet, proxyAddress, contractV2Artifact);
+    console.log('Successfully upgraded crowdfundingCampaign_UUPS to crowdfundingCampaignV2_UUPS');
+
+    upgradedContract.connect(deployer.zkWallet);
+    // wait some time before the next call
+    await new Promise((resolve) => setTimeout(resolve, 2000));
+    
+    const durationInSeconds = 30 * 24 * 60 * 60; // For example, setting a 30-day duration
+
+    const initTx = await upgradedContract.initializeV2(durationInSeconds);
+    const receipt = await initTx.wait();
+
+    console.log('CrowdfundingCampaignV2_UUPS initialized!', receipt.hash);
+}
+```
+
+Ensure to replace `YOUR_PROXY_ADDRESS_HERE` with the actual address of your
+deployed Transparent Proxy from the previous deployment step.
+
+**Key Components:**
+
+- **`upgradeProxy`:** A critical method from the `hre.zkUpgrades` module that
+performs the contract upgrade. It takes the wallet, the proxy address, and the
+new contract artifact as arguments to transition the proxy to use the `CrowdfundingCampaignV2_UUPS` logic.
+
+- **`initializeV2`:** Post-upgrade, this function is invoked to initialize the new
+variables or logic introduced in `CrowdfundingCampaignV2_UUPS`. In this example,
+it sets a new campaign duration, illustrating how contract upgrades can add
+functionalities without losing the existing state or funds.
+
+#### Upgrade contract
+Execute the test command corresponding to your package manager:
+
+::code-group
+
+```bash [yarn]
+yarn hardhat deploy-zksync --script upgrade-scripts/upgradeUUPSCrowdfundingCampaign.ts
+```
+
+```bash [pnpm]
+pnpm run hardhat deploy-zksync --script upgrade-scripts/upgradeUUPSCrowdfundingCampaign.ts
+```
+
+```bash [npm]
+npm run hardhat deploy-zksync --script upgrade-scripts/upgradeUUPSCrowdfundingCampaign.ts
+```
+
+```bash [bun]
+bun run hardhat deploy-zksync --script upgrade-scripts/upgradeUUPSCrowdfundingCampaign.ts
+```
+
+::
+
+#### Expected Output
+
+Upon successful deployment, you'll receive output detailing the upgrade process,
+including the new beacon address, and transaction hash:
+
+```bash
+Contract successfully upgraded to 0x9BE22706966D717d7b0C8aEC99A1a9d1b3bFeC50 with tx 0x24ad582828b23b98d207ec7c057cd6a9c911bea22dbe85e0affd7479b00d90e9
+Successfully upgraded crowdfundingCampaign_UUPS to crowdfundingCampaignV2_UUPS
+CrowdfundingCampaignV2_UUPS initialized! 0xab959f588b64dc6dee1e94d5fa0da2ae205c7438cf097d26d3ba73690e2b09e8
+```
+
+## Step 6: Verify upgradable contracts
+
+To verify our upgradable contracts we need to the proxy address we previously used in our upgrade script.
+With that execute the following command:
+
+::code-group
+
+```bash [yarn]
+yarn hardhat verify <PROXY-ADDRESS>
+```
+
+```bash [pnpm]
+pnpm run hardhat verify <PROXY-ADDRESS>
+```
+
+```bash [npm]
+npm run hardhat verify <PROXY-ADDRESS>
+```
+
+```bash [bun]
+bun run hardhat verify <PROXY-ADDRESS>
+```
+
+::
+
+#### Expected Output
+
+Upon successful verification, you'll receive output detailing the verification process:
+
+```bash
+Verifying implementation: 0x9BE22706966D717d7b0C8aEC99A1a9d1b3bFeC50
+Your verification ID is: 10618
+Contract successfully verified on zkSync block explorer!
+Verifying proxy: 0x91921fDb0F8942c18eCeE4E3896b369ca0650483
+Your verification ID is: 10619
+Contract successfully verified on zkSync block explorer!
+```
+
+🎉 Congratulations! The `CrowdfundingCampaignV2_UUPS` contract has been upgraded and verified!
diff --git a/content/10.quick-start/_upgrading/_uups_contract_upgradability.md b/content/10.quick-start/_upgrading/_uups_contract_upgradability.md
new file mode 100644
index 00000000..ad252b53
--- /dev/null
+++ b/content/10.quick-start/_upgrading/_uups_contract_upgradability.md
@@ -0,0 +1,33 @@
+---
+title: UUPS Proxy Contract Upgradeability
+---
+
+### What is a UUPS upgradeable contract?
+UUPS (Universal Upgradeable Proxy Standard) Upgradeable Contracts embed the upgrade logic
+within the contract itself, simplifying upgrades and enhancing security. The components are:
+
+1. **Proxy Contract**: Contains minimal logic, primarily delegating calls to the implementation
+contract. Unlike other proxies, it doesn't require a separate upgrade function.
+2. **Implementation Contract**: Houses the business logic and the upgrade functionality,
+enabling the contract to upgrade itself from within.
+3. **Admin Role**: Assigned to an entity with the authority to initiate upgrades, ensuring
+controlled access to the upgrade function.
+
+In UUPS contracts, upgrades are performed by invoking the upgrade function within the
+implementation contract, which updates the proxy's reference to point to a new implementation.
+This self-contained approach minimizes the proxy's complexity and gas costs, while the
+implementation contract's built-in upgrade mechanism ensures only authorized upgrades.
+The contract's state remains intact across upgrades, facilitating continuous improvement
+with a stable user experience.
+
+::content-switcher
+---
+items: [{
+  label: 'Hardhat',
+  partial: '_upgrading/_uups/_hardhat_uups_contract_upgradability'
+}, {
+  label: 'Foundry',
+  partial: '_upgrading/_uups/_foundry_uups_contract_upgradability'
+}]
+---
+::
diff --git a/content/90.contributing-to-documentation/30.documentation-styleguide.md b/content/90.contributing-to-documentation/30.documentation-styleguide.md
index af681990..7312f895 100644
--- a/content/90.contributing-to-documentation/30.documentation-styleguide.md
+++ b/content/90.contributing-to-documentation/30.documentation-styleguide.md
@@ -119,14 +119,14 @@ A callout should not contain anything essential to understanding the main conten
 
 #### Example
 ::callout{icon="i-heroicons-exclamation-triangle" color="amber"}
-This is a `callout` with full **markdown** support. It can be used to link to [another page](/getting-started/installation).
+This is a `callout` with full **markdown** support. It can be used to link to [another page](/quick-start).
 ::
 
 #### Code
 
 ```md
 ::callout{icon="i-heroicons-exclamation-triangle" color="amber"}
-This is a `callout` with full **markdown** support. It can be used to link to [another page](/getting-started/installation).
+This is a `callout` with full **markdown** support. It can be used to link to [another page](/quick-start).
 ::
 ```
 
@@ -180,12 +180,12 @@ in the `ui.icons.collections` property.
 ## Links
 
 Internal links are generated by the `/content` directory structure and the name of the markdown file.
-For example, the file `/content/10.getting-started/20.overview.md` is defined as the path `/getting-started/overview`.
+For example, the file `/content/1.quick-start/2.deploy-contract.md` is defined as the path `/quick-start/deploy-contract`.
 
 Link to internal pages using markdown format.
 
 ```md
-[Getting Started](/getting-started/overview)
+[Getting Started](/quick-start)
 ```
 
 ### Anchor Tags
@@ -195,7 +195,7 @@ Link to the page the anchor point is located in and add
 the name of the anchor tag separated by dashes.
 
 ```md
-[Getting Started](/getting-started/overview#learn-more)
+[Getting Started](/quick-start)
 ```
 
 ### External Links
diff --git a/content/_partials/_compile-solidity-contracts.md b/content/_partials/_compile-solidity-contracts.md
new file mode 100644
index 00000000..edd54343
--- /dev/null
+++ b/content/_partials/_compile-solidity-contracts.md
@@ -0,0 +1,28 @@
+---
+title: Compile Solidity Contract
+---
+
+Smart contracts deployed to zkSync must be compiled using our custom compiler.
+For this particular guide we are making use of `zksolc`.
+
+To compile the contracts in the project, run the following command:
+
+::code-group
+
+```bash [yarn]
+yarn compile
+```
+
+```bash [pnpm]
+pnpm run compile
+```
+
+```bash [npm]
+npm run compile
+```
+
+```bash [bun]
+bun run compile
+```
+
+::
diff --git a/content/_partials/_deploy-contract.md b/content/_partials/_deploy-contract.md
new file mode 100644
index 00000000..7bea2ee7
--- /dev/null
+++ b/content/_partials/_deploy-contract.md
@@ -0,0 +1,19 @@
+---
+title: Deploy Contract
+---
+
+::drop-panel
+  ::panel{label = "Deploy Contract"}
+  Deploying contracts on the zkSync Sepolia testnet requires having testnet ETH.
+  If you're working within the local development environment,
+  you can utilize pre-configured rich wallets and skip this step.
+  For testnet deployments, follow these steps to secure your funds:
+
+    1. Obtaining Testnet ETH:
+      - Use the [LearnWeb3 faucet](https://learnweb3.io/faucets/zksync_sepolia/) to directly receive testnet ETH on zkSync Sepolia.
+      - Alternatively, acquire SepoliaETH from [recommended faucets](https://www.notion.so/tooling/network-faucets.md) and transfer it to the zkSync Sepolia testnet via the [zkSync bridge](https://portal.zksync.io/bridge/?network=sepolia).
+
+    1. Verify your balance:
+      - Check your wallet's balance using the [zkSync Sepolia explorer](https://sepolia.explorer.zksync.io/).
+  ::
+::
diff --git a/content/_partials/_environment-setup-with-foundry.md b/content/_partials/_environment-setup-with-foundry.md
new file mode 100644
index 00000000..63206ff5
--- /dev/null
+++ b/content/_partials/_environment-setup-with-foundry.md
@@ -0,0 +1,43 @@
+---
+title: Foundry-zksync Installation
+---
+
+::drop-panel
+  ::panel{label="Install foundry-zksync"}
+   Begin by installing `foundry-zksync` in your environment using the command below:
+
+    ```
+    curl -L https://foundry-zksync.zksync.io | bash
+    ```
+  ::
+
+  ::panel{label="Setup local node (optional)"}
+  Leveraging **zksync-cli** to set up
+  a local development environment is a beneficial next step.
+  This local setup allows for quicker testing and debugging
+  processes without incurring testnet transaction costs.
+
+  **Prerequisites:**
+
+  **Docker Installation:** **zksync-cli**'s local environment relies on Docker.
+  Download the appropriate version from the Docker website.
+  If you're new to Docker, consider exploring the Docker getting started guide.
+
+  1. **Open Your Terminal:** Access it from the Applications folder or use Spotlight search (Command + Space).
+  2. **Initialize Local zkSync Node:**
+      - Run the command: **npx zksync-cli@latest dev start**
+      - When prompted, choose “In memory node” to deploy a local zkSync node in a Docker container.
+  3. **Access Rich Accounts:** For pre-configured rich wallets, visit [era-test-node rich wallets](https://era.zksync.io/docs/tools/testing/era-test-node.html#use-pre-configured-rich-wallets).
+  4. **Local Node URL:** Your local zkSync node is accessible at
+  **[http://127.0.0.1:8011](http://127.0.0.1:8011/)**, ready for deployment or testing purposes.
+  ::
+
+  ::panel{label="Initialize project"}
+  Run the following command in your terminal to create a new Foundry project using `foundry-zksync`.
+
+    ```sh
+    forge init --template https://github.com/dutterbutter/zksync-foundry-quickstart-guide
+    ```
+
+  ::
+::
diff --git a/content/_partials/_environment-setup-with-zksync-cli.md b/content/_partials/_environment-setup-with-zksync-cli.md
new file mode 100644
index 00000000..8d313f52
--- /dev/null
+++ b/content/_partials/_environment-setup-with-zksync-cli.md
@@ -0,0 +1,47 @@
+---
+title: Environment Setup With zkSync CLI
+---
+
+::drop-panel
+  ::panel{label="Install Node.js or Bun.sh"}
+  To effectively utilize the **zksync-cli** tool, your
+  development environment needs to be set up with either Node.js or Bun.sh.
+  The choice depends on your project's requirements and personal preference for package management and execution speed.
+
+    - Node.js
+        - Download the Long-Term Support (LTS) version from the [official Node.js website](https://nodejs.org/en/download).
+        - For first-time users, the [Node.js usage guide](https://nodejs.org/api/synopsis.html#usage) offers comprehensive instructions on getting started.
+    - Bun.sh
+        - Obtain the latest version from the [Bun installation page](https://bun.sh/docs/installation). Bun.sh is known for its high performance and modern JavaScript features.
+  ::
+
+  ::panel{label="Setup local node (optional)"}
+  After installing Node.js or Bun, leveraging **zksync-cli** to set up
+  a local development environment is a beneficial next step.
+  This local setup allows for quicker testing and debugging
+  processes without incurring testnet transaction costs.
+
+  **Prerequisites:**
+
+  **Docker Installation:** **zksync-cli**'s local environment relies on Docker.
+  Download the appropriate version from the Docker website.
+  If you're new to Docker, consider exploring the Docker getting started guide.
+
+  1. **Open Your Terminal:** Access it from the Applications folder or use Spotlight search (Command + Space).
+  2. **Initialize Local zkSync Node:**
+      - Run the command: **npx zksync-cli@latest dev start**
+      - When prompted, choose “In memory node” to deploy a local zkSync node in a Docker container.
+  3. **Access Rich Accounts:** For pre-configured rich wallets, visit [era-test-node rich wallets](https://era.zksync.io/docs/tools/testing/era-test-node.html#use-pre-configured-rich-wallets).
+  4. **Local Node URL:** Your local zkSync node is accessible at
+  **[http://127.0.0.1:8011](http://127.0.0.1:8011/)**, ready for deployment or testing purposes.
+  ::
+
+  ::panel{label="Initialize project"}
+  Run the following command in your terminal to create a new project using zkSync CLI.
+
+    ```sh
+    npx zksync-cli@latest —template zksync-quickstart
+    ```
+
+  ::
+::
diff --git a/content/_partials/_setting-up-your-wallet.md b/content/_partials/_setting-up-your-wallet.md
new file mode 100644
index 00000000..4f7e6a89
--- /dev/null
+++ b/content/_partials/_setting-up-your-wallet.md
@@ -0,0 +1,40 @@
+---
+title: Setting up your wallet
+---
+
+::drop-panel
+  ::panel{label="Fund Wallet"}
+
+  1. Obtaining Testnet ETH:
+
+      - Use the [LearnWeb3 faucet](https://learnweb3.io/faucets/zksync_sepolia/)
+      to directly receive testnet ETH on zkSync Sepolia.
+      - Alternatively, acquire SepoliaETH from [recommended faucets](https://www.notion.so/tooling/network-faucets.md) and
+      transfer it to the zkSync Sepolia testnet via the [zkSync bridge](https://portal.zksync.io/bridge/?network=sepolia).
+
+  1. Verify your balance:
+
+      - Check your wallet's balance using the zkSync Sepolia explorer.
+  ::
+
+  ::panel{label="Configuring Your Wallet in the Project"}
+  To deploy contracts, you'll need to securely add your wallet's private key to the project environment:
+
+  1. **Extract Your Private Key:**
+      - Find your wallet's private key. For MetaMask users, here's how to
+      [export your wallet's private key](https://support.metamask.io/hc/en-us/articles/360015289632-How-to-export-an-account-s-private-key).
+      If you're in the local environment, use a private key from the available rich accounts.
+
+  1. **Prepare the Environment File:**
+      - Locate the **`.env-example`** file in your project directory. Rename this file to **`.env`**.
+
+  1. **Add Your Private Key:**
+      - Open the `.env` file and add your private key in the following format:
+
+        ```sh
+        WALLET_PRIVATE_KEY=your_private_key_here
+        ```
+
+      - Replace **`your_private_key_here`** with your actual private key.
+  ::
+::
diff --git a/content/_partials/setting-up-your-wallet.md b/content/_partials/setting-up-your-wallet.md
deleted file mode 100644
index c1070e6d..00000000
--- a/content/_partials/setting-up-your-wallet.md
+++ /dev/null
@@ -1,54 +0,0 @@
----
-title: Setting up your wallet
----
-
-  <div>
-    <p>
-      Deploying contracts on the zkSync Sepolia testnet requires having testnet ETH. If you're working within the local
-      development environment, you can utilize pre-configured rich wallets and skip this step. For testnet deployments,
-      follow these steps to secure your funds:
-    </p>
-    <ol>
-      <li>
-        <strong>Obtaining Testnet ETH:</strong>
-        <ul>
-          <li>
-            Use the
-            <a
-              href="https://learnweb3.io/faucets/zksync_sepolia/"
-              target="_blank"
-              >LearnWeb3 faucet</a
-            >
-            to directly receive testnet ETH on zkSync Sepolia.
-          </li>
-          <li>
-            Alternatively, acquire SepoliaETH from
-            <a
-              href="https://www.notion.so/tooling/network-faucets.md"
-              target="_blank"
-              >recommended faucets</a
-            >
-            and transfer it to the zkSync Sepolia testnet via the
-            <a
-              href="https://portal.zksync.io/bridge/?network=sepolia"
-              target="_blank"
-              >zkSync bridge</a
-            >.
-          </li>
-        </ul>
-      </li>
-      <li>
-        <strong>Verify your balance:</strong>
-        <ul>
-          <li>
-            Check your wallet's balance using the
-            <a
-              href="https://sepolia.explorer.zksync.io/"
-              target="_blank"
-              >zkSync Sepolia explorer</a
-            >.
-          </li>
-        </ul>
-      </li>
-    </ol>
-  </div>
\ No newline at end of file
diff --git a/content/index.yml b/content/index.yml
index 874ef19b..0769ee37 100644
--- a/content/index.yml
+++ b/content/index.yml
@@ -15,7 +15,7 @@ hero:
     - label: Start building on zkSync
       icon: i-heroicons-arrow-right-20-solid
       trailing: true
-      to: '/quick-code'
+      to: '/quick-start'
       size: lg
     # - label: Use this template
     #   icon: i-simple-icons-github
diff --git a/cspell-config/cspell-blockchain.txt b/cspell-config/cspell-blockchain.txt
index 6dd649e1..64b898e0 100644
--- a/cspell-config/cspell-blockchain.txt
+++ b/cspell-config/cspell-blockchain.txt
@@ -3,6 +3,13 @@ EVM
 ethereum
 keccak
 merkle
+upgradability
+Initializable
+initializable
+UUPS
+merkle
+uups
+Sepolia
 Weth
 Geth
 gwei
diff --git a/cspell-config/cspell-dev.txt b/cspell-config/cspell-dev.txt
index ea3d2734..3f79c14c 100644
--- a/cspell-config/cspell-dev.txt
+++ b/cspell-config/cspell-dev.txt
@@ -18,3 +18,18 @@ zksolc
 zkvyper
 ZKEVM
 zkout
+nomicfoundation
+Nuxt
+nuxi
+nuxt
+nuxtdotjs
+nuxtjs
+!NuxtUI
+!NuxtContent
+NVMe
+rocksdb
+Vue
+!vue
+
+// devs
+dutterbutter
diff --git a/cspell-config/cspell-zksync.txt b/cspell-config/cspell-zksync.txt
index bfa3887c..57a020f8 100644
--- a/cspell-config/cspell-zksync.txt
+++ b/cspell-config/cspell-zksync.txt
@@ -5,3 +5,8 @@ zkSync
 zksync
 zksync-cli
 Zeek
+MatterLabs
+zkSync
+zksync
+zksync-cli
+zksync
\ No newline at end of file
diff --git a/nuxt.config.ts b/nuxt.config.ts
index 1700f8e6..63fac83b 100644
--- a/nuxt.config.ts
+++ b/nuxt.config.ts
@@ -3,7 +3,15 @@ import { zksyncIcons } from './assets/zksync-icons';
 // https://nuxt.com/docs/api/configuration/nuxt-config
 export default defineNuxtConfig({
   extends: ['@nuxt/ui-pro'],
-  modules: ['@nuxt/content', '@nuxt/ui', '@nuxt/fonts', '@nuxthq/studio', 'nuxt-og-image'],
+  modules: [
+    '@nuxt/content',
+    '@nuxt/ui',
+    '@nuxt/fonts',
+    '@nuxthq/studio',
+    'nuxt-og-image',
+    'nuxt-headlessui',
+    '@nuxt/devtools',
+  ],
   hooks: {
     // Define `@nuxt/ui` components as global to use them in `.md` (feel free to add those you need)
     'components:extend': (components) => {
diff --git a/package.json b/package.json
index 015ae393..7c4bb12e 100644
--- a/package.json
+++ b/package.json
@@ -7,6 +7,7 @@
   "author": "Matter Labs",
   "homepage": "https://zksync.io",
   "devDependencies": {
+    "@nuxt/devtools": "^1.1.5",
     "@nuxt/eslint-config": "^0.2.0",
     "@nuxthq/studio": "^1.0.13",
     "@types/bun": "^1.0.8",