From 3926753e2a90c26889f7cea733dd34123f26a6b9 Mon Sep 17 00:00:00 2001
From: Ngozi Peace Okafor <ngozi@txfusion.io>
Date: Mon, 8 Jul 2024 12:39:54 +0100
Subject: [PATCH] feat: update go documentation structure (#69)

* feat: update go documentation structure

* fix: update links

* fix: update links

* fix: update url

* fix: update types

* fix: updated smartaccount

* fix: update types

* fix: update contracts description

* chore: fix errors

---------

Co-authored-by: danijelTxFusion <danijel@txfusion.io>
---
 content/sdk/00.index.md                       |    2 +-
 .../sdk/20.go/00.introduction/00.overview.md  |   24 +
 .../00.introduction/01.why-zksync2-go.md      |   45 +
 .../20.go/00.introduction/02.installation.md  |   26 +
 .../{ => 01.guides}/00.getting-started.md     |   44 +-
 .../01.features.md}                           |   21 +-
 .../02.accounts-l1-l2.md}                     |   27 +-
 .../02.api/00.clients/00.introduction.md      |   36 +
 .../00.clients/01.baseclient.md}              |   56 +-
 .../00.clients/02.types.md}                   |    9 +-
 .../02.api/01.accounts/00.introduction.md     |   55 +
 .../20.go/02.api/01.accounts/01.basesigner.md |   76 +
 .../02.api/01.accounts/02.basedeployer.md     |  165 ++
 .../sdk/20.go/02.api/01.accounts/03.wallet.md |  214 ++
 .../20.go/02.api/01.accounts/04.walletl1.md   | 1002 +++++++
 .../20.go/02.api/01.accounts/05.walletl2.md   |  523 ++++
 .../02.api/01.accounts/06.smartaccount.md     |  482 ++++
 .../01.accounts/07.smartaccount-factories.md  |   68 +
 .../01.accounts}/08.smart-account-utils.md    |   23 +-
 .../01.accounts/09.types.md}                  |   10 +-
 .../02.eip712/00.eip712.md}                   |    7 +-
 .../03.contracts/00.contracts.md}             |    7 +-
 .../04.utilities/00.utils.md}                 |   12 +-
 .../04.utilities/01.paymaster-utils.md}       |    8 +-
 .../{types/04.types.md => 02.api/05.types.md} |   18 +-
 content/sdk/20.go/02.api/_dir.yml             |    1 +
 content/sdk/20.go/04.accounts.md              | 2524 -----------------
 content/sdk/20.go/types/00.intro.md           |   14 -
 28 files changed, 2849 insertions(+), 2650 deletions(-)
 create mode 100644 content/sdk/20.go/00.introduction/00.overview.md
 create mode 100644 content/sdk/20.go/00.introduction/01.why-zksync2-go.md
 create mode 100644 content/sdk/20.go/00.introduction/02.installation.md
 rename content/sdk/20.go/{ => 01.guides}/00.getting-started.md (62%)
 rename content/sdk/20.go/{02.features.md => 01.guides/01.features.md} (83%)
 rename content/sdk/20.go/{05.accounts-l1-l2.md => 01.guides/02.accounts-l1-l2.md} (69%)
 create mode 100644 content/sdk/20.go/02.api/00.clients/00.introduction.md
 rename content/sdk/20.go/{03.clients.md => 02.api/00.clients/01.baseclient.md} (92%)
 rename content/sdk/20.go/{types/02.clients.md => 02.api/00.clients/02.types.md} (86%)
 create mode 100644 content/sdk/20.go/02.api/01.accounts/00.introduction.md
 create mode 100644 content/sdk/20.go/02.api/01.accounts/01.basesigner.md
 create mode 100644 content/sdk/20.go/02.api/01.accounts/02.basedeployer.md
 create mode 100644 content/sdk/20.go/02.api/01.accounts/03.wallet.md
 create mode 100644 content/sdk/20.go/02.api/01.accounts/04.walletl1.md
 create mode 100644 content/sdk/20.go/02.api/01.accounts/05.walletl2.md
 create mode 100644 content/sdk/20.go/02.api/01.accounts/06.smartaccount.md
 create mode 100644 content/sdk/20.go/02.api/01.accounts/07.smartaccount-factories.md
 rename content/sdk/20.go/{ => 02.api/01.accounts}/08.smart-account-utils.md (88%)
 rename content/sdk/20.go/{types/01.accounts.md => 02.api/01.accounts/09.types.md} (97%)
 rename content/sdk/20.go/{types/03.eip712.md => 02.api/02.eip712/00.eip712.md} (58%)
 rename content/sdk/20.go/{06.contracts.md => 02.api/03.contracts/00.contracts.md} (86%)
 rename content/sdk/20.go/{06.utils.md => 02.api/04.utilities/00.utils.md} (94%)
 rename content/sdk/20.go/{07.paymaster-utils.md => 02.api/04.utilities/01.paymaster-utils.md} (85%)
 rename content/sdk/20.go/{types/04.types.md => 02.api/05.types.md} (93%)
 create mode 100644 content/sdk/20.go/02.api/_dir.yml
 delete mode 100644 content/sdk/20.go/04.accounts.md
 delete mode 100644 content/sdk/20.go/types/00.intro.md

diff --git a/content/sdk/00.index.md b/content/sdk/00.index.md
index 700cde22..2587a20e 100644
--- a/content/sdk/00.index.md
+++ b/content/sdk/00.index.md
@@ -66,7 +66,7 @@ Integrate JS with ZKsync Era for secure transactions.
 ---
 title: GO
 icon: i-heroicons-cog
-to: /sdk/go/getting-started
+to: /sdk/go/introduction/overview
 ---
 Integrate ZKsync GO SDK for ZKsync Era features.
 ::
diff --git a/content/sdk/20.go/00.introduction/00.overview.md b/content/sdk/20.go/00.introduction/00.overview.md
new file mode 100644
index 00000000..4dc41cdf
--- /dev/null
+++ b/content/sdk/20.go/00.introduction/00.overview.md
@@ -0,0 +1,24 @@
+---
+title: Overview
+description: An introduction to `zksync2-go`
+tags: ["zksync", "zksync2-go", "ethereum", "layer-2", "zero-knowledge rollups", "go library", "blockchain scalability", "crypto transactions"]
+---
+
+This guide will help you understand the fundamentals of `zksync2-go` and how to get started.
+
+## What is `zksync2-go`?
+`zksync2-go` is a Go library designed to interact with ZKsync, providing developers with the tools to integrate
+ZKsync functionality into their Go applications. It simplifies the development process, offering easy-to-use
+interfaces and comprehensive documentation.
+
+## Features of `zksync2-go`
+
+- **Scalability**: Leverages ZKsync's layer-2 technology to provide high transaction throughput.
+- **Cost Efficiency**: Reduces transaction fees compared to on-chain transactions.
+- **Security**: Ensures secure transactions through zero-knowledge proofs.
+- **Ease of Use**: Provides an intuitive API for seamless integration into Go applications.
+- **Interoperability**: Compatible with existing Ethereum tools and infrastructure.
+
+::callout{icon="i-heroicons-light-bulb"}
+To get started with `zksync2-go`, follow the [installation instructions](/sdk/go/introduction/installation) provided.
+::
diff --git a/content/sdk/20.go/00.introduction/01.why-zksync2-go.md b/content/sdk/20.go/00.introduction/01.why-zksync2-go.md
new file mode 100644
index 00000000..cbe12581
--- /dev/null
+++ b/content/sdk/20.go/00.introduction/01.why-zksync2-go.md
@@ -0,0 +1,45 @@
+---
+title: Why zksync2-go
+description: Benefits and Advantages of using `zksync2-go`
+tags: ["zksync", "zksync2-go", "ethereum", "layer-2", "zero-knowledge rollups", "go library"]
+---
+
+Choosing the right tools and libraries for your blockchain project is crucial. `zksync2-go` offers a robust and
+efficient solution for developers looking to leverage the benefits of ZKsync within their Go applications.
+
+## Key advantages of `zksync2-go`
+
+### 1. High performance and scalability
+
+- **Layer-2 scaling**: Using ZKsync's layer-2 technology, `zksync2-go` significantly increases transaction
+throughput, allowing your applications to handle more transactions per second.
+- **Reduced latency**: Transactions are processed off-chain and then batched together for on-chain validation,
+minimizing the delays associated with on-chain processing.
+
+### 2. Cost efficiency
+
+- **Lower fees**: Off-chain processing dramatically reduces transaction fees compared to traditional on-chain
+transactions, making it cost-effective for developers and users.
+- **Optimized resource usage**: Efficiently manages computational resources, reducing the overall cost of running
+blockchain applications.
+
+### 3. Security and reliability
+
+- **Zero-knowledge proofs**: Ensures transaction integrity and privacy through zero-knowledge proofs, providing high security.
+- **Trusted infrastructure**: Built on the reliable and proven ZKsync infrastructure, `zksync2-go` inherits its
+security features and robustness.
+
+### 4. Developer-friendly
+
+- **Easy integration**: Provides a straightforward API that simplifies the integration of ZKsync functionality into Go applications.
+- **Comprehensive documentation**: Offers detailed guides, examples, and API references to help developers start
+quickly and efficiently.
+- **Active Community and Support**: Benefit from an active community of developers and timely support from the
+maintainers of `zksync2-go`.
+
+### 5. Interoperability
+
+- **Ethereum Compatibility**: Fully compatible with existing Ethereum tools and infrastructure, ensuring seamless
+integration with other parts of the Ethereum ecosystem.
+- **Future-Proof**: Designed to stay up-to-date with the latest advancements in the ZKsync protocol and the broader
+blockchain landscape.
diff --git a/content/sdk/20.go/00.introduction/02.installation.md b/content/sdk/20.go/00.introduction/02.installation.md
new file mode 100644
index 00000000..6a0c0de0
--- /dev/null
+++ b/content/sdk/20.go/00.introduction/02.installation.md
@@ -0,0 +1,26 @@
+---
+title: Installation
+description: How to install and set up zksync2-go for your project.
+tags: ["zksync", "zksync2-go", "go", "sdk installation"]
+---
+
+Follow the steps below to set up the SDK in your development environment.
+
+### Prerequisites
+
+- Go: >=1.17 ([installation guide](https://go.dev/dl/))
+
+### Installation steps
+
+   To install SDK for ZKsync Era, run the command below in your terminal.
+
+   ```shell
+   go get github.com/zksync-sdk/zksync2-go
+   ```
+
+   This command will download and install the `zksync2-go` package and its dependencies into your Go workspace.
+
+### What next?
+
+After completing these steps, `zksync2-go` will be installed and ready to use in your Go projects. You can now proceed
+to integrate ZKsync functionalities into your applications by following the usage examples and API documentation.
diff --git a/content/sdk/20.go/00.getting-started.md b/content/sdk/20.go/01.guides/00.getting-started.md
similarity index 62%
rename from content/sdk/20.go/00.getting-started.md
rename to content/sdk/20.go/01.guides/00.getting-started.md
index 3382ba7a..611121b6 100644
--- a/content/sdk/20.go/00.getting-started.md
+++ b/content/sdk/20.go/01.guides/00.getting-started.md
@@ -1,37 +1,29 @@
 ---
 title: Getting Started
-description:
+description: Getting Started with zksync2-go
+tags: ["zksync", "zksync2-go", "go", "getting started"]
 ---
 
-This is a short introduction to `zksync2-go` SDK, but covers many of the most common operations that developers require
-and provides a starting point for those newer to ZKsync Era.
+This guide provides an overview of the most common operations developers need to start using Go with ZKsync Era.
 
-## Getting zksync2-go
-
-### Prerequisites
-
-- Go: >=1.17 ([installation guide](https://go.dev/dl/))
-
-In order to install SDK for ZKsync Era, run the command below in your terminal.
-
-```shell
- go get github.com/zksync-sdk/zksync2-go
-```
+::callout{icon="i-heroicons-light-bulb"}
+Ensure you have installed the `zksync2-go` SDK. If you still need to do so, please refer to
+the [installation guide](/sdk/go/introduction/installation) for detailed instructions.
+::
 
 ## Overview
+The `zksync2-go` SDK enables developers to interact with the ZKsync Era blockchain using the Go programming
+language. While many standard SDK features work out of the box, some advanced functionalities like deploying smart
+contracts or utilizing ZKsync-specific features (such as account abstraction) require additional fields beyond what
+typical Ethereum transactions include.
 
-While most of the existing SDKs should work out of the box, deploying smart contracts or using unique ZKsync features,
-like account abstraction, requires providing additional fields to those that Ethereum transactions have by default.
-
-To begin, it is useful to have a basic understanding of the types of objects available and what they are responsible
-for, at a high level:
+To start, it’s beneficial to understand the primary components of the SDK and their roles:
 
-- `Client` provides connection to the ZKsync Era blockchain, which allows querying the blockchain state, such as
-  account, block or transaction details, querying event logs or evaluating read-only code using call.
-  Additionally, the client facilitates writing to the blockchain by sending transactions.
-- `Signer` wraps all operations that interact with an account. An account generally has a private key, which can
-  be used to sign a variety of types of payloads.
-- `Wallet` is a wrapper around `Client` and `Signer` that provides easy usage of the most common features.
+- **Client**: Connects to the ZKsync Era blockchain, enabling you to query the blockchain state (e.g., account
+details, blocks, and transactions), query event logs, or execute read-only code. It also facilitates sending
+transactions to the blockchain.
+- **Signer**: Manages operations that interact with an account, typically involving a private key used to sign various payloads.
+- **Wallet**: A convenient wrapper around `Client` and `Signer`, providing easy access to the most commonly used features.
 
 ## Examples
 
@@ -108,5 +100,5 @@ Also, the following examples demonstrate how to:
 7. [Deploy smart account](https://github.com/zksync-sdk/zksync2-examples/blob/main/go/16_deploy_create_account.go).
 8. [Use paymaster to pay fee with token](https://github.com/zksync-sdk/zksync2-examples/blob/main/go/18_use_paymaster.go).
 
-Full code for all examples is available [here](https://github.com/zksync-sdk/zksync2-examples/tree/main/go).
+Full code for all examples is available in the [documentation](https://github.com/zksync-sdk/zksync2-examples/tree/main/go).
 Examples are configured to interact with `ZKsync Era`, and `Sepolia` test networks.
diff --git a/content/sdk/20.go/02.features.md b/content/sdk/20.go/01.guides/01.features.md
similarity index 83%
rename from content/sdk/20.go/02.features.md
rename to content/sdk/20.go/01.guides/01.features.md
index 11bc88b7..ffee8c41 100644
--- a/content/sdk/20.go/02.features.md
+++ b/content/sdk/20.go/01.guides/01.features.md
@@ -1,6 +1,7 @@
 ---
 title: ZKsync Era Features
-description:
+description: An overview of ZKsync Era features
+tags: ["zksync", "zksync2-go", "ethereum", "blockchain", "eip-712", "paymaster", "sdk"]
 ---
 
 While ZKsync Era is mostly Web3-compatible, it has some differences compared to Ethereum. The major of those are:
@@ -11,21 +12,23 @@ While ZKsync Era is mostly Web3-compatible, it has some differences compared to
 
 These require us to extend standard Ethereum transactions with new custom fields. Such extended transactions are
 called EIP-712 transactions since [EIP-712](https://eips.ethereum.org/EIPS/eip-712) is used to sign them.
-You can look at the internal structure of the EIP-712 transactions
-[here](https://docs.zksync.io/zk-stack/concepts/transaction-lifecycle.html#eip-712-0x71).
+You can look at the internal structure of the EIP-712 transactions in the
+[ZKsync documentation](https://docs.zksync.io/zk-stack/concepts/transaction-lifecycle.html#eip-712-0x71).
 
+::callout{icon="i-heroicons-light-bulb"}
 This document will focus solely on how to pass these arguments to the SDK.
+::
 
 ## EIP-712 Metadata
 
-[`EIP712Meta`](/sdk/go/types/types#eip712meta) contains EIP-712 transaction metadata.
+[`EIP712Meta`](/sdk/go/api/types#eip712meta) contains EIP-712 transaction metadata.
 The following objects contain `EIP712Meta` and provides working with
 EIP-712 transactions:
 
-- [`types.CallMsg`](/sdk/go/types/types#callmsg)
-- [`types.Transaction712`](/sdk/go/types/types#transaction712)
-- [`accounts.CallMsg`](/sdk/go/types/types#callmsg)
-- [`accounts.Transaction`](/sdk/go/types/types#transactiondetails)
+- [`types.CallMsg`](/sdk/go/api/types#callmsg)
+- [`types.Transaction712`](/sdk/go/api/types#transaction712)
+- [`accounts.CallMsg`](/sdk/go/api/types#callmsg)
+- [`accounts.Transaction`](/sdk/go/api/types#transactiondetails)
 
 ## Encoding paymaster params
 
@@ -35,7 +38,7 @@ the Matter Labs team endorses certain types of
 that are processable by EOAs.
 
 ZKsync SDK provides a utility method that can be used to get the correctly formed `PaymasterParams` object:
-[GetPaymasterParams](/sdk/go/paymaster-utils#getpaymasterparams).
+[GetPaymasterParams](/sdk/go/api/utilities/paymaster-utils#getpaymasterparams).
 
 ## See in action
 
diff --git a/content/sdk/20.go/05.accounts-l1-l2.md b/content/sdk/20.go/01.guides/02.accounts-l1-l2.md
similarity index 69%
rename from content/sdk/20.go/05.accounts-l1-l2.md
rename to content/sdk/20.go/01.guides/02.accounts-l1-l2.md
index 92015f8a..2bd753ae 100644
--- a/content/sdk/20.go/05.accounts-l1-l2.md
+++ b/content/sdk/20.go/01.guides/02.accounts-l1-l2.md
@@ -1,19 +1,22 @@
 ---
-title: Accounts | L1<->L2 Transactions
-description:
+title: L1<->L2 Transactions
+description: Methods for handling transactions between L1 and L2 networks on ZKsync
+tags: ["zksync", "l1", "l2", "transactions", "go", "sdk"]
 ---
 
-This section explores the methods which allow the [account](/sdk/go/accounts) to send transactions among both L1 to L2 networks.
-
-If you want some background on how L1<->L2 interaction works on ZKsync, go through the
+This section explores the methods which allow the [account](/sdk/go/api/accounts/introduction) to send transactions
+among both L1 to
+L2 networks. For background on how L1<->L2 interaction works on ZKsync, go through the
 [introduction](https://docs.zksync.io/build/developer-reference/l1-l2-interoperability).
 
-Full examples of actions below are available on the [getting started](/sdk/go/getting-started) page.
+::callout{icon="i-heroicons-light-bulb"}
+Full examples of actions below are available on the [getting started](/sdk/go/guides/getting-started) page.
+::
 
 ## Deposit
 
 `WalletL1` and `Wallet` objects provide a deposit workflow. For more information, please refer to the method
-specification [`Deposit`](/sdk/go/accounts#deposit).
+specification [`Deposit`](/sdk/go/api/accounts/walletl1#deposit).
 
 For a comprehensive example demonstrating the deposit workflow, refer to the following:
 
@@ -23,27 +26,27 @@ For a comprehensive example demonstrating the deposit workflow, refer to the fol
 ## Request execute
 
 `WalletL1` and `Wallet` objects provide an option to request execution of L2 transaction from L1.
-For more information, please refer to the method specification [`RequestExecute`](/sdk/go/accounts#requestexecute).
+For more information, please refer to the method specification [`RequestExecute`](/sdk/go/api/accounts/walletl1#requestexecute).
 
 ## Base cost
 
 `WalletL1` and `Wallet` objects provide an option to calculate base cost for L2 transaction.
-For more information, please refer to the method specification [`BaseCost`](/sdk/go/accounts#basecost).
+For more information, please refer to the method specification [`BaseCost`](/sdk/go/api/accounts/walletl1#basecost).
 
 ## Claim failed deposit
 
 `WalletL1` and `Wallet` objects provide a claim fail deposit workflow. For more information,
-please refer to the method specification [`ClaimFailedDeposit`](/sdk/go/accounts#claimfaileddeposit).
+please refer to the method specification [`ClaimFailedDeposit`](/sdk/go/api/accounts/walletl1#claimfaileddeposit).
 
 ## Finalize withdraw
 
 `WalletL1` and `Wallet` objects provide a finalize withdraw workflow. For more information,
-please refer to the method specification [`FinalizeWithdraw`](/sdk/go/accounts#finalizewithdraw).
+please refer to the method specification [`FinalizeWithdraw`](/sdk/go/api/accounts/introduction#finalizewithdraw).
 
 ## Withdrawal
 
 `WalletL2` and `Wallet` objects provide a withdrawal workflow. For more information,
-please refer to the method specification [`Deposit`](/sdk/go/accounts#deposit).
+please refer to the method specification [`Deposit`](/sdk/go/api/accounts/walletl1#deposit).
 
 For a complete example of how to execute the deposit workflow, take a look at the following:
 
diff --git a/content/sdk/20.go/02.api/00.clients/00.introduction.md b/content/sdk/20.go/02.api/00.clients/00.introduction.md
new file mode 100644
index 00000000..577f9383
--- /dev/null
+++ b/content/sdk/20.go/02.api/00.clients/00.introduction.md
@@ -0,0 +1,36 @@
+---
+title: Introduction
+description: Overview of the Client component in the ZKsync Era
+tags: ["zksync", "client", "go", "sdk"]
+---
+
+The `Client` is a critical component that enables interaction with the ZKsync Era. It serves as a wrapper around the
+ZKsync Era RPC API and supports `ethclient.Client` from the `geth` library, along with additional methods specific to
+ZKsync Era.
+
+::callout{icon="i-heroicons-information-circle" color="blue"}
+Since the `geth` library has the concept of a `Client`, not a `Provider`, the Go SDK for ZKsync Era also adopts the
+concept of a `Client`, as opposed to using a Provider like in other ZKsync Era SDKs.
+::
+
+In code, the `Client` interface is composed of two main interfaces:
+
+### `EthereumClient`
+
+This interface provides Ethereum RPC methods on the ZKsync Era node, prefixed with `eth_`. It includes the same
+methods as `ethclient.Client` from the `geth` library, ensuring compatibility with existing Ethereum tools and
+workflows. Additionally, it has extra methods capable of handling EIP-712 transactions, which are essential for the
+unique features of the ZKsync Era. The `EthereumClient` interface is designed to be compatible with
+the `bind.ContractBackend` interface from `geth`, which enables support for smart contracts generated using
+the `abigen` tool.
+
+### `ZkSyncEraClient`
+
+This interface provides the API methods specific to ZKsync Era, prefixed with `zks_`. These methods facilitate the
+use of ZKsync Era’s unique features, such as account abstraction, custom fee systems, and other layer-2
+functionalities. The `ZkSyncEraClient` interface ensures that developers can leverage all the capabilities of the
+ZKsync Era blockchain efficiently.
+
+::callout{icon="i-heroicons-light-bulb"}
+These interfaces are designed to make the SDK flexible and extensible.
+::
diff --git a/content/sdk/20.go/03.clients.md b/content/sdk/20.go/02.api/00.clients/01.baseclient.md
similarity index 92%
rename from content/sdk/20.go/03.clients.md
rename to content/sdk/20.go/02.api/00.clients/01.baseclient.md
index adf3d929..2124bccd 100644
--- a/content/sdk/20.go/03.clients.md
+++ b/content/sdk/20.go/02.api/00.clients/01.baseclient.md
@@ -1,30 +1,13 @@
 ---
-title: Clients
-description:
+title: BaseClient
+description: Primary implementation of ZKsync client
+tags: ["zksync", "client", "baseclient", "go", "sdk"]
 ---
 
-::callout{icon="i-heroicons-information-circle" color="blue"}
-Since the `geth` library has the concept of a `Client`, not a `Provider`, that's why the Go SDK for ZKsync Era
-also adopts the concept of a `Client`, as opposed to using a Provider like in the other ZKsync Era SDKs.
-::
-
-`Client` is a wrapper around the ZKsync Era RPC API, which supports `ethclient.Client` from the `geth` library
-and additional methods specific to ZKsync Era.
-
-`Client` in code represents the interface that is composed of the following two interfaces:
-
-- `EthereumClient` provides Ethereum RPC methods on the ZKsync Era node, those with the `eth_` prefix.
-  This interface contains the same methods as `ethclient.Client` from the `geth` library. Additionally,
-  it has extra methods capable of working with EIP-712 transactions. It is designed to be compatible with
-  the `bind.ContractBackend` interface from `geth`, enabling support for smart contracts generated using the
-  `abigen` tool.
-- `ZkSyncEraClient` provides the API for ZKsync Era features and specific RPC methods, those with the `zks_` prefix.
-
-These interfaces are separated to make the SDK more flexible and extensible.
-
-## `BaseClient`
-
-`BaseClient` implements the `Client` interface and provides interaction with ZKsync Era RPC API.
+The `BaseClient` is the primary implementation of the `Client` interface. It facilitates
+interaction with the ZKsync Era RPC API, providing the necessary methods to perform various blockchain
+operations. The `BaseClient` leverages both Ethereum RPC methods and ZKsync-specific functionalities to offer a
+comprehensive toolset for developers.
 
 ### `Init`
 
@@ -71,7 +54,7 @@ defer wsClient.Close()
 
 Executes a log filter operation, blocking during execution, and returns all the results in one batch. This method is
 a replacement for `FilterLogs` because the returned `types.Log` type does not contain additional data specific to L2,
-as found in [`Log`](/sdk/go/types/types#log). The `FilterLogs` method is kept in order to be compatible with `bind.ContractBackend`,
+as found in [`Log`](/sdk/go/api/types#log). The `FilterLogs` method is kept in order to be compatible with `bind.ContractBackend`,
 and this method can be used, but additional L2 data won't be retrieved.
 
 #### Inputs
@@ -112,7 +95,8 @@ for _, l := range zkLogs {
 
 Creates a background log filtering operation, returning a subscription immediately, which can be used to stream the
 found events. This method is a replacement for `SubscribeFilterLogs` because the returned `types.Log` type does not
-contain additional data specific to L2, as found in [`Log`](/sdk/go/types/types#log). The `SubscribeFilterLogs` method is
+contain additional data specific to L2, as found
+in [`Log`](/sdk/go/api/types#log). The `SubscribeFilterLogs` method is
 kept in order to be compatible with `bind.ContractBackend`, and this method can be used, but additional L2 data
 won't be retrieved.
 
@@ -122,7 +106,7 @@ won't be retrieved.
 | --------- | --------------------------------------------------------------------------------------------- | -------------------------- |
 | `ctx`     | `context.Context`                                                                             | Context.                   |
 | `query`   | [`ethereum.FilterQuery`](https://pkg.go.dev/github.com/ethereum/go-ethereum@v1.12.0#FilterQuery) | Filter query parameters.   |
-| `ch`      | [`chan<- zkTypes.Log`](/sdk/go/types/types#log)                                                       | Channel that receives Log. |
+| `ch`      | [`chan<- zkTypes.Log`](/sdk/go/api/types#log)                                                       | Channel that receives Log. |
 
 ```go
 SubscribeFilterLogsL2(ctx context.Context, query ethereum.FilterQuery, ch chan<- zkTypes.Log) (ethereum.Subscription, error)
@@ -169,7 +153,7 @@ but never mined into the blockchain.
 | Parameter     | Type                                     | Description                                                                                                                                                                                 |
 | ------------- | ---------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `ctx`         | `context.Context`                        | Context.                                                                                                                                                                                    |
-| `msg`         | [`zkTypes.CallMsg`](/sdk/go/types/types#callmsg) | Contains parameters for contract call using EIP-712 transaction.                                                                                                                            |
+| `msg`         | [`zkTypes.CallMsg`](/sdk/go/api/types#callmsg) | Contains parameters for contract call using EIP-712 transaction.                                                                                                                            |
 | `blockNumber` | `*big.Int` (optional)                    | Selects the block height at which the call runs. It can be `nil`, in which case the code is taken from the latest known block. Note that state from very old blocks might not be available. |
 
 ```go
@@ -218,7 +202,7 @@ block height.
 | Parameter   | Type                                     | Description                                                      |
 | ----------- | ---------------------------------------- | ---------------------------------------------------------------- |
 | `ctx`       | `context.Context`                        | Context.                                                         |
-| `msg`       | [`zkTypes.CallMsg`](/sdk/go/types/types#callmsg) | Contains parameters for contract call using EIP-712 transaction. |
+| `msg`       | [`zkTypes.CallMsg`](/sdk/go/api/types#callmsg) | Contains parameters for contract call using EIP-712 transaction. |
 | `blockHash` | `common.Hash`                            | Block hash.                                                      |
 
 ```go
@@ -235,7 +219,7 @@ pending state.
 | Parameter | Type                                     | Description                                                      |
 | --------- | ---------------------------------------- | ---------------------------------------------------------------- |
 | `ctx`     | `context.Context`                        | Context.                                                         |
-| `msg`     | [`zkTypes.CallMsg`](/sdk/go/types/types#callmsg) | Contains parameters for contract call using EIP-712 transaction. |
+| `msg`     | [`zkTypes.CallMsg`](/sdk/go/api/types#callmsg) | Contains parameters for contract call using EIP-712 transaction. |
 
 ```go
 PendingCallContractL2(ctx context.Context, msg zkTypes.CallMsg) ([]byte, error)
@@ -252,7 +236,7 @@ transactions may be added or removed by miners, but it should provide a basis fo
 | Parameter | Type                                     | Description                                                      |
 | --------- | ---------------------------------------- | ---------------------------------------------------------------- |
 | `ctx`     | `context.Context`                        | Context.                                                         |
-| `msg`     | [`zkTypes.CallMsg`](/sdk/go/types/types#callmsg) | Contains parameters for contract call using EIP-712 transaction. |
+| `msg`     | [`zkTypes.CallMsg`](/sdk/go/api/types#callmsg) | Contains parameters for contract call using EIP-712 transaction. |
 
 ```go
 EstimateGasL2(ctx context.Context, msg zkTypes.CallMsg) (uint64, error)
@@ -1086,7 +1070,7 @@ Returns the fee for the transaction.
 | Parameter | Type                                     | Description                                                      |
 | --------- | ---------------------------------------- | ---------------------------------------------------------------- |
 | `ctx`     | `context.Context`                        | Context.                                                         |
-| `msg`     | [`zkTypes.CallMsg`](/sdk/go/types/types#callmsg) | Contains parameters for contract call using EIP-712 transaction. |
+| `msg`     | [`zkTypes.CallMsg`](/sdk/go/api/types#callmsg) | Contains parameters for contract call using EIP-712 transaction. |
 
 ```go
 EstimateFee(ctx context.Context, tx zkTypes.CallMsg) (*zkTypes.Fee, error)
@@ -1119,7 +1103,7 @@ Estimates the amount of gas required to submit a transaction from L1 to L2.
 | Parameter | Type                                     | Description                                                      |
 | --------- | ---------------------------------------- | ---------------------------------------------------------------- |
 | `ctx`     | `context.Context`                        | Context.                                                         |
-| `msg`     | [`zkTypes.CallMsg`](/sdk/go/types/types#callmsg) | Contains parameters for contract call using EIP-712 transaction. |
+| `msg`     | [`zkTypes.CallMsg`](/sdk/go/api/types#callmsg) | Contains parameters for contract call using EIP-712 transaction. |
 
 ```go
 EstimateGasL1(ctx context.Context, tx zkTypes.CallMsg) (uint64, error)
@@ -1154,7 +1138,7 @@ Estimates the amount of gas required for a transfer transaction.
 | Parameter | Type                                               | Description                            |
 | --------- | -------------------------------------------------- | -------------------------------------- |
 | `ctx`     | `context.Context`                                  | Context.                               |
-| `msg`     | [`TransferCallMsg`](/sdk/go/types/accounts#transfercallmsg) | Contains parameters for transfer call. |
+| `msg`     | [`TransferCallMsg`](/sdk/go/api/accounts/types#transfercallmsg) | Contains parameters for transfer call. |
 
 ```go
 EstimateGasTransfer(ctx context.Context, msg TransferCallMsg) (uint64, error)
@@ -1184,7 +1168,7 @@ Estimates the amount of gas required for a withdrawal transaction.
 | Parameter | Type                                                   | Description                              |
 | --------- | ------------------------------------------------------ | ---------------------------------------- |
 | `ctx`     | `context.Context`                                      | Context.                                 |
-| `msg`     | [`WithdrawalCallMsg`](/sdk/go/types/accounts#withdrawalcallmsg) | Contains parameters for withdrawal call. |
+| `msg`     | [`WithdrawalCallMsg`](/sdk/go/api/accounts/types#withdrawalcallmsg) | Contains parameters for withdrawal call. |
 
 ```go
 EstimateGasWithdraw(ctx context.Context, msg WithdrawalCallMsg) (uint64, error)
@@ -1214,7 +1198,7 @@ Estimates the amount of gas required for an L1 to L2 execute operation.
 | Parameter | Type                                        | Description                                                      |
 | --------- | ------------------------------------------- | ---------------------------------------------------------------- |
 | `ctx`     | `context.Context`                           | Context.                                                         |
-| `msg`     | [`zkTypes.CallMsg`](/sdk/go/types/accounts#callmsg) | Contains parameters for contract call using EIP-712 transaction. |
+| `msg`     | [`zkTypes.CallMsg`](/sdk/go/api/accounts/types#callmsg) | Contains parameters for contract call using EIP-712 transaction. |
 
 ```go
 EstimateL1ToL2Execute(ctx context.Context, msg zkTypes.CallMsg) (uint64, error)
diff --git a/content/sdk/20.go/types/02.clients.md b/content/sdk/20.go/02.api/00.clients/02.types.md
similarity index 86%
rename from content/sdk/20.go/types/02.clients.md
rename to content/sdk/20.go/02.api/00.clients/02.types.md
index e089183a..0378ba11 100644
--- a/content/sdk/20.go/types/02.clients.md
+++ b/content/sdk/20.go/02.api/00.clients/02.types.md
@@ -1,8 +1,13 @@
 ---
-title: Clients Package
-description:
+title: Types
+description: Primary types used in the ZKsync Era
+tags: ["zksync", "types", "go", "sdk", "clients"]
 ---
 
+The following section describes key types used in the ZKsync
+Era. These types facilitate various blockchain operations, such as specifying block ranges, performing withdrawals, and
+executing transfers.
+
 ### `BlockRange`
 
 Represents a range of blocks with the starting and ending block numbers.
diff --git a/content/sdk/20.go/02.api/01.accounts/00.introduction.md b/content/sdk/20.go/02.api/01.accounts/00.introduction.md
new file mode 100644
index 00000000..6a4bdf29
--- /dev/null
+++ b/content/sdk/20.go/02.api/01.accounts/00.introduction.md
@@ -0,0 +1,55 @@
+---
+title: Introduction
+description: Overview of the accounts package in ZKsync Era
+tags: ["zksync", "accounts", "go", "sdk"]
+---
+
+The `accounts` package provides abstractions that wrap operations that interact with an account. An account typically
+contains a private key, allowing it to sign various types of payloads. There are the following interfaces that
+provide account operations for different purposes:
+
+- **Signer**: Provides support for signing EIP-712 transactions as well as other types of transactions supported by [`types.Signer`](https://pkg.go.dev/github.com/ethereum/go-ethereum@v1.12.0/core/types#Signer).
+- **AdapterL1**: Associated with an account and provides common operations on the L1 network for the associated account.
+- **AdapterL2**: Associated with an account and provides common operations on the L2 network for the associated account.
+- **Deployer**: Associated with an account and provides deployment of smart contracts and smart accounts on the L2
+network for the associated account.
+- **Adapter**: Consists of `AdapterL1`, `AdapterL2`, and `Deployer` interfaces.
+
+There are the following objects that provide account operations:
+
+### `BaseSigner`
+Implements the `Signer` interface. The `BaseSigner` is responsible for signing various types of transactions, including
+EIP-712 transactions. It abstracts the complexities involved in signing transactions, making it easier for developers
+to handle secure and authenticated interactions with the blockchain.
+
+### `WalletL1`
+Implements the `AdapterL1` interface. `WalletL1` is designed to manage and perform common operations on the Layer 1
+(L1) network. This includes sending transactions, checking balances, and interacting with smart contracts deployed on
+the Ethereum mainnet.
+
+### `WalletL2`
+Implements the `AdapterL2` interface. `WalletL2` facilitates operations on the Layer 2 (L2) network, specifically
+tailored for ZKsync Era. It handles transactions that benefit from the scalability and low fees of L2 solutions,
+providing a seamless way to interact with the L2 environment.
+
+### `BaseDeployer`
+Implements the `Deployer` interface. The `BaseDeployer` provides functionalities for deploying smart contracts and
+smart accounts on the L2 network. It simplifies the deployment process, ensuring that developers can easily and
+efficiently deploy their applications on ZKsync Era.
+
+### `Wallet`
+Implements the `Adapter` interface. The `Wallet` object combines the functionalities of `AdapterL1`, `AdapterL2`,
+and `Deployer`, offering a comprehensive tool for managing accounts and performing operations across both L1 and L2
+networks. It is the recommended object for most use cases as it provides all necessary operations in one place.
+
+### `SmartAccount`
+Provides enhanced support for account abstraction. The `SmartAccount` is designed to offer advanced account
+management capabilities, supporting complex account structures and operations.
+
+#### `NewECDSASmartAccount`
+Uses a single ECDSA key for signing payloads. This factory method creates a `SmartAccount` that leverages a single
+ECDSA key, ensuring simple yet secure transaction signing.
+
+#### `NewMultisigECDSASmartAccount`
+Uses multiple ECDSA keys for signing payloads. This method creates a `SmartAccount` that supports multisig
+functionality, enhancing security by requiring multiple signatures for transaction approval.
diff --git a/content/sdk/20.go/02.api/01.accounts/01.basesigner.md b/content/sdk/20.go/02.api/01.accounts/01.basesigner.md
new file mode 100644
index 00000000..b6cdfc63
--- /dev/null
+++ b/content/sdk/20.go/02.api/01.accounts/01.basesigner.md
@@ -0,0 +1,76 @@
+---
+title: BaseSigner
+description: Handles transaction signing for ZKsync
+tags: ["zksync", "baseSigner", "signer", "go", "sdk"]
+---
+
+The `BaseSigner` class is designed to handle the creation and management of signing keys, allowing secure and
+authenticated interactions with the ZKsync Era blockchain.
+
+### `Init`
+
+Creates a new instance of `BaseSigner` based on the provided mnemonic phrase.
+
+```go
+func NewBaseSignerFromMnemonic(mnemonic string, chainId int64) (*BaseSigner, error)
+```
+
+Creates a new instance of `BaseSigner` based on the provided mnemonic phrase and account ID.
+
+```go
+func NewBaseSignerFromMnemonicAndAccountId(mnemonic string, accountId uint32, chainId int64) (*BaseSigner, error)
+```
+
+Creates a new instance of BaseSigner based on the provided raw private key.
+
+```go
+func NewBaseSignerFromRawPrivateKey(rawPk []byte, chainId int64) (*BaseSigner, error)
+```
+
+Creates an instance of Signer with a randomly generated private key.
+
+```go
+func NewRandomBaseSigner(chainId int64) (*BaseSigner, error)
+```
+
+### `Address`
+
+Returns the address associated with the signer.
+
+```go
+Address() common.Address
+```
+
+### `Domain`
+
+Returns the EIP-712 domain used for signing.
+
+```go
+Domain() *eip712.Domain
+```
+
+### `PrivateKey`
+
+Returns the private key associated with the signer.
+
+```go
+PrivateKey() *ecdsa.PrivateKey
+```
+
+Signs the given hash using the signer's private key and returns the signature. The hash should be the 32-byte hash
+of the data to be signed.
+
+### `SignHash`
+
+```go
+SignHash(msg []byte) ([]byte, error)
+```
+
+### `SignTypeData`
+
+Signs the given EIP-712 typed data using the signer's private key and returns the signature. The domain parameter
+is the EIP-712 domain separator, and the data parameter is the EIP-712 typed data.
+
+```go
+SignTypedData(d *eip712.Domain, data eip712.TypedData) ([]byte, error)
+```
diff --git a/content/sdk/20.go/02.api/01.accounts/02.basedeployer.md b/content/sdk/20.go/02.api/01.accounts/02.basedeployer.md
new file mode 100644
index 00000000..aba81f20
--- /dev/null
+++ b/content/sdk/20.go/02.api/01.accounts/02.basedeployer.md
@@ -0,0 +1,165 @@
+---
+title: BaseDeployer
+description: Deploys smart contracts and accounts
+tags: ["zksync", "deployer", "smart contracts", "go", "sdk"]
+---
+
+The `BaseDeployer` facilitates the deployment of smart contracts and smart accounts on the ZKsync Era network. It
+provides methods to deploy contracts using both the `CREATE` and `CREATE2` methods, ensuring flexibility and security in
+contract deployment.
+
+### `Init`
+
+Creates an instance of `BaseDeployer` based on provided `AdapterL2`.
+
+```go
+func NewBaseDeployer(adapter *AdapterL2) *BaseDeployer
+```
+
+### `Deploy`
+
+Deploys smart contract using CREATE2 method.
+
+#### Inputs
+
+| Parameter | Type                                                      | Description                     |
+| --------- | --------------------------------------------------------- | ------------------------------- |
+| `auth`    | [`*TransactOpts`](/sdk/go/api/accounts/types#transactopts) (optional) | Transaction options.            |
+| `tx`      | [`Create2Transaction`](/sdk/go/api/accounts/types#create2transaction) | CREATE2 transaction parameters. |
+
+```go
+Deploy(auth *TransactOpts, tx Create2Transaction) (common.Hash, error)
+```
+
+#### Example
+
+```go
+bytecode, err := os.ReadFile("Storage.zbin")
+if err != nil {
+	log.Panic(err)
+}
+
+//Deploy smart contract
+hash, err := wallet.Deploy(nil, accounts.Create2Transaction{Bytecode: bytecode})
+if err != nil {
+	panic(err)
+}
+fmt.Println("Transaction: ", hash)
+```
+
+### `DeployWithCreate`
+
+Deploys smart contract using CREATE method.
+
+#### Inputs
+
+| Parameter | Type                                                    | Description                    |
+| --------- | ------------------------------------------------------- | ------------------------------ |
+| `auth`    | [`*TransactOpts`](/sdk/go/api/accounts/types#transactopts) (optional) | Transaction options.           |
+| `tx`      | [`CreateTransaction`](/sdk/go/api/accounts/types#createtransaction) | CREATE transaction parameters. |
+
+```go
+DeployWithCreate(auth *TransactOpts, tx CreateTransaction) (common.Hash, error)
+```
+
+#### Example
+
+```go
+bytecode, err := os.ReadFile("Storage.zbin")
+if err != nil {
+	log.Panic(err)
+}
+
+//Deploy smart contract
+hash, err := wallet.DeployWithCreate(nil, accounts.CreateTransaction{Bytecode: bytecode})
+if err != nil {
+	panic(err)
+}
+fmt.Println("Transaction: ", hash)
+```
+
+### `DeployAccount`
+
+Deploys smart account using CREATE2 method.
+
+#### Inputs
+
+| Parameter | Type                                                      | Description                     |
+| --------- | --------------------------------------------------------- | ------------------------------- |
+| `auth`    | [`*TransactOpts`](/sdk/go/api/accounts/types#transactopts) (optional) | Transaction options.            |
+| `tx`      | [`Create2Transaction`](/sdk/go/api/accounts/types#create2transaction) | CREATE2 transaction parameters. |
+
+```go
+DeployAccount(auth *TransactOpts, tx Create2Transaction) (common.Hash, error)
+```
+
+#### Example
+
+```go
+# Crown token on testnet
+TokenAddress := common.HexToAddress("0x927488F48ffbc32112F1fF721759649A89721F8F")
+
+_, paymasterAbi, bytecode, err := utils.ReadStandardJson("Paymaster.json")
+if err != nil {
+	log.Panic(err)
+}
+
+// Encode paymaster constructor
+constructor, err := paymasterAbi.Pack("", common.HexToAddress(TokenAddress))
+if err != nil {
+	log.Panic(err)
+}
+
+// Deploy paymaster contract
+hash, err := wallet.DeployAccount(nil, accounts.Create2Transaction{Bytecode: bytecode, Calldata: constructor})
+if err != nil {
+	log.Panic(err)
+}
+if err != nil {
+	log.Panic(err)
+}
+fmt.Println("Transaction: ", hash)
+
+```
+
+### `DeployAccountWithCreate`
+
+Deploys smart account using CREATE method.
+
+#### Inputs
+
+| Parameter | Type                                                    | Description                    |
+| --------- | ------------------------------------------------------- | ------------------------------ |
+| `auth`    | [`*TransactOpts`](/sdk/go/api/accounts/types#transactopts) (optional) | Transaction options.           |
+| `tx`      | [`CreateTransaction`](/sdk/go/api/accounts/types#createtransaction) | CREATE transaction parameters. |
+
+```go
+DeployAccountWithCreate(auth *TransactOpts, tx CreateTransaction) (common.Hash, error)
+```
+
+#### Example
+
+```go
+# Crown token on testnet
+TokenAddress := common.HexToAddress("0x927488F48ffbc32112F1fF721759649A89721F8F")
+
+_, paymasterAbi, bytecode, err := utils.ReadStandardJson("Paymaster.json")
+if err != nil {
+	log.Panic(err)
+}
+
+constructor, err := paymasterAbi.Pack("", common.HexToAddress(TokenAddress))
+if err != nil {
+	log.Panic(err)
+}
+
+// Deploy paymaster contract
+hash, err := wallet.DeployAccountWithCreate(nil, accounts.CreateTransaction{
+	Bytecode: bytecode,
+	Calldata: constructor,
+})
+if err != nil {
+	log.Panic(err)
+}
+fmt.Println("Transaction: ", hash)
+```
diff --git a/content/sdk/20.go/02.api/01.accounts/03.wallet.md b/content/sdk/20.go/02.api/01.accounts/03.wallet.md
new file mode 100644
index 00000000..6cc04be0
--- /dev/null
+++ b/content/sdk/20.go/02.api/01.accounts/03.wallet.md
@@ -0,0 +1,214 @@
+---
+title: Wallet
+description: Unified interface for managing accounts
+tags: ["zksync", "wallet", "account management", "go", "sdk"]
+---
+
+It contains the same functions
+as [`WalletL1`](/sdk/go/api/accounts/walletl1), [`WalletL2`](/sdk/go/api/accounts/walletl2), and [`BaseDeployer`](/sdk/go/api/accounts/basedeployer)
+since it implements the Adapter interface, and the usage of those methods is the same.
+
+### `Init`
+
+Creates an instance of `Wallet` associated with the account provided by the `rawPrivateKey`. The `clientL1`
+parameters is optional; if not provided, only methods from `AdapterL2` and `Deployer` interfaces can be used,
+as the rest of the functionalities require communication with the L1 network. A `Wallet` can be configured to
+communicate with L1 networks by using and [`ConnectL1`](#connectl1) method.
+
+```go
+func NewWallet(rawPrivateKey []byte, clientL2 *clients.Client, clientL1 *ethclient.Client) (*Wallet, error)
+```
+
+Creates an instance of Wallet associated with the account provided by the signer. The `clientL2` and `clientL1`
+parameters are optional; if not provided, only `SignTransaction`, `Address` and `Signer` methods can be used,
+as the rest of the functionalities require communication with the network. A wallet that contains only a
+signer can be configured to communicate with L2 and L1 networks by using [`Connect`](#connect) and
+[`ConnectL1`](#connectl1), respectively.
+
+```go
+func NewWalletFromSigner(signer Signer, clientL2 *clients.Client, clientL1 *ethclient.Client) (*Wallet, error)
+```
+
+Creates a new instance of `Wallet` based on the provided mnemonic phrase. The `clientL2` and `clientL1`
+parameters are optional, and can be configured with [`Connect`](#connect) and [`ConnectL1`](#connectl1), respectively.
+
+```go
+func NewWalletFromMnemonic(mnemonic string, chainId int64, clientL2 *clients.Client, clientL1 *ethclient.Client) (*Wallet, error)
+```
+
+Creates a new instance of `Wallet` based on the provided private key of the account and chain ID.
+The `clientL2` and `clientL1` parameters are optional, and can be configured with [`Connect`](#connect)
+and [`ConnectL1`](#connectl1), respectively.
+
+```go
+func NewWalletFromRawPrivateKey(rawPk []byte, chainId int64, clientL2 *clients.Client, clientL1 *ethclient.Client) (*Wallet, error)
+```
+
+Creates an instance of `Wallet` with a randomly generated account. The `clientL2` and `clientL1` parameters are
+optional, and can be configured with [`Connect`](#connect) and [`ConnectL1`](#connectl1), respectively.
+
+```go
+func NewRandomWallet(chainId int64, clientL2 *clients.Client, clientL1 *ethclient.Client) (*Wallet, error)
+```
+
+#### Example
+
+```go
+PrivateKey     := os.Getenv("PRIVATE_KEY")
+ZkSyncEraProvider := "https://sepolia.era.zksync.dev"
+EthereumProvider := "https://rpc.ankr.com/eth_sepolia"
+
+client, err := clients.Dial(ZkSyncEraProvider)
+if err != nil {
+	log.Panic(err)
+}
+defer client.Close()
+
+ethClient, err := ethclient.Dial(EthereumProvider)
+if err != nil {
+	log.Panic(err)
+}
+defer ethClient.Close()
+
+wallet, err := accounts.NewWallet(common.Hex2Bytes(PrivateKey), &client, ethClient)
+if err != nil {
+	log.Panic(err)
+}
+
+chainID, err := client.ChainID(context.Background())
+if err != nil {
+	log.Panic(err)
+}
+wallet, err = accounts.NewRandomWallet(chainID.Int64(),nil,nil)
+if err != nil {
+	log.Panic(err)
+}
+```
+
+### `Connect`
+
+Returns a new instance of `Wallet` with the provided client for the L2 network.
+
+#### Inputs
+
+| Parameter | Type                         | Description |
+| --------- | ---------------------------- | ----------- |
+| `client`  | [`*clients.Client`](/sdk/go/api/clients/introduction) | L2 client.  |
+
+```go
+Connect(client *clients.Client) (*Wallet, error)
+```
+
+#### Example
+
+```go
+PrivateKey     := os.Getenv("PRIVATE_KEY")
+ZkSyncEraProvider := "https://testnet.era.zksync.dev"
+
+client, err := clients.Dial(ZkSyncEraProvider)
+if err != nil {
+	log.Panic(err)
+}
+defer client.Close()
+
+chainID, err := client.ChainID(context.Background())
+if err != nil {
+	log.Panic(err)
+}
+
+wallet, err := accounts.NewRandomWallet(chainID, nil, nil)
+if err != nil {
+	log.Panic(err)
+}
+
+// create new wallet with connection to L2
+wallet, err = wallet.Connect(&client)
+if err != nil {
+	log.Panic(err)
+}
+```
+
+### `ConnectL1`
+
+Returns a new instance of `Wallet` with the provided client for the L1 network.
+
+#### Inputs
+
+| Parameter | Type                                                                                               | Description |
+| --------- | -------------------------------------------------------------------------------------------------- | ----------- |
+| `client`  | [`*ethclient.Client`](https://pkg.go.dev/github.com/ethereum/go-ethereum@v1.12.0/ethclient#Client) | L1 client.  |
+
+```go
+ConnectL1(client *ethclient.Client) (*Wallet, error)
+```
+
+#### Example
+
+```go
+chainID, err := client.ChainID(context.Background())
+if err != nil {
+	log.Panic(err)
+}
+
+wallet, err = accounts.NewRandomWallet(chainID, nil, nil)
+if err != nil {
+	log.Panic(err)
+}
+
+// create new wallet with connection to L1
+wallet, err = wallet.Connect(&ethClient)
+if err != nil {
+	log.Panic(err)
+}
+```
+
+### `Nonce`
+
+Returns the account nonce of the associated account. The block number can be `nil`, in which case the nonce is taken
+from the latest known block.
+
+#### Inputs
+
+| Parameter     | Type                  | Description   |
+| ------------- | --------------------- | ------------- |
+| `ctx`         | `context.Context`     | Context.      |
+| `blockNumber` | `*big.Int` (optional) | Block number. |
+
+```go
+Nonce(ctx context.Context, blockNumber *big.Int) (uint64, error)
+```
+
+#### Example
+
+```go
+nonce, err := wallet.Nonce(context.Background(), big.NewInt(9000))
+if err != nil {
+	log.Panic(err)
+}
+fmt.Println("Nonce: ", nonce)
+```
+
+### `PendingNonce`
+
+Returns the account nonce of the associated account in the pending state.
+This is the nonce that should be used for the next transaction.
+
+#### Inputs
+
+| Parameter | Type              | Description |
+| --------- | ----------------- | ----------- |
+| `ctx`     | `context.Context` | Context.    |
+
+```go
+PendingNonce(ctx context.Context) (uint64, error)
+```
+
+#### Example
+
+```go
+nonce, err := wallet.PendingNonce(context.Background())
+if err != nil {
+	log.Panic(err)
+}
+fmt.Println("Nonce: ", nonce)
+```
diff --git a/content/sdk/20.go/02.api/01.accounts/04.walletl1.md b/content/sdk/20.go/02.api/01.accounts/04.walletl1.md
new file mode 100644
index 00000000..d2479163
--- /dev/null
+++ b/content/sdk/20.go/02.api/01.accounts/04.walletl1.md
@@ -0,0 +1,1002 @@
+---
+title: WalletL1
+description: Manages and interacts with accounts on L1
+tags: ["zksync", "walletL1", "account management", "go", "sdk"]
+---
+
+The `WalletL1` class provides functionalities for managing and interacting with accounts on
+the Layer 1 (L1) network. It includes methods for creating wallets, querying contracts, checking balances, and
+performing transactions on the Ethereum network.
+
+### `Init`
+
+Creates an instance of WalletL1 associated with the account provided by the raw private key.
+
+```go
+func NewWalletL1(rawPrivateKey []byte, clientL1 *ethclient.Client, clientL2 *clients.Client) (*WalletL1, error
+```
+
+Creates an instance of WalletL1 associated with the account provided by the signer.
+
+```go
+NewWalletL1FromSigner(signer *Signer, clientL1 *ethclient.Client, clientL2 *clients.Client) (*WalletL1, error)
+```
+
+#### Example
+
+```go
+PrivateKey     := os.Getenv("PRIVATE_KEY")
+ZkSyncEraProvider := "https://sepolia.era.zksync.dev"
+EthereumProvider := "https://rpc.ankr.com/eth_sepolia"
+
+client, err := clients.Dial(ZkSyncEraProvider)
+if err != nil {
+	log.Panic(err)
+}
+defer client.Close()
+
+ethClient, err := ethclient.Dial(EthereumProvider)
+if err != nil {
+	log.Panic(err)
+}
+defer ethClient.Close()
+
+wallet, err := accounts.NewWalletL1(common.Hex2Bytes(PrivateKey), &client, ethClient)
+if err != nil {
+	log.Panic(err)
+}
+```
+
+### `MainContract`
+
+Returns the ZKsync L1 smart contract.
+
+#### Inputs
+
+| Parameter | Type              | Description |
+| --------- | ----------------- | ----------- |
+| `ctx`     | `context.Context` | Context.    |
+
+```go
+MainContract(ctx context.Context) (*zksync.IZkSync, error)
+```
+
+#### Example
+
+```go
+mainContract, err := wallet.MainContract(context.Background())
+if err != nil {
+	log.Panic(err)
+}
+```
+
+### `BridgehubContract`
+
+Returns the Bridgehub L1 smart contract.
+
+#### Inputs
+
+| Parameter | Type              | Description |
+| --------- | ----------------- | ----------- |
+| `ctx`     | `context.Context` | Context.    |
+
+```go
+BridgehubContract(_ context.Context) (*bridgehub.IBridgehub, error)
+```
+
+#### Example
+
+```go
+bridgehub, err := wallet.BridgehubContract(context.Background())
+if err != nil {
+	log.Panic(err)
+}
+```
+
+### `L1BridgeContracts`
+
+Returns L1 bridge contracts.
+
+#### Inputs
+
+| Parameter | Type              | Description |
+| --------- | ----------------- | ----------- |
+| `ctx`     | `context.Context` | Context.    |
+
+```go
+L1BridgeContracts(ctx context.Context) (*zkTypes.L1BridgeContracts, error)
+```
+
+#### Example
+
+```go
+contracts, err := wallet.L1BridgeContracts(context.Background())
+if err != nil {
+	log.Panic(err)
+}
+```
+
+### `BaseToken`
+
+Returns the address of the base token on L1.
+
+#### Inputs
+
+| Parameter | Type                                                     | Description |
+|-----------|----------------------------------------------------------| ----------- |
+| `opts`    | [`CallOpts`](/sdk/go/api/accounts/types#callopts) (optional) | Call options.  |
+
+```go
+BaseToken(opts *CallOpts) (common.Address, error)
+```
+
+#### Example
+
+```go
+baseToken, err := wallet.BaseToken(nil)
+if err != nil {
+	log.Panic(err)
+}
+fmt.Println("Base token: ", baseToken)
+```
+
+### `IsEthBasedChain`
+
+Returns whether the chain is ETH-based.
+
+#### Inputs
+
+| Parameter | Type              | Description |
+| --------- | ----------------- | ----------- |
+| `ctx`     | `context.Context` | Context.    |
+
+```go
+IsEthBasedChain(ctx context.Context) (bool, error)
+```
+
+#### Example
+
+```go
+isEthBased, err := wallet.IsEthBasedChain(context.Background())
+if err != nil {
+	log.Panic(err)
+}
+fmt.Println("Is ETH-based chain: ", isEthBased)
+```
+
+### `BalanceL1`
+
+Returns the balance of the specified token on L1 that can be either ETH or any ERC20 token.
+
+#### Inputs
+
+| Parameter | Type                                             | Description    |
+| --------- | ------------------------------------------------ | -------------- |
+| `opts`    | [`CallOpts`](/sdk/go/api/accounts/types#callopts) (optional) | Call options.  |
+| `token`   | `common.Address`                                 | Token address. |
+
+```go
+BalanceL1(opts *CallOpts, token common.Address) (*big.Int, error)
+```
+
+#### Example
+
+```go
+balance, err := wallet.BalanceL1(nil, utils.EthAddress)
+if err != nil {
+	log.Panic(err)
+}
+fmt.Println("Balance: ", balance)
+```
+
+### `AllowanceL1`
+
+Returns the amount of approved tokens for a specific L1 bridge.
+
+#### Inputs
+
+| Parameter       | Type                                             | Description     |
+| --------------- | ------------------------------------------------ | --------------- |
+| `opts`          | [`CallOpts`](/sdk/go/api/accounts/types#callopts) (optional) | Call options.   |
+| `token`         | `common.Address`                                 | Token address.  |
+| `bridgeAddress` | `common.Address`                                 | Bridge address. |
+
+```go
+AllowanceL1(opts *CallOpts, token common.Address, bridgeAddress common.Address) (*big.Int, error)
+```
+
+#### Example
+
+```go
+// The Crown token on testnet
+TokenAddress := common.HexToAddress("0x927488F48ffbc32112F1fF721759649A89721F8F")
+
+contracts, err := client.BridgeContracts(context.Background())
+if err != nil {
+	log.Panic(err)
+}
+bridgeAllowance, err := wallet.AllowanceL1(nil, TokenAddress, contracts.L1Erc20DefaultBridge)
+if err != nil {
+	log.Panic(err)
+}
+fmt.Println("Bridge allowance: ", bridgeAllowance)
+```
+
+### `L2TokenAddress`
+
+Returns the corresponding address on the L2 network for the token on the L1 network.
+
+#### Inputs
+
+| Parameter | Type              | Description       |
+| --------- | ----------------- | ----------------- |
+| `ctx`     | `context.Context` | Context.          |
+| `token`   | `common.Address`  | L1 token address. |
+
+```go
+L2TokenAddress(ctx context.Context, token common.Address) (common.Address, error)
+```
+
+#### Example
+
+```go
+l1DAI := common.HexToAddress("0x5C221E77624690fff6dd741493D735a17716c26B")
+l2DAI, err := wallet.L2TokenAddress(context.Background(), l1DAI)
+if err != nil {
+	log.Panic(err)
+}
+fmt.Println("L2 DAI address: ", l2DAI)
+```
+
+### `ApproveERC20`
+
+Approves the specified amount of tokens for the specified L1 bridge.
+
+#### Inputs
+
+| Parameter | Type              | Description       |
+| --------- | ----------------- | ----------------- |
+| `ctx`     | `context.Context` | Context.          |
+| `token`   | `common.Address`  | L1 token address. |
+| `amount`  | `*big.Int`        | Approval amount.  |
+
+```go
+ApproveERC20(auth *TransactOpts, token common.Address, amount *big.Int, bridgeAddress common.Address) (*types.Transaction, error)
+```
+
+#### Example
+
+```go
+// The Crown token on testnet
+TokenAddress := common.HexToAddress("0x927488F48ffbc32112F1fF721759649A89721F8F")
+
+contracts, err := client.BridgeContracts(context.Background())
+if err != nil {
+	log.Panic(err)
+}
+tx, err := wallet.ApproveERC20(nil, TokenAddress, contracts.L1Erc20DefaultBridge)
+if err != nil {
+	log.Panic(err)
+}
+fmt.Println("Tx: ", tx.Hash())
+```
+
+### `BaseCost`
+
+Returns base cost for L2 transaction.
+
+#### Inputs
+
+| Parameter           | Type                                             | Description                                                                            |
+| ------------------- | ------------------------------------------------ | -------------------------------------------------------------------------------------- |
+| `opts`              | [`CallOpts`](/sdk/go/api/accounts/types#callopts) (optional) | Call options.                                                                          |
+| `gasLimit`          | `*big.Int`                                       | The gasLimit for the the L2 contract call.                                             |
+| `gasPerPubdataByte` | `*big.Int`                                       | The L2 gas price for each published L1 calldata byte.                                  |
+| `gasPrice`          | `*big.Int` (optional)                            | The L1 gas price of the L1 transaction that will send the request for an execute call. |
+
+```go
+BaseCost(opts *CallOpts, gasLimit, gasPerPubdataByte, gasPrice *big.Int) (*big.Int, error)
+```
+
+#### Example
+
+```go
+gasPrice, err := client.SuggestGasPrice(context.Background())
+if err != nil {
+	log.Panic(err)
+}
+
+baseCost, err := wallet.BaseCost(nil, big.NewInt(9000), utils.RequiredL1ToL2GasPerPubdataLimit, gasPrice)
+if err != nil {
+	log.Panic(err)
+}
+fmt.Println("Base cost: ", baseCost)
+```
+
+### `DepositAllowanceParams`
+
+Returns the parameters for the approval token transaction based on the deposit token and amount.
+Some deposit transactions require multiple approvals. Existing allowance for the bridge is not checked;
+allowance is calculated solely based on the specified amount.
+
+#### Inputs
+
+| Parameter           | Type                                     | Description                                                                            |
+|---------------------| ---------------------------------------- | -------------------------------------------------------------------------------------- |
+| `opts`              | [`CallOpts`](/sdk/go/api/accounts/types#callopts) (optional) | Call options.                                                                          |
+| `msg`     | [`DepositCallMsg`](/sdk/go/api/accounts/types#depositcallmsg) | Deposit call parameters. |
+
+```go
+DepositAllowanceParams(opts *CallOpts, msg DepositCallMsg) ([]struct {
+    Token     common.Address
+    Allowance *big.Int
+}, error)
+```
+
+#### Example
+
+Get allowance parameters for depositing token on ETH-based chain.
+
+```go
+msg := accounts.DepositCallMsg{
+		Token:  common.HexToAddress("<L1 token address>"),
+		To:     Receiver,
+		Amount: big.NewInt(5),
+}
+
+allowanceParams, err := wallet.DepositAllowanceParams(nil, msg)
+if err != nil {
+    log.Panic(err)
+}
+bridgeContracts, err := client.BridgeContracts(context.Background())
+if err != nil {
+    log.Panic(err)
+}
+approveTx, err := wallet.ApproveERC20(nil, allowanceParams[0].Token, allowanceParams[0].Allowance, bridgeContracts.L1SharedBridge)
+if err != nil {
+    log.Panic(err)
+}
+_, err = bind.WaitMined(context.Background(), ethClient, approveTx)
+if err != nil {
+    log.Panic(err)
+}
+```
+
+Get allowance parameters for depositing ETH on non-ETH-based chain.
+
+```go
+msg := accounts.DepositCallMsg{
+		Token:  utils.LegacyEthAddress,
+		To:     Receiver,
+		Amount: big.NewInt(7_000_000_000),
+}
+
+allowanceParams, err := wallet.DepositAllowanceParams(nil, msg)
+if err != nil {
+    log.Panic(err)
+}
+bridgeContracts, err := client.BridgeContracts(context.Background())
+if err != nil {
+    log.Panic(err)
+}
+approveTx, err := wallet.ApproveERC20(nil, allowanceParams[0].Token, allowanceParams[0].Allowance, bridgeContracts.L1SharedBridge)
+if err != nil {
+    log.Panic(err)
+}
+_, err = bind.WaitMined(context.Background(), ethClient, approveTx)
+if err != nil {
+    log.Panic(err)
+}
+```
+
+Get allowance parameters for depositing base token on non-ETH-based chain.
+
+```go
+token, err := wallet.BaseToken(nil)
+if err != nil {
+    log.Panic(err)
+}
+
+msg := accounts.DepositCallMsg{
+    Token:  token,
+    To:     Receiver,
+    Amount: big.NewInt(7_000_000_000),
+}
+
+allowanceParams, err := wallet.DepositAllowanceParams(nil, msg)
+if err != nil {
+    log.Panic(err)
+}
+bridgeContracts, err := client.BridgeContracts(context.Background())
+if err != nil {
+    log.Panic(err)
+}
+approveTx, err := wallet.ApproveERC20(nil, allowanceParams[0].Token, allowanceParams[0].Allowance, bridgeContracts.L1SharedBridge)
+if err != nil {
+    log.Panic(err)
+}
+_, err = bind.WaitMined(context.Background(), ethClient, approveTx)
+if err != nil {
+    log.Panic(err)
+}
+```
+
+Get allowance parameters for depositing non-base token on non-ETH-based chain.
+
+```go
+msg := accounts.DepositCallMsg{
+		Token:  common.HexToAddress("<L1 token address>"),
+		To:     Receiver,
+		Amount: big.NewInt(5),
+}
+
+allowanceParams, err := wallet.DepositAllowanceParams(nil, msg)
+if err != nil {
+    log.Panic(err)
+}
+bridgeContracts, err := client.BridgeContracts(context.Background())
+if err != nil {
+    log.Panic(err)
+}
+approveTx, err := wallet.ApproveERC20(nil, allowanceParams[0].Token, allowanceParams[0].Allowance, bridgeContracts.L1SharedBridge)
+if err != nil {
+    log.Panic(err)
+}
+_, err = bind.WaitMined(context.Background(), ethClient, approveTx)
+if err != nil {
+    log.Panic(err)
+}
+approveTx, err = wallet.ApproveERC20(nil, allowanceParams[1].Token, allowanceParams[1].Allowance, bridgeContracts.L1SharedBridge)
+if err != nil {
+    log.Panic(err)
+}
+_, err = bind.WaitMined(context.Background(), ethClient, approveTx)
+if err != nil {
+    log.Panic(err)
+}
+```
+
+```go
+ZkSyncEraProvider := "https://testnet.era.zksync.dev"
+
+client, err := clients.Dial(ZkSyncEraProvider)
+if err != nil {
+	log.Panic(err)
+}
+defer client.Close()
+
+gasPrice, err := client.SuggestGasPrice(context.Background())
+if err != nil {
+	log.Panic(err)
+}
+
+baseCost, err := wallet.BaseCost(nil, big.NewInt(9000), utils.RequiredL1ToL2GasPerPubdataLimit, gasPrice)
+if err != nil {
+	log.Panic(err)
+}
+fmt.Println("Base cost: ", baseCost)
+```
+
+### `Deposit`
+
+Transfers the specified token from the associated account on the L1 network to the target account on the L2 network.
+The token can be either ETH or any ERC20 token. For ERC20 tokens, enough approved tokens must be associated with the
+specified L1 bridge (default one or the one defined in `BridgeAddress`). In this case, depending on is the chain
+ETH-based or not `ApproveERC20` or `ApproveBaseERC20` can be enabled to perform token approval.
+to perform token approval. If there are already enough approved tokens for the L1 bridge, token approval will be
+skipped. To check the amount of approved tokens for a specific bridge, use the [`AllowanceL1`](#allowancel1) method.
+
+#### Inputs
+
+| Parameter | Type                                                      | Description                    |
+| --------- | --------------------------------------------------------- |--------------------------------|
+| `auth`    | [`*TransactOpts`](/sdk/go/api/accounts/types#transactopts) (optional) | Transaction options.           |
+| `tx`      | [`DepositTransaction`](/sdk/go/api/accounts/types#deposittransaction) | Deposit transaction parameters.|
+
+```go
+Deposit(auth *TransactOpts, tx DepositTransaction) (*types.Transaction, error)
+```
+
+#### Example
+
+Deposit ETH on ETH-based chain.
+
+```go
+tx, err := wallet.Deposit(nil, accounts.DepositTransaction{
+		To:              wallet.Address(),
+		Token:           utils.LegacyEthAddress,
+		Amount:          amount,
+		RefundRecipient: wallet.Address(),
+})
+if err != nil {
+    log.Panic(err)
+}
+
+l1Receipt, err := bind.WaitMined(context.Background(), ethClient, tx)
+if err != nil {
+    log.Panic(err)
+}
+
+l2Tx, err := client.L2TransactionFromPriorityOp(context.Background(), l1Receipt)
+if err != nil {
+    log.Panic(err)
+}
+
+l2Receipt, err := client.WaitMined(context.Background(), l2Tx.Hash)
+if err != nil {
+    log.Panic(err)
+}
+```
+
+Deposit token on ETH-based chain.
+
+```go
+tx, err := wallet.Deposit(nil, accounts.DepositTransaction{
+		To:              wallet.Address(),
+		Token:           L1Dai,
+		Amount:          amount,
+		ApproveERC20:    true,
+		RefundRecipient: wallet.Address(),
+})
+if err != nil {
+    log.Panic(err)
+}
+
+l1Receipt, err := bind.WaitMined(context.Background(), ethClient, tx)
+if err != nil {
+    log.Panic(err)
+}
+
+l2Tx, err := client.L2TransactionFromPriorityOp(context.Background(), l1Receipt)
+if err != nil {
+    log.Panic(err)
+}
+
+l2Receipt, err := client.WaitMined(context.Background(), l2Tx.Hash)
+if err != nil {
+    log.Panic(err)
+}
+```
+
+Deposit ETH on non-ETH-based chain.
+
+```go
+tx, err := wallet.Deposit(nil, accounts.DepositTransaction{
+		To:               wallet.Address(),
+		Token:            utils.LegacyEthAddress,
+		Amount:           amount,
+		ApproveBaseERC20: true,
+		RefundRecipient:  wallet.Address(),
+})
+if err != nil {
+    log.Panic(err)
+}
+
+l1Receipt, err := bind.WaitMined(context.Background(), ethClient, tx)
+if err != nil {
+    log.Panic(err)
+}
+
+l2Tx, err := client.L2TransactionFromPriorityOp(context.Background(), l1Receipt)
+if err != nil {
+    log.Panic(err)
+}
+
+l2Receipt, err := client.WaitMined(context.Background(), l2Tx.Hash)
+if err != nil {
+    log.Panic(err)
+}
+```
+
+Deposit base token on non-ETH-based chain.
+
+```go
+baseToken, err := wallet.BaseToken(nil)
+if err != nil {
+    log.Panic(err)
+}
+
+tx, err := wallet.Deposit(nil, accounts.DepositTransaction{
+		To:               wallet.Address(),
+		Token:            baseToken,
+		Amount:           amount,
+		ApproveBaseERC20: true,
+		RefundRecipient:  wallet.Address(),
+})
+if err != nil {
+    log.Panic(err)
+}
+
+l1Receipt, err := bind.WaitMined(context.Background(), ethClient, tx)
+if err != nil {
+    log.Panic(err)
+}
+
+l2Tx, err := client.L2TransactionFromPriorityOp(context.Background(), l1Receipt)
+if err != nil {
+    log.Panic(err)
+}
+
+l2Receipt, err := client.WaitMined(context.Background(), l2Tx.Hash)
+if err != nil {
+    log.Panic(err)
+}
+```
+
+Deposit non-base token on non-ETH-based chain.
+
+```go
+tx, err := wallet.Deposit(nil, accounts.DepositTransaction{
+  To:               wallet.Address(),
+  Token:            L1Dai,
+  Amount:           amount,
+  ApproveERC20:     true,
+  ApproveBaseERC20: true,
+  RefundRecipient:  wallet.Address(),
+})
+if err != nil {
+    log.Panic(err)
+}
+
+l1Receipt, err := bind.WaitMined(context.Background(), ethClient, tx)
+if err != nil {
+    log.Panic(err)
+}
+
+l2Tx, err := client.L2TransactionFromPriorityOp(context.Background(), l1Receipt)
+if err != nil {
+    log.Panic(err)
+}
+
+l2Receipt, err := client.WaitMined(context.Background(), l2Tx.Hash)
+if err != nil {
+    log.Panic(err)
+}
+```
+
+### `EstimateGasDeposit`
+
+Estimates the amount of gas required for a deposit transaction on L1 network. Gas of approving ERC20 token is not
+included in the estimation.
+
+#### Inputs
+
+| Parameter | Type                                              | Description              |
+| --------- | ------------------------------------------------- | ------------------------ |
+| `ctx`     | `context.Context`                                 | Context.                 |
+| `msg`     | [`DepositCallMsg`](/sdk/go/api/accounts/types#depositcallmsg) | Deposit call parameters. |
+
+```go
+EstimateGasDeposit(ctx context.Context, msg DepositCallMsg) (uint64, error)
+```
+
+#### Example
+
+```go
+depositGas, err := wallet.EstimateGasDeposit(context.Background(), accounts.DepositCallMsg{
+	To:    wallet.Address(),
+	Token: utils.EthAddress,
+	Amount: big.NewInt(7_000_000_000),
+})
+if err != nil {
+	log.Panic(err)
+}
+fmt.Println("Deposit gas: ", depositGas)
+```
+
+### `FullRequiredDepositFee`
+
+Retrieves the full needed ETH fee for the deposit on both L1 and L2 networks.
+
+#### Inputs
+
+| Parameter | Type                                              | Description              |
+| --------- | ------------------------------------------------- | ------------------------ |
+| `ctx`     | `context.Context`                                 | Context.                 |
+| `msg`     | [`DepositCallMsg`](/sdk/go/api/accounts/types#depositcallmsg) | Deposit call parameters. |
+
+```go
+FullRequiredDepositFee(ctx context.Context, msg DepositCallMsg) (*FullDepositFee, error)
+```
+
+#### Example
+
+```go
+fee, err := wallet.FullRequiredDepositFee(context.Background(), accounts.DepositCallMsg{
+	To:    wallet.Address(),
+	Token: utils.EthAddress,
+	Amount: big.NewInt(7_000_000_000),
+})
+if err != nil {
+	log.Panic(err)
+}
+fmt.Printf("Fee: %+v\n", fee)
+```
+
+### `FinalizeWithdraw`
+
+Proves the inclusion of the L2 -> L1 withdrawal message.
+
+#### Inputs
+
+| Parameter        | Type                                                      | Description                                                                                                               |
+| ---------------- | --------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------- |
+| `auth`           | [`*TransactOpts`](/sdk/go/api/accounts/types#transactopts) (optional) | Transaction options.                                                                                                      |
+| `withdrawalHash` | `common.Hash`                                             | Hash of the L2 transaction where the withdrawal was initiated.                                                            |
+| `index`          | `int`                                                     | In case there were multiple withdrawals in one transaction, you may pass an index of the withdrawal you want to finalize. |
+
+```go
+FinalizeWithdraw(auth *TransactOpts, withdrawalHash common.Hash, index int) (*types.Transaction, error)
+```
+
+#### Example
+
+```go
+withdrawalHash := common.HexToHash("<tx hash>")
+finalizeWithdrawTx, err := wallet.FinalizeWithdraw(nil, withdrawalHash, 0)
+if err != nil {
+	log.Panic(err)
+}
+fmt.Println("Finalize withdraw transaction: ", finalizeWithdrawTx.Hash())
+```
+
+### `IsWithdrawFinalized`
+
+Checks if the withdrawal finalized on L1 network.
+
+#### Inputs
+
+| Parameter        | Type                                             | Description                                                                                                                |
+| ---------------- | ------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------- |
+| `opts`           | [`CallOpts`](/sdk/go/api/accounts/types#callopts) (optional) | Call options.                                                                                                              |
+| `withdrawalHash` | `common.Hash`                                    | Hash of the L2 transaction where the withdrawal was initiated.                                                             |
+| `index`          | `int`                                            | In case there where multiple withdrawals in one transaction, you may pass an index of the withdrawal you want to finalize. |
+
+```go
+IsWithdrawFinalized(opts *CallOpts, withdrawalHash common.Hash, index int) (bool, error)
+```
+
+#### Example
+
+```go
+withdrawalHash := common.HexToHash("<tx hash>")
+isFinalized, err := wallet.IsWithdrawFinalized(nil, withdrawalHash, 0)
+if err != nil {
+	log.Panic(err)
+}
+fmt.Println("Is withdrawal finalized: ", isFinalized)
+```
+
+### `ClaimFailedDeposit`
+
+Withdraws funds from the initiated deposit, which failed when finalizing on L2. If the deposit L2 transaction has
+failed, it sends an L1 transaction calling ClaimFailedDeposit method of the L1 bridge, which results in returning
+L1 tokens back to the depositor, otherwise throws the error.
+
+#### Inputs
+
+| Parameter     | Type                                                      | Description                                    |
+| ------------- | --------------------------------------------------------- | ---------------------------------------------- |
+| `auth`        | [`*TransactOpts`](/sdk/go/api/accounts/types#transactopts) (optional) | Transaction options.                           |
+| `depositHash` | `common.Hash`                                             | The L2 transaction hash of the failed deposit. |
+
+```go
+ClaimFailedDeposit(auth *TransactOpts, depositHash common.Hash) (*types.Transaction, error)
+```
+
+#### Example
+
+```go
+failedDepositL2Hash := common.HexToHash("<deposit L2 hash>")
+cfdTx, err := wallet.ClaimFailedDeposit(nil, failedDepositL2Hash)
+if err != nil {
+		log.Panic(err)
+}
+fmt.Println("ClaimFailedDeposit hash: ", cfdTx.Hash)
+```
+
+### `RequestExecute`
+
+Request execution of L2 transaction from L1.
+
+#### Inputs
+
+| Parameter | Type                                                                    | Description                             |
+| --------- | ----------------------------------------------------------------------- | --------------------------------------- |
+| `auth`    | [`*TransactOpts`](/sdk/go/api/accounts/types#transactopts) (optional)               | Transaction options.                    |
+| `tx`      | [`RequestExecuteTransaction`](/sdk/go/api/accounts/types#requestexecutetransaction) | Request execute transaction parameters. |
+
+```go
+RequestExecute(auth *TransactOpts, tx RequestExecuteTransaction) (*types.Transaction, error)
+```
+
+#### Example
+
+```go
+contractAddress := common.HexToAddress("<Contract address>")
+requestExecuteTx, err := wallet.RequestExecute(nil, accounts.RequestExecuteTransaction{
+	ContractAddress:   contractAddress,
+	L2Value:           big.NewInt(7_000_000_000),
+	L2GasLimit:        big.NewInt(90_000),
+	GasPerPubdataByte: utils.RequiredL1ToL2GasPerPubdataLimit,
+	RefundRecipient:   to,
+})
+if err != nil {
+	log.Panic(err)
+}
+fmt.Println("Request execute tx: ", requestExecuteTx.Hash())
+```
+
+### `EstimateGasRequestExecute`
+
+Estimates the amount of gas required for a request execute transaction.
+
+#### Inputs
+
+| Parameter | Type                                                            | Description                      |
+| --------- | --------------------------------------------------------------- | -------------------------------- |
+| `ctx`     | `context.Context`                                               | Context.                         |
+| `msg`     | [`RequestExecuteCallMsg`](/sdk/go/api/accounts/types#requestexecutecallmsg) | Request execute call parameters. |
+
+```go
+EstimateGasRequestExecute(ctx context.Context, msg RequestExecuteCallMsg) (uint64, error)
+```
+
+#### Example
+
+```go
+contractAddress := common.HexToAddress("<Contract address>")
+gas, err := wallet.EstimateGasRequestExecute(context.Background(), accounts.RequestExecuteCallMsg{
+	ContractAddress:   contractAddress,
+	L2Value:           big.NewInt(7_000_000_000),
+	L2GasLimit:        big.NewInt(90_000),
+	GasPerPubdataByte: utils.RequiredL1ToL2GasPerPubdataLimit,
+	RefundRecipient:   to,
+})
+if err != nil {
+	log.Panic(err)
+}
+fmt.Println("Gas: ", gas)
+```
+
+### `RequestExecuteAllowanceParams`
+
+Returns the parameters for the approval token transaction based on the request execute transaction.
+Existing allowance for the bridge is not checked; allowance is calculated solely based on the specified transaction.
+
+#### Inputs
+
+| Parameter | Type                                                            | Description                      |
+| --------- | --------------------------------------------------------------- | -------------------------------- |
+| `opts`           | [`CallOpts`](/sdk/go/api/accounts/types#callopts) (optional) | Call options.                                                                                                              |
+| `msg`     | [`RequestExecuteCallMsg`](/sdk/go/api/accounts/types#requestexecutecallmsg) | Request execute call parameters. |
+
+```go
+RequestExecuteAllowanceParams(opts *CallOpts, msg RequestExecuteCallMsg) (AllowanceParams, error)
+```
+
+#### Example
+
+```go
+msg := accounts.RequestExecuteCallMsg{
+  ContractAddress: wallet.Address(),
+  L2Value:         big.NewInt(7_000_000_000),
+  Value:           big.NewInt(0),
+}
+allowanceParams, err := wallet.RequestExecuteAllowanceParams(nil, msg)
+if err != nil {
+    log.Panic(err)
+}
+
+bridgeContracts, err := client.BridgeContracts(context.Background())
+if err != nil {
+    log.Panic(err)
+}
+
+approveTx, err := wallet.ApproveERC20(nil, allowanceParams.Token, allowanceParams.Allowance, bridgeContracts.L1SharedBridge)
+if err != nil {
+    log.Panic(err)
+}
+
+_, err = bind.WaitMined(context.Background(), ethClient, approveTx)
+if err != nil {
+    log.Panic(err)
+}
+```
+
+### `EstimateCustomBridgeDepositL2Gas`
+
+Used by [`EstimateDefaultBridgeDepositL2Gas`](#estimatedefaultbridgedepositl2gas) to estimate L2 gas
+required for token bridging via a custom ERC20 bridge.
+
+::callout{icon="i-heroicons-information-circle" color="blue"}
+See the [default bridges documentation](https://docs.zksync.io/build/developer-reference/bridging-assets#default-bridges)
+::
+
+#### Inputs
+
+| Parameter           | Type                        | Description                      |
+| ------------------- | --------------------------- | -------------------------------- |
+| `ctx`               | `context.Context`           | Context.                         |
+| `l1BridgeAddress`   | `common.Address`            | L1 bridge address.               |
+| `l2BridgeAddress`   | `common.Address`            | L2 bridge address.               |
+| `token`             | `common.Address`            | Token address.                   |
+| `amount`            | `*big.Int`                  | Deposit amount.                  |
+| `to`                | `common.Address`            | Recipient address.               |
+| `bridgeData`        | `[]byte`                    | Bridge data.                     |
+| `from`              | `common.Address` (optional) | Sender address.                  |
+| `gasPerPubdataByte` | `*big.Int` (optional)       | Current gas per byte of pubdata. |
+
+```go
+EstimateCustomBridgeDepositL2Gas(ctx context.Context, l1BridgeAddress, l2BridgeAddress, token common.Address,
+	amount *big.Int, to common.Address, bridgeData []byte, from common.Address, gasPerPubdataByte *big.Int) (uint64, error)
+```
+
+#### Example
+
+```go
+L1BridgeAddress := common.HexToAddress("<Bridge address>")
+Token := common.HexToAddress("<Token address>")
+From := common.HexToAddress("<Sender address>")
+To := common.HexToAddress("<Receipt address>")
+
+
+bridge, err := l1bridge.NewIL1Bridge(L1BridgeAddress, ethClient)
+if err != nil {
+	log.Panic(err)
+}
+l2BridgeAddress, err := bridge.L2Bridge(nil)
+if err != nil {
+	log.Panic(err)
+}
+customBridgeData, err := utils.Erc20DefaultBridgeData(Token, ethClient)
+if err != nil {
+	log.Panic(err)
+}
+
+gas, err := wallet1.EstimateCustomBridgeDepositL2Gas(context.Background(), L1BridgeAddress, l2BridgeAddress, Token,
+	big.NewInt(7), To, customBridgeData, From, utils.RequiredL1ToL2GasPerPubdataLimit)
+if err != nil {
+	log.Panic(err)
+}
+fmt.Println("L2 gas: ", gas)
+```
+
+### `EstimateDefaultBridgeDepositL2Gas`
+
+Returns an estimation of L2 gas required for token bridging via the default ERC20 bridge.
+
+::callout{icon="i-heroicons-information-circle" color="blue"}
+See the [default bridges documentation](https://docs.zksync.io/build/developer-reference/bridging-assets#default-bridges)
+::
+
+#### Inputs
+
+| Parameter           | Type                        | Description                      |
+| ------------------- | --------------------------- | -------------------------------- |
+| `ctx`               | `context.Context`           | Context.                         |
+| `token`             | `common.Address`            | Token address.                   |
+| `amount`            | `*big.Int`                  | Deposit amount.                  |
+| `to`                | `common.Address`            | Recipient address.               |
+| `from`              | `common.Address` (optional) | Sender address.                  |
+| `gasPerPubdataByte` | `*big.Int` (optional)       | Current gas per byte of pubdata. |
+
+```go
+EstimateDefaultBridgeDepositL2Gas(ctx context.Context, token common.Address, amount *big.Int,
+	to, from common.Address, gasPerPubdataByte *big.Int) (uint64, error)
+```
+
+#### Example
+
+```go
+Token := common.HexToAddress("<Token address>")
+From := common.HexToAddress("<Sender address>")
+To := common.HexToAddress("<Receipt address>")
+gas, err := wallet1.EstimateDefaultBridgeDepositL2Gas(
+	context.Background(), Token, big.NewInt(7), To, From, utils.RequiredL1ToL2GasPerPubdataLimit,
+)
+if err != nil {
+	log.Panic(err)
+}
+fmt.Println("L2 gas: ", gas)
+```
diff --git a/content/sdk/20.go/02.api/01.accounts/05.walletl2.md b/content/sdk/20.go/02.api/01.accounts/05.walletl2.md
new file mode 100644
index 00000000..ff702eb2
--- /dev/null
+++ b/content/sdk/20.go/02.api/01.accounts/05.walletl2.md
@@ -0,0 +1,523 @@
+---
+title: WalletL2
+description: Manages and interacts with accounts on L2
+tags: ["zksync", "walletL2", "account management", "go", "sdk"]
+---
+
+The `WalletL2` class provides functionalities for managing and interacting with accounts on
+the Layer 2 (L2) network. It includes methods for creating wallets, querying balances, transferring tokens, and
+interacting with smart contracts on the ZKsync network.
+
+### `Init`
+
+Creates an instance of `WalletL2` associated with the account provided by the raw private key.
+
+```go
+func NewWalletL2(rawPrivateKey []byte, client *clients.Client) (*WalletL2, error)
+```
+
+Creates an instance of `WalletL2`. The `client` can be optional; if it is not provided, only
+`SignTransaction`, `Address`, `Signer` can be  performed, as the rest of the functionalities
+require communication to the network.
+
+```go
+func NewWalletL2FromSigner(signer *Signer, client *clients.Client) (*WalletL2, error)
+```
+
+#### Example
+
+```go
+PrivateKey     := os.Getenv("PRIVATE_KEY")
+ZkSyncEraProvider := "https://testnet.era.zksync.dev"
+
+client, err := clients.Dial(ZkSyncEraProvider)
+if err != nil {
+	log.Panic(err)
+}
+defer client.Close()
+
+wallet, err := accounts.NewWallet(common.Hex2Bytes(PrivateKey), &client)
+if err != nil {
+	log.Panic(err)
+}
+
+```
+
+### `Address`
+
+Returns the address of the associated account.
+
+```go
+Address() common.Address
+```
+
+#### Example
+
+```go
+fmt.Println("Address: ", wallet.Address())
+```
+
+### `Signer`
+
+Returns the signer of the associated account.
+
+```go
+Signer() Signer
+```
+
+#### Example
+
+```go
+fmt.Printf("Signer %+v\n", wallet.Signer())
+```
+
+### `Balance`
+
+Returns the balance of the specified token that can be either ETH or any ERC20 token. The block number can be `nil`,
+in which case the balance is taken from the latest known block.
+
+#### Inputs
+
+| Parameter | Type              | Description       |
+| --------- | ----------------- | ----------------- |
+| `ctx`     | `context.Context` | Context.          |
+| `token`   | `common.Address`  | L2 token address. |
+| `at`      | `*big.Int`        | Block number.     |
+
+```go
+Balance(ctx context.Context, token common.Address, at *big.Int) (*big.Int, error)
+```
+
+#### Example
+
+```go
+balance, err := wallet.Balance(context.Background(), utils.EthAddress, nil)
+if err != nil {
+	log.Panic(err)
+}
+fmt.Println("Balance: ", balance)
+```
+
+### `AllBalances`
+
+Returns all balances for confirmed tokens given by an associated account.
+
+#### Inputs
+
+| Parameter | Type              | Description |
+| --------- | ----------------- | ----------- |
+| `ctx`     | `context.Context` | Context.    |
+
+```go
+AllBalances(ctx context.Context) (map[common.Address]*big.Int, error)
+```
+
+#### Example
+
+```go
+balances, err := wallet.AllBalances(context.Background())
+if err != nil {
+	log.Panic(err)
+}
+fmt.Printf("Balances: %+v\n", balances)
+```
+
+### `L2BridgeContracts`
+
+Returns L2 bridge contracts.
+
+#### Inputs
+
+| Parameter | Type              | Description |
+| --------- | ----------------- | ----------- |
+| `ctx`     | `context.Context` | Context.    |
+
+```go
+L2BridgeContracts(ctx context.Context) (*zkTypes.L2BridgeContracts, error)
+```
+
+#### Example
+
+```go
+contracts, err := wallet.L2BridgeContracts(context.Background())
+if err != nil {
+	log.Panic(err)
+}
+```
+
+### `DeploymentNonce`
+
+Returns the deployment nonce of the account.
+
+#### Inputs
+
+| Parameter | Type                                             | Description   |
+| --------- | ------------------------------------------------ | ------------- |
+| `opts`    | [`CallOpts`](/sdk/go/api/accounts/types#callopts) (optional) | Call options. |
+
+```go
+func (a *WalletL2) DeploymentNonce(opts *CallOpts) (*big.Int, error)
+```
+
+#### Example
+
+```go
+deploymentNonce, err := wallet.DeploymentNonce(nil)
+if err != nil {
+    log.Panic(err)
+}
+```
+
+### `IsBaseToken`
+
+Returns whether the token is the base token.
+
+#### Inputs
+
+| Parameter | Type              | Description    |
+| --------- | ----------------- |----------------|
+| `ctx`     | `context.Context` | Context.       |
+| `token`   | `common.Address`  | Token address. |
+
+```go
+IsBaseToken(ctx context.Context, token common.Address) (bool, error)
+```
+
+#### Example
+
+```go
+isBaseToken, err := wallet.IsBaseToken(
+  context.Background(),
+  common.HexToAddress("0x5C221E77624690fff6dd741493D735a17716c26B")
+)
+if err != nil {
+    log.Panic(err)
+}
+fmt.Println("Is base token: ", isBaseToken)
+```
+
+### `Withdraw`
+
+Initiates the withdrawal process which withdraws ETH or any ERC20 token from the associated account on L2 network
+to the target account on L1 network.
+
+#### Inputs
+
+| Parameter | Type                                                            | Description                        |
+| --------- | --------------------------------------------------------------- | ---------------------------------- |
+| `auth`    | [`*TransactOpts`](/sdk/go/api/accounts/types#transactopts) (optional)       | Transaction options.               |
+| `tx`      | [`WithdrawalTransaction`](/sdk/go/api/accounts/types#withdrawaltransaction) | Withdrawal transaction parameters. |
+
+```go
+Withdraw(auth *TransactOpts, tx WithdrawalTransaction) (*types.Transaction, error)
+```
+
+#### Example
+
+```go
+tx, err := wallet.Withdraw(nil, accounts.WithdrawalTransaction{
+	To:     wallet.Address(),
+	Amount: big.NewInt(1_000_000_000_000_000_000),
+	Token:  utils.EthAddress,
+})
+if err != nil {
+	panic(err)
+}
+fmt.Println("Withdraw transaction: ", tx.Hash())
+```
+
+### `EstimateGasWithdraw`
+
+Estimates the amount of gas required for a withdrawal transaction.
+
+#### Inputs
+
+| Parameter | Type                                                    | Description                 |
+| --------- | ------------------------------------------------------- | --------------------------- |
+| `ctx`     | `context.Context`                                       | Context.                    |
+| `msg`     | [`WithdrawalCallMsg`](/sdk/go/api/accounts/types#withdrawalcallmsg) | Withdrawal call parameters. |
+
+```go
+EstimateGasWithdraw(ctx context.Context, msg WithdrawalCallMsg) (uint64, error)
+```
+
+#### Example
+
+```go
+gas, err := wallet.EstimateGasWithdraw(context.Background(), accounts.WithdrawalCallMsg{
+	To:   wallet.Address(),
+	Amount: big.NewInt(7_000_000),
+	Token:  utils.EthAddress,
+})
+if err != nil {
+	log.Panic(err)
+}
+fmt.Println("Gas: ", gas)
+```
+
+### `Transfer`
+
+Moves the ETH or any ERC20 token from the associated account to the target account.
+
+#### Inputs
+
+| Parameter | Type                                                        | Description                      |
+| --------- | ----------------------------------------------------------- | -------------------------------- |
+| `auth`    | [`*TransactOpts`](/sdk/go/api/accounts/types#transactopts) (optional)   | Transaction options.             |
+| `tx`      | [`TransferTransaction`](/sdk/go/api/accounts/types#transfertransaction) | Transfer transaction parameters. |
+
+```go
+Transfer(auth *TransactOpts, tx TransferTransaction) (*types.Transaction, error)
+```
+
+#### Example
+
+```go
+tx, err := wallet.Transfer(nil, accounts.TransferTransaction{
+	To:     common.HexToAddress("<Receipt address>"),
+	Amount: big.NewInt(7_000_000_000),
+	Token:  utils.EthAddress,
+})
+if err != nil {
+	log.Panic(err)
+}
+fmt.Println("Transaction: ", tx.Hash())
+```
+
+### `EstimateGasTransfer`
+
+Estimates the amount of gas required for a transfer transaction.
+
+#### Inputs
+
+| Parameter | Type                                                | Description               |
+| --------- | --------------------------------------------------- | ------------------------- |
+| `ctx`     | `context.Context`                                   | Context.                  |
+| `msg`     | [`TransferCallMsg`](/sdk/go/api/accounts/types#transfercallmsg) | Transfer call parameters. |
+
+```go
+EstimateGasTransfer(ctx context.Context, msg TransferCallMsg) (uint64, error)
+```
+
+#### Example
+
+```go
+gas, err := wallet.EstimateGasTransfer(context.Background(), accounts.TransferCallMsg{
+	To:   common.HexToAddress("<Receipt address>"),
+	Amount: big.NewInt(7_000_000_000),
+	Token:  utils.EthAddress,
+})
+if err != nil {
+	log.Panic(err)
+}
+fmt.Println("Gas: ", gas)
+```
+
+### `CallContract`
+
+Executes a message call for EIP-712 transaction, which is directly executed in the VM of the node, but never mined
+into the blockchain.
+
+#### Inputs
+
+| Parameter     | Type                                | Description                                                                                                                                                                                 |
+| ------------- | ----------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `ctx`         | `context.Context`                   | Context.                                                                                                                                                                                    |
+| `msg`         | [`CallMsg`](/sdk/go/api/accounts/types#callmsg) | Contains parameters for contract call using EIP-712 transaction.                                                                                                                            |
+| `blockNumber` | `*big.Int` (optional)               | Selects the block height at which the call runs. It can be `nil`, in which case the code is taken from the latest known block. Note that state from very old blocks might not be available. |
+
+```go
+CallContract(ctx context.Context, msg CallMsg, blockNumber *big.Int) ([]byte, error)
+```
+
+#### Example
+
+```go
+// The Crown token on testnet
+TokenAddress := common.HexToAddress("0x927488F48ffbc32112F1fF721759649A89721F8F")
+
+tokenAbi, err := erc20.IERC20MetaData.GetAbi()
+if err != nil {
+	log.Panic(err)
+}
+symbolCalldata, err := tokenAbi.Pack("symbol")
+if err != nil {
+	log.Panic(err)
+}
+
+result, err := wallet.CallContract(context.Background(), types.CallMsg{
+	CallMsg: ethereum.CallMsg{
+		To:   &TokenAddress,
+		Data: symbolCalldata,
+	},
+}, nil)
+if err != nil {
+	log.Panic(err)
+}
+unpack, err := tokenAbi.Unpack("symbol", result)
+if err != nil {
+	log.Panic(err)
+}
+symbol := *abi.ConvertType(unpack[0], new(string)).(*string)
+fmt.Println("Symbol: ", symbol)
+```
+
+### PopulateTransaction
+
+Designed for users who prefer a simplified approach by providing only the necessary data to create a valid
+[EIP-712 transaction](/sdk/go/api/types#transaction712). The only required fields are `Transaction.To` and either
+`Transaction.Data` or `Transaction.Value` (or both, if the method is payable).
+Any other fields that are not set will be prepared by this method.
+
+#### Inputs
+
+| Parameter | Type                                        | Description             |
+| --------- | ------------------------------------------- | ----------------------- |
+| `ctx`     | `context.Context`                           | Context.                |
+| `tx`      | [`Transaction`](/sdk/go/api/accounts/types#transaction) | Transaction parameters. |
+
+```go
+PopulateTransaction(ctx context.Context, tx Transaction) (*zkTypes.Transaction712, error)
+```
+
+#### Example
+
+```go
+// The Crown token on testnet
+TokenAddress := common.HexToAddress("0x927488F48ffbc32112F1fF721759649A89721F8F")
+// Paymaster for Crown token on testnet
+PaymasterAddress := common.HexToAddress("0x13D0D8550769f59aa241a41897D4859c87f7Dd46")
+ReceiptAddress := common.HexToAddress("0xa61464658AfeAf65CccaaFD3a512b69A83B77618")
+
+abi, err := erc20.IERC20MetaData.GetAbi()
+if err != nil {
+	log.Panic(err)
+}
+
+// Encode transfer function from token contract
+calldata, err := abi.Pack("transfer", ReceiptAddress, big.NewInt(7))
+if err != nil {
+	log.Panic(err)
+}
+
+preparedTx, err := wallet.PopulateTransaction(context.Background(), &accounts.Transaction{
+	To:   &TokenAddress,
+	Data: calldata,
+})
+fmt.Printf("Prepared tx: %+v\n", preparedTx)
+```
+
+### `SignTransaction`
+
+Returns a signed transaction that is ready to be broadcast to the network. The input transaction must be a valid
+transaction with all fields having appropriate values. To obtain a valid transaction, you can use the
+[`PopulateTransaction`](#populatetransaction) method.
+
+#### Inputs
+
+| Parameter | Type                                                           | Description                     |
+| --------- |----------------------------------------------------------------| ------------------------------- |
+| `tx`      | [`zkTypes.Transaction712`](/sdk/go/api/types#transaction712) | EIP-712 transaction parameters. |
+
+```go
+SignTransaction(tx *zkTypes.Transaction712) ([]byte, error)
+```
+
+#### Example
+
+```go
+// The Crown token on testnet
+TokenAddress := common.HexToAddress("0x927488F48ffbc32112F1fF721759649A89721F8F")
+// Paymaster for Crown token on testnet
+PaymasterAddress := common.HexToAddress("0x13D0D8550769f59aa241a41897D4859c87f7Dd46")
+ReceiptAddress := common.HexToAddress("0xa61464658AfeAf65CccaaFD3a512b69A83B77618")
+
+abi, err := erc20.IERC20MetaData.GetAbi()
+if err != nil {
+	log.Panic(err)
+}
+
+// Encode transfer function from token contract
+calldata, err := abi.Pack("transfer", ReceiptAddress, big.NewInt(7))
+if err != nil {
+	log.Panic(err)
+}
+
+preparedTx, err := wallet.PopulateTransaction(context.Background(), &accounts.Transaction{
+	To:   &TokenAddress,
+	Data: calldata,
+})
+
+signedTx, err := wallet.SignTransaction(preparedTx)
+if err != nil {
+	log.Panic(err)
+}
+fmt.Printf("Signed tx: %+v\n", signedTx)
+```
+
+### `SendTransaction`
+
+Injects a transaction into the pending pool for execution. Any unset transaction fields are prepared using the
+`PopulateTransaction` method.
+
+#### Inputs
+
+| Parameter | Type                                        | Description             |
+| --------- | ------------------------------------------- | ----------------------- |
+| `ctx`     | `context.Context`                           | Context.                |
+| `tx`      | [`Transaction`](/sdk/go/api/accounts/types#transaction) | Transaction parameters. |
+
+```go
+SendTransaction(ctx context.Context, tx *Transaction) (common.Hash, error)
+```
+
+#### Example
+
+```go
+// The Crown token on testnet
+TokenAddress := common.HexToAddress("0x927488F48ffbc32112F1fF721759649A89721F8F")
+// Paymaster for Crown token on testnet
+PaymasterAddress := common.HexToAddress("0x13D0D8550769f59aa241a41897D4859c87f7Dd46")
+ReceiptAddress := common.HexToAddress("0xa61464658AfeAf65CccaaFD3a512b69A83B77618")
+
+abi, err := erc20.IERC20MetaData.GetAbi()
+if err != nil {
+	log.Panic(err)
+}
+
+// Encode transfer function from token contract
+calldata, err := abi.Pack("transfer", ReceiptAddress, big.NewInt(7))
+if err != nil {
+	log.Panic(err)
+}
+
+// Create paymaster parameters with encoded paymaster input
+paymasterParams, err := utils.GetPaymasterParams(
+	PaymasterAddress,
+	&zkTypes.ApprovalBasedPaymasterInput{
+		Token:            TokenAddress,
+		MinimalAllowance: big.NewInt(1),
+		InnerInput:       []byte{},
+	})
+if err != nil {
+	log.Panic(err)
+}
+
+hash, err := wallet.SendTransaction(context.Background(), &accounts.Transaction{
+	To:   &TokenAddress,
+	Data: calldata,
+	Meta: &types.Eip712Meta{
+		PaymasterParams: paymasterParams,
+	},
+})
+if err != nil {
+	log.Panic(err)
+}
+
+_, err = client.WaitMined(context.Background(), hash)
+if err != nil {
+	log.Panic(err)
+}
+
+fmt.Println("Tx: ", hash)
+```
diff --git a/content/sdk/20.go/02.api/01.accounts/06.smartaccount.md b/content/sdk/20.go/02.api/01.accounts/06.smartaccount.md
new file mode 100644
index 00000000..19da7ee3
--- /dev/null
+++ b/content/sdk/20.go/02.api/01.accounts/06.smartaccount.md
@@ -0,0 +1,482 @@
+---
+title: SmartAccount
+description: Flexible signer for various payloads
+tags: ["zksync", "smart account", "signer", "go", "sdk"]
+---
+
+A `SmartAccount` is a signer which can be configured to sign various payloads using a provided secret.
+The secret can be in any form, allowing for flexibility when working with different account implementations.
+The `SmartAccount` is bound to a specific address and provides the ability to define custom method for populating transactions
+and custom signing method used for signing messages, typed data, and transactions.
+
+### `Init`
+
+Creates a new `SmartAccount` instance. By default, it uses [`SignPayloadWithECDSA`](/sdk/go/api/accounts/smart-account-utils#signpayloadwithecdsa)
+as a signer and [`PopulateTransactionECDSA`](/sdk/go/api/accounts/smart-account-utils#populatetransactionecdsa) as
+a builder and
+requires private key in hex format to be provided.
+
+#### Inputs
+
+| Parameter | Type                                                               | Description                                             |
+|-----------|--------------------------------------------------------------------|---------------------------------------------------------|
+| `address` | `common.Address`                                                   | Account address.                                        |
+| `secret`  | `interface{}`                                                      | Secret used for signing.                                |
+| `signer`  | [`*PayloadSigner`](/sdk/go/api/accounts/types#payloadsigner)           | Function used for signing payload.                      |
+| `builder` | [`*TransactionBuilder`](/sdk/go/api/accounts/types#transactionbuilder) | Function used for populating transaction.               |
+| `client`  | [`*clients.BaseClient`](/sdk/go/api/clients/baseclient)                       | The client to connect to. Can be `nil` for offline usage. |
+
+```go
+
+func NewSmartAccount(
+	address common.Address,
+	secret interface{},
+	signer *PayloadSigner,
+	builder *TransactionBuilder,
+	client *clients.BaseClient) *SmartAccount
+```
+
+#### Examples
+
+```go
+privateKey     := os.Getenv("PRIVATE_KEY")
+address := common.HexToAddress("<ACCOUNT ADDRESS>")
+ZkSyncEraProvider := "https://sepolia.era.zksync.dev"
+
+client, err := clients.DialBase(ZkSyncEraProvider)
+if err != nil {
+	log.Panic(err)
+}
+defer client.Close()
+
+account := accounts.NewSmartAccount(
+    address,
+    privateKey,
+    &accounts.SignPayloadWithECDSA,
+    &accounts.PopulateTransactionECDSA,
+nil)
+```
+
+### `Connect`
+
+Creates a new instance of SmartAccount connected to a client or
+detached from any provider if `nil` is provided.
+
+#### Inputs
+
+| Parameter | Type                                              | Description                                                                                                   |
+| --------- |---------------------------------------------------|---------------------------------------------------------------------------------------------------------------|
+| `client`  | [`*clients.DialBase`](/sdk/go/api/clients/baseclient) | The client to connect the `SmartAccount` to. If `nil`, the `SmartAccount` will be detached from any provider. |
+
+```go
+Connect(client *clients.BaseClient) *SmartAccount
+```
+
+#### Example
+
+```go
+privateKey     := os.Getenv("PRIVATE_KEY")
+ZkSyncEraProvider := "https://testnet.era.zksync.dev"
+
+client, err := clients.Dial(ZkSyncEraProvider)
+if err != nil {
+	log.Panic(err)
+}
+defer client.Close()
+
+account := accounts.NewECDSASmartAccount(Address1, PrivateKey1, nil)
+account = account.Connect(client)
+```
+
+### `Address`
+
+Returns the address of the associated account.
+
+```go
+Address() common.Address
+```
+
+#### Example
+
+```go
+fmt.Println("Address: ", account.Address())
+```
+
+### `Balance`
+
+Returns the balance of the specified token that can be either ETH or any ERC20 token. The block number can be `nil`,
+in which case the balance is taken from the latest known block.
+
+#### Inputs
+
+| Parameter | Type              | Description       |
+| --------- | ----------------- | ----------------- |
+| `ctx`     | `context.Context` | Context.          |
+| `token`   | `common.Address`  | L2 token address. |
+| `at`      | `*big.Int`        | Block number.     |
+
+```go
+Balance(ctx context.Context, token common.Address, at *big.Int) (*big.Int, error)
+```
+
+#### Example
+
+```go
+balance, err := account.Balance(context.Background(), utils.EthAddress, nil)
+if err != nil {
+	log.Panic(err)
+}
+fmt.Println("Balance: ", balance)
+```
+
+### `AllBalances`
+
+Returns all balances for confirmed tokens given by an associated account.
+
+#### Inputs
+
+| Parameter | Type              | Description |
+| --------- | ----------------- | ----------- |
+| `ctx`     | `context.Context` | Context.    |
+
+```go
+AllBalances(ctx context.Context) (map[common.Address]*big.Int, error)
+```
+
+#### Example
+
+```go
+balances, err := account.AllBalances(context.Background())
+if err != nil {
+	log.Panic(err)
+}
+fmt.Printf("Balances: %+v\n", balances)
+```
+
+### `Nonce`
+
+Returns the account nonce of the associated account. The block number can be `nil`, in which case the nonce is taken
+from the latest known block.
+
+#### Inputs
+
+| Parameter     | Type                  | Description   |
+| ------------- | --------------------- | ------------- |
+| `ctx`         | `context.Context`     | Context.      |
+| `blockNumber` | `*big.Int` (optional) | Block number. |
+
+```go
+Nonce(ctx context.Context, blockNumber *big.Int) (uint64, error)
+```
+
+#### Example
+
+```go
+nonce, err := account.Nonce(context.Background(), big.NewInt(9000))
+if err != nil {
+	log.Panic(err)
+}
+fmt.Println("Nonce: ", nonce)
+```
+
+### `DeploymentNonce`
+
+Returns the deployment nonce of the account.
+
+#### Inputs
+
+| Parameter | Type                                             | Description   |
+| --------- | ------------------------------------------------ | ------------- |
+| `opts`    | [`CallOpts`](/sdk/go/api/accounts/types#callopts) (optional) | Call options. |
+
+```go
+DeploymentNonce(opts *CallOpts) (*big.Int, error)
+```
+
+#### Example
+
+```go
+deploymentNonce, err := account.DeploymentNonce(nil)
+if err != nil {
+    log.Panic(err)
+}
+```
+
+### `PopulateTransaction`
+
+Populates the transaction `tx` using the provided [`TransactionBuilder`](/sdk/go/api/accounts/types#transactionbuilder) function.
+If `tx.From` is not set, it sets the value from the `Address()` method which can
+be utilized in the `TransactionBuilder` function.
+
+#### Inputs
+
+| Parameter | Type                                                     | Description                        |
+|-----------|----------------------------------------------------------|------------------------------------|
+| `ctx`     | `context.Context`                                        | Context.                           |
+| `tx`      | [`*zkTypes.Transaction712`](/sdk/go/api/types#transaction712) | The transaction that needs to be populated.     |
+
+```go
+PopulateTransaction(ctx context.Context, tx *zkTypes.Transaction712) error
+```
+
+#### Example
+
+```go
+address := common.HexToAddress("<ACCOUNT ADDRESS>")
+tx := &zkTypes.Transaction712{
+  To:    &address,
+  Value: big.NewInt(7_000_000_000),
+}
+
+err = account.PopulateTransaction(context.Background(), tx)
+if err != nil {
+    log.Panic(err)
+}
+```
+
+### `SignTransaction`
+
+Returns a signed transaction that is ready to be broadcast to
+the network. The `PopulateTransaction` method is called first to ensure that all
+necessary properties for the transaction to be valid have been populated.
+
+#### Inputs
+
+| Parameter | Type                                                    | Description                              |
+|-----------|---------------------------------------------------------|------------------------------------------|
+| `ctx`     | `context.Context`                                       | Context.                                 |
+| `tx`      | [`*zkTypes.Transaction712`](/sdk/go/api/types#transaction712) | The transaction that needs to be signed. |
+
+```go
+
+SignTransaction(ctx context.Context, tx *zkTypes.Transaction712) ([]byte, error)
+```
+
+#### Example
+
+```go
+address := common.HexToAddress("<ACCOUNT ADDRESS>")
+signedTx, err := account.SignTransaction(context.Background(), &zkTypes.Transaction712{
+    To:    &address,
+    Value: big.NewInt(1_000_000_000_000_000_000), // 1ETH
+})
+if err != nil {
+  log.Panic(err)
+}
+```
+
+### `SendTransaction`
+
+Injects a transaction into the pending pool for execution.
+The `SignTransaction` is called first to ensure transaction is properly signed.
+
+#### Inputs
+
+| Parameter | Type                                                    | Description                              |
+|-----------|---------------------------------------------------------|------------------------------------------|
+| `ctx`     | `context.Context`                                       | Context.                                 |
+| `tx`      | [`*zkTypes.Transaction712`](/sdk/go/api/types#transaction712) | The transaction that needs to be signed. |
+
+```go
+SendTransaction(ctx context.Context, tx *zkTypes.Transaction712) (common.Hash, error)
+```
+
+#### Example
+
+```go
+address := common.HexToAddress("<ACCOUNT ADDRESS>")
+txHash, err := account.SendTransaction(context.Background(), &zkTypes.Transaction712{
+    To:    &address,
+    Value: big.NewInt(1_000_000_000_000_000_000), // 1ETH
+})
+if err != nil {
+  log.Panic(err)
+}
+```
+
+### `SignMessage`
+
+Signs a message using the provided [`PayloadSigner`](/sdk/go/api/accounts/types#payloadsigner) function.
+
+#### Inputs
+
+| Parameter | Type              | Description                          |
+|-----------|-------------------|--------------------------------------|
+| `ctx`     | `context.Context` | Context.                             |
+| `message` | `[]byte`           | The message that needs to be signed. |
+
+```go
+SignMessage(ctx context.Context, message []byte) ([]byte, error)
+```
+
+#### Example
+
+```go
+signature, err := account.SignMessage(context.Background(), []byte("Hello World!"))
+if err != nil {
+  log.Panic(err)
+}
+```
+
+### `SignTypedData`
+
+signs a typed data using the provided [`PayloadSigner`](/sdk/go/api/accounts/types#payloadsigner) function.
+
+#### Inputs
+
+| Parameter   | Type                  | Description                             |
+|-------------|-----------------------|-----------------------------------------|
+| `ctx`       | `context.Context`     | Context.                                |
+| `typedData` | `apitypes.TypedData`  | The typed data that needs to be signed. |
+
+```go
+SignTypedData(ctx context.Context, typedData apitypes.TypedData) ([]byte, error)
+```
+
+#### Example
+
+```go
+signature, err := account.SignTypedData(context.Background(), apitypes.TypedData{
+  Domain: apitypes.TypedDataDomain{
+    Name:    "Example",
+    Version: "1",
+    ChainId: math.NewHexOrDecimal256(270),
+  },
+  Types: apitypes.Types{
+    "Person": []apitypes.Type{
+      {Name: "name", Type: "string"},
+      {Name: "age", Type: "uint8"},
+    },
+    "EIP712Domain": []apitypes.Type{
+      {Name: "name", Type: "string"},
+      {Name: "version", Type: "string"},
+      {Name: "chainId", Type: "uint256"},
+    },
+  },
+  PrimaryType: "Person",
+  Message: apitypes.TypedDataMessage{
+    "name": "John",
+    "age":  hexutil.EncodeUint64(30),
+  },
+})
+if err != nil {
+  log.Panic(err)
+}
+```
+
+### `Withdraw`
+
+Initiates the withdrawal process which withdraws ETH or any ERC20 token from the associated account on L2 network
+to the target account on L1 network.
+
+#### Inputs
+
+| Parameter | Type                                                            | Description                        |
+| --------- | --------------------------------------------------------------- | ---------------------------------- |
+| `auth`    | [`*TransactOpts`](/sdk/go/api/accounts/types#transactopts) (optional)       | Transaction options.               |
+| `tx`      | [`WithdrawalTransaction`](/sdk/go/api/accounts/types#withdrawaltransaction) | Withdrawal transaction parameters. |
+
+```go
+Withdraw(auth *TransactOpts, tx WithdrawalTransaction) (common.Hash, error)
+```
+
+#### Examples
+
+Withdraw ETH.
+
+```go
+txHash, err := account.Withdraw(nil, accounts.WithdrawalTransaction{
+    To:     account.Address(),
+    Amount: big.NewInt(1_000_000_000_000_000_000),
+    Token:  utils.LegacyEthAddress,
+})
+if err != nil {
+	log.Panic(err)
+}
+fmt.Println("Withdraw transaction: ", txHash)
+```
+
+Withdraw ETH using paymaster to facilitate fee payment with an ERC20 token.
+
+```go
+token := common.HexToAddress("0x927488F48ffbc32112F1fF721759649A89721F8F"); // Crown token which can be minted for free
+paymaster := common.HexToAddress("0x13D0D8550769f59aa241a41897D4859c87f7Dd46"); // Paymaster for Crown token
+
+paymasterParams, err := utils.GetPaymasterParams(
+		paymaster,
+		&zkTypes.ApprovalBasedPaymasterInput{
+			Token:            token,
+			MinimalAllowance: big.NewInt(1),
+			InnerInput:       []byte{},
+})
+if err != nil {
+    log.Panic(err)
+}
+
+txHash, err := account.Withdraw(nil, accounts.WithdrawalTransaction{
+		To:              account.Address(),
+		Amount:          big.NewInt(1_000_000_000_000_000_000),
+		Token:           utils.LegacyEthAddress,
+		PaymasterParams: paymasterParams,
+	})
+```
+
+### `Transfer`
+
+Moves the ETH or any ERC20 token from the associated account to the target account.
+
+#### Inputs
+
+| Parameter | Type                                                        | Description                      |
+| --------- | ----------------------------------------------------------- | -------------------------------- |
+| `auth`    | [`*TransactOpts`](/sdk/go/api/accounts/types#transactopts) (optional)   | Transaction options.             |
+| `tx`      | [`TransferTransaction`](/sdk/go/api/accounts/types#transfertransaction) | Transfer transaction parameters. |
+
+```go
+Transfer(auth *TransactOpts, tx TransferTransaction) (common.Hash, error)
+```
+
+#### Examples
+
+Transfer ETH.
+
+```go
+txHash, err := account.Transfer(nil, accounts.TransferTransaction{
+  To:     Address2,
+  Amount: amount,
+  Token:  utils.LegacyEthAddress,
+})
+if err != nil {
+	log.Panic(err)
+}
+fmt.Println("Transaction: ", txHash)
+```
+
+Transfer ETH using paymaster to facilitate fee payment with an ERC20 token.
+
+```go
+token := common.HexToAddress("0x927488F48ffbc32112F1fF721759649A89721F8F"); // Crown token which can be minted for free
+paymaster := common.HexToAddress("0x13D0D8550769f59aa241a41897D4859c87f7Dd46"); // Paymaster for Crown token
+
+paymasterParams, err := utils.GetPaymasterParams(
+  paymaster,
+  &zkTypes.ApprovalBasedPaymasterInput{
+    Token:            token,
+    MinimalAllowance: big.NewInt(1),
+    InnerInput:       []byte{},
+})
+if err != nil {
+  log.Panic(err)
+}
+
+txHash, err := account.Transfer(nil, accounts.TransferTransaction{
+  To:     Address2,
+  Amount: amount,
+  Token:  utils.LegacyEthAddress,
+  PaymasterParams: paymasterParams,
+})
+if err != nil {
+	log.Panic(err)
+}
+fmt.Println("Transaction: ", txHash)
+```
diff --git a/content/sdk/20.go/02.api/01.accounts/07.smartaccount-factories.md b/content/sdk/20.go/02.api/01.accounts/07.smartaccount-factories.md
new file mode 100644
index 00000000..471cd049
--- /dev/null
+++ b/content/sdk/20.go/02.api/01.accounts/07.smartaccount-factories.md
@@ -0,0 +1,68 @@
+---
+title: SmartAccount Factories
+description: NewECDSA and NewMultisigECDSA for SmartAccount
+tags: ["ecdsa", "smartaccount", "go", "sdk"]
+---
+
+## NewECDSASmartAccount
+
+Creates a `SmartAccount` instance that uses single ECDSA key for signing payload.
+
+| Parameter    | Type                                                | Description                                              |
+|--------------|-----------------------------------------------------|----------------------------------------------------------|
+| `address`    | `common.Address`                                    | Account address.                                         |
+| `privateKey` | `string`                                            | The ECDSA private key.                   |
+| `client`     | [`*clients.BaseClient`](/sdk/go/api/clients/baseclient) | The client to connect to. Can be `nil` for offline usage. |
+
+```go
+
+func NewECDSASmartAccount(address common.Address, privateKey string, client *clients.BaseClient) *SmartAccount
+```
+
+#### Example
+
+```go
+privateKey := os.Getenv("PRIVATE_KEY")
+address := common.HexToAddress("<ACCOUNT ADDRESS>")
+ZkSyncEraProvider := "https://sepolia.era.zksync.dev"
+
+client, err := clients.DialBase(ZkSyncEraProvider)
+if err != nil {
+    log.Panic(err)
+}
+defer client.Close()
+
+account := accounts.NewECDSASmartAccount(address, privateKey, client)
+```
+
+## NewMultisigECDSASmartAccount
+
+Creates a `SmartAccount` instance that uses multiple ECDSA keys for signing payloads.
+The signature is generated by concatenating signatures created by signing with each key individually.
+
+| Parameter     | Type                                                | Description                                               |
+|---------------|-----------------------------------------------------|-----------------------------------------------------------|
+| `address`     | `common.Address`                                    | Account address.                                          |
+| `privateKeys` | `[]string`                                          | The list of the ECDSA private keys.                       |
+| `client`      | [`*clients.BaseClient`](/sdk/go/api/clients/baseclient) | The client to connect to. Can be `nil` for offline usage. |
+
+```go
+NewMultisigECDSASmartAccount(address common.Address, privateKeys []string, client *clients.BaseClient) *SmartAccount
+```
+
+#### Example
+
+```go
+privateKey1 := os.Getenv("PRIVATE_KEY1")
+privateKey2 := os.Getenv("PRIVATE_KEY2")
+address := common.HexToAddress("<ACCOUNT ADDRESS>")
+ZkSyncEraProvider := "https://sepolia.era.zksync.dev"
+
+client, err := clients.DialBase(ZkSyncEraProvider)
+if err != nil {
+    log.Panic(err)
+}
+defer client.Close()
+
+account := accounts.NewMultisigECDSASmartAccount(address, []string{privateKey1, privateKey2}, client)
+```
diff --git a/content/sdk/20.go/08.smart-account-utils.md b/content/sdk/20.go/02.api/01.accounts/08.smart-account-utils.md
similarity index 88%
rename from content/sdk/20.go/08.smart-account-utils.md
rename to content/sdk/20.go/02.api/01.accounts/08.smart-account-utils.md
index c5e55935..4b51a01c 100644
--- a/content/sdk/20.go/08.smart-account-utils.md
+++ b/content/sdk/20.go/02.api/01.accounts/08.smart-account-utils.md
@@ -1,13 +1,18 @@
 ---
 title: SmartAccount Utilities
-description:
+description: Utilities for signing and populating transactions
+tags: ["zksync", "smart account", "utilities", "signing", "go", "sdk"]
 ---
 
+The `SmartAccount Utilities` provide functions for signing payloads and populating transactions using ECDSA and
+multiple ECDSA keys. These utilities offer flexibility and ease of use for developers working with smart accounts in
+the ZKsync Era.
+
 ## Functions
 
 ### `SignPayloadWithECDSA`
 
-Implementation of [`PayloadSigner`](/sdk/go/types/accounts#payloadsigner) which signs the payload using
+Implementation of [`PayloadSigner`](/sdk/go/api/accounts/types#payloadsigner) which signs the payload using
 an ECDSA private key.
 
 #### Inputs
@@ -17,7 +22,7 @@ an ECDSA private key.
 | `ctx`      | `context.Context`                                   | Context.                             |
 | `payload`  | `[]byte`                                            | The payload that needs to be signed. |
 | `secret`   | `string`                                            | The ECDSA private key.               |
-| `client`   | [`*clients.BaseClient`](/sdk/go/clients#baseclient) | Not used and should be `nil`.         |
+| `client`   | [`*clients.BaseClient`](/sdk/go/api/clients/baseclient) | Not used and should be `nil`.         |
 
 ```go
 var SignPayloadWithECDSA PayloadSigner = func(ctx context.Context, payload []byte, secret interface{}, client *clients.BaseClient) ([]byte, error)
@@ -141,7 +146,7 @@ if err != nil {
 
 ### `SignPayloadWithMultipleECDSA`
 
-Implementation of [`PayloadSigner`](/sdk/go/types/accounts#payloadsigner) which signs the payload using
+Implementation of [`PayloadSigner`](/sdk/go/api/accounts/types#payloadsigner) which signs the payload using
 multiple ECDSA private keys.
 The signature is generated by concatenating signatures created by signing with each key individually.
 The length of the resulting signature is `len(secret) * 65`.
@@ -153,7 +158,7 @@ The length of the resulting signature is `len(secret) * 65`.
 | `ctx`      | `context.Context`                                   | Context.                               |
 | `payload`  | `[]byte`                                            | The payload that needs to be signed.   |
 | `secret`   | `[]string`                                          | The list of the ECDSA private keys.    |
-| `client`   | [`*clients.BaseClient`](/sdk/go/clients#baseclient) | Not used and should be `nil`.          |
+| `client`   | [`*clients.BaseClient`](/sdk/go/api/clients/baseclient) | Not used and should be `nil`.          |
 
 ```go
 var SignPayloadWithMultipleECDSA PayloadSigner = func(ctx context.Context, payload []byte, secret interface{}, client *clients.BaseClient) ([]byte, error)
@@ -300,9 +305,9 @@ Expects the secret to be ECDSA private in hex format.
 | Parameter | Type                                                            | Description                        |
 |-----------|-----------------------------------------------------------------|------------------------------------|
 | `ctx`     | `context.Context`                                               | Context.                           |
-| `tx`      | [`*zkTypes.Transaction712`](/sdk/go/types/types#transaction712) | The transaction that needs to be populated.     |
+| `tx`      | [`*zkTypes.Transaction712`](/sdk/go/api/types#transaction712) | The transaction that needs to be populated.     |
 | `secret`  | `string`                                                        | The ECDSA private key.             |
-| `client`  | [`*clients.BaseClient`](/sdk/go/clients#baseclient)             | The client which fetches data from the network. |
+| `client`  | [`*clients.BaseClient`](/sdk/go/api/clients/baseclient)             | The client which fetches data from the network. |
 
 ```go
 var PopulateTransactionECDSA TransactionBuilder = func(ctx context.Context, tx *zkTypes.Transaction712, secret interface{}, client *clients.BaseClient) error
@@ -342,9 +347,9 @@ Expects the secret to be a slice of ECDSA private in hex format.
 | Parameter | Type                                                            | Description                                     |
 |-----------|-----------------------------------------------------------------|-------------------------------------------------|
 | `ctx`     | `context.Context`                                               | Context.                                        |
-| `tx`      | [`*zkTypes.Transaction712`](/sdk/go/types/types#transaction712) | The transaction that needs to be populated.     |
+| `tx`      | [`*zkTypes.Transaction712`](/sdk/go/api/types#transaction712) | The transaction that needs to be populated.     |
 | `secret`  | `[]string`                                                      | The list of the ECDSA private keys.             |
-| `client`  | [`*clients.BaseClient`](/sdk/go/clients#baseclient)             | The client which fetches data from the network. |
+| `client`  | [`*clients.BaseClient`](/sdk/go/api/clients/baseclient)             | The client which fetches data from the network. |
 
 ```go
 var PopulateTransactionMultipleECDSA TransactionBuilder = func(ctx context.Context, tx *zkTypes.Transaction712, secret interface{}, client *clients.BaseClient) error
diff --git a/content/sdk/20.go/types/01.accounts.md b/content/sdk/20.go/02.api/01.accounts/09.types.md
similarity index 97%
rename from content/sdk/20.go/types/01.accounts.md
rename to content/sdk/20.go/02.api/01.accounts/09.types.md
index 75e1a828..9ea58ed8 100644
--- a/content/sdk/20.go/types/01.accounts.md
+++ b/content/sdk/20.go/02.api/01.accounts/09.types.md
@@ -1,8 +1,12 @@
 ---
-title: Accounts Package
-description:
+title: Types
+description: Defines essential types for ZKsync Era
+tags: ["zksync", "types", "go", "sdk", "accounts"]
 ---
 
+This section describes various types used in the ZKsync Era. These types are essential for interacting with the
+blockchain, performing transactions, and managing accounts.
+
 ### `AllowanceParams`
 
 Contains the parameters required for approval of an ERC20 token.
@@ -221,7 +225,7 @@ func (t *TransactOpts) ToTransactOpts(from common.Address, signer bind.SignerFn)
 
 ### `Transaction`
 
-Transaction is similar to [`types.Transaction712`](/sdk/go/types/types#eip712txtype) but does not include the From field.
+Transaction is similar to [`types.Transaction712`](/sdk/go/api/types#eip712txtype) but does not include the From field.
 This design is intended for use abstraction which already have an associated account with `AdapterL2`.
 The From field is bound to the specific account, and thus, it is not included in this type.
 
diff --git a/content/sdk/20.go/types/03.eip712.md b/content/sdk/20.go/02.api/02.eip712/00.eip712.md
similarity index 58%
rename from content/sdk/20.go/types/03.eip712.md
rename to content/sdk/20.go/02.api/02.eip712/00.eip712.md
index 7046532c..b18e3894 100644
--- a/content/sdk/20.go/types/03.eip712.md
+++ b/content/sdk/20.go/02.api/02.eip712/00.eip712.md
@@ -1,8 +1,13 @@
 ---
 title: EIP712 Package
-description:
+description: Provides types and structures for EIP-712 signing
+tags: ["eip712", "signing", "ethereum", "go", "sdk"]
 ---
 
+The `EIP-712` is a standard for typed structured data hashing and signing in Ethereum, which is widely used for
+secure and human-readable transaction signing. The package provides the necessary types and structures for EIP-712
+signing.
+
 ### `Domain`
 
 Represents the domain parameters used for EIP-712 signing.
diff --git a/content/sdk/20.go/06.contracts.md b/content/sdk/20.go/02.api/03.contracts/00.contracts.md
similarity index 86%
rename from content/sdk/20.go/06.contracts.md
rename to content/sdk/20.go/02.api/03.contracts/00.contracts.md
index 7aee3741..0c86db80 100644
--- a/content/sdk/20.go/06.contracts.md
+++ b/content/sdk/20.go/02.api/03.contracts/00.contracts.md
@@ -1,6 +1,7 @@
 ---
 title: Contracts
-description:
+description: Methods and interfaces for deploying smart contracts on ZKsync Era
+tags: ["zksync", "contracts", "deployment", "go", "sdk"]
 ---
 
 The usual way to deploy a contract with the `geth` library is to use `abigen` with the provided `--bin` option,
@@ -9,8 +10,8 @@ an EIP-712 transaction, the deployment function generated with the `abigen` tool
 the `Deploy` interface is created, which provides methods for the deployment of smart contracts and smart
 accounts. There are the following objects that implement the `Deploy` interface:
 
-- [`BaseDeployer`](/sdk/go/accounts#basedeployer),
-- [`Wallet`](/sdk/go/accounts#wallet).
+- [`BaseDeployer`](/sdk/go/api/accounts/basedeployer),
+- [`Wallet`](/sdk/go/api/accounts/wallet).
 
 Contract instantiation is the same as in the
 [`geth`](https://geth.ethereum.org/docs/developers/dapp-developer/native-bindings)
diff --git a/content/sdk/20.go/06.utils.md b/content/sdk/20.go/02.api/04.utilities/00.utils.md
similarity index 94%
rename from content/sdk/20.go/06.utils.md
rename to content/sdk/20.go/02.api/04.utilities/00.utils.md
index 8bd55735..bc240521 100644
--- a/content/sdk/20.go/06.utils.md
+++ b/content/sdk/20.go/02.api/04.utilities/00.utils.md
@@ -1,9 +1,11 @@
 ---
-title: Utilities
-description:
+title: Common Utilities
+description: Utilities for building on ZKsync Era
+tags: ["zksync", "utilities", "go", "sdk", "blockchain"]
 ---
 
-Provides essential utilities for building on ZKsync Era.
+Provides essential utilities for building on ZKsync Era. These utilities include constants, useful addresses, and
+functions that facilitate the development and interaction with the ZKsync blockchain.
 
 ## Constants
 
@@ -207,7 +209,7 @@ Returns the encoded constructor data for CREATE method used for smart account de
 | ---------- | -------------------------------------------------------------------------- | ---------------------------------- |
 | `bytecode` | `[]byte`                                                                   | Output from zkSolc.                |
 | `calldata` | `[]byte`                                                                   | ABI encoded constructor arguments. |
-| `version`  | [`types.AccountAbstractionVersion`](/sdk/go/types/types#accountabstractionversion) | Account abstraction version.       |
+| `version`  | [`types.AccountAbstractionVersion`](/sdk/go/api/types#accountabstractionversion) | Account abstraction version.       |
 
 ```go
  EncodeCreate2Account(bytecode, calldata, version types.AccountAbstractionVersion) ([]byte, error)
@@ -224,7 +226,7 @@ Returns the encoded constructor data for CREATE2 method used for smart account d
 | `bytecode` | `[]byte`                                                                   | Output from zkSolc.                |
 | `calldata` | `[]byte`                                                                   | ABI encoded constructor arguments. |
 | `salt`     | `[]byte`                                                                   | Randomization element.             |
-| `version`  | [`types.AccountAbstractionVersion`](/sdk/go/types/types#accountabstractionversion) | Account abstraction version.       |
+| `version`  | [`types.AccountAbstractionVersion`](/sdk/go/api/types#accountabstractionversion) | Account abstraction version.       |
 
 ```go
  EncodeCreate2Account(bytecode, calldata, salt []byte, version types.AccountAbstractionVersion) ([]byte, error)
diff --git a/content/sdk/20.go/07.paymaster-utils.md b/content/sdk/20.go/02.api/04.utilities/01.paymaster-utils.md
similarity index 85%
rename from content/sdk/20.go/07.paymaster-utils.md
rename to content/sdk/20.go/02.api/04.utilities/01.paymaster-utils.md
index ec3abdbd..28b678a2 100644
--- a/content/sdk/20.go/07.paymaster-utils.md
+++ b/content/sdk/20.go/02.api/04.utilities/01.paymaster-utils.md
@@ -1,10 +1,12 @@
 ---
 title: Paymaster Utilities
-description:
+description: Essential utilities for using paymasters on ZKsync Era
+tags: ["zksync", "paymaster", "utilities", "go", "sdk"]
 ---
 
 The [paymaster utilities library](https://github.com/zksync-sdk/zksync2-go/blob/main/utils/paymaster.go) contains
-essential utilities for using paymasters on ZKsync Era.
+essential utilities for using paymasters on ZKsync Era. These utilities facilitate the integration and use of
+paymaster contracts, providing functions and interfaces to encode inputs and create paymaster parameters.
 
 ## Contract interfaces
 
@@ -69,5 +71,5 @@ Returns a correctly-formed `paymasterParams` object for common paymaster flows.
 func GetPaymasterParams(paymasterAddress common.Address, paymasterInput types.PaymasterInput) (*types.PaymasterParams, error)
 ```
 
-Find out more about the [`PaymasterInput` type](/sdk/go/types/types).
+Find out more about the [`PaymasterInput` type](/sdk/go/api/types).
 Check out the [example](https://github.com/zksync-sdk/zksync2-examples/blob/main/go/18_use_paymaster.go) how to use paymaster.
diff --git a/content/sdk/20.go/types/04.types.md b/content/sdk/20.go/02.api/05.types.md
similarity index 93%
rename from content/sdk/20.go/types/04.types.md
rename to content/sdk/20.go/02.api/05.types.md
index 75ed6685..f980425b 100644
--- a/content/sdk/20.go/types/04.types.md
+++ b/content/sdk/20.go/02.api/05.types.md
@@ -1,8 +1,22 @@
 ---
-title: Types Package
-description:
+title: Types
+description: Defines various types for ZKsync Go SDK.
+tags: ["go", "zksync", "sdk", "types"]
 ---
 
+Types are placed in three packages for different purposes:
+
+- [`types`](/sdk/go/api/types): Contains common and general types used to build basic features and other types.
+- [`eip712`](/sdk/go/api/eip712/eip712): Contains types used for EIP-712 implementation.
+- [`clients`](/sdk/go/api/clients/types): Contains types that are meant to be used along with [`Client`](/sdk/go/api/clients/introduction).
+- [`accounts`](/sdk/go/api/accounts/types): Contains types that are meant to be used along with an account, specifically
+with the [`Adapter`](/sdk/go/api/accounts/types) abstraction. Many types are similar to those from the `geth` library, but
+the `From` or `Signer` fields are omitted because these fields are inherited from `Adapter`, which already has an
+associated account.
+
+This section provides a list of various types used in the ZKsync Go SDK. These types are categorized based on their
+purposes and usage within the SDK.
+
 ### `AccountAbstractionVersion`
 
 Represents an enumeration of account abstraction versions.
diff --git a/content/sdk/20.go/02.api/_dir.yml b/content/sdk/20.go/02.api/_dir.yml
new file mode 100644
index 00000000..04d91e0c
--- /dev/null
+++ b/content/sdk/20.go/02.api/_dir.yml
@@ -0,0 +1 @@
+title: API
diff --git a/content/sdk/20.go/04.accounts.md b/content/sdk/20.go/04.accounts.md
deleted file mode 100644
index d20f43f5..00000000
--- a/content/sdk/20.go/04.accounts.md
+++ /dev/null
@@ -1,2524 +0,0 @@
----
-title: Accounts
-description:
----
-
-## Overview
-
-The `accounts` package provides abstractions that wrap operations that interact with an account. An account typically
-contains a private key, allowing it to sign various types of payloads. There are the following interfaces that provide
-account operations for different purposes:
-
-- `Signer` provides support for signing EIP-712 transactions as well as other types of transactions supported by
-  [`types.Signer`](https://pkg.go.dev/github.com/ethereum/go-ethereum@v1.12.0/core/types#Signer).
-- `AdapterL1` is associated with an account and provides common operations on the L1 network
-  for the associated account.
-- `AdapterL2` is associated with an account and provides common operations on the L2 network for the
- associated account.
-- `Deployer` is associated with an account and provides deployment of smart contracts and smart accounts on the L2
- network for the associated account.
-- `Adapter` consists of `AdapterL1`, `AdapterL2`, and `Deployer` interfaces.
-
-There are the following objects that provide account operations:
-
-- `BaseSigner` implements the `Signer` interface.
-- `WalletL1` implements the `AdapterL1` interface.
-- `WalletL2` implements the `AdapterL2` interface.
-- `BaseDeployer` implements the `Deployer` interface.
-- `Wallet` implements the `Adapter` interface.
-- `SmartAccount` which provides better support for account abstraction. There are following factory methods:
-  - `NewECDSASmartAccount`: uses a single ECDSA key for signing payload.
-  - `NewMultisigECDSASmartAccount`: uses multiple ECDSA keys for signing payloads.
-
-In most cases, `Wallet` should be used because it provides all the necessary operations. Other objects and interfaces
-are separated to make the SDK more flexible and extensible.
-
-## `BaseSigner`
-
-### `Init`
-
-Creates a new instance of `BaseSigner` based on the provided mnemonic phrase.
-
-```go
-func NewBaseSignerFromMnemonic(mnemonic string, chainId int64) (*BaseSigner, error)
-```
-
-Creates a new instance of `BaseSigner` based on the provided mnemonic phrase and account ID.
-
-```go
-func NewBaseSignerFromMnemonicAndAccountId(mnemonic string, accountId uint32, chainId int64) (*BaseSigner, error)
-```
-
-Creates a new instance of BaseSigner based on the provided raw private key.
-
-```go
-func NewBaseSignerFromRawPrivateKey(rawPk []byte, chainId int64) (*BaseSigner, error)
-```
-
-Creates an instance of Signer with a randomly generated private key.
-
-```go
-func NewRandomBaseSigner(chainId int64) (*BaseSigner, error)
-```
-
-### `Address`
-
-Returns the address associated with the signer.
-
-```go
-Address() common.Address
-```
-
-### `Domain`
-
-Returns the EIP-712 domain used for signing.
-
-```go
-Domain() *eip712.Domain
-```
-
-### `PrivateKey`
-
-Returns the private key associated with the signer.
-
-```go
-PrivateKey() *ecdsa.PrivateKey
-```
-
-Signs the given hash using the signer's private key and returns the signature. The hash should be the 32-byte hash
-of the data to be signed.
-
-### `SignHash`
-
-```go
-SignHash(msg []byte) ([]byte, error)
-```
-
-### `SignTypeData`
-
-Signs the given EIP-712 typed data using the signer's private key and returns the signature. The domain parameter
-is the EIP-712 domain separator, and the data parameter is the EIP-712 typed data.
-
-```go
-SignTypedData(d *eip712.Domain, data eip712.TypedData) ([]byte, error)
-```
-
-## `WalletL1`
-
-### `Init`
-
-Creates an instance of WalletL1 associated with the account provided by the raw private key.
-
-```go
-func NewWalletL1(rawPrivateKey []byte, clientL1 *ethclient.Client, clientL2 *clients.Client) (*WalletL1, error
-```
-
-Creates an instance of WalletL1 associated with the account provided by the signer.
-
-```go
-NewWalletL1FromSigner(signer *Signer, clientL1 *ethclient.Client, clientL2 *clients.Client) (*WalletL1, error)
-```
-
-#### Example
-
-```go
-PrivateKey     := os.Getenv("PRIVATE_KEY")
-ZkSyncEraProvider := "https://sepolia.era.zksync.dev"
-EthereumProvider := "https://rpc.ankr.com/eth_sepolia"
-
-client, err := clients.Dial(ZkSyncEraProvider)
-if err != nil {
-	log.Panic(err)
-}
-defer client.Close()
-
-ethClient, err := ethclient.Dial(EthereumProvider)
-if err != nil {
-	log.Panic(err)
-}
-defer ethClient.Close()
-
-wallet, err := accounts.NewWalletL1(common.Hex2Bytes(PrivateKey), &client, ethClient)
-if err != nil {
-	log.Panic(err)
-}
-```
-
-### `MainContract`
-
-Returns the ZKsync L1 smart contract.
-
-#### Inputs
-
-| Parameter | Type              | Description |
-| --------- | ----------------- | ----------- |
-| `ctx`     | `context.Context` | Context.    |
-
-```go
-MainContract(ctx context.Context) (*zksync.IZkSync, error)
-```
-
-#### Example
-
-```go
-mainContract, err := wallet.MainContract(context.Background())
-if err != nil {
-	log.Panic(err)
-}
-```
-
-### `BridgehubContract`
-
-Returns the Bridgehub L1 smart contract.
-
-#### Inputs
-
-| Parameter | Type              | Description |
-| --------- | ----------------- | ----------- |
-| `ctx`     | `context.Context` | Context.    |
-
-```go
-BridgehubContract(_ context.Context) (*bridgehub.IBridgehub, error)
-```
-
-#### Example
-
-```go
-bridgehub, err := wallet.BridgehubContract(context.Background())
-if err != nil {
-	log.Panic(err)
-}
-```
-
-### `L1BridgeContracts`
-
-Returns L1 bridge contracts.
-
-#### Inputs
-
-| Parameter | Type              | Description |
-| --------- | ----------------- | ----------- |
-| `ctx`     | `context.Context` | Context.    |
-
-```go
-L1BridgeContracts(ctx context.Context) (*zkTypes.L1BridgeContracts, error)
-```
-
-#### Example
-
-```go
-contracts, err := wallet.L1BridgeContracts(context.Background())
-if err != nil {
-	log.Panic(err)
-}
-```
-
-### `BaseToken`
-
-Returns the address of the base token on L1.
-
-#### Inputs
-
-| Parameter | Type                                                     | Description |
-|-----------|----------------------------------------------------------| ----------- |
-| `opts`    | [`CallOpts`](/sdk/go/types/accounts#callopts) (optional) | Call options.  |
-
-```go
-BaseToken(opts *CallOpts) (common.Address, error)
-```
-
-#### Example
-
-```go
-baseToken, err := wallet.BaseToken(nil)
-if err != nil {
-	log.Panic(err)
-}
-fmt.Println("Base token: ", baseToken)
-```
-
-### `IsEthBasedChain`
-
-Returns whether the chain is ETH-based.
-
-#### Inputs
-
-| Parameter | Type              | Description |
-| --------- | ----------------- | ----------- |
-| `ctx`     | `context.Context` | Context.    |
-
-```go
-IsEthBasedChain(ctx context.Context) (bool, error)
-```
-
-#### Example
-
-```go
-isEthBased, err := wallet.IsEthBasedChain(context.Background())
-if err != nil {
-	log.Panic(err)
-}
-fmt.Println("Is ETH-based chain: ", isEthBased)
-```
-
-### `BalanceL1`
-
-Returns the balance of the specified token on L1 that can be either ETH or any ERC20 token.
-
-#### Inputs
-
-| Parameter | Type                                             | Description    |
-| --------- | ------------------------------------------------ | -------------- |
-| `opts`    | [`CallOpts`](/sdk/go/types/accounts#callopts) (optional) | Call options.  |
-| `token`   | `common.Address`                                 | Token address. |
-
-```go
-BalanceL1(opts *CallOpts, token common.Address) (*big.Int, error)
-```
-
-#### Example
-
-```go
-balance, err := wallet.BalanceL1(nil, utils.EthAddress)
-if err != nil {
-	log.Panic(err)
-}
-fmt.Println("Balance: ", balance)
-```
-
-### `AllowanceL1`
-
-Returns the amount of approved tokens for a specific L1 bridge.
-
-#### Inputs
-
-| Parameter       | Type                                             | Description     |
-| --------------- | ------------------------------------------------ | --------------- |
-| `opts`          | [`CallOpts`](/sdk/go/types/accounts#callopts) (optional) | Call options.   |
-| `token`         | `common.Address`                                 | Token address.  |
-| `bridgeAddress` | `common.Address`                                 | Bridge address. |
-
-```go
-AllowanceL1(opts *CallOpts, token common.Address, bridgeAddress common.Address) (*big.Int, error)
-```
-
-#### Example
-
-```go
-// The Crown token on testnet
-TokenAddress := common.HexToAddress("0x927488F48ffbc32112F1fF721759649A89721F8F")
-
-contracts, err := client.BridgeContracts(context.Background())
-if err != nil {
-	log.Panic(err)
-}
-bridgeAllowance, err := wallet.AllowanceL1(nil, TokenAddress, contracts.L1Erc20DefaultBridge)
-if err != nil {
-	log.Panic(err)
-}
-fmt.Println("Bridge allowance: ", bridgeAllowance)
-```
-
-### `L2TokenAddress`
-
-Returns the corresponding address on the L2 network for the token on the L1 network.
-
-#### Inputs
-
-| Parameter | Type              | Description       |
-| --------- | ----------------- | ----------------- |
-| `ctx`     | `context.Context` | Context.          |
-| `token`   | `common.Address`  | L1 token address. |
-
-```go
-L2TokenAddress(ctx context.Context, token common.Address) (common.Address, error)
-```
-
-#### Example
-
-```go
-l1DAI := common.HexToAddress("0x5C221E77624690fff6dd741493D735a17716c26B")
-l2DAI, err := wallet.L2TokenAddress(context.Background(), l1DAI)
-if err != nil {
-	log.Panic(err)
-}
-fmt.Println("L2 DAI address: ", l2DAI)
-```
-
-### `ApproveERC20`
-
-Approves the specified amount of tokens for the specified L1 bridge.
-
-#### Inputs
-
-| Parameter | Type              | Description       |
-| --------- | ----------------- | ----------------- |
-| `ctx`     | `context.Context` | Context.          |
-| `token`   | `common.Address`  | L1 token address. |
-| `amount`  | `*big.Int`        | Approval amount.  |
-
-```go
-ApproveERC20(auth *TransactOpts, token common.Address, amount *big.Int, bridgeAddress common.Address) (*types.Transaction, error)
-```
-
-#### Example
-
-```go
-// The Crown token on testnet
-TokenAddress := common.HexToAddress("0x927488F48ffbc32112F1fF721759649A89721F8F")
-
-contracts, err := client.BridgeContracts(context.Background())
-if err != nil {
-	log.Panic(err)
-}
-tx, err := wallet.ApproveERC20(nil, TokenAddress, contracts.L1Erc20DefaultBridge)
-if err != nil {
-	log.Panic(err)
-}
-fmt.Println("Tx: ", tx.Hash())
-```
-
-### `BaseCost`
-
-Returns base cost for L2 transaction.
-
-#### Inputs
-
-| Parameter           | Type                                             | Description                                                                            |
-| ------------------- | ------------------------------------------------ | -------------------------------------------------------------------------------------- |
-| `opts`              | [`CallOpts`](/sdk/go/types/accounts#callopts) (optional) | Call options.                                                                          |
-| `gasLimit`          | `*big.Int`                                       | The gasLimit for the the L2 contract call.                                             |
-| `gasPerPubdataByte` | `*big.Int`                                       | The L2 gas price for each published L1 calldata byte.                                  |
-| `gasPrice`          | `*big.Int` (optional)                            | The L1 gas price of the L1 transaction that will send the request for an execute call. |
-
-```go
-BaseCost(opts *CallOpts, gasLimit, gasPerPubdataByte, gasPrice *big.Int) (*big.Int, error)
-```
-
-#### Example
-
-```go
-gasPrice, err := client.SuggestGasPrice(context.Background())
-if err != nil {
-	log.Panic(err)
-}
-
-baseCost, err := wallet.BaseCost(nil, big.NewInt(9000), utils.RequiredL1ToL2GasPerPubdataLimit, gasPrice)
-if err != nil {
-	log.Panic(err)
-}
-fmt.Println("Base cost: ", baseCost)
-```
-
-### `DepositAllowanceParams`
-
-Returns the parameters for the approval token transaction based on the deposit token and amount.
-Some deposit transactions require multiple approvals. Existing allowance for the bridge is not checked;
-allowance is calculated solely based on the specified amount.
-
-#### Inputs
-
-| Parameter           | Type                                     | Description                                                                            |
-|---------------------| ---------------------------------------- | -------------------------------------------------------------------------------------- |
-| `opts`              | [`CallOpts`](/sdk/go/types/accounts#callopts) (optional) | Call options.                                                                          |
-| `msg`     | [`DepositCallMsg`](/sdk/go/types/accounts#depositcallmsg) | Deposit call parameters. |
-
-```go
-DepositAllowanceParams(opts *CallOpts, msg DepositCallMsg) ([]struct {
-    Token     common.Address
-    Allowance *big.Int
-}, error)
-```
-
-#### Example
-
-Get allowance parameters for depositing token on ETH-based chain.
-
-```go
-msg := accounts.DepositCallMsg{
-		Token:  common.HexToAddress("<L1 token address>"),
-		To:     Receiver,
-		Amount: big.NewInt(5),
-}
-
-allowanceParams, err := wallet.DepositAllowanceParams(nil, msg)
-if err != nil {
-    log.Panic(err)
-}
-bridgeContracts, err := client.BridgeContracts(context.Background())
-if err != nil {
-    log.Panic(err)
-}
-approveTx, err := wallet.ApproveERC20(nil, allowanceParams[0].Token, allowanceParams[0].Allowance, bridgeContracts.L1SharedBridge)
-if err != nil {
-    log.Panic(err)
-}
-_, err = bind.WaitMined(context.Background(), ethClient, approveTx)
-if err != nil {
-    log.Panic(err)
-}
-```
-
-Get allowance parameters for depositing ETH on non-ETH-based chain.
-
-```go
-msg := accounts.DepositCallMsg{
-		Token:  utils.LegacyEthAddress,
-		To:     Receiver,
-		Amount: big.NewInt(7_000_000_000),
-}
-
-allowanceParams, err := wallet.DepositAllowanceParams(nil, msg)
-if err != nil {
-    log.Panic(err)
-}
-bridgeContracts, err := client.BridgeContracts(context.Background())
-if err != nil {
-    log.Panic(err)
-}
-approveTx, err := wallet.ApproveERC20(nil, allowanceParams[0].Token, allowanceParams[0].Allowance, bridgeContracts.L1SharedBridge)
-if err != nil {
-    log.Panic(err)
-}
-_, err = bind.WaitMined(context.Background(), ethClient, approveTx)
-if err != nil {
-    log.Panic(err)
-}
-```
-
-Get allowance parameters for depositing base token on non-ETH-based chain.
-
-```go
-token, err := wallet.BaseToken(nil)
-if err != nil {
-    log.Panic(err)
-}
-
-msg := accounts.DepositCallMsg{
-    Token:  token,
-    To:     Receiver,
-    Amount: big.NewInt(7_000_000_000),
-}
-
-allowanceParams, err := wallet.DepositAllowanceParams(nil, msg)
-if err != nil {
-    log.Panic(err)
-}
-bridgeContracts, err := client.BridgeContracts(context.Background())
-if err != nil {
-    log.Panic(err)
-}
-approveTx, err := wallet.ApproveERC20(nil, allowanceParams[0].Token, allowanceParams[0].Allowance, bridgeContracts.L1SharedBridge)
-if err != nil {
-    log.Panic(err)
-}
-_, err = bind.WaitMined(context.Background(), ethClient, approveTx)
-if err != nil {
-    log.Panic(err)
-}
-```
-
-Get allowance parameters for depositing non-base token on non-ETH-based chain.
-
-```go
-msg := accounts.DepositCallMsg{
-		Token:  common.HexToAddress("<L1 token address>"),
-		To:     Receiver,
-		Amount: big.NewInt(5),
-}
-
-allowanceParams, err := wallet.DepositAllowanceParams(nil, msg)
-if err != nil {
-    log.Panic(err)
-}
-bridgeContracts, err := client.BridgeContracts(context.Background())
-if err != nil {
-    log.Panic(err)
-}
-approveTx, err := wallet.ApproveERC20(nil, allowanceParams[0].Token, allowanceParams[0].Allowance, bridgeContracts.L1SharedBridge)
-if err != nil {
-    log.Panic(err)
-}
-_, err = bind.WaitMined(context.Background(), ethClient, approveTx)
-if err != nil {
-    log.Panic(err)
-}
-approveTx, err = wallet.ApproveERC20(nil, allowanceParams[1].Token, allowanceParams[1].Allowance, bridgeContracts.L1SharedBridge)
-if err != nil {
-    log.Panic(err)
-}
-_, err = bind.WaitMined(context.Background(), ethClient, approveTx)
-if err != nil {
-    log.Panic(err)
-}
-```
-
-```go
-ZkSyncEraProvider := "https://testnet.era.zksync.dev"
-
-client, err := clients.Dial(ZkSyncEraProvider)
-if err != nil {
-	log.Panic(err)
-}
-defer client.Close()
-
-gasPrice, err := client.SuggestGasPrice(context.Background())
-if err != nil {
-	log.Panic(err)
-}
-
-baseCost, err := wallet.BaseCost(nil, big.NewInt(9000), utils.RequiredL1ToL2GasPerPubdataLimit, gasPrice)
-if err != nil {
-	log.Panic(err)
-}
-fmt.Println("Base cost: ", baseCost)
-```
-
-### `Deposit`
-
-Transfers the specified token from the associated account on the L1 network to the target account on the L2 network.
-The token can be either ETH or any ERC20 token. For ERC20 tokens, enough approved tokens must be associated with the
-specified L1 bridge (default one or the one defined in `BridgeAddress`). In this case, depending on is the chain
-ETH-based or not `ApproveERC20` or `ApproveBaseERC20` can be enabled to perform token approval.
-to perform token approval. If there are already enough approved tokens for the L1 bridge, token approval will be
-skipped. To check the amount of approved tokens for a specific bridge, use the [`AllowanceL1`](#allowancel1) method.
-
-#### Inputs
-
-| Parameter | Type                                                      | Description                    |
-| --------- | --------------------------------------------------------- |--------------------------------|
-| `auth`    | [`*TransactOpts`](/sdk/go/types/accounts#transactopts) (optional) | Transaction options.           |
-| `tx`      | [`DepositTransaction`](/sdk/go/types/accounts#deposittransaction) | Deposit transaction parameters.|
-
-```go
-Deposit(auth *TransactOpts, tx DepositTransaction) (*types.Transaction, error)
-```
-
-#### Example
-
-Deposit ETH on ETH-based chain.
-
-```go
-tx, err := wallet.Deposit(nil, accounts.DepositTransaction{
-		To:              wallet.Address(),
-		Token:           utils.LegacyEthAddress,
-		Amount:          amount,
-		RefundRecipient: wallet.Address(),
-})
-if err != nil {
-    log.Panic(err)
-}
-
-l1Receipt, err := bind.WaitMined(context.Background(), ethClient, tx)
-if err != nil {
-    log.Panic(err)
-}
-
-l2Tx, err := client.L2TransactionFromPriorityOp(context.Background(), l1Receipt)
-if err != nil {
-    log.Panic(err)
-}
-
-l2Receipt, err := client.WaitMined(context.Background(), l2Tx.Hash)
-if err != nil {
-    log.Panic(err)
-}
-```
-
-Deposit token on ETH-based chain.
-
-```go
-tx, err := wallet.Deposit(nil, accounts.DepositTransaction{
-		To:              wallet.Address(),
-		Token:           L1Dai,
-		Amount:          amount,
-		ApproveERC20:    true,
-		RefundRecipient: wallet.Address(),
-})
-if err != nil {
-    log.Panic(err)
-}
-
-l1Receipt, err := bind.WaitMined(context.Background(), ethClient, tx)
-if err != nil {
-    log.Panic(err)
-}
-
-l2Tx, err := client.L2TransactionFromPriorityOp(context.Background(), l1Receipt)
-if err != nil {
-    log.Panic(err)
-}
-
-l2Receipt, err := client.WaitMined(context.Background(), l2Tx.Hash)
-if err != nil {
-    log.Panic(err)
-}
-```
-
-Deposit ETH on non-ETH-based chain.
-
-```go
-tx, err := wallet.Deposit(nil, accounts.DepositTransaction{
-		To:               wallet.Address(),
-		Token:            utils.LegacyEthAddress,
-		Amount:           amount,
-		ApproveBaseERC20: true,
-		RefundRecipient:  wallet.Address(),
-})
-if err != nil {
-    log.Panic(err)
-}
-
-l1Receipt, err := bind.WaitMined(context.Background(), ethClient, tx)
-if err != nil {
-    log.Panic(err)
-}
-
-l2Tx, err := client.L2TransactionFromPriorityOp(context.Background(), l1Receipt)
-if err != nil {
-    log.Panic(err)
-}
-
-l2Receipt, err := client.WaitMined(context.Background(), l2Tx.Hash)
-if err != nil {
-    log.Panic(err)
-}
-```
-
-Deposit base token on non-ETH-based chain.
-
-```go
-baseToken, err := wallet.BaseToken(nil)
-if err != nil {
-    log.Panic(err)
-}
-
-tx, err := wallet.Deposit(nil, accounts.DepositTransaction{
-		To:               wallet.Address(),
-		Token:            baseToken,
-		Amount:           amount,
-		ApproveBaseERC20: true,
-		RefundRecipient:  wallet.Address(),
-})
-if err != nil {
-    log.Panic(err)
-}
-
-l1Receipt, err := bind.WaitMined(context.Background(), ethClient, tx)
-if err != nil {
-    log.Panic(err)
-}
-
-l2Tx, err := client.L2TransactionFromPriorityOp(context.Background(), l1Receipt)
-if err != nil {
-    log.Panic(err)
-}
-
-l2Receipt, err := client.WaitMined(context.Background(), l2Tx.Hash)
-if err != nil {
-    log.Panic(err)
-}
-```
-
-Deposit non-base token on non-ETH-based chain.
-
-```go
-tx, err := wallet.Deposit(nil, accounts.DepositTransaction{
-  To:               wallet.Address(),
-  Token:            L1Dai,
-  Amount:           amount,
-  ApproveERC20:     true,
-  ApproveBaseERC20: true,
-  RefundRecipient:  wallet.Address(),
-})
-if err != nil {
-    log.Panic(err)
-}
-
-l1Receipt, err := bind.WaitMined(context.Background(), ethClient, tx)
-if err != nil {
-    log.Panic(err)
-}
-
-l2Tx, err := client.L2TransactionFromPriorityOp(context.Background(), l1Receipt)
-if err != nil {
-    log.Panic(err)
-}
-
-l2Receipt, err := client.WaitMined(context.Background(), l2Tx.Hash)
-if err != nil {
-    log.Panic(err)
-}
-```
-
-### `EstimateGasDeposit`
-
-Estimates the amount of gas required for a deposit transaction on L1 network. Gas of approving ERC20 token is not
-included in the estimation.
-
-#### Inputs
-
-| Parameter | Type                                              | Description              |
-| --------- | ------------------------------------------------- | ------------------------ |
-| `ctx`     | `context.Context`                                 | Context.                 |
-| `msg`     | [`DepositCallMsg`](/sdk/go/types/accounts#depositcallmsg) | Deposit call parameters. |
-
-```go
-EstimateGasDeposit(ctx context.Context, msg DepositCallMsg) (uint64, error)
-```
-
-#### Example
-
-```go
-depositGas, err := wallet.EstimateGasDeposit(context.Background(), accounts.DepositCallMsg{
-	To:    wallet.Address(),
-	Token: utils.EthAddress,
-	Amount: big.NewInt(7_000_000_000),
-})
-if err != nil {
-	log.Panic(err)
-}
-fmt.Println("Deposit gas: ", depositGas)
-```
-
-### `FullRequiredDepositFee`
-
-Retrieves the full needed ETH fee for the deposit on both L1 and L2 networks.
-
-#### Inputs
-
-| Parameter | Type                                              | Description              |
-| --------- | ------------------------------------------------- | ------------------------ |
-| `ctx`     | `context.Context`                                 | Context.                 |
-| `msg`     | [`DepositCallMsg`](/sdk/go/types/accounts#depositcallmsg) | Deposit call parameters. |
-
-```go
-FullRequiredDepositFee(ctx context.Context, msg DepositCallMsg) (*FullDepositFee, error)
-```
-
-#### Example
-
-```go
-fee, err := wallet.FullRequiredDepositFee(context.Background(), accounts.DepositCallMsg{
-	To:    wallet.Address(),
-	Token: utils.EthAddress,
-	Amount: big.NewInt(7_000_000_000),
-})
-if err != nil {
-	log.Panic(err)
-}
-fmt.Printf("Fee: %+v\n", fee)
-```
-
-### `FinalizeWithdraw`
-
-Proves the inclusion of the L2 -> L1 withdrawal message.
-
-#### Inputs
-
-| Parameter        | Type                                                      | Description                                                                                                               |
-| ---------------- | --------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------- |
-| `auth`           | [`*TransactOpts`](/sdk/go/types/accounts#transactopts) (optional) | Transaction options.                                                                                                      |
-| `withdrawalHash` | `common.Hash`                                             | Hash of the L2 transaction where the withdrawal was initiated.                                                            |
-| `index`          | `int`                                                     | In case there were multiple withdrawals in one transaction, you may pass an index of the withdrawal you want to finalize. |
-
-```go
-FinalizeWithdraw(auth *TransactOpts, withdrawalHash common.Hash, index int) (*types.Transaction, error)
-```
-
-#### Example
-
-```go
-withdrawalHash := common.HexToHash("<tx hash>")
-finalizeWithdrawTx, err := wallet.FinalizeWithdraw(nil, withdrawalHash, 0)
-if err != nil {
-	log.Panic(err)
-}
-fmt.Println("Finalize withdraw transaction: ", finalizeWithdrawTx.Hash())
-```
-
-### `IsWithdrawFinalized`
-
-Checks if the withdrawal finalized on L1 network.
-
-#### Inputs
-
-| Parameter        | Type                                             | Description                                                                                                                |
-| ---------------- | ------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------- |
-| `opts`           | [`CallOpts`](/sdk/go/types/accounts#callopts) (optional) | Call options.                                                                                                              |
-| `withdrawalHash` | `common.Hash`                                    | Hash of the L2 transaction where the withdrawal was initiated.                                                             |
-| `index`          | `int`                                            | In case there where multiple withdrawals in one transaction, you may pass an index of the withdrawal you want to finalize. |
-
-```go
-IsWithdrawFinalized(opts *CallOpts, withdrawalHash common.Hash, index int) (bool, error)
-```
-
-#### Example
-
-```go
-withdrawalHash := common.HexToHash("<tx hash>")
-isFinalized, err := wallet.IsWithdrawFinalized(nil, withdrawalHash, 0)
-if err != nil {
-	log.Panic(err)
-}
-fmt.Println("Is withdrawal finalized: ", isFinalized)
-```
-
-### `ClaimFailedDeposit`
-
-Withdraws funds from the initiated deposit, which failed when finalizing on L2. If the deposit L2 transaction has
-failed, it sends an L1 transaction calling ClaimFailedDeposit method of the L1 bridge, which results in returning
-L1 tokens back to the depositor, otherwise throws the error.
-
-#### Inputs
-
-| Parameter     | Type                                                      | Description                                    |
-| ------------- | --------------------------------------------------------- | ---------------------------------------------- |
-| `auth`        | [`*TransactOpts`](/sdk/go/types/accounts#transactopts) (optional) | Transaction options.                           |
-| `depositHash` | `common.Hash`                                             | The L2 transaction hash of the failed deposit. |
-
-```go
-ClaimFailedDeposit(auth *TransactOpts, depositHash common.Hash) (*types.Transaction, error)
-```
-
-#### Example
-
-```go
-failedDepositL2Hash := common.HexToHash("<deposit L2 hash>")
-cfdTx, err := wallet.ClaimFailedDeposit(nil, failedDepositL2Hash)
-if err != nil {
-		log.Panic(err)
-}
-fmt.Println("ClaimFailedDeposit hash: ", cfdTx.Hash)
-```
-
-### `RequestExecute`
-
-Request execution of L2 transaction from L1.
-
-#### Inputs
-
-| Parameter | Type                                                                    | Description                             |
-| --------- | ----------------------------------------------------------------------- | --------------------------------------- |
-| `auth`    | [`*TransactOpts`](/sdk/go/types/accounts#transactopts) (optional)               | Transaction options.                    |
-| `tx`      | [`RequestExecuteTransaction`](/sdk/go/types/accounts#requestexecutetransaction) | Request execute transaction parameters. |
-
-```go
-RequestExecute(auth *TransactOpts, tx RequestExecuteTransaction) (*types.Transaction, error)
-```
-
-#### Example
-
-```go
-contractAddress := common.HexToAddress("<Contract address>")
-requestExecuteTx, err := wallet.RequestExecute(nil, accounts.RequestExecuteTransaction{
-	ContractAddress:   contractAddress,
-	L2Value:           big.NewInt(7_000_000_000),
-	L2GasLimit:        big.NewInt(90_000),
-	GasPerPubdataByte: utils.RequiredL1ToL2GasPerPubdataLimit,
-	RefundRecipient:   to,
-})
-if err != nil {
-	log.Panic(err)
-}
-fmt.Println("Request execute tx: ", requestExecuteTx.Hash())
-```
-
-### `EstimateGasRequestExecute`
-
-Estimates the amount of gas required for a request execute transaction.
-
-#### Inputs
-
-| Parameter | Type                                                            | Description                      |
-| --------- | --------------------------------------------------------------- | -------------------------------- |
-| `ctx`     | `context.Context`                                               | Context.                         |
-| `msg`     | [`RequestExecuteCallMsg`](/sdk/go/types/accounts#requestexecutecallmsg) | Request execute call parameters. |
-
-```go
-EstimateGasRequestExecute(ctx context.Context, msg RequestExecuteCallMsg) (uint64, error)
-```
-
-#### Example
-
-```go
-contractAddress := common.HexToAddress("<Contract address>")
-gas, err := wallet.EstimateGasRequestExecute(context.Background(), accounts.RequestExecuteCallMsg{
-	ContractAddress:   contractAddress,
-	L2Value:           big.NewInt(7_000_000_000),
-	L2GasLimit:        big.NewInt(90_000),
-	GasPerPubdataByte: utils.RequiredL1ToL2GasPerPubdataLimit,
-	RefundRecipient:   to,
-})
-if err != nil {
-	log.Panic(err)
-}
-fmt.Println("Gas: ", gas)
-```
-
-### `RequestExecuteAllowanceParams`
-
-Returns the parameters for the approval token transaction based on the request execute transaction.
-Existing allowance for the bridge is not checked; allowance is calculated solely based on the specified transaction.
-
-#### Inputs
-
-| Parameter | Type                                                            | Description                      |
-| --------- | --------------------------------------------------------------- | -------------------------------- |
-| `opts`           | [`CallOpts`](/sdk/go/types/accounts#callopts) (optional) | Call options.                                                                                                              |
-| `msg`     | [`RequestExecuteCallMsg`](/sdk/go/types/accounts#requestexecutecallmsg) | Request execute call parameters. |
-
-```go
-RequestExecuteAllowanceParams(opts *CallOpts, msg RequestExecuteCallMsg) (AllowanceParams, error)
-```
-
-#### Example
-
-```go
-msg := accounts.RequestExecuteCallMsg{
-  ContractAddress: wallet.Address(),
-  L2Value:         big.NewInt(7_000_000_000),
-  Value:           big.NewInt(0),
-}
-allowanceParams, err := wallet.RequestExecuteAllowanceParams(nil, msg)
-if err != nil {
-    log.Panic(err)
-}
-
-bridgeContracts, err := client.BridgeContracts(context.Background())
-if err != nil {
-    log.Panic(err)
-}
-
-approveTx, err := wallet.ApproveERC20(nil, allowanceParams.Token, allowanceParams.Allowance, bridgeContracts.L1SharedBridge)
-if err != nil {
-    log.Panic(err)
-}
-
-_, err = bind.WaitMined(context.Background(), ethClient, approveTx)
-if err != nil {
-    log.Panic(err)
-}
-```
-
-### `EstimateCustomBridgeDepositL2Gas`
-
-Used by [`EstimateDefaultBridgeDepositL2Gas`](#estimatedefaultbridgedepositl2gas) to estimate L2 gas
-required for token bridging via a custom ERC20 bridge.
-
-::callout{icon="i-heroicons-information-circle" color="blue"}
-See the [default bridges documentation](https://docs.zksync.io/build/developer-reference/bridging-assets#default-bridges)
-::
-
-#### Inputs
-
-| Parameter           | Type                        | Description                      |
-| ------------------- | --------------------------- | -------------------------------- |
-| `ctx`               | `context.Context`           | Context.                         |
-| `l1BridgeAddress`   | `common.Address`            | L1 bridge address.               |
-| `l2BridgeAddress`   | `common.Address`            | L2 bridge address.               |
-| `token`             | `common.Address`            | Token address.                   |
-| `amount`            | `*big.Int`                  | Deposit amount.                  |
-| `to`                | `common.Address`            | Recipient address.               |
-| `bridgeData`        | `[]byte`                    | Bridge data.                     |
-| `from`              | `common.Address` (optional) | Sender address.                  |
-| `gasPerPubdataByte` | `*big.Int` (optional)       | Current gas per byte of pubdata. |
-
-```go
-EstimateCustomBridgeDepositL2Gas(ctx context.Context, l1BridgeAddress, l2BridgeAddress, token common.Address,
-	amount *big.Int, to common.Address, bridgeData []byte, from common.Address, gasPerPubdataByte *big.Int) (uint64, error)
-```
-
-#### Example
-
-```go
-L1BridgeAddress := common.HexToAddress("<Bridge address>")
-Token := common.HexToAddress("<Token address>")
-From := common.HexToAddress("<Sender address>")
-To := common.HexToAddress("<Receipt address>")
-
-
-bridge, err := l1bridge.NewIL1Bridge(L1BridgeAddress, ethClient)
-if err != nil {
-	log.Panic(err)
-}
-l2BridgeAddress, err := bridge.L2Bridge(nil)
-if err != nil {
-	log.Panic(err)
-}
-customBridgeData, err := utils.Erc20DefaultBridgeData(Token, ethClient)
-if err != nil {
-	log.Panic(err)
-}
-
-gas, err := wallet1.EstimateCustomBridgeDepositL2Gas(context.Background(), L1BridgeAddress, l2BridgeAddress, Token,
-	big.NewInt(7), To, customBridgeData, From, utils.RequiredL1ToL2GasPerPubdataLimit)
-if err != nil {
-	log.Panic(err)
-}
-fmt.Println("L2 gas: ", gas)
-```
-
-### `EstimateDefaultBridgeDepositL2Gas`
-
-Returns an estimation of L2 gas required for token bridging via the default ERC20 bridge.
-
-::callout{icon="i-heroicons-information-circle" color="blue"}
-See the [default bridges documentation](https://docs.zksync.io/build/developer-reference/bridging-assets#default-bridges)
-::
-
-#### Inputs
-
-| Parameter           | Type                        | Description                      |
-| ------------------- | --------------------------- | -------------------------------- |
-| `ctx`               | `context.Context`           | Context.                         |
-| `token`             | `common.Address`            | Token address.                   |
-| `amount`            | `*big.Int`                  | Deposit amount.                  |
-| `to`                | `common.Address`            | Recipient address.               |
-| `from`              | `common.Address` (optional) | Sender address.                  |
-| `gasPerPubdataByte` | `*big.Int` (optional)       | Current gas per byte of pubdata. |
-
-```go
-EstimateDefaultBridgeDepositL2Gas(ctx context.Context, token common.Address, amount *big.Int,
-	to, from common.Address, gasPerPubdataByte *big.Int) (uint64, error)
-```
-
-#### Example
-
-```go
-Token := common.HexToAddress("<Token address>")
-From := common.HexToAddress("<Sender address>")
-To := common.HexToAddress("<Receipt address>")
-gas, err := wallet1.EstimateDefaultBridgeDepositL2Gas(
-	context.Background(), Token, big.NewInt(7), To, From, utils.RequiredL1ToL2GasPerPubdataLimit,
-)
-if err != nil {
-	log.Panic(err)
-}
-fmt.Println("L2 gas: ", gas)
-```
-
-## `WalletL2`
-
-### `Init`
-
-Creates an instance of `WalletL2` associated with the account provided by the raw private key.
-
-```go
-func NewWalletL2(rawPrivateKey []byte, client *clients.Client) (*WalletL2, error)
-```
-
-Creates an instance of `WalletL2`. The `client` can be optional; if it is not provided, only
-`SignTransaction`, `Address`, `Signer` can be  performed, as the rest of the functionalities
-require communication to the network.
-
-```go
-func NewWalletL2FromSigner(signer *Signer, client *clients.Client) (*WalletL2, error)
-```
-
-#### Example
-
-```go
-PrivateKey     := os.Getenv("PRIVATE_KEY")
-ZkSyncEraProvider := "https://testnet.era.zksync.dev"
-
-client, err := clients.Dial(ZkSyncEraProvider)
-if err != nil {
-	log.Panic(err)
-}
-defer client.Close()
-
-wallet, err := accounts.NewWallet(common.Hex2Bytes(PrivateKey), &client)
-if err != nil {
-	log.Panic(err)
-}
-
-```
-
-### `Address`
-
-Returns the address of the associated account.
-
-```go
-Address() common.Address
-```
-
-#### Example
-
-```go
-fmt.Println("Address: ", wallet.Address())
-```
-
-### `Signer`
-
-Returns the signer of the associated account.
-
-```go
-Signer() Signer
-```
-
-#### Example
-
-```go
-fmt.Printf("Signer %+v\n", wallet.Signer())
-```
-
-### `Balance`
-
-Returns the balance of the specified token that can be either ETH or any ERC20 token. The block number can be `nil`,
-in which case the balance is taken from the latest known block.
-
-#### Inputs
-
-| Parameter | Type              | Description       |
-| --------- | ----------------- | ----------------- |
-| `ctx`     | `context.Context` | Context.          |
-| `token`   | `common.Address`  | L2 token address. |
-| `at`      | `*big.Int`        | Block number.     |
-
-```go
-Balance(ctx context.Context, token common.Address, at *big.Int) (*big.Int, error)
-```
-
-#### Example
-
-```go
-balance, err := wallet.Balance(context.Background(), utils.EthAddress, nil)
-if err != nil {
-	log.Panic(err)
-}
-fmt.Println("Balance: ", balance)
-```
-
-### `AllBalances`
-
-Returns all balances for confirmed tokens given by an associated account.
-
-#### Inputs
-
-| Parameter | Type              | Description |
-| --------- | ----------------- | ----------- |
-| `ctx`     | `context.Context` | Context.    |
-
-```go
-AllBalances(ctx context.Context) (map[common.Address]*big.Int, error)
-```
-
-#### Example
-
-```go
-balances, err := wallet.AllBalances(context.Background())
-if err != nil {
-	log.Panic(err)
-}
-fmt.Printf("Balances: %+v\n", balances)
-```
-
-### `L2BridgeContracts`
-
-Returns L2 bridge contracts.
-
-#### Inputs
-
-| Parameter | Type              | Description |
-| --------- | ----------------- | ----------- |
-| `ctx`     | `context.Context` | Context.    |
-
-```go
-L2BridgeContracts(ctx context.Context) (*zkTypes.L2BridgeContracts, error)
-```
-
-#### Example
-
-```go
-contracts, err := wallet.L2BridgeContracts(context.Background())
-if err != nil {
-	log.Panic(err)
-}
-```
-
-### `DeploymentNonce`
-
-Returns the deployment nonce of the account.
-
-#### Inputs
-
-| Parameter | Type                                             | Description   |
-| --------- | ------------------------------------------------ | ------------- |
-| `opts`    | [`CallOpts`](/sdk/go/types/accounts#callopts) (optional) | Call options. |
-
-```go
-func (a *WalletL2) DeploymentNonce(opts *CallOpts) (*big.Int, error)
-```
-
-#### Example
-
-```go
-deploymentNonce, err := wallet.DeploymentNonce(nil)
-if err != nil {
-    log.Panic(err)
-}
-```
-
-### `IsBaseToken`
-
-Returns whether the token is the base token.
-
-#### Inputs
-
-| Parameter | Type              | Description    |
-| --------- | ----------------- |----------------|
-| `ctx`     | `context.Context` | Context.       |
-| `token`   | `common.Address`  | Token address. |
-
-```go
-IsBaseToken(ctx context.Context, token common.Address) (bool, error)
-```
-
-#### Example
-
-```go
-isBaseToken, err := wallet.IsBaseToken(
-  context.Background(),
-  common.HexToAddress("0x5C221E77624690fff6dd741493D735a17716c26B")
-)
-if err != nil {
-    log.Panic(err)
-}
-fmt.Println("Is base token: ", isBaseToken)
-```
-
-### `Withdraw`
-
-Initiates the withdrawal process which withdraws ETH or any ERC20 token from the associated account on L2 network
-to the target account on L1 network.
-
-#### Inputs
-
-| Parameter | Type                                                            | Description                        |
-| --------- | --------------------------------------------------------------- | ---------------------------------- |
-| `auth`    | [`*TransactOpts`](/sdk/go/types/accounts#transactopts) (optional)       | Transaction options.               |
-| `tx`      | [`WithdrawalTransaction`](/sdk/go/types/accounts#withdrawaltransaction) | Withdrawal transaction parameters. |
-
-```go
-Withdraw(auth *TransactOpts, tx WithdrawalTransaction) (*types.Transaction, error)
-```
-
-#### Example
-
-```go
-tx, err := wallet.Withdraw(nil, accounts.WithdrawalTransaction{
-	To:     wallet.Address(),
-	Amount: big.NewInt(1_000_000_000_000_000_000),
-	Token:  utils.EthAddress,
-})
-if err != nil {
-	panic(err)
-}
-fmt.Println("Withdraw transaction: ", tx.Hash())
-```
-
-### `EstimateGasWithdraw`
-
-Estimates the amount of gas required for a withdrawal transaction.
-
-#### Inputs
-
-| Parameter | Type                                                    | Description                 |
-| --------- | ------------------------------------------------------- | --------------------------- |
-| `ctx`     | `context.Context`                                       | Context.                    |
-| `msg`     | [`WithdrawalCallMsg`](/sdk/go/types/accounts#withdrawalcallmsg) | Withdrawal call parameters. |
-
-```go
-EstimateGasWithdraw(ctx context.Context, msg WithdrawalCallMsg) (uint64, error)
-```
-
-#### Example
-
-```go
-gas, err := wallet.EstimateGasWithdraw(context.Background(), accounts.WithdrawalCallMsg{
-	To:   wallet.Address(),
-	Amount: big.NewInt(7_000_000),
-	Token:  utils.EthAddress,
-})
-if err != nil {
-	log.Panic(err)
-}
-fmt.Println("Gas: ", gas)
-```
-
-### `Transfer`
-
-Moves the ETH or any ERC20 token from the associated account to the target account.
-
-#### Inputs
-
-| Parameter | Type                                                        | Description                      |
-| --------- | ----------------------------------------------------------- | -------------------------------- |
-| `auth`    | [`*TransactOpts`](/sdk/go/types/accounts#transactopts) (optional)   | Transaction options.             |
-| `tx`      | [`TransferTransaction`](/sdk/go/types/accounts#transfertransaction) | Transfer transaction parameters. |
-
-```go
-Transfer(auth *TransactOpts, tx TransferTransaction) (*types.Transaction, error)
-```
-
-#### Example
-
-```go
-tx, err := wallet.Transfer(nil, accounts.TransferTransaction{
-	To:     common.HexToAddress("<Receipt address>"),
-	Amount: big.NewInt(7_000_000_000),
-	Token:  utils.EthAddress,
-})
-if err != nil {
-	log.Panic(err)
-}
-fmt.Println("Transaction: ", tx.Hash())
-```
-
-### `EstimateGasTransfer`
-
-Estimates the amount of gas required for a transfer transaction.
-
-#### Inputs
-
-| Parameter | Type                                                | Description               |
-| --------- | --------------------------------------------------- | ------------------------- |
-| `ctx`     | `context.Context`                                   | Context.                  |
-| `msg`     | [`TransferCallMsg`](/sdk/go/types/accounts#transfercallmsg) | Transfer call parameters. |
-
-```go
-EstimateGasTransfer(ctx context.Context, msg TransferCallMsg) (uint64, error)
-```
-
-#### Example
-
-```go
-gas, err := wallet.EstimateGasTransfer(context.Background(), accounts.TransferCallMsg{
-	To:   common.HexToAddress("<Receipt address>"),
-	Amount: big.NewInt(7_000_000_000),
-	Token:  utils.EthAddress,
-})
-if err != nil {
-	log.Panic(err)
-}
-fmt.Println("Gas: ", gas)
-```
-
-### `CallContract`
-
-Executes a message call for EIP-712 transaction, which is directly executed in the VM of the node, but never mined
-into the blockchain.
-
-#### Inputs
-
-| Parameter     | Type                                | Description                                                                                                                                                                                 |
-| ------------- | ----------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `ctx`         | `context.Context`                   | Context.                                                                                                                                                                                    |
-| `msg`         | [`CallMsg`](/sdk/go/types/accounts#callmsg) | Contains parameters for contract call using EIP-712 transaction.                                                                                                                            |
-| `blockNumber` | `*big.Int` (optional)               | Selects the block height at which the call runs. It can be `nil`, in which case the code is taken from the latest known block. Note that state from very old blocks might not be available. |
-
-```go
-CallContract(ctx context.Context, msg CallMsg, blockNumber *big.Int) ([]byte, error)
-```
-
-#### Example
-
-```go
-// The Crown token on testnet
-TokenAddress := common.HexToAddress("0x927488F48ffbc32112F1fF721759649A89721F8F")
-
-tokenAbi, err := erc20.IERC20MetaData.GetAbi()
-if err != nil {
-	log.Panic(err)
-}
-symbolCalldata, err := tokenAbi.Pack("symbol")
-if err != nil {
-	log.Panic(err)
-}
-
-result, err := wallet.CallContract(context.Background(), types.CallMsg{
-	CallMsg: ethereum.CallMsg{
-		To:   &TokenAddress,
-		Data: symbolCalldata,
-	},
-}, nil)
-if err != nil {
-	log.Panic(err)
-}
-unpack, err := tokenAbi.Unpack("symbol", result)
-if err != nil {
-	log.Panic(err)
-}
-symbol := *abi.ConvertType(unpack[0], new(string)).(*string)
-fmt.Println("Symbol: ", symbol)
-```
-
-### PopulateTransaction
-
-Designed for users who prefer a simplified approach by providing only the necessary data to create a valid
-[EIP-712 transaction](/sdk/go/types/types#transaction712). The only required fields are `Transaction.To` and either
-`Transaction.Data` or `Transaction.Value` (or both, if the method is payable).
-Any other fields that are not set will be prepared by this method.
-
-#### Inputs
-
-| Parameter | Type                                        | Description             |
-| --------- | ------------------------------------------- | ----------------------- |
-| `ctx`     | `context.Context`                           | Context.                |
-| `tx`      | [`Transaction`](/sdk/go/types/accounts#transaction) | Transaction parameters. |
-
-```go
-PopulateTransaction(ctx context.Context, tx Transaction) (*zkTypes.Transaction712, error)
-```
-
-#### Example
-
-```go
-// The Crown token on testnet
-TokenAddress := common.HexToAddress("0x927488F48ffbc32112F1fF721759649A89721F8F")
-// Paymaster for Crown token on testnet
-PaymasterAddress := common.HexToAddress("0x13D0D8550769f59aa241a41897D4859c87f7Dd46")
-ReceiptAddress := common.HexToAddress("0xa61464658AfeAf65CccaaFD3a512b69A83B77618")
-
-abi, err := erc20.IERC20MetaData.GetAbi()
-if err != nil {
-	log.Panic(err)
-}
-
-// Encode transfer function from token contract
-calldata, err := abi.Pack("transfer", ReceiptAddress, big.NewInt(7))
-if err != nil {
-	log.Panic(err)
-}
-
-preparedTx, err := wallet.PopulateTransaction(context.Background(), &accounts.Transaction{
-	To:   &TokenAddress,
-	Data: calldata,
-})
-fmt.Printf("Prepared tx: %+v\n", preparedTx)
-```
-
-### `SignTransaction`
-
-Returns a signed transaction that is ready to be broadcast to the network. The input transaction must be a valid
-transaction with all fields having appropriate values. To obtain a valid transaction, you can use the
-[`PopulateTransaction`](#populatetransaction) method.
-
-#### Inputs
-
-| Parameter | Type                                                           | Description                     |
-| --------- |----------------------------------------------------------------| ------------------------------- |
-| `tx`      | [`zkTypes.Transaction712`](/sdk/go/types/types#transaction712) | EIP-712 transaction parameters. |
-
-```go
-SignTransaction(tx *zkTypes.Transaction712) ([]byte, error)
-```
-
-#### Example
-
-```go
-// The Crown token on testnet
-TokenAddress := common.HexToAddress("0x927488F48ffbc32112F1fF721759649A89721F8F")
-// Paymaster for Crown token on testnet
-PaymasterAddress := common.HexToAddress("0x13D0D8550769f59aa241a41897D4859c87f7Dd46")
-ReceiptAddress := common.HexToAddress("0xa61464658AfeAf65CccaaFD3a512b69A83B77618")
-
-abi, err := erc20.IERC20MetaData.GetAbi()
-if err != nil {
-	log.Panic(err)
-}
-
-// Encode transfer function from token contract
-calldata, err := abi.Pack("transfer", ReceiptAddress, big.NewInt(7))
-if err != nil {
-	log.Panic(err)
-}
-
-preparedTx, err := wallet.PopulateTransaction(context.Background(), &accounts.Transaction{
-	To:   &TokenAddress,
-	Data: calldata,
-})
-
-signedTx, err := wallet.SignTransaction(preparedTx)
-if err != nil {
-	log.Panic(err)
-}
-fmt.Printf("Signed tx: %+v\n", signedTx)
-```
-
-### `SendTransaction`
-
-Injects a transaction into the pending pool for execution. Any unset transaction fields are prepared using the
-`PopulateTransaction` method.
-
-#### Inputs
-
-| Parameter | Type                                        | Description             |
-| --------- | ------------------------------------------- | ----------------------- |
-| `ctx`     | `context.Context`                           | Context.                |
-| `tx`      | [`Transaction`](/sdk/go/types/accounts#transaction) | Transaction parameters. |
-
-```go
-SendTransaction(ctx context.Context, tx *Transaction) (common.Hash, error)
-```
-
-#### Example
-
-```go
-// The Crown token on testnet
-TokenAddress := common.HexToAddress("0x927488F48ffbc32112F1fF721759649A89721F8F")
-// Paymaster for Crown token on testnet
-PaymasterAddress := common.HexToAddress("0x13D0D8550769f59aa241a41897D4859c87f7Dd46")
-ReceiptAddress := common.HexToAddress("0xa61464658AfeAf65CccaaFD3a512b69A83B77618")
-
-abi, err := erc20.IERC20MetaData.GetAbi()
-if err != nil {
-	log.Panic(err)
-}
-
-// Encode transfer function from token contract
-calldata, err := abi.Pack("transfer", ReceiptAddress, big.NewInt(7))
-if err != nil {
-	log.Panic(err)
-}
-
-// Create paymaster parameters with encoded paymaster input
-paymasterParams, err := utils.GetPaymasterParams(
-	PaymasterAddress,
-	&zkTypes.ApprovalBasedPaymasterInput{
-		Token:            TokenAddress,
-		MinimalAllowance: big.NewInt(1),
-		InnerInput:       []byte{},
-	})
-if err != nil {
-	log.Panic(err)
-}
-
-hash, err := wallet.SendTransaction(context.Background(), &accounts.Transaction{
-	To:   &TokenAddress,
-	Data: calldata,
-	Meta: &types.Eip712Meta{
-		PaymasterParams: paymasterParams,
-	},
-})
-if err != nil {
-	log.Panic(err)
-}
-
-_, err = client.WaitMined(context.Background(), hash)
-if err != nil {
-	log.Panic(err)
-}
-
-fmt.Println("Tx: ", hash)
-```
-
-## `BaseDeployer`
-
-### `Init`
-
-Creates an instance of `BaseDeployer` based on provided `AdapterL2`.
-
-```go
-func NewBaseDeployer(adapter *AdapterL2) *BaseDeployer
-```
-
-### `Deploy`
-
-Deploys smart contract using CREATE2 method.
-
-#### Inputs
-
-| Parameter | Type                                                      | Description                     |
-| --------- | --------------------------------------------------------- | ------------------------------- |
-| `auth`    | [`*TransactOpts`](/sdk/go/types/accounts#transactopts) (optional) | Transaction options.            |
-| `tx`      | [`Create2Transaction`](/sdk/go/types/accounts#create2transaction) | CREATE2 transaction parameters. |
-
-```go
-Deploy(auth *TransactOpts, tx Create2Transaction) (common.Hash, error)
-```
-
-#### Example
-
-```go
-bytecode, err := os.ReadFile("Storage.zbin")
-if err != nil {
-	log.Panic(err)
-}
-
-//Deploy smart contract
-hash, err := wallet.Deploy(nil, accounts.Create2Transaction{Bytecode: bytecode})
-if err != nil {
-	panic(err)
-}
-fmt.Println("Transaction: ", hash)
-```
-
-### `DeployWithCreate`
-
-Deploys smart contract using CREATE method.
-
-#### Inputs
-
-| Parameter | Type                                                    | Description                    |
-| --------- | ------------------------------------------------------- | ------------------------------ |
-| `auth`    | [`*TransactOpts`](/sdk/go/types/accounts#transactopts) (optional) | Transaction options.           |
-| `tx`      | [`CreateTransaction`](/sdk/go/types/accounts#createtransaction) | CREATE transaction parameters. |
-
-```go
-DeployWithCreate(auth *TransactOpts, tx CreateTransaction) (common.Hash, error)
-```
-
-#### Example
-
-```go
-bytecode, err := os.ReadFile("Storage.zbin")
-if err != nil {
-	log.Panic(err)
-}
-
-//Deploy smart contract
-hash, err := wallet.DeployWithCreate(nil, accounts.CreateTransaction{Bytecode: bytecode})
-if err != nil {
-	panic(err)
-}
-fmt.Println("Transaction: ", hash)
-```
-
-### `DeployAccount`
-
-Deploys smart account using CREATE2 method.
-
-#### Inputs
-
-| Parameter | Type                                                      | Description                     |
-| --------- | --------------------------------------------------------- | ------------------------------- |
-| `auth`    | [`*TransactOpts`](/sdk/go/types/accounts#transactopts) (optional) | Transaction options.            |
-| `tx`      | [`Create2Transaction`](/sdk/go/types/accounts#create2transaction) | CREATE2 transaction parameters. |
-
-```go
-DeployAccount(auth *TransactOpts, tx Create2Transaction) (common.Hash, error)
-```
-
-#### Example
-
-```go
-# Crown token on testnet
-TokenAddress := common.HexToAddress("0x927488F48ffbc32112F1fF721759649A89721F8F")
-
-_, paymasterAbi, bytecode, err := utils.ReadStandardJson("Paymaster.json")
-if err != nil {
-	log.Panic(err)
-}
-
-// Encode paymaster constructor
-constructor, err := paymasterAbi.Pack("", common.HexToAddress(TokenAddress))
-if err != nil {
-	log.Panic(err)
-}
-
-// Deploy paymaster contract
-hash, err := wallet.DeployAccount(nil, accounts.Create2Transaction{Bytecode: bytecode, Calldata: constructor})
-if err != nil {
-	log.Panic(err)
-}
-if err != nil {
-	log.Panic(err)
-}
-fmt.Println("Transaction: ", hash)
-
-```
-
-### `DeployAccountWithCreate`
-
-Deploys smart account using CREATE method.
-
-#### Inputs
-
-| Parameter | Type                                                    | Description                    |
-| --------- | ------------------------------------------------------- | ------------------------------ |
-| `auth`    | [`*TransactOpts`](/sdk/go/types/accounts#transactopts) (optional) | Transaction options.           |
-| `tx`      | [`CreateTransaction`](/sdk/go/types/accounts#createtransaction) | CREATE transaction parameters. |
-
-```go
-DeployAccountWithCreate(auth *TransactOpts, tx CreateTransaction) (common.Hash, error)
-```
-
-#### Example
-
-```go
-# Crown token on testnet
-TokenAddress := common.HexToAddress("0x927488F48ffbc32112F1fF721759649A89721F8F")
-
-_, paymasterAbi, bytecode, err := utils.ReadStandardJson("Paymaster.json")
-if err != nil {
-	log.Panic(err)
-}
-
-constructor, err := paymasterAbi.Pack("", common.HexToAddress(TokenAddress))
-if err != nil {
-	log.Panic(err)
-}
-
-// Deploy paymaster contract
-hash, err := wallet.DeployAccountWithCreate(nil, accounts.CreateTransaction{
-	Bytecode: bytecode,
-	Calldata: constructor,
-})
-if err != nil {
-	log.Panic(err)
-}
-fmt.Println("Transaction: ", hash)
-```
-
-## `Wallet`
-
-It contains the same functions as [`WalletL1`](#walletl1), [`WalletL2`](#walletl2), and [`BaseDeployer`](#basedeployer)
-since it implements the Adapter interface, and the usage of those methods is the same.
-
-### `Init`
-
-Creates an instance of `Wallet` associated with the account provided by the `rawPrivateKey`. The `clientL1`
-parameters is optional; if not provided, only methods from `AdapterL2` and `Deployer` interfaces can be used,
-as the rest of the functionalities require communication with the L1 network. A `Wallet` can be configured to
-communicate with L1 networks by using and [`ConnectL1`](#connectl1) method.
-
-```go
-func NewWallet(rawPrivateKey []byte, clientL2 *clients.Client, clientL1 *ethclient.Client) (*Wallet, error)
-```
-
-Creates an instance of Wallet associated with the account provided by the signer. The `clientL2` and `clientL1`
-parameters are optional; if not provided, only `SignTransaction`, `Address` and `Signer` methods can be used,
-as the rest of the functionalities require communication with the network. A wallet that contains only a
-signer can be configured to communicate with L2 and L1 networks by using [`Connect`](#connect) and
-[`ConnectL1`](#connectl1), respectively.
-
-```go
-func NewWalletFromSigner(signer Signer, clientL2 *clients.Client, clientL1 *ethclient.Client) (*Wallet, error)
-```
-
-Creates a new instance of `Wallet` based on the provided mnemonic phrase. The `clientL2` and `clientL1`
-parameters are optional, and can be configured with [`Connect`](#connect) and [`ConnectL1`](#connectl1), respectively.
-
-```go
-func NewWalletFromMnemonic(mnemonic string, chainId int64, clientL2 *clients.Client, clientL1 *ethclient.Client) (*Wallet, error)
-```
-
-Creates a new instance of `Wallet` based on the provided private key of the account and chain ID.
-The `clientL2` and `clientL1` parameters are optional, and can be configured with [`Connect`](#connect)
-and [`ConnectL1`](#connectl1), respectively.
-
-```go
-func NewWalletFromRawPrivateKey(rawPk []byte, chainId int64, clientL2 *clients.Client, clientL1 *ethclient.Client) (*Wallet, error)
-```
-
-Creates an instance of `Wallet` with a randomly generated account. The `clientL2` and `clientL1` parameters are
-optional, and can be configured with [`Connect`](#connect) and [`ConnectL1`](#connectl1), respectively.
-
-```go
-func NewRandomWallet(chainId int64, clientL2 *clients.Client, clientL1 *ethclient.Client) (*Wallet, error)
-```
-
-#### Example
-
-```go
-PrivateKey     := os.Getenv("PRIVATE_KEY")
-ZkSyncEraProvider := "https://sepolia.era.zksync.dev"
-EthereumProvider := "https://rpc.ankr.com/eth_sepolia"
-
-client, err := clients.Dial(ZkSyncEraProvider)
-if err != nil {
-	log.Panic(err)
-}
-defer client.Close()
-
-ethClient, err := ethclient.Dial(EthereumProvider)
-if err != nil {
-	log.Panic(err)
-}
-defer ethClient.Close()
-
-wallet, err := accounts.NewWallet(common.Hex2Bytes(PrivateKey), &client, ethClient)
-if err != nil {
-	log.Panic(err)
-}
-
-chainID, err := client.ChainID(context.Background())
-if err != nil {
-	log.Panic(err)
-}
-wallet, err = accounts.NewRandomWallet(chainID.Int64(),nil,nil)
-if err != nil {
-	log.Panic(err)
-}
-```
-
-### `Connect`
-
-Returns a new instance of `Wallet` with the provided client for the L2 network.
-
-#### Inputs
-
-| Parameter | Type                         | Description |
-| --------- | ---------------------------- | ----------- |
-| `client`  | [`*clients.Client`](/sdk/go/clients) | L2 client.  |
-
-```go
-Connect(client *clients.Client) (*Wallet, error)
-```
-
-#### Example
-
-```go
-PrivateKey     := os.Getenv("PRIVATE_KEY")
-ZkSyncEraProvider := "https://testnet.era.zksync.dev"
-
-client, err := clients.Dial(ZkSyncEraProvider)
-if err != nil {
-	log.Panic(err)
-}
-defer client.Close()
-
-chainID, err := client.ChainID(context.Background())
-if err != nil {
-	log.Panic(err)
-}
-
-wallet, err := accounts.NewRandomWallet(chainID, nil, nil)
-if err != nil {
-	log.Panic(err)
-}
-
-// create new wallet with connection to L2
-wallet, err = wallet.Connect(&client)
-if err != nil {
-	log.Panic(err)
-}
-```
-
-### `ConnectL1`
-
-Returns a new instance of `Wallet` with the provided client for the L1 network.
-
-#### Inputs
-
-| Parameter | Type                                                                                               | Description |
-| --------- | -------------------------------------------------------------------------------------------------- | ----------- |
-| `client`  | [`*ethclient.Client`](https://pkg.go.dev/github.com/ethereum/go-ethereum@v1.12.0/ethclient#Client) | L1 client.  |
-
-```go
-ConnectL1(client *ethclient.Client) (*Wallet, error)
-```
-
-#### Example
-
-```go
-chainID, err := client.ChainID(context.Background())
-if err != nil {
-	log.Panic(err)
-}
-
-wallet, err = accounts.NewRandomWallet(chainID, nil, nil)
-if err != nil {
-	log.Panic(err)
-}
-
-// create new wallet with connection to L1
-wallet, err = wallet.Connect(&ethClient)
-if err != nil {
-	log.Panic(err)
-}
-```
-
-### `Nonce`
-
-Returns the account nonce of the associated account. The block number can be `nil`, in which case the nonce is taken
-from the latest known block.
-
-#### Inputs
-
-| Parameter     | Type                  | Description   |
-| ------------- | --------------------- | ------------- |
-| `ctx`         | `context.Context`     | Context.      |
-| `blockNumber` | `*big.Int` (optional) | Block number. |
-
-```go
-Nonce(ctx context.Context, blockNumber *big.Int) (uint64, error)
-```
-
-#### Example
-
-```go
-nonce, err := wallet.Nonce(context.Background(), big.NewInt(9000))
-if err != nil {
-	log.Panic(err)
-}
-fmt.Println("Nonce: ", nonce)
-```
-
-### `PendingNonce`
-
-Returns the account nonce of the associated account in the pending state.
-This is the nonce that should be used for the next transaction.
-
-#### Inputs
-
-| Parameter | Type              | Description |
-| --------- | ----------------- | ----------- |
-| `ctx`     | `context.Context` | Context.    |
-
-```go
-PendingNonce(ctx context.Context) (uint64, error)
-```
-
-#### Example
-
-```go
-nonce, err := wallet.PendingNonce(context.Background())
-if err != nil {
-	log.Panic(err)
-}
-fmt.Println("Nonce: ", nonce)
-```
-
-## `SmartAccount`
-
-A `SmartAccount` is a signer which can be configured to sign various payloads using a provided secret.
-The secret can be in any form, allowing for flexibility when working with different account implementations.
-The `SmartAccount` is bound to a specific address and provides the ability to define custom method for populating transactions
-and custom signing method used for signing messages, typed data, and transactions.
-
-### `Init`
-
-Creates a new `SmartAccount` instance. By default, it uses [`SignPayloadWithECDSA`](/sdk/go/smart-account-utils#signpayloadwithecdsa)
-as a signer and [`PopulateTransactionECDSA`](/sdk/go/smart-account-utils#populatetransactionecdsa) as a builder and
-requires private key in hex format to be provided.
-
-#### Inputs
-
-| Parameter | Type                                                               | Description                                             |
-|-----------|--------------------------------------------------------------------|---------------------------------------------------------|
-| `address` | `common.Address`                                                   | Account address.                                        |
-| `secret`  | `interface{}`                                                      | Secret used for signing.                                |
-| `signer`  | [`*PayloadSigner`](/sdk/go/types/accounts#payloadsigner)           | Function used for signing payload.                      |
-| `builder` | [`*TransactionBuilder`](/sdk/go/types/accounts#transactionbuilder) | Function used for populating transaction.               |
-| `client`  | [`*clients.BaseClient`](/sdk/go/clients#baseclient)                       | The client to connect to. Can be `nil` for offline usage. |
-
-```go
-
-func NewSmartAccount(
-	address common.Address,
-	secret interface{},
-	signer *PayloadSigner,
-	builder *TransactionBuilder,
-	client *clients.BaseClient) *SmartAccount
-```
-
-#### Examples
-
-```go
-privateKey     := os.Getenv("PRIVATE_KEY")
-address := common.HexToAddress("<ACCOUNT ADDRESS>")
-ZkSyncEraProvider := "https://sepolia.era.zksync.dev"
-
-client, err := clients.DialBase(ZkSyncEraProvider)
-if err != nil {
-	log.Panic(err)
-}
-defer client.Close()
-
-account := accounts.NewSmartAccount(
-    address,
-    privateKey,
-    &accounts.SignPayloadWithECDSA,
-    &accounts.PopulateTransactionECDSA,
-nil)
-```
-
-### `NewECDSASmartAccount`
-
-Creates a `SmartAccount` instance that uses single ECDSA key for signing payload.
-
-| Parameter    | Type                                                | Description                                              |
-|--------------|-----------------------------------------------------|----------------------------------------------------------|
-| `address`    | `common.Address`                                    | Account address.                                         |
-| `privateKey` | `string`                                            | The ECDSA private key.                   |
-| `client`     | [`*clients.BaseClient`](/sdk/go/clients#baseclient) | The client to connect to. Can be `nil` for offline usage. |
-
-```go
-
-func NewECDSASmartAccount(address common.Address, privateKey string, client *clients.BaseClient) *SmartAccount
-```
-
-#### Example
-
-```go
-privateKey := os.Getenv("PRIVATE_KEY")
-address := common.HexToAddress("<ACCOUNT ADDRESS>")
-ZkSyncEraProvider := "https://sepolia.era.zksync.dev"
-
-client, err := clients.DialBase(ZkSyncEraProvider)
-if err != nil {
-    log.Panic(err)
-}
-defer client.Close()
-
-account := accounts.NewECDSASmartAccount(address, privateKey, client)
-```
-
-### `NewMultisigECDSASmartAccount`
-
-Creates a `SmartAccount` instance that uses multiple ECDSA keys for signing payloads.
-The signature is generated by concatenating signatures created by signing with each key individually.
-
-| Parameter     | Type                                                | Description                                               |
-|---------------|-----------------------------------------------------|-----------------------------------------------------------|
-| `address`     | `common.Address`                                    | Account address.                                          |
-| `privateKeys` | `[]string`                                          | The list of the ECDSA private keys.                       |
-| `client`      | [`*clients.BaseClient`](/sdk/go/clients#baseclient) | The client to connect to. Can be `nil` for offline usage. |
-
-```go
-NewMultisigECDSASmartAccount(address common.Address, privateKeys []string, client *clients.BaseClient) *SmartAccount
-```
-
-#### Example
-
-```go
-privateKey1 := os.Getenv("PRIVATE_KEY1")
-privateKey2 := os.Getenv("PRIVATE_KEY2")
-address := common.HexToAddress("<ACCOUNT ADDRESS>")
-ZkSyncEraProvider := "https://sepolia.era.zksync.dev"
-
-client, err := clients.DialBase(ZkSyncEraProvider)
-if err != nil {
-    log.Panic(err)
-}
-defer client.Close()
-
-account := accounts.NewMultisigECDSASmartAccount(address, []string{privateKey1, privateKey2}, client)
-```
-
-### `Connect`
-
-Creates a new instance of SmartAccount connected to a client or
-detached from any provider if `nil` is provided.
-
-#### Inputs
-
-| Parameter | Type                                              | Description                                                                                                   |
-| --------- |---------------------------------------------------|---------------------------------------------------------------------------------------------------------------|
-| `client`  | [`*clients.DialBase`](/sdk/go/clients#baseclient) | The client to connect the `SmartAccount` to. If `nil`, the `SmartAccount` will be detached from any provider. |
-
-```go
-Connect(client *clients.BaseClient) *SmartAccount
-```
-
-#### Example
-
-```go
-privateKey     := os.Getenv("PRIVATE_KEY")
-ZkSyncEraProvider := "https://testnet.era.zksync.dev"
-
-client, err := clients.Dial(ZkSyncEraProvider)
-if err != nil {
-	log.Panic(err)
-}
-defer client.Close()
-
-account := accounts.NewECDSASmartAccount(Address1, PrivateKey1, nil)
-account = account.Connect(client)
-```
-
-### `Address`
-
-Returns the address of the associated account.
-
-```go
-Address() common.Address
-```
-
-#### Example
-
-```go
-fmt.Println("Address: ", account.Address())
-```
-
-### `Balance`
-
-Returns the balance of the specified token that can be either ETH or any ERC20 token. The block number can be `nil`,
-in which case the balance is taken from the latest known block.
-
-#### Inputs
-
-| Parameter | Type              | Description       |
-| --------- | ----------------- | ----------------- |
-| `ctx`     | `context.Context` | Context.          |
-| `token`   | `common.Address`  | L2 token address. |
-| `at`      | `*big.Int`        | Block number.     |
-
-```go
-Balance(ctx context.Context, token common.Address, at *big.Int) (*big.Int, error)
-```
-
-#### Example
-
-```go
-balance, err := account.Balance(context.Background(), utils.EthAddress, nil)
-if err != nil {
-	log.Panic(err)
-}
-fmt.Println("Balance: ", balance)
-```
-
-### `AllBalances`
-
-Returns all balances for confirmed tokens given by an associated account.
-
-#### Inputs
-
-| Parameter | Type              | Description |
-| --------- | ----------------- | ----------- |
-| `ctx`     | `context.Context` | Context.    |
-
-```go
-AllBalances(ctx context.Context) (map[common.Address]*big.Int, error)
-```
-
-#### Example
-
-```go
-balances, err := account.AllBalances(context.Background())
-if err != nil {
-	log.Panic(err)
-}
-fmt.Printf("Balances: %+v\n", balances)
-```
-
-### `Nonce`
-
-Returns the account nonce of the associated account. The block number can be `nil`, in which case the nonce is taken
-from the latest known block.
-
-#### Inputs
-
-| Parameter     | Type                  | Description   |
-| ------------- | --------------------- | ------------- |
-| `ctx`         | `context.Context`     | Context.      |
-| `blockNumber` | `*big.Int` (optional) | Block number. |
-
-```go
-Nonce(ctx context.Context, blockNumber *big.Int) (uint64, error)
-```
-
-#### Example
-
-```go
-nonce, err := account.Nonce(context.Background(), big.NewInt(9000))
-if err != nil {
-	log.Panic(err)
-}
-fmt.Println("Nonce: ", nonce)
-```
-
-### `DeploymentNonce`
-
-Returns the deployment nonce of the account.
-
-#### Inputs
-
-| Parameter | Type                                             | Description   |
-| --------- | ------------------------------------------------ | ------------- |
-| `opts`    | [`CallOpts`](/sdk/go/types/accounts#callopts) (optional) | Call options. |
-
-```go
-DeploymentNonce(opts *CallOpts) (*big.Int, error)
-```
-
-#### Example
-
-```go
-deploymentNonce, err := account.DeploymentNonce(nil)
-if err != nil {
-    log.Panic(err)
-}
-```
-
-### `PopulateTransaction`
-
-Populates the transaction `tx` using the provided [`TransactionBuilder`](/sdk/go/types/accounts#transactionbuilder) function.
-If `tx.From` is not set, it sets the value from the `Address()` method which can
-be utilized in the `TransactionBuilder` function.
-
-#### Inputs
-
-| Parameter | Type                                                     | Description                        |
-|-----------|----------------------------------------------------------|------------------------------------|
-| `ctx`     | `context.Context`                                        | Context.                           |
-| `tx`      | [`*zkTypes.Transaction712`](/sdk/go/types/types#transaction712) | The transaction that needs to be populated.     |
-
-```go
-PopulateTransaction(ctx context.Context, tx *zkTypes.Transaction712) error
-```
-
-#### Example
-
-```go
-address := common.HexToAddress("<ACCOUNT ADDRESS>")
-tx := &zkTypes.Transaction712{
-  To:    &address,
-  Value: big.NewInt(7_000_000_000),
-}
-
-err = account.PopulateTransaction(context.Background(), tx)
-if err != nil {
-    log.Panic(err)
-}
-```
-
-### `SignTransaction`
-
-Returns a signed transaction that is ready to be broadcast to
-the network. The `PopulateTransaction` method is called first to ensure that all
-necessary properties for the transaction to be valid have been populated.
-
-#### Inputs
-
-| Parameter | Type                                                    | Description                              |
-|-----------|---------------------------------------------------------|------------------------------------------|
-| `ctx`     | `context.Context`                                       | Context.                                 |
-| `tx`      | [`*zkTypes.Transaction712`](/sdk/go/types/types#transaction712) | The transaction that needs to be signed. |
-
-```go
-
-SignTransaction(ctx context.Context, tx *zkTypes.Transaction712) ([]byte, error)
-```
-
-#### Example
-
-```go
-address := common.HexToAddress("<ACCOUNT ADDRESS>")
-signedTx, err := account.SignTransaction(context.Background(), &zkTypes.Transaction712{
-    To:    &address,
-    Value: big.NewInt(1_000_000_000_000_000_000), // 1ETH
-})
-if err != nil {
-  log.Panic(err)
-}
-```
-
-### `SendTransaction`
-
-Injects a transaction into the pending pool for execution.
-The `SignTransaction` is called first to ensure transaction is properly signed.
-
-#### Inputs
-
-| Parameter | Type                                                    | Description                              |
-|-----------|---------------------------------------------------------|------------------------------------------|
-| `ctx`     | `context.Context`                                       | Context.                                 |
-| `tx`      | [`*zkTypes.Transaction712`](/sdk/go/types/types#transaction712) | The transaction that needs to be signed. |
-
-```go
-SendTransaction(ctx context.Context, tx *zkTypes.Transaction712) (common.Hash, error)
-```
-
-#### Example
-
-```go
-address := common.HexToAddress("<ACCOUNT ADDRESS>")
-txHash, err := account.SendTransaction(context.Background(), &zkTypes.Transaction712{
-    To:    &address,
-    Value: big.NewInt(1_000_000_000_000_000_000), // 1ETH
-})
-if err != nil {
-  log.Panic(err)
-}
-```
-
-### `SignMessage`
-
-Signs a message using the provided [`PayloadSigner`](/sdk/go/types/accounts#payloadsigner) function.
-
-#### Inputs
-
-| Parameter | Type              | Description                          |
-|-----------|-------------------|--------------------------------------|
-| `ctx`     | `context.Context` | Context.                             |
-| `message` | `[]byte`           | The message that needs to be signed. |
-
-```go
-SignMessage(ctx context.Context, message []byte) ([]byte, error)
-```
-
-#### Example
-
-```go
-signature, err := account.SignMessage(context.Background(), []byte("Hello World!"))
-if err != nil {
-  log.Panic(err)
-}
-```
-
-### `SignTypedData`
-
-signs a typed data using the provided [`PayloadSigner`](/sdk/go/types/accounts#payloadsigner) function.
-
-#### Inputs
-
-| Parameter   | Type                  | Description                             |
-|-------------|-----------------------|-----------------------------------------|
-| `ctx`       | `context.Context`     | Context.                                |
-| `typedData` | `apitypes.TypedData`  | The typed data that needs to be signed. |
-
-```go
-SignTypedData(ctx context.Context, typedData apitypes.TypedData) ([]byte, error)
-```
-
-#### Example
-
-```go
-signature, err := account.SignTypedData(context.Background(), apitypes.TypedData{
-  Domain: apitypes.TypedDataDomain{
-    Name:    "Example",
-    Version: "1",
-    ChainId: math.NewHexOrDecimal256(270),
-  },
-  Types: apitypes.Types{
-    "Person": []apitypes.Type{
-      {Name: "name", Type: "string"},
-      {Name: "age", Type: "uint8"},
-    },
-    "EIP712Domain": []apitypes.Type{
-      {Name: "name", Type: "string"},
-      {Name: "version", Type: "string"},
-      {Name: "chainId", Type: "uint256"},
-    },
-  },
-  PrimaryType: "Person",
-  Message: apitypes.TypedDataMessage{
-    "name": "John",
-    "age":  hexutil.EncodeUint64(30),
-  },
-})
-if err != nil {
-  log.Panic(err)
-}
-```
-
-### `Withdraw`
-
-Initiates the withdrawal process which withdraws ETH or any ERC20 token from the associated account on L2 network
-to the target account on L1 network.
-
-#### Inputs
-
-| Parameter | Type                                                            | Description                        |
-| --------- | --------------------------------------------------------------- | ---------------------------------- |
-| `auth`    | [`*TransactOpts`](/sdk/go/types/accounts#transactopts) (optional)       | Transaction options.               |
-| `tx`      | [`WithdrawalTransaction`](/sdk/go/types/accounts#withdrawaltransaction) | Withdrawal transaction parameters. |
-
-```go
-Withdraw(auth *TransactOpts, tx WithdrawalTransaction) (common.Hash, error)
-```
-
-#### Examples
-
-Withdraw ETH.
-
-```go
-txHash, err := account.Withdraw(nil, accounts.WithdrawalTransaction{
-    To:     account.Address(),
-    Amount: big.NewInt(1_000_000_000_000_000_000),
-    Token:  utils.LegacyEthAddress,
-})
-if err != nil {
-	log.Panic(err)
-}
-fmt.Println("Withdraw transaction: ", txHash)
-```
-
-Withdraw ETH using paymaster to facilitate fee payment with an ERC20 token.
-
-```go
-token := common.HexToAddress("0x927488F48ffbc32112F1fF721759649A89721F8F"); // Crown token which can be minted for free
-paymaster := common.HexToAddress("0x13D0D8550769f59aa241a41897D4859c87f7Dd46"); // Paymaster for Crown token
-
-paymasterParams, err := utils.GetPaymasterParams(
-		paymaster,
-		&zkTypes.ApprovalBasedPaymasterInput{
-			Token:            token,
-			MinimalAllowance: big.NewInt(1),
-			InnerInput:       []byte{},
-})
-if err != nil {
-    log.Panic(err)
-}
-
-txHash, err := account.Withdraw(nil, accounts.WithdrawalTransaction{
-		To:              account.Address(),
-		Amount:          big.NewInt(1_000_000_000_000_000_000),
-		Token:           utils.LegacyEthAddress,
-		PaymasterParams: paymasterParams,
-	})
-```
-
-### `Transfer`
-
-Moves the ETH or any ERC20 token from the associated account to the target account.
-
-#### Inputs
-
-| Parameter | Type                                                        | Description                      |
-| --------- | ----------------------------------------------------------- | -------------------------------- |
-| `auth`    | [`*TransactOpts`](/sdk/go/types/accounts#transactopts) (optional)   | Transaction options.             |
-| `tx`      | [`TransferTransaction`](/sdk/go/types/accounts#transfertransaction) | Transfer transaction parameters. |
-
-```go
-Transfer(auth *TransactOpts, tx TransferTransaction) (common.Hash, error)
-```
-
-#### Examples
-
-Transfer ETH.
-
-```go
-txHash, err := account.Transfer(nil, accounts.TransferTransaction{
-  To:     Address2,
-  Amount: amount,
-  Token:  utils.LegacyEthAddress,
-})
-if err != nil {
-	log.Panic(err)
-}
-fmt.Println("Transaction: ", txHash)
-```
-
-Transfer ETH using paymaster to facilitate fee payment with an ERC20 token.
-
-```go
-token := common.HexToAddress("0x927488F48ffbc32112F1fF721759649A89721F8F"); // Crown token which can be minted for free
-paymaster := common.HexToAddress("0x13D0D8550769f59aa241a41897D4859c87f7Dd46"); // Paymaster for Crown token
-
-paymasterParams, err := utils.GetPaymasterParams(
-  paymaster,
-  &zkTypes.ApprovalBasedPaymasterInput{
-    Token:            token,
-    MinimalAllowance: big.NewInt(1),
-    InnerInput:       []byte{},
-})
-if err != nil {
-  log.Panic(err)
-}
-
-txHash, err := account.Transfer(nil, accounts.TransferTransaction{
-  To:     Address2,
-  Amount: amount,
-  Token:  utils.LegacyEthAddress,
-  PaymasterParams: paymasterParams,
-})
-if err != nil {
-	log.Panic(err)
-}
-fmt.Println("Transaction: ", txHash)
-```
diff --git a/content/sdk/20.go/types/00.intro.md b/content/sdk/20.go/types/00.intro.md
deleted file mode 100644
index 0666e209..00000000
--- a/content/sdk/20.go/types/00.intro.md
+++ /dev/null
@@ -1,14 +0,0 @@
----
-title: Types
-description:
----
-
-Types are placed in three packages for different purposes:
-
-- [`types`](/sdk/go/types/types): Contains common and general types used to build basic features and other types.
-- [`eip712`](/sdk/go/types/eip712): Contains types used for EIP-712 implementation.
-- [`clients`](/sdk/go/types/clients): Contains types that are meant to be used along with [`Client`](/sdk/go/clients).
-- [`accounts`](/sdk/go/types/accounts): Contains types that are meant to be used along with an account,
-  specifically with the [`Adapter`](/sdk/go/types/accounts) abstraction.
-  Many types are similar to those from the `geth` library, but the `From` or `Signer` fields are omitted
-  because these fields are inherited from `Adapter`, which already has an associated account.