Repository: 0xSpaceShard/starknet-devnet (language: python)

Issue:
Update RPC API to tx version 1
Currently 0 (specified by constant `SUPPORTED_RPC_TX_VERSION`).

From what I saw, a significant part of adaptation would have to be done in RPC tests.
Version 0.1.8 throws error on start
## Issue

`MultiDict` doesn't support generic types, which results in error:
```
> poetry run starknet-devnet
Traceback (most recent call last):
  File "<string>", line 1, in <module>
  File "/Users/user/.pyenv/versions/3.7.12/lib/python3.7/importlib/__init__.py", line 127, in import_module
    return _bootstrap._gcd_import(name[level:], package, level)
  File "<frozen importlib._bootstrap>", line 1006, in _gcd_import
  File "<frozen importlib._bootstrap>", line 983, in _find_and_load
  File "<frozen importlib._bootstrap>", line 967, in _find_and_load_unlocked
  File "<frozen importlib._bootstrap>", line 677, in _load_unlocked
  File "<frozen importlib._bootstrap_external>", line 728, in exec_module
  File "<frozen importlib._bootstrap>", line 219, in _call_with_frames_removed
  File "/Users/user/work/starknet/starknet-devnet/starknet_devnet/server.py", line 124, in <module>
    def check_block_hash(request_args: MultiDict[str, str]):
TypeError: 'type' object is not subscriptable
```

The same thing happens when using starknet-devnet as a package.

## Repro
```
git checkout v0.1.8
poetry run starknet-devnet
```

## Possible fix
After replacing `MultiDict[int, int]` with `MultiDict` in `starknet_devnet/server.py` it seems to be working properly. I can create a PR if needed.


Discussion / hints:

Thanks for the report! Which version of Python are you using?
Ahh, sorry I forgot about it. I am using `Python 3.7.12`.
Hm, I would have expected that version to work. Anyway, you are welcome to create the PR.

Fix patch:
diff --git a/page/docs/guide/json-rpc-api.md b/page/docs/guide/json-rpc-api.md
index de01473ff..1596b53f5 100644
--- a/page/docs/guide/json-rpc-api.md
+++ b/page/docs/guide/json-rpc-api.md
@@ -4,7 +4,7 @@ sidebar_position: 3
 
 # JSON-RPC API
 
-Devnet also partially supports JSON-RPC API v0.1.0: [**specifications**](https://github.com/starkware-libs/starknet-specs/releases/tag/v0.1.0) . It can be reached under `/rpc`. For an example:
+Devnet also supports JSON-RPC API v0.2.0: [specifications](https://github.com/starkware-libs/starknet-specs/releases/tag/v0.2.0) . It can be reached under `/rpc`. For an example:
 
 ```
 POST /rpc
@@ -28,10 +28,6 @@ Response:
 }
 ```
 
-Methods currently not supported:
-
-- `starknet_protocolVersion` - will be removed in a future version of the specification
-
 Methods that require a `block_id` only support ids of the `latest` or `pending` block.
 Please note however, that the `pending` block will be the same block as the `latest`.
 
diff --git a/starknet_devnet/blueprints/rpc/call.py b/starknet_devnet/blueprints/rpc/call.py
index c2b506bd2..1ad39fe43 100644
--- a/starknet_devnet/blueprints/rpc/call.py
+++ b/starknet_devnet/blueprints/rpc/call.py
@@ -48,8 +48,7 @@ async def call(request: FunctionCall, block_id: BlockId) -> List[Felt]:
         result = await state.starknet_wrapper.call(
             transaction=make_invoke_function(request)
         )
-        result = [rpc_felt(int(res, 16)) for res in result["result"]]
-        return result
+        return [rpc_felt(res) for res in result["result"]]
     except StarknetDevnetException as ex:
         raise RpcError(
             code=RpcErrorCode.INTERNAL_ERROR.value, message=ex.message
diff --git a/starknet_devnet/blueprints/rpc/classes.py b/starknet_devnet/blueprints/rpc/classes.py
index fe578d6b3..388003282 100644
--- a/starknet_devnet/blueprints/rpc/classes.py
+++ b/starknet_devnet/blueprints/rpc/classes.py
@@ -17,18 +17,18 @@
 from starknet_devnet.util import StarknetDevnetException
 
 
-async def get_class(class_hash: Felt) -> dict:
+async def get_class(block_id: BlockId, class_hash: Felt) -> dict:
     """
-    Get the contract class definition associated with the given hash
+    Get the contract class definition in the given block associated with the given hash
     """
+    assert_block_id_is_latest_or_pending(block_id)
+
     try:
         result = state.starknet_wrapper.contracts.get_class_by_hash(
             class_hash=int(class_hash, 16)
         )
     except StarknetDevnetException as ex:
-        raise RpcError(
-            code=28, message="The supplied contract class hash is invalid or unknown"
-        ) from ex
+        raise RpcError(code=28, message="Class hash not found") from ex
 
     return rpc_contract_class(result)
 
@@ -44,9 +44,7 @@ async def get_class_hash_at(block_id: BlockId, contract_address: Address) -> Fel
             address=int(contract_address, 16)
         )
     except StarknetDevnetException as ex:
-        raise RpcError(
-            code=28, message="The supplied contract class hash is invalid or unknown"
-        ) from ex
+        raise RpcError(code=28, message="Class hash not found") from ex
 
     return rpc_felt(result)
 
diff --git a/starknet_devnet/blueprints/rpc/misc.py b/starknet_devnet/blueprints/rpc/misc.py
index 981a08e3b..22d13fa86 100644
--- a/starknet_devnet/blueprints/rpc/misc.py
+++ b/starknet_devnet/blueprints/rpc/misc.py
@@ -8,11 +8,15 @@
     BlockId,
     Felt,
     Address,
+    RpcError,
 )
 from starknet_devnet.blueprints.rpc.structures.responses import (
     RpcEventsResult,
 )
-
+from starknet_devnet.blueprints.rpc.utils import (
+    assert_block_id_is_latest_or_pending,
+    rpc_felt,
+)
 from starknet_devnet.state import state
 
 
@@ -98,11 +102,17 @@ async def get_events(
     )
 
 
-async def get_nonce(contract_address: Address) -> Felt:
+async def get_nonce(block_id: BlockId, contract_address: Address) -> Felt:
     """
-    Get the latest nonce associated with the given address
+    Get the nonce associated with the given address in the given block
     """
+    assert_block_id_is_latest_or_pending(block_id)
+
+    if not state.starknet_wrapper.contracts.is_deployed(int(contract_address, 16)):
+        raise RpcError(code=20, message="Contract not found")
+
     result = await state.starknet_wrapper.get_nonce(
         contract_address=int(contract_address, 16)
     )
-    return hex(result)
+
+    return rpc_felt(result)
diff --git a/starknet_devnet/blueprints/rpc/state.py b/starknet_devnet/blueprints/rpc/state.py
index 1e0283b00..50c649ec7 100644
--- a/starknet_devnet/blueprints/rpc/state.py
+++ b/starknet_devnet/blueprints/rpc/state.py
@@ -25,6 +25,6 @@ async def get_state_update(block_id: BlockId) -> dict:
                 block_number=block_id["block_number"]
             )
     except StarknetDevnetException as ex:
-        raise RpcError(code=24, message="Invalid block id") from ex
+        raise RpcError(code=24, message="Block not found") from ex
 
     return rpc_state_update(result)
diff --git a/starknet_devnet/blueprints/rpc/storage.py b/starknet_devnet/blueprints/rpc/storage.py
index b2bafbd90..91ae4e88c 100644
--- a/starknet_devnet/blueprints/rpc/storage.py
+++ b/starknet_devnet/blueprints/rpc/storage.py
@@ -29,4 +29,4 @@ async def get_storage_at(
     storage = await state.starknet_wrapper.get_storage_at(
         contract_address=int(contract_address, 16), key=int(key, 16)
     )
-    return rpc_felt(int(storage, 16))
+    return rpc_felt(storage)
diff --git a/starknet_devnet/blueprints/rpc/structures/payloads.py b/starknet_devnet/blueprints/rpc/structures/payloads.py
index 3d2d7a267..dfcce04bd 100644
--- a/starknet_devnet/blueprints/rpc/structures/payloads.py
+++ b/starknet_devnet/blueprints/rpc/structures/payloads.py
@@ -6,7 +6,9 @@
 
 from typing import Callable, Union, List, Optional
 
+from test.shared import LEGACY_RPC_TX_VERSION
 from starkware.starknet.definitions.general_config import StarknetGeneralConfig
+from starkware.starknet.public.abi import AbiEntryType
 from starkware.starknet.services.api.contract_class import ContractClass
 from starkware.starknet.services.api.feeder_gateway.response_objects import (
     StarknetBlock,
@@ -16,13 +18,13 @@
     TransactionType,
     BlockStateUpdate,
     DeclareSpecificInfo,
+    L1HandlerSpecificInfo,
     FeeEstimationInfo,
 )
 from starkware.starknet.services.api.gateway.transaction import InvokeFunction
 from starkware.starknet.services.api.gateway.transaction_utils import compress_program
-from typing_extensions import TypedDict
+from typing_extensions import TypedDict, Literal
 
-from starknet_devnet.blueprints.rpc.utils import rpc_root, rpc_felt
 from starknet_devnet.blueprints.rpc.structures.types import (
     RpcBlockStatus,
     BlockHash,
@@ -34,14 +36,14 @@
     NumAsHex,
     TxnType,
     rpc_txn_type,
+    Signature,
 )
+from starknet_devnet.blueprints.rpc.utils import rpc_root, rpc_felt
 from starknet_devnet.state import state
 
 
 class RpcBlock(TypedDict):
-    """
-    TypeDict for rpc block
-    """
+    """TypedDict for rpc block"""
 
     status: RpcBlockStatus
     block_hash: BlockHash
@@ -95,95 +97,163 @@ def config() -> StarknetGeneralConfig:
     return block
 
 
-class RpcInvokeTransaction(TypedDict):
-    """
-    TypedDict for rpc invoke transaction
-    """
+class RpcBroadcastedTxnCommon(TypedDict):
+    """TypedDict for RpcBroadcastedTxnCommon"""
+
+    type: TxnType
+    max_fee: Felt
+    version: NumAsHex
+    signature: Signature
+    nonce: Felt
+
+
+class RpcBroadcastedInvokeTxnV0(RpcBroadcastedTxnCommon):
+    """TypedDict for RpcBroadcastedInvokeTxnV0"""
 
     contract_address: Address
     entry_point_selector: Felt
     calldata: List[Felt]
-    # Common
-    transaction_hash: TxnHash
-    max_fee: Felt
+
+
+class RpcBroadcastedInvokeTxnV1(RpcBroadcastedTxnCommon):
+    """TypedDict for RpcBroadcastedInvokeTxnV1"""
+
+    sender_address: Address
+    calldata: List[Felt]
+
+
+RpcBroadcastedInvokeTxn = Union[RpcBroadcastedInvokeTxnV0, RpcBroadcastedInvokeTxnV1]
+
+
+class RpcBroadcastedDeclareTxn(RpcBroadcastedTxnCommon):
+    """TypedDict for RpcBroadcastedDeclareTxn"""
+
+    contract_class: RpcContractClass
+    sender_address: Address
+
+
+class RpcBroadcastedDeployTxn(TypedDict):
+    """TypedDict for RpcBroadcastedDeployTxn"""
+
+    contract_class: RpcContractClass
     version: NumAsHex
-    signature: List[Felt]
-    nonce: Felt
     type: TxnType
+    contract_address_salt: Felt
+    constructor_calldata: List[Felt]
 
 
-class RpcDeclareTransaction(TypedDict):
-    """
-    TypedDict for rpc declare transaction
-    """
+# rpc transaction's representation when it's sent to the sequencer (but not yet in a block)
+RpcBroadcastedTxn = Union[
+    RpcBroadcastedDeployTxn, RpcBroadcastedDeclareTxn, RpcBroadcastedInvokeTxn
+]
+
+
+class RpcTransactionCommon(RpcBroadcastedTxnCommon):
+    """TypedDict for RpcTransactionCommon"""
+
+    transaction_hash: TxnHash
+
+
+class RpcInvokeTransactionV0(RpcTransactionCommon):
+    """TypedDict for rpc invoke transaction version 0"""
+
+    contract_address: Address
+    entry_point_selector: Felt
+    calldata: List[Felt]
+
+
+class RpcInvokeTransactionV1(RpcTransactionCommon):
+    """TypedDict for rpc invoke transaction version 1"""
 
-    class_hash: Felt
     sender_address: Address
-    # Common
+    calldata: List[Felt]
+
+
+class RpcL1HandlerTransaction(TypedDict):
+    """TypedDict for rpc L1 -> L2 message transaction"""
+
+    contract_address: Address
+    entry_point_selector: Felt
+    calldata: List[Felt]
     transaction_hash: TxnHash
-    max_fee: Felt
     version: NumAsHex
-    signature: List[Felt]
-    nonce: Felt
     type: TxnType
+    nonce: Felt
+
+
+class RpcDeclareTransaction(RpcTransactionCommon):
+    """TypedDict for rpc declare transaction"""
+
+    class_hash: Felt
+    sender_address: Address
 
 
 class RpcDeployTransaction(TypedDict):
-    """
-    TypedDict for rpc deploy transaction
-    """
+    """TypedDict for rpc deploy transaction"""
 
     transaction_hash: TxnHash
     class_hash: Felt
     version: NumAsHex
     type: TxnType
-    contract_address: Felt
     contract_address_salt: Felt
     constructor_calldata: List[Felt]
 
 
 RpcTransaction = Union[
-    RpcInvokeTransaction, RpcDeclareTransaction, RpcDeployTransaction
+    RpcInvokeTransactionV0,
+    RpcInvokeTransactionV1,
+    RpcL1HandlerTransaction,
+    RpcDeclareTransaction,
+    RpcDeployTransaction,
 ]
 
 
 def rpc_transaction(transaction: TransactionSpecificInfo) -> RpcTransaction:
-    """
-    Convert gateway transaction to rpc transaction
-    """
+    """Convert gateway transaction to rpc transaction"""
     tx_mapping = {
         TransactionType.DEPLOY: rpc_deploy_transaction,
         TransactionType.INVOKE_FUNCTION: rpc_invoke_transaction,
         TransactionType.DECLARE: rpc_declare_transaction,
+        TransactionType.L1_HANDLER: rpc_l1_handler_transaction,
     }
     return tx_mapping[transaction.tx_type](transaction)
 
 
 class FunctionCall(TypedDict):
-    """
-    TypedDict for rpc function call
-    """
+    """TypedDict for rpc function call"""
 
     contract_address: Address
     entry_point_selector: Felt
     calldata: List[Felt]
 
 
-def rpc_invoke_transaction(transaction: InvokeSpecificInfo) -> RpcInvokeTransaction:
+def rpc_invoke_transaction(
+    transaction: InvokeSpecificInfo,
+) -> Union[RpcInvokeTransactionV0, RpcInvokeTransactionV1]:
     """
     Convert gateway invoke transaction to rpc format
     """
-    txn: RpcInvokeTransaction = {
-        "contract_address": rpc_felt(transaction.contract_address),
-        "entry_point_selector": rpc_felt(transaction.entry_point_selector),
-        "calldata": [rpc_felt(data) for data in transaction.calldata],
+    common_data = {
         "transaction_hash": rpc_felt(transaction.transaction_hash),
+        "calldata": [rpc_felt(data) for data in transaction.calldata],
         "max_fee": rpc_felt(transaction.max_fee),
         "version": hex(transaction.version),
         "signature": [rpc_felt(value) for value in transaction.signature],
-        "nonce": rpc_felt(0),
         "type": rpc_txn_type(transaction.tx_type.name),
+        "nonce": rpc_felt(transaction.nonce or 0),
     }
+
+    if transaction.version == LEGACY_RPC_TX_VERSION:
+        txn: RpcInvokeTransactionV0 = {
+            "contract_address": rpc_felt(transaction.contract_address),
+            "entry_point_selector": rpc_felt(transaction.entry_point_selector),
+            **common_data,
+        }
+    else:
+        txn: RpcInvokeTransactionV1 = {
+            "sender_address": rpc_felt(transaction.contract_address),
+            **common_data,
+        }
     return txn
 
 
@@ -222,10 +292,26 @@ def rpc_deploy_transaction(transaction: DeploySpecificInfo) -> RpcDeployTransact
     return txn
 
 
-class RpcFeeEstimate(TypedDict):
+def rpc_l1_handler_transaction(
+    transaction: L1HandlerSpecificInfo,
+) -> RpcL1HandlerTransaction:
     """
-    Fee estimate TypedDict for rpc
+    Convert gateway l1_handler transaction to rpc format
     """
+    txn: RpcL1HandlerTransaction = {
+        "contract_address": rpc_felt(transaction.contract_address),
+        "entry_point_selector": rpc_felt(transaction.entry_point_selector),
+        "calldata": [rpc_felt(data) for data in transaction.calldata],
+        "transaction_hash": rpc_felt(transaction.transaction_hash),
+        "version": hex(transaction.version),
+        "type": rpc_txn_type(transaction.tx_type.name),
+        "nonce": rpc_felt(transaction.nonce),
+    }
+    return txn
+
+
+class RpcFeeEstimate(TypedDict):
+    """Fee estimate TypedDict for rpc"""
 
     gas_consumed: NumAsHex
     gas_price: NumAsHex
@@ -248,41 +334,155 @@ def make_invoke_function(request_body: dict) -> InvokeFunction:
     """
     Convert RPC request to internal InvokeFunction
     """
-
+    version = int(request_body.get("version", str(LEGACY_RPC_TX_VERSION)), 16)
     nonce = request_body.get("nonce")
-    entry_point_selector = request_body.get("entry_point_selector")
-    return InvokeFunction(
-        contract_address=int(request_body["contract_address"], 16),
-        entry_point_selector=int(entry_point_selector, 16)
-        if entry_point_selector is not None
-        else None,
-        calldata=[int(data, 16) for data in request_body["calldata"]],
-        max_fee=int(request_body["max_fee"], 16) if "max_fee" in request_body else 0,
-        version=int(request_body["version"], 16) if "version" in request_body else 0,
-        signature=[int(data, 16) for data in request_body.get("signature", [])],
-        nonce=int(nonce, 16) if nonce is not None else None,
-    )
+
+    common_data = {
+        "max_fee": int(request_body.get("max_fee", "0"), 16),
+        "version": version,
+        "signature": [int(data, 16) for data in request_body.get("signature", [])],
+        "nonce": int(nonce, 16) if nonce is not None else None,
+    }
+
+    if version == LEGACY_RPC_TX_VERSION:
+        invoke_function = InvokeFunction(
+            contract_address=int(request_body["contract_address"], 16),
+            entry_point_selector=int(request_body["entry_point_selector"], 16),
+            calldata=[int(data, 16) for data in request_body.get("calldata", [])],
+            **common_data,
+        )
+    else:
+        invoke_function = InvokeFunction(
+            contract_address=int(request_body["sender_address"], 16),
+            calldata=[int(data, 16) for data in request_body.get("calldata", [])],
+            **common_data,
+        )
+
+    return invoke_function
 
 
 class EntryPoint(TypedDict):
-    """
-    TypedDict for rpc contract class entry point
-    """
+    """TypedDict for rpc contract class entry point"""
 
     offset: NumAsHex
     selector: Felt
 
 
 class EntryPoints(TypedDict):
-    """
-    TypedDict for rpc contract class entry points
-    """
+    """TypedDict for rpc contract class entry points"""
 
     CONSTRUCTOR: List[EntryPoint]
     EXTERNAL: List[EntryPoint]
     L1_HANDLER: List[EntryPoint]
 
 
+FunctionAbiType = Literal["function", "l1_handler"]
+EventAbiType = Literal["event"]
+StructAbiType = Literal["struct"]
+
+
+class TypedParameter(TypedDict):
+    """TypedDict for TypedParameter"""
+
+    name: str
+    type: str
+
+
+class StructMember(TypedDict):
+    """TypedDict for StructMember"""
+
+    name: str
+    type: str
+    offset: int
+
+
+class FunctionAbiEntry(TypedDict):
+    """TypedDict for FunctionAbiEntry"""
+
+    type: FunctionAbiType
+    name: str
+    inputs: List[TypedParameter]
+    outputs: List[TypedParameter]
+
+
+class EventAbiEntry(TypedDict):
+    """TypedDict for EventAbiEntry"""
+
+    type: EventAbiType
+    name: str
+    keys: List[TypedParameter]
+    data: List[TypedParameter]
+
+
+class StructAbiEntry(TypedDict):
+    """TypedDict for StructAbiEntry"""
+
+    type: StructAbiType
+    name: str
+    size: int  # minimum 1
+    members: List[StructMember]
+
+
+AbiEntry = Union[FunctionAbiEntry, EventAbiEntry, StructAbiEntry]
+
+
+def function_abi_entry(abi_entry: AbiEntryType) -> FunctionAbiEntry:
+    """
+    Convert function gateway abi entry to rpc FunctionAbiEntry
+    """
+    return FunctionAbiEntry(
+        type=abi_entry["type"],
+        name=abi_entry["name"],
+        inputs=abi_entry["inputs"],
+        outputs=abi_entry["outputs"],
+    )
+
+
+def struct_abi_entry(abi_entry: AbiEntryType) -> StructAbiEntry:
+    """
+    Convert struct gateway abi entry to rpc StructAbiEntry
+    """
+    return StructAbiEntry(
+        type=abi_entry["type"],
+        name=abi_entry["name"],
+        size=abi_entry["size"],
+        members=abi_entry["members"],
+    )
+
+
+def event_abi_entry(abi_entry: AbiEntryType) -> EventAbiEntry:
+    """
+    Convert event gateway abi entry to rpc EventAbiEntry
+    """
+    return EventAbiEntry(
+        type=abi_entry["type"],
+        name=abi_entry["name"],
+        keys=abi_entry["keys"],
+        data=abi_entry["data"],
+    )
+
+
+def rpc_abi_entry(abi_entry: AbiEntryType) -> AbiEntry:
+    """
+    Convert gateway abi entry to rpc AbiEntry
+    """
+    type_map = {
+        "constructor": "function",
+    }
+
+    function_map = {
+        "l1_handler": function_abi_entry,
+        "function": function_abi_entry,
+        "struct": struct_abi_entry,
+        "event": event_abi_entry,
+    }
+
+    if abi_entry["type"] in type_map:
+        abi_entry["type"] = type_map[abi_entry["type"]]
+
+    return function_map[abi_entry["type"]](abi_entry)
+
+
 class RpcContractClass(TypedDict):
     """
     TypedDict for rpc contract class
@@ -290,6 +490,7 @@ class RpcContractClass(TypedDict):
 
     program: str
     entry_points_by_type: EntryPoints
+    abi: Optional[List[AbiEntry]]
 
 
 def rpc_contract_class(contract_class: ContractClass) -> RpcContractClass:
@@ -316,64 +517,58 @@ def entry_points_by_type() -> EntryPoints:
                 _entry_points[typ.name].append(_entry_point)
         return _entry_points
 
+    def abi() -> Optional[List[AbiEntry]]:
+        if contract_class.abi is None:
+            return None
+        return [rpc_abi_entry(abi_entry_type) for abi_entry_type in contract_class.abi]
+
     _contract_class: RpcContractClass = {
         "program": program(),
         "entry_points_by_type": entry_points_by_type(),
+        "abi": abi(),
     }
     return _contract_class
 
 
-class RpcStorageDiff(TypedDict):
-    """
-    TypedDict for rpc storage diff
-    """
+class RpcStorageEntry(TypedDict):
+    """TypedDict for rpc storage entry"""
 
-    address: Felt
     key: Felt
     value: Felt
 
 
-class RpcDeclaredContractDiff(TypedDict):
-    """
-    TypedDict for rpc declared contract diff
-    """
+class RpcStorageDiff(TypedDict):
+    """TypedDict for rpc storage diff"""
 
-    class_hash: Felt
+    address: Felt
+    storage_entries: List[RpcStorageEntry]
 
 
 class RpcDeployedContractDiff(TypedDict):
-    """
-    TypedDict for rpc deployed contract diff
-    """
+    """TypedDict for rpc deployed contract diff"""
 
     address: Felt
     class_hash: Felt
 
 
 class RpcNonceDiff(TypedDict):
-    """
-    TypedDict for rpc nonce diff
-    """
+    """TypedDict for rpc nonce diff"""
 
     contract_address: Address
     nonce: Felt
 
 
 class RpcStateDiff(TypedDict):
-    """
-    TypedDict for rpc state diff
-    """
+    """TypedDict for rpc state diff"""
 
     storage_diffs: List[RpcStorageDiff]
-    declared_contracts: List[RpcDeclaredContractDiff]
+    declared_contract_hashes: List[Felt]
     deployed_contracts: List[RpcDeployedContractDiff]
     nonces: List[RpcNonceDiff]
 
 
 class RpcStateUpdate(TypedDict):
-    """
-    TypedDict for rpc state update
-    """
+    """TypedDict for rpc state update"""
 
     block_hash: BlockHash
     new_root: Felt
@@ -389,21 +584,24 @@ def rpc_state_update(state_update: BlockStateUpdate) -> RpcStateUpdate:
     def storage_diffs() -> List[RpcStorageDiff]:
         _storage_diffs = []
         for address, diffs in state_update.state_diff.storage_diffs.items():
+            storage_entries = []
             for diff in diffs:
-                _diff: RpcStorageDiff = {
-                    "address": rpc_felt(address),
-                    "key": rpc_felt(diff.key),
-                    "value": rpc_felt(diff.value),
-                }
-                _storage_diffs.append(_diff)
+                storage_entry = RpcStorageEntry(
+                    key=rpc_felt(diff.key), value=rpc_felt(diff.value)
+                )
+                storage_entries.append(storage_entry)
+
+            _diff = RpcStorageDiff(
+                address=rpc_felt(address), storage_entries=storage_entries
+            )
+            _storage_diffs.append(_diff)
         return _storage_diffs
 
-    def declared_contracts() -> List[RpcDeclaredContractDiff]:
-        _contracts = []
-        for contract in state_update.state_diff.declared_contracts:
-            diff: RpcDeclaredContractDiff = {"class_hash": rpc_felt(contract)}
-            _contracts.append(diff)
-        return _contracts
+    def declared_contract_hashes() -> List[Felt]:
+        return [
+            rpc_felt(contract)
+            for contract in state_update.state_diff.declared_contracts
+        ]
 
     def deployed_contracts() -> List[RpcDeployedContractDiff]:
         _contracts = []
@@ -415,15 +613,21 @@ def deployed_contracts() -> List[RpcDeployedContractDiff]:
             _contracts.append(diff)
         return _contracts
 
+    def nonces() -> List[RpcNonceDiff]:
+        return [
+            RpcNonceDiff(contract_address=rpc_felt(address), nonce=rpc_felt(nonce))
+            for address, nonce in state_update.state_diff.nonces.items()
+        ]
+
     rpc_state: RpcStateUpdate = {
         "block_hash": rpc_felt(state_update.block_hash),
         "new_root": rpc_root(state_update.new_root.hex()),
         "old_root": rpc_root(state_update.old_root.hex()),
         "state_diff": {
             "storage_diffs": storage_diffs(),
-            "declared_contracts": declared_contracts(),
+            "declared_contract_hashes": declared_contract_hashes(),
             "deployed_contracts": deployed_contracts(),
-            "nonces": [],
+            "nonces": nonces(),
         },
     }
     return rpc_state
diff --git a/starknet_devnet/blueprints/rpc/structures/responses.py b/starknet_devnet/blueprints/rpc/structures/responses.py
index 16a61fd44..20b345e76 100644
--- a/starknet_devnet/blueprints/rpc/structures/responses.py
+++ b/starknet_devnet/blueprints/rpc/structures/responses.py
@@ -2,8 +2,7 @@
 RPC response structures
 """
 
-from typing import List, Optional, Union
-from typing_extensions import TypedDict
+from typing import List, TypedDict
 
 from starkware.starknet.definitions.transaction_type import TransactionType
 from starkware.starknet.services.api.feeder_gateway.response_objects import (
@@ -11,7 +10,6 @@
     TransactionStatus,
 )
 
-from starknet_devnet.blueprints.rpc.utils import rpc_felt
 from starknet_devnet.blueprints.rpc.structures.types import (
     TxnHash,
     Felt,
@@ -19,58 +17,42 @@
     BlockNumber,
     BlockHash,
     TxnStatus,
+    TxnType,
+    rpc_txn_type,
 )
+from starknet_devnet.blueprints.rpc.utils import rpc_felt
 from starknet_devnet.state import state
 
 
 class RpcInvokeTransactionResult(TypedDict):
-    """
-    TypedDict for rpc invoke transaction result
-    """
+    """TypedDict for rpc invoke transaction result"""
 
     transaction_hash: TxnHash
 
 
 class RpcDeclareTransactionResult(TypedDict):
-    """
-    TypedDict for rpc declare transaction result
-    """
+    """TypedDict for rpc declare transaction result"""
 
     transaction_hash: TxnHash
     class_hash: Felt
 
 
 class RpcDeployTransactionResult(TypedDict):
-    """
-    TypedDict for rpc deploy transaction result
-    """
+    """TypedDict for rpc deploy transaction result"""
 
     transaction_hash: TxnHash
     contract_address: Felt
 
 
 class MessageToL1(TypedDict):
-    """
-    TypedDict for rpc message from l2 to l1
-    """
+    """TypedDict for rpc message from l2 to l1"""
 
     to_address: Felt
     payload: List[Felt]
 
 
-class MessageToL2(TypedDict):
-    """
-    TypedDict for rpc message from l1 to l2
-    """
-
-    from_address: str
-    payload: List[Felt]
-
-
 class Event(TypedDict):
-    """
-    TypedDict for rpc event
-    """
+    """TypedDict for rpc event"""
 
     from_address: Address
     keys: List[Felt]
@@ -87,70 +69,72 @@ class RpcEventsResult(TypedDict):
 
 
 class RpcBaseTransactionReceipt(TypedDict):
-    """
-    TypedDict for rpc transaction receipt
-    """
+    """TypedDict for rpc transaction receipt"""
 
-    # Common
     transaction_hash: TxnHash
     actual_fee: Felt
     status: TxnStatus
-    status_data: Optional[str]
     block_hash: BlockHash
     block_number: BlockNumber
+    type: TxnType
+    messages_sent: List[MessageToL1]
+    events: List[Event]
+
 
+RpcInvokeReceipt = RpcBaseTransactionReceipt
+RpcDeclareReceipt = RpcBaseTransactionReceipt
+RpcL1HandlerReceipt = RpcBaseTransactionReceipt
 
-class RpcInvokeReceipt(TypedDict):
+
+class RpcDeployReceipt(RpcBaseTransactionReceipt):
+    """TypedDict for rpc declare transaction receipt"""
+
+    contract_address: Felt
+
+
+def rpc_invoke_receipt(txr: TransactionReceipt) -> RpcInvokeReceipt:
     """
-    TypedDict for rpc invoke transaction receipt
+    Convert rpc invoke transaction receipt to rpc format
     """
+    return rpc_base_transaction_receipt(txr)
 
-    messages_sent: List[MessageToL1]
-    l1_origin_message: Optional[MessageToL2]
-    events: List[Event]
-    # Common
-    transaction_hash: TxnHash
-    actual_fee: Felt
-    status: TxnStatus
-    status_data: Optional[str]
-    block_hash: BlockHash
-    block_number: BlockNumber
+
+def rpc_declare_receipt(txr: TransactionReceipt) -> RpcDeclareReceipt:
+    """
+    Convert rpc declare transaction receipt to rpc format
+    """
+    return rpc_base_transaction_receipt(txr)
 
 
-class RpcDeclareReceipt(TypedDict):
+def rpc_deploy_receipt(txr: TransactionReceipt) -> RpcDeployReceipt:
     """
-    TypedDict for rpc declare transaction receipt
+    Convert rpc deploy transaction receipt to rpc format
     """
+    base_receipt = rpc_base_transaction_receipt(txr)
+    transaction = state.starknet_wrapper.transactions.get_transaction(
+        hex(txr.transaction_hash)
+    ).transaction
 
-    # Common
-    transaction_hash: TxnHash
-    actual_fee: Felt
-    status: TxnStatus
-    status_data: Optional[str]
-    block_hash: BlockHash
-    block_number: BlockNumber
+    receipt: RpcDeployReceipt = {
+        "contract_address": rpc_felt(transaction.contract_address),
+        **base_receipt,
+    }
+    return receipt
 
 
-class RpcDeployReceipt(TypedDict):
+def rpc_l1_handler_receipt(txr: TransactionReceipt) -> RpcL1HandlerReceipt:
     """
-    TypedDict for rpc declare transaction receipt
+    Convert rpc l1 handler transaction receipt to rpc format
     """
-
-    # Common
-    transaction_hash: TxnHash
-    actual_fee: Felt
-    status: TxnStatus
-    status_data: Optional[str]
-    block_hash: BlockHash
-    block_number: BlockNumber
+    return rpc_base_transaction_receipt(txr)
 
 
-def rpc_invoke_receipt(txr: TransactionReceipt) -> RpcInvokeReceipt:
+def rpc_base_transaction_receipt(txr: TransactionReceipt) -> dict:
     """
-    Convert rpc invoke transaction receipt to rpc format
+    Convert gateway transaction receipt to rpc base transaction receipt
     """
 
-    def l2_to_l1_messages() -> List[MessageToL1]:
+    def messages_sent() -> List[MessageToL1]:
         return [
             {
                 "to_address": rpc_felt(message.to_address),
@@ -159,16 +143,6 @@ def l2_to_l1_messages() -> List[MessageToL1]:
             for message in txr.l2_to_l1_messages
         ]
 
-    def l1_to_l2_message() -> Optional[MessageToL2]:
-        if txr.l1_to_l2_consumed_message is None:
-            return None
-
-        msg: MessageToL2 = {
-            "from_address": txr.l1_to_l2_consumed_message.from_address,
-            "payload": [rpc_felt(p) for p in txr.l1_to_l2_consumed_message.payload],
-        }
-        return msg
-
     def events() -> List[Event]:
         _events = []
         for event in txr.events:
@@ -180,35 +154,6 @@ def events() -> List[Event]:
             _events.append(event)
         return _events
 
-    base_receipt = rpc_base_transaction_receipt(txr)
-    receipt: RpcInvokeReceipt = {
-        "messages_sent": l2_to_l1_messages(),
-        "l1_origin_message": l1_to_l2_message(),
-        "events": events(),
-        **base_receipt,
-    }
-    return receipt
-
-
-def rpc_declare_receipt(txr) -> RpcDeclareReceipt:
-    """
-    Convert rpc declare transaction receipt to rpc format
-    """
-    return rpc_base_transaction_receipt(txr)
-
-
-def rpc_deploy_receipt(txr) -> RpcDeployReceipt:
-    """
-    Convert rpc deploy transaction receipt to rpc format
-    """
-    return rpc_base_transaction_receipt(txr)
-
-
-def rpc_base_transaction_receipt(txr: TransactionReceipt) -> RpcBaseTransactionReceipt:
-    """
-    Convert gateway transaction receipt to rpc transaction receipt
-    """
-
     def status() -> str:
         if txr.status is None:
             return "UNKNOWN"
@@ -223,19 +168,21 @@ def status() -> str:
         }
         return mapping[txr.status]
 
-    def status_data() -> Union[str, None]:
-        if txr.transaction_failure_reason is not None:
-            if txr.transaction_failure_reason.error_message is not None:
-                return txr.transaction_failure_reason.error_message
-        return None
+    def txn_type() -> TxnType:
+        transaction = state.starknet_wrapper.transactions.get_transaction(
+            hex(txr.transaction_hash)
+        ).transaction
+        return rpc_txn_type(transaction.tx_type.name)
 
     receipt: RpcBaseTransactionReceipt = {
         "transaction_hash": rpc_felt(txr.transaction_hash),
         "actual_fee": rpc_felt(txr.actual_fee or 0),
         "status": status(),
-        "status_data": status_data(),
         "block_hash": rpc_felt(txr.block_hash) if txr.block_hash is not None else None,
-        "block_number": txr.block_number,
+        "block_number": txr.block_number or None,
+        "messages_sent": messages_sent(),
+        "events": events(),
+        "type": txn_type(),
     }
     return receipt
 
@@ -248,6 +195,7 @@ def rpc_transaction_receipt(txr: TransactionReceipt) -> dict:
         TransactionType.DEPLOY: rpc_deploy_receipt,
         TransactionType.INVOKE_FUNCTION: rpc_invoke_receipt,
         TransactionType.DECLARE: rpc_declare_receipt,
+        TransactionType.L1_HANDLER: rpc_l1_handler_receipt,
     }
     transaction = state.starknet_wrapper.transactions.get_transaction(
         hex(txr.transaction_hash)
diff --git a/starknet_devnet/blueprints/rpc/structures/types.py b/starknet_devnet/blueprints/rpc/structures/types.py
index de8101166..16abac98a 100644
--- a/starknet_devnet/blueprints/rpc/structures/types.py
+++ b/starknet_devnet/blueprints/rpc/structures/types.py
@@ -3,7 +3,7 @@
 """
 
 from enum import Enum
-from typing import Union
+from typing import Union, List
 from typing_extensions import Literal, TypedDict
 
 from starkware.starknet.services.api.feeder_gateway.response_objects import BlockStatus
@@ -15,19 +15,17 @@
 BlockNumber = int
 BlockTag = Literal["latest", "pending"]
 
+Signature = List[Felt]
+
 
 class BlockHashDict(TypedDict):
-    """
-    TypedDict class for BlockId with block hash
-    """
+    """TypedDict class for BlockId with block hash"""
 
     block_hash: BlockHash
 
 
 class BlockNumberDict(TypedDict):
-    """
-    TypedDict class for BlockId with block number
-    """
+    """TypedDict class for BlockId with block number"""
 
     block_number: BlockNumber
 
@@ -59,7 +57,7 @@ def rpc_block_status(block_status: BlockStatus) -> RpcBlockStatus:
 
 # Pending transactions will not be supported since it
 # doesn't make much sense with the current implementation of devnet
-TxnType = Literal["DECLARE", "DEPLOY", "INVOKE"]
+TxnType = Literal["DECLARE", "DEPLOY", "INVOKE", "L1_HANDLER"]
 
 
 def rpc_txn_type(transaction_type: str) -> TxnType:
@@ -70,6 +68,7 @@ def rpc_txn_type(transaction_type: str) -> TxnType:
         "DEPLOY": "DEPLOY",
         "DECLARE": "DECLARE",
         "INVOKE_FUNCTION": "INVOKE",
+        "L1_HANDLER": "L1_HANDLER",
     }
     if transaction_type not in txn_type_map:
         raise RpcError(
@@ -93,7 +92,8 @@ def __init__(self, code, message):
 class RpcErrorCode(Enum):
     """
     Constants used in JSON-RPC protocol
-    https://www.jsonrpc.org/specification"""
+    https://www.jsonrpc.org/specification
+    """
 
     INVALID_REQUEST = -32600
     METHOD_NOT_FOUND = -32601
diff --git a/starknet_devnet/blueprints/rpc/transactions.py b/starknet_devnet/blueprints/rpc/transactions.py
index 6a85af431..1e906f390 100644
--- a/starknet_devnet/blueprints/rpc/transactions.py
+++ b/starknet_devnet/blueprints/rpc/transactions.py
@@ -2,9 +2,9 @@
 RPC transaction endpoints
 """
 
-import dataclasses
 from typing import List
 
+from test.shared import LEGACY_RPC_TX_VERSION
 from marshmallow.exceptions import MarshmallowError
 from starkware.starknet.services.api.contract_class import ContractClass
 from starkware.starknet.services.api.feeder_gateway.response_objects import (
@@ -13,25 +13,20 @@
 from starkware.starknet.services.api.gateway.transaction import (
     InvokeFunction,
     Declare,
-    DEFAULT_DECLARE_SENDER_ADDRESS,
     Deploy,
 )
 from starkware.starknet.services.api.gateway.transaction_utils import decompress_program
 from starkware.starkware_utils.error_handling import StarkException
 
-from starknet_devnet.blueprints.rpc.utils import (
-    get_block_by_block_id,
-    rpc_felt,
-    assert_block_id_is_latest_or_pending,
-)
 from starknet_devnet.blueprints.rpc.structures.payloads import (
     rpc_transaction,
     RpcTransaction,
-    FunctionCall,
-    RpcContractClass,
-    RpcInvokeTransaction,
     make_invoke_function,
     rpc_fee_estimate,
+    RpcBroadcastedInvokeTxn,
+    RpcBroadcastedDeclareTxn,
+    RpcBroadcastedDeployTxn,
+    RpcBroadcastedTxn,
 )
 from starknet_devnet.blueprints.rpc.structures.responses import (
     rpc_transaction_receipt,
@@ -42,11 +37,13 @@
 from starknet_devnet.blueprints.rpc.structures.types import (
     TxnHash,
     BlockId,
-    NumAsHex,
-    Felt,
     RpcError,
 )
-from starknet_devnet.constants import SUPPORTED_RPC_TX_VERSION
+from starknet_devnet.blueprints.rpc.utils import (
+    get_block_by_block_id,
+    rpc_felt,
+    assert_block_id_is_latest_or_pending,
+)
 from starknet_devnet.state import state
 from starknet_devnet.util import StarknetDevnetException
 
@@ -58,10 +55,10 @@ async def get_transaction_by_hash(transaction_hash: TxnHash) -> dict:
     try:
         result = state.starknet_wrapper.transactions.get_transaction(transaction_hash)
     except StarknetDevnetException as ex:
-        raise RpcError(code=25, message="Invalid transaction hash") from ex
+        raise RpcError(code=25, message="Transaction hash not found") from ex
 
     if result.status == TransactionStatus.NOT_RECEIVED:
-        raise RpcError(code=25, message="Invalid transaction hash")
+        raise RpcError(code=25, message="Transaction hash not found")
 
     return rpc_transaction(result.transaction)
 
@@ -89,10 +86,10 @@ async def get_transaction_receipt(transaction_hash: TxnHash) -> dict:
             tx_hash=transaction_hash
         )
     except StarknetDevnetException as ex:
-        raise RpcError(code=25, message="Invalid transaction hash") from ex
+        raise RpcError(code=25, message="Transaction hash not found") from ex
 
     if result.status == TransactionStatus.NOT_RECEIVED:
-        raise RpcError(code=25, message="Invalid transaction hash")
+        raise RpcError(code=25, message="Transaction hash not found")
 
     return rpc_transaction_receipt(result)
 
@@ -104,30 +101,32 @@ async def pending_transactions() -> List[RpcTransaction]:
     raise NotImplementedError()
 
 
-async def add_invoke_transaction(
-    function_invocation: FunctionCall,
-    signature: List[Felt],
-    max_fee: NumAsHex,
-    version: NumAsHex,
-    nonce: NumAsHex = None,
-) -> dict:
+async def add_invoke_transaction(invoke_transaction: RpcBroadcastedInvokeTxn) -> dict:
     """
     Submit a new transaction to be added to the chain
     """
-    entry_point_selector = function_invocation.get("entry_point_selector")
-    invoke_function = InvokeFunction(
-        contract_address=int(function_invocation["contract_address"], 16),
-        entry_point_selector=int(entry_point_selector, 16)
-        if entry_point_selector is not None
-        else None,
-        calldata=[int(data, 16) for data in function_invocation["calldata"]],
-        max_fee=int(max_fee, 16),
-        version=int(version, 16),
-        signature=[int(data, 16) for data in signature]
-        if signature is not None
-        else [],
-        nonce=int(nonce, 16) if nonce is not None else None,
-    )
+    version = int(invoke_transaction["version"], 16)
+
+    common_data = {
+        "calldata": [int(data, 16) for data in invoke_transaction["calldata"]],
+        "max_fee": int(invoke_transaction["max_fee"], 16),
+        "version": int(invoke_transaction["version"], 16),
+        "signature": [int(data, 16) for data in invoke_transaction["signature"]],
+    }
+
+    if version == LEGACY_RPC_TX_VERSION:
+        invoke_function = InvokeFunction(
+            contract_address=int(invoke_transaction["contract_address"], 16),
+            entry_point_selector=int(invoke_transaction["entry_point_selector"], 16),
+            nonce=None,
+            **common_data,
+        )
+    else:
+        invoke_function = InvokeFunction(
+            contract_address=int(invoke_transaction["sender_address"], 16),
+            nonce=int(invoke_transaction["nonce"], 16),
+            **common_data,
+        )
 
     _, transaction_hash = await state.starknet_wrapper.invoke(
         external_tx=invoke_function
@@ -138,30 +137,31 @@ async def add_invoke_transaction(
 
 
 async def add_declare_transaction(
-    contract_class: RpcContractClass, version: NumAsHex
+    declare_transaction: RpcBroadcastedDeclareTxn,
 ) -> dict:
     """
     Submit a new class declaration transaction
     """
-    try:
-        decompressed_program = decompress_program(
-            {"contract_class": contract_class}, False
-        )
-        decompressed_program = decompressed_program["contract_class"]
+    contract_class = declare_transaction["contract_class"]
+    if "abi" not in contract_class:
+        contract_class["abi"] = []
 
-        contract_definition = ContractClass.load(decompressed_program)
-        # Replace None with [] in abi key to avoid Missing Abi exception
-        contract_definition = dataclasses.replace(contract_definition, abi=[])
+    try:
+        contract_class = decompress_program(declare_transaction, False)[
+            "contract_class"
+        ]
+        contract_class = ContractClass.load(contract_class)
     except (StarkException, TypeError, MarshmallowError) as ex:
         raise RpcError(code=50, message="Invalid contract class") from ex
 
+    nonce = declare_transaction.get("nonce")
     declare_transaction = Declare(
-        contract_class=contract_definition,
-        version=int(version, 16),
-        sender_address=DEFAULT_DECLARE_SENDER_ADDRESS,
-        max_fee=0,
-        signature=[],
-        nonce=0,
+        contract_class=contract_class,
+        sender_address=int(declare_transaction["sender_address"], 16),
+        nonce=int(nonce, 16) if nonce is not None else 0,
+        version=int(declare_transaction["version"], 16),
+        max_fee=int(declare_transaction["max_fee"], 16),
+        signature=[int(sig, 16) for sig in declare_transaction["signature"]],
     )
 
     class_hash, transaction_hash = await state.starknet_wrapper.declare(
@@ -173,30 +173,27 @@ async def add_declare_transaction(
     )
 
 
-async def add_deploy_transaction(
-    contract_address_salt: Felt,
-    constructor_calldata: List[Felt],
-    contract_definition: RpcContractClass,
-) -> dict:
+async def add_deploy_transaction(deploy_transaction: RpcBroadcastedDeployTxn) -> dict:
     """
     Submit a new deploy contract transaction
     """
-    try:
-        decompressed_program = decompress_program(
-            {"contract_definition": contract_definition}, False
-        )
-        decompressed_program = decompressed_program["contract_definition"]
+    contract_class = deploy_transaction["contract_class"]
+    if "abi" not in contract_class:
+        contract_class["abi"] = []
 
-        contract_class = ContractClass.load(decompressed_program)
-        contract_class = dataclasses.replace(contract_class, abi=[])
+    try:
+        contract_class = decompress_program(deploy_transaction, False)["contract_class"]
+        contract_class = ContractClass.load(contract_class)
     except (StarkException, TypeError, MarshmallowError) as ex:
         raise RpcError(code=50, message="Invalid contract class") from ex
 
     deploy_transaction = Deploy(
-        contract_address_salt=int(contract_address_salt, 16),
-        constructor_calldata=[int(data, 16) for data in constructor_calldata],
+        contract_address_salt=int(deploy_transaction["contract_address_salt"], 16),
+        constructor_calldata=[
+            int(data, 16) for data in deploy_transaction["constructor_calldata"]
+        ],
         contract_definition=contract_class,
-        version=SUPPORTED_RPC_TX_VERSION,
+        version=int(deploy_transaction["version"], 16),
     )
 
     contract_address, transaction_hash = await state.starknet_wrapper.deploy(
@@ -208,15 +205,19 @@ async def add_deploy_transaction(
     )
 
 
-async def estimate_fee(request: RpcInvokeTransaction, block_id: BlockId) -> dict:
+async def estimate_fee(request: RpcBroadcastedTxn, block_id: BlockId) -> dict:
     """
     Estimate the fee for a given StarkNet transaction
     """
     assert_block_id_is_latest_or_pending(block_id)
 
-    if not state.starknet_wrapper.contracts.is_deployed(
-        int(request["contract_address"], 16)
-    ):
+    address = (
+        request["contract_address"]
+        if "contract_address" in request
+        else request["sender_address"]
+    )
+
+    if not state.starknet_wrapper.contracts.is_deployed(int(address, 16)):
         raise RpcError(code=20, message="Contract not found")
 
     invoke_function = make_invoke_function(request)
@@ -226,12 +227,12 @@ async def estimate_fee(request: RpcInvokeTransaction, block_id: BlockId) -> dict
             invoke_function
         )
     except StarkException as ex:
-        if (
+        if "entry_point_selector" in request and (
             f"Entry point {hex(int(request['entry_point_selector'], 16))} not found"
             in ex.message
         ):
             raise RpcError(code=21, message="Invalid message selector") from ex
-        if "While handling calldata" in ex.message:
+        if "While handling calldata" in ex.message or "Error at pc=" in ex.message:
             raise RpcError(code=22, message="Invalid call data") from ex
         raise RpcError(code=-1, message=ex.message) from ex
     return rpc_fee_estimate(fee_response)
diff --git a/starknet_devnet/blueprints/rpc/utils.py b/starknet_devnet/blueprints/rpc/utils.py
index 5aa611806..b51cc0e51 100644
--- a/starknet_devnet/blueprints/rpc/utils.py
+++ b/starknet_devnet/blueprints/rpc/utils.py
@@ -1,6 +1,7 @@
 """
 RPC utilities
 """
+from typing import Union
 
 from starknet_devnet.blueprints.rpc.structures.types import (
     BlockId,
@@ -27,7 +28,7 @@ def block_tag_to_block_number(block_id: BlockId) -> BlockId:
                 message="Calls with block_id == 'pending' are not supported currently.",
             )
 
-        raise RpcError(code=24, message="Invalid block id")
+        raise RpcError(code=24, message="Block not found")
 
     return block_id
 
@@ -48,7 +49,7 @@ def get_block_by_block_id(block_id: BlockId) -> dict:
             block_number=block_id["block_number"]
         )
     except StarknetDevnetException as ex:
-        raise RpcError(code=24, message="Invalid block id") from ex
+        raise RpcError(code=24, message="Block not found") from ex
 
 
 def assert_block_id_is_latest_or_pending(block_id: BlockId) -> None:
@@ -82,24 +83,19 @@ def assert_block_id_is_latest_or_pending(block_id: BlockId) -> None:
     )
 
 
-def rpc_felt(value: int) -> Felt:
+def rpc_felt(value: Union[int, str]) -> Felt:
     """
-    Convert integer to 0x0 prefixed felt
+    Convert value to 0x0 prefixed felt
+    The value can be base 10 integer, base 10 string or base 16 string
     """
+    if isinstance(value, str):
+        value = int(value) if value.isnumeric() else int(value, 16)
+
     if value == 0:
         return "0x00"
     return "0x0" + hex(value).lstrip("0x")
 
 
-def pad_zero(felt: str) -> Felt:
-    """
-    Convert felt with format `0xValue` to format `0x0Value`
-    """
-    if felt == "0x0":
-        return "0x00"
-    return "0x0" + felt.lstrip("0x")
-
-
 def rpc_root(root: str) -> Felt:
     """
     Convert 0 prefixed root to 0x prefixed root
diff --git a/starknet_devnet/constants.py b/starknet_devnet/constants.py
index 37ed2fbbc..605b592c3 100644
--- a/starknet_devnet/constants.py
+++ b/starknet_devnet/constants.py
@@ -20,7 +20,7 @@
 DEFAULT_GAS_PRICE = 10**11
 
 SUPPORTED_TX_VERSION = 1
-SUPPORTED_RPC_TX_VERSION = 0
+SUPPORTED_RPC_TX_VERSION = 1
 
 DUMMY_STATE_ROOT = bytes(32)
 


Test patch:
diff --git a/test/conftest.py b/test/conftest.py
index 044aa89a6..563c11ab3 100644
--- a/test/conftest.py
+++ b/test/conftest.py
@@ -5,6 +5,7 @@
 from __future__ import annotations
 import pytest
 
+from .shared import PREDEPLOY_ACCOUNT_CLI_ARGS
 from .util import run_devnet_in_background, terminate_and_wait
 
 
@@ -35,3 +36,15 @@ def fixture_run_devnet_in_background(request) -> None:
         yield
     finally:
         terminate_and_wait(proc)
+
+
+@pytest.fixture(name="devnet_with_account")
+def fixture_devnet_with_account() -> None:
+    """
+    Run devnet instance in background with predeployed account
+    """
+    proc = run_devnet_in_background(*PREDEPLOY_ACCOUNT_CLI_ARGS)
+    try:
+        yield
+    finally:
+        terminate_and_wait(proc)
diff --git a/test/declare_rpc.json b/test/declare_rpc.json
new file mode 100644
index 000000000..e596a5850
--- /dev/null
+++ b/test/declare_rpc.json
@@ -0,0 +1,111 @@
+{
+    "sender_address": "0x1",
+    "max_fee": "0x0",
+    "signature": [],
+    "nonce": "0x0",
+    "type": "DECLARE",
+    "contract_class": {
+        "program": "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",
+        "abi": [
+            {
+                "members": [
+                    {
+                        "name": "x",
+                        "offset": 0,
+                        "type": "felt"
+                    },
+                    {
+                        "name": "y",
+                        "offset": 1,
+                        "type": "felt"
+                    }
+                ],
+                "name": "Point",
+                "size": 2,
+                "type": "struct"
+            },
+            {
+                "inputs": [
+                    {
+                        "name": "initial_balance",
+                        "type": "felt"
+                    }
+                ],
+                "name": "constructor",
+                "outputs": [],
+                "type": "constructor"
+            },
+            {
+                "inputs": [
+                    {
+                        "name": "amount1",
+                        "type": "felt"
+                    },
+                    {
+                        "name": "amount2",
+                        "type": "felt"
+                    }
+                ],
+                "name": "increase_balance",
+                "outputs": [],
+                "type": "function"
+            },
+            {
+                "inputs": [],
+                "name": "get_balance",
+                "outputs": [
+                    {
+                        "name": "res",
+                        "type": "felt"
+                    }
+                ],
+                "stateMutability": "view",
+                "type": "function"
+            },
+            {
+                "inputs": [
+                    {
+                        "name": "points_len",
+                        "type": "felt"
+                    },
+                    {
+                        "name": "points",
+                        "type": "Point*"
+                    }
+                ],
+                "name": "sum_point_array",
+                "outputs": [
+                    {
+                        "name": "res",
+                        "type": "Point"
+                    }
+                ],
+                "stateMutability": "view",
+                "type": "function"
+            }
+        ],
+        "entry_points_by_type": {
+            "CONSTRUCTOR": [
+                {
+                    "offset": "0x35",
+                    "selector": "0x28ffe4ff0f226a9107253e17a904099aa4f63a02a5621de0576e5aa71bc5194"
+                }
+            ],
+            "EXTERNAL": [
+                {
+                    "offset": "0x54",
+                    "selector": "0x362398bec32bc0ebb411203221a35a0301193a96f317ebe5e40be9f60d15320"
+                },
+                {
+                    "offset": "0x76",
+                    "selector": "0x39e11d48192e4333233c7eb19d10ad67c362bb28580c604d67884c85da39695"
+                },
+                {
+                    "offset": "0xa1",
+                    "selector": "0x3cd0a5d52a5573221431e4a61c6bdffd7f157bd278be73f332f0b10f12d895b"
+                }
+            ],
+            "L1_HANDLER": []
+        }
+    }
+}
diff --git a/test/deploy_rpc.json b/test/deploy_rpc.json
index c82270cb8..1fba0070e 100644
--- a/test/deploy_rpc.json
+++ b/test/deploy_rpc.json
@@ -3,91 +3,85 @@
       "69"
     ],
     "contract_definition":{
-      "program":"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",
+      "program":"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",
       "abi":[
         {
-          "members":[
-            {
-              "name":"x",
-              "offset":0,
-              "type":"felt"
-            },
-            {
-              "name":"y",
-              "offset":1,
-              "type":"felt"
-            }
-          ],
-          "name":"Point",
-          "size":2,
-          "type":"struct"
+            "members": [
+                {
+                    "name": "x",
+                    "offset": 0,
+                    "type": "felt"
+                },
+                {
+                    "name": "y",
+                    "offset": 1,
+                    "type": "felt"
+                }
+            ],
+            "name": "Point",
+            "size": 2,
+            "type": "struct"
         },
         {
-          "inputs":[
-            {
-              "name":"initial_balance",
-              "type":"felt"
-            }
-          ],
-          "name":"constructor",
-          "outputs":[
-            
-          ],
-          "type":"constructor"
+            "inputs": [
+                {
+                    "name": "initial_balance",
+                    "type": "felt"
+                }
+            ],
+            "name": "constructor",
+            "outputs": [],
+            "type": "constructor"
         },
         {
-          "inputs":[
-            {
-              "name":"amount1",
-              "type":"felt"
-            },
-            {
-              "name":"amount2",
-              "type":"felt"
-            }
-          ],
-          "name":"increase_balance",
-          "outputs":[
-            
-          ],
-          "type":"function"
+            "inputs": [
+                {
+                    "name": "amount1",
+                    "type": "felt"
+                },
+                {
+                    "name": "amount2",
+                    "type": "felt"
+                }
+            ],
+            "name": "increase_balance",
+            "outputs": [],
+            "type": "function"
         },
         {
-          "inputs":[
-            
-          ],
-          "name":"get_balance",
-          "outputs":[
-            {
-              "name":"res",
-              "type":"felt"
-            }
-          ],
-          "stateMutability":"view",
-          "type":"function"
+            "inputs": [],
+            "name": "get_balance",
+            "outputs": [
+                {
+                    "name": "res",
+                    "type": "felt"
+                }
+            ],
+            "stateMutability": "view",
+            "type": "function"
         },
         {
-          "inputs":[
-            {
-              "name":"points_len",
-              "type":"felt"
-            },
-            {
-              "name":"points",
-              "type":"Point*"
-            }
-          ],
-          "name":"sum_point_array",
-          "outputs":[
-            {
-              "name":"res",
-              "type":"Point"
-            }
-          ],
-          "stateMutability":"view",
-          "type":"function"
+            "inputs": [
+                {
+                    "name": "points_len",
+                    "type": "felt"
+                },
+                {
+                    "name": "points",
+                    "type": "Point*"
+                }
+            ],
+            "name": "sum_point_array",
+            "outputs": [
+                {
+                    "name": "res",
+                    "type": "Point"
+                }
+            ],
+            "stateMutability": "view",
+            "type": "function"
         }
-      ],
+    ],
       "entry_points_by_type":{
         "CONSTRUCTOR":[
           {
@@ -110,10 +104,11 @@
           }
         ],
         "L1_HANDLER":[
-          
+
         ]
       }
     },
     "contract_address_salt":"0x2",
-    "type":"DEPLOY"
+    "type":"DEPLOY",
+    "version":"0x1"
 }
\ No newline at end of file
diff --git a/test/invoke_rpc.json b/test/invoke_rpc.json
index ca71890ab..5e073ceab 100644
--- a/test/invoke_rpc.json
+++ b/test/invoke_rpc.json
@@ -7,6 +7,6 @@
   "signature":[
     
   ],
-  "contract_address":"0x0491c87978cb8d8a82c2a96dddd1888eb5ef8aa7209d5da86d2b703c3572032a",
+  "contract_address":"0x066cd141aa76c97c0ca6e513ad6789b2fe259f4b120909041219b298751423aa",
   "type":"INVOKE_FUNCTION"
-}
\ No newline at end of file
+}
diff --git a/test/invoke_rpc_v1.json b/test/invoke_rpc_v1.json
deleted file mode 100644
index 90fad8344..000000000
--- a/test/invoke_rpc_v1.json
+++ /dev/null
@@ -1,12 +0,0 @@
-{
-  "calldata": [
-    "10",
-    "11"
-  ],
-  "signature": [],
-  "contract_address": "0x0491c87978cb8d8a82c2a96dddd1888eb5ef8aa7209d5da86d2b703c3572032a",
-  "type": "INVOKE_FUNCTION",
-  "nonce": "0x1",
-  "version": "0x1",
-  "max_fee": "0x2"
-}
\ No newline at end of file
diff --git a/test/rpc/conftest.py b/test/rpc/conftest.py
index da243e505..f4f271206 100644
--- a/test/rpc/conftest.py
+++ b/test/rpc/conftest.py
@@ -7,29 +7,29 @@
 import json
 import typing
 
+from test.rpc.rpc_utils import (
+    gateway_call,
+    get_block_with_transaction,
+    add_transaction,
+    get_latest_block,
+)
+from test.util import load_file_content
+
+import pytest
 from starkware.starknet.services.api.contract_class import ContractClass
 from starkware.starknet.services.api.gateway.transaction import Transaction, Deploy
 
-import pytest
+from starknet_devnet.blueprints.rpc.utils import rpc_felt
 from starknet_devnet.blueprints.rpc.structures.types import (
     BlockNumberDict,
     BlockHashDict,
     Felt,
 )
-from ..util import load_file_content
-from ..shared import SUPPORTED_RPC_TX_VERSION
-from .rpc_utils import (
-    gateway_call,
-    get_block_with_transaction,
-    pad_zero,
-    add_transaction,
-    get_latest_block,
-)
 
 DEPLOY_CONTENT = load_file_content("deploy_rpc.json")
 INVOKE_CONTENT = load_file_content("invoke_rpc.json")
-INVOKE_CONTENT_V1 = load_file_content("invoke_rpc_v1.json")
 DECLARE_CONTENT = load_file_content("declare.json")
+DECLARE_CONTENT = load_file_content("declare_rpc.json")
 
 
 @pytest.fixture(name="contract_class")
@@ -49,7 +49,7 @@ def fixture_class_hash(deploy_info) -> Felt:
     class_hash = gateway_call(
         "get_class_hash_at", contractAddress=deploy_info["address"]
     )
-    return pad_zero(class_hash)
+    return rpc_felt(class_hash)
 
 
 @pytest.fixture(name="deploy_info")
@@ -57,7 +57,9 @@ def fixture_deploy_info() -> dict:
     """
     Deploy a contract on devnet and return deployment info dict
     """
-    return add_transaction(json.loads(DEPLOY_CONTENT))
+    deploy_tx = json.loads(DEPLOY_CONTENT)
+    deploy_info = add_transaction(deploy_tx)
+    return {**deploy_info, **deploy_tx}
 
 
 @pytest.fixture(name="invoke_info")
@@ -88,14 +90,6 @@ def fixture_invoke_content() -> dict:
     return json.loads(INVOKE_CONTENT)
 
 
-@pytest.fixture(name="invoke_content_v1")
-def fixture_invoke_content_v1() -> dict:
-    """
-    Invoke content v1 JSON object
-    """
-    return json.loads(INVOKE_CONTENT_V1)
-
-
 @pytest.fixture(name="deploy_content")
 def fixture_deploy_content() -> dict:
     """
@@ -131,7 +125,7 @@ def fixture_latest_block() -> dict:
 def _block_to_block_id(block: dict, key: str) -> dict:
     block_id_map = {
         "number": BlockNumberDict(block_number=int(block["block_number"])),
-        "hash": BlockHashDict(block_hash=pad_zero(block["block_hash"])),
+        "hash": BlockHashDict(block_hash=rpc_felt(block["block_hash"])),
         "tag": "latest",
         "tag_pending": "pending",
     }
@@ -152,19 +146,3 @@ def fixture_latest_block_id(latest_block, request) -> dict:
     Parametrized BlockId of latest gateway_block
     """
     return _block_to_block_id(latest_block, request.param)
-
-
-@pytest.fixture(name="rpc_invoke_tx_common")
-def fixture_rpc_invoke_tx_common() -> dict:
-    """
-    Common fields on RpcInvokeTransaction
-    """
-    return {
-        # It is not verified and might be removed in next RPC version
-        "transaction_hash": "0x00",
-        "max_fee": "0x00",
-        "version": hex(SUPPORTED_RPC_TX_VERSION),
-        "signature": [],
-        "nonce": None,
-        "type": "INVOKE",
-    }
diff --git a/test/rpc/rpc_utils.py b/test/rpc/rpc_utils.py
index 75e13d324..f8ed606a7 100644
--- a/test/rpc/rpc_utils.py
+++ b/test/rpc/rpc_utils.py
@@ -4,12 +4,20 @@
 
 from __future__ import annotations
 
-from typing import Union
+import re
+from typing import Union, List
 
-import requests
+from test.account import invoke
+
+from test.settings import APP_URL
+from test.shared import (
+    STORAGE_CONTRACT_PATH,
+    PREDEPLOYED_ACCOUNT_ADDRESS,
+    PREDEPLOYED_ACCOUNT_PRIVATE_KEY,
+)
+from test.util import deploy, assert_transaction
 
-from starknet_devnet.blueprints.rpc.structures.types import Felt
-from ..settings import APP_URL
+import requests
 
 
 class BackgroundDevnetClient:
@@ -88,10 +96,25 @@ def get_latest_block() -> dict:
     return gateway_call("get_block", blockNumber="latest")
 
 
-def pad_zero(felt: str) -> Felt:
+def deploy_and_invoke_storage_contract(value: int) -> List[str]:
+    """
+    Deploy and invoke storage contract
+    """
+    deploy_dict = deploy(STORAGE_CONTRACT_PATH)
+    contract_address = deploy_dict["address"]
+
+    invoke_tx_hash = invoke(
+        calls=[(contract_address, "store_value", [value])],
+        account_address=PREDEPLOYED_ACCOUNT_ADDRESS,
+        private_key=PREDEPLOYED_ACCOUNT_PRIVATE_KEY,
+    )
+    assert_transaction(invoke_tx_hash, "ACCEPTED_ON_L2")
+
+    return contract_address, invoke_tx_hash
+
+
+def is_felt(value: str) -> bool:
     """
-    Convert felt with format `0xValue` to format `0x0Value`
+    Check whether value is a Felt
     """
-    if felt == "0x0":
-        return "0x00"
-    return "0x0" + felt.lstrip("0x")
+    return bool(re.match(r"^0x0[a-fA-F0-9]{1,63}$", value))
diff --git a/test/rpc/test_data/get_events.py b/test/rpc/test_data/get_events.py
index d4aa9d6ed..9c5bfa424 100644
--- a/test/rpc/test_data/get_events.py
+++ b/test/rpc/test_data/get_events.py
@@ -2,7 +2,7 @@
 RPC get events test data.
 """
 
-from ...shared import (
+from test.shared import (
     EXPECTED_FEE_TOKEN_ADDRESS,
     PREDEPLOY_ACCOUNT_CLI_ARGS,
     PREDEPLOYED_ACCOUNT_ADDRESS,
diff --git a/test/rpc/test_rpc_blocks.py b/test/rpc/test_rpc_blocks.py
index 8bca49b5d..a74b71ae8 100644
--- a/test/rpc/test_rpc_blocks.py
+++ b/test/rpc/test_rpc_blocks.py
@@ -2,22 +2,23 @@
 Tests RPC blocks
 """
 
+from test.rpc.rpc_utils import rpc_call, gateway_call
+from test.shared import (
+    GENESIS_BLOCK_NUMBER,
+    INCORRECT_GENESIS_BLOCK_HASH,
+    SUPPORTED_RPC_TX_VERSION,
+)
+
 import pytest
+
 from starknet_devnet.blueprints.rpc.structures.types import (
     BlockNumberDict,
     BlockHashDict,
     rpc_txn_type,
 )
-from starknet_devnet.blueprints.rpc.utils import rpc_root
+from starknet_devnet.blueprints.rpc.utils import rpc_root, rpc_felt
 from starknet_devnet.general_config import DEFAULT_GENERAL_CONFIG
 
-from .rpc_utils import rpc_call, pad_zero, gateway_call
-from ..shared import (
-    GENESIS_BLOCK_NUMBER,
-    INCORRECT_GENESIS_BLOCK_HASH,
-    SUPPORTED_RPC_TX_VERSION,
-)
-
 
 @pytest.mark.usefixtures("run_devnet_in_background")
 def test_get_block_with_tx_hashes(deploy_info, gateway_block, block_id):
@@ -30,14 +31,14 @@ def test_get_block_with_tx_hashes(deploy_info, gateway_block, block_id):
 
     resp = rpc_call("starknet_getBlockWithTxHashes", params={"block_id": block_id})
     block = resp["result"]
-    transaction_hash: str = pad_zero(deploy_info["transaction_hash"])
+    transaction_hash: str = rpc_felt(deploy_info["transaction_hash"])
 
     assert block == {
-        "block_hash": pad_zero(block_hash),
-        "parent_hash": pad_zero(gateway_block["parent_block_hash"]),
+        "block_hash": rpc_felt(block_hash),
+        "parent_hash": rpc_felt(gateway_block["parent_block_hash"]),
         "block_number": block_number,
         "status": "ACCEPTED_ON_L2",
-        "sequencer_address": pad_zero(hex(DEFAULT_GENERAL_CONFIG.sequencer_address)),
+        "sequencer_address": rpc_felt(DEFAULT_GENERAL_CONFIG.sequencer_address),
         "new_root": new_root,
         "timestamp": gateway_block["timestamp"],
         "transactions": [transaction_hash],
@@ -49,7 +50,7 @@ def test_get_block_with_tx_hashes(deploy_info, gateway_block, block_id):
     "block_id",
     [
         BlockNumberDict(block_number=1234),
-        BlockHashDict(block_hash=pad_zero(INCORRECT_GENESIS_BLOCK_HASH)),
+        BlockHashDict(block_hash=rpc_felt(INCORRECT_GENESIS_BLOCK_HASH)),
     ],
 )
 def test_get_block_with_tx_hashes_raises_on_incorrect_block_id(block_id):
@@ -58,7 +59,7 @@ def test_get_block_with_tx_hashes_raises_on_incorrect_block_id(block_id):
     """
     ex = rpc_call("starknet_getBlockWithTxHashes", params={"block_id": block_id})
 
-    assert ex["error"] == {"code": 24, "message": "Invalid block id"}
+    assert ex["error"] == {"code": 24, "message": "Block not found"}
 
 
 @pytest.mark.usefixtures("run_devnet_in_background", "deploy_info")
@@ -75,22 +76,22 @@ def test_get_block_with_txs(gateway_block, block_id):
     block = resp["result"]
 
     assert block == {
-        "block_hash": pad_zero(block_hash),
-        "parent_hash": pad_zero(gateway_block["parent_block_hash"]),
+        "block_hash": rpc_felt(block_hash),
+        "parent_hash": rpc_felt(gateway_block["parent_block_hash"]),
         "block_number": block_number,
         "status": "ACCEPTED_ON_L2",
-        "sequencer_address": pad_zero(hex(DEFAULT_GENERAL_CONFIG.sequencer_address)),
+        "sequencer_address": rpc_felt(DEFAULT_GENERAL_CONFIG.sequencer_address),
         "new_root": new_root,
         "timestamp": gateway_block["timestamp"],
         "transactions": [
             {
-                "class_hash": pad_zero(block_tx["class_hash"]),
+                "class_hash": rpc_felt(block_tx["class_hash"]),
                 "constructor_calldata": [
-                    pad_zero(data) for data in block_tx["constructor_calldata"]
+                    rpc_felt(data) for data in block_tx["constructor_calldata"]
                 ],
-                "contract_address": pad_zero(block_tx["contract_address"]),
-                "contract_address_salt": pad_zero(block_tx["contract_address_salt"]),
-                "transaction_hash": pad_zero(block_tx["transaction_hash"]),
+                "contract_address": rpc_felt(block_tx["contract_address"]),
+                "contract_address_salt": rpc_felt(block_tx["contract_address_salt"]),
+                "transaction_hash": rpc_felt(block_tx["transaction_hash"]),
                 "type": rpc_txn_type(block_tx["type"]),
                 "version": hex(SUPPORTED_RPC_TX_VERSION),
             }
@@ -103,7 +104,7 @@ def test_get_block_with_txs(gateway_block, block_id):
     "block_id",
     [
         BlockNumberDict(block_number=1234),
-        BlockHashDict(block_hash=pad_zero(INCORRECT_GENESIS_BLOCK_HASH)),
+        BlockHashDict(block_hash=rpc_felt(INCORRECT_GENESIS_BLOCK_HASH)),
     ],
 )
 def test_get_block_with_txs_raises_on_incorrect_block_id(block_id):
@@ -112,7 +113,7 @@ def test_get_block_with_txs_raises_on_incorrect_block_id(block_id):
     """
     ex = rpc_call("starknet_getBlockWithTxHashes", params={"block_id": block_id})
 
-    assert ex["error"] == {"code": 24, "message": "Invalid block id"}
+    assert ex["error"] == {"code": 24, "message": "Block not found"}
 
 
 @pytest.mark.usefixtures("run_devnet_in_background", "deploy_info", "gateway_block")
@@ -134,7 +135,7 @@ def test_get_block_transaction_count(block_id):
     "block_id",
     [
         BlockNumberDict(block_number=99999),
-        BlockHashDict(block_hash=pad_zero(INCORRECT_GENESIS_BLOCK_HASH)),
+        BlockHashDict(block_hash=rpc_felt(INCORRECT_GENESIS_BLOCK_HASH)),
     ],
 )
 def test_get_block_transaction_count_raises_on_incorrect_block_id(block_id):
@@ -143,7 +144,7 @@ def test_get_block_transaction_count_raises_on_incorrect_block_id(block_id):
     """
     ex = rpc_call("starknet_getBlockTransactionCount", params={"block_id": block_id})
 
-    assert ex["error"] == {"code": 24, "message": "Invalid block id"}
+    assert ex["error"] == {"code": 24, "message": "Block not found"}
 
 
 @pytest.mark.usefixtures("run_devnet_in_background", "deploy_info")
diff --git a/test/rpc/test_rpc_call.py b/test/rpc/test_rpc_call.py
index 1e63e6eb6..4eb2bddd2 100644
--- a/test/rpc/test_rpc_call.py
+++ b/test/rpc/test_rpc_call.py
@@ -2,10 +2,12 @@
 Tests RPC rpc_call
 """
 
+from test.rpc.rpc_utils import rpc_call
 import pytest
+
 from starkware.starknet.public.abi import get_selector_from_name
 
-from .rpc_utils import rpc_call, pad_zero
+from starknet_devnet.blueprints.rpc.utils import rpc_felt
 
 
 @pytest.mark.usefixtures("run_devnet_in_background")
@@ -19,7 +21,7 @@ def test_call(deploy_info, latest_block_id):
         "starknet_call",
         params={
             "request": {
-                "contract_address": pad_zero(contract_address),
+                "contract_address": rpc_felt(contract_address),
                 "entry_point_selector": hex(get_selector_from_name("get_balance")),
                 "calldata": [],
             },
@@ -86,7 +88,7 @@ def test_call_raises_on_incorrect_selector(deploy_info):
         "starknet_call",
         params={
             "request": {
-                "contract_address": pad_zero(contract_address),
+                "contract_address": rpc_felt(contract_address),
                 "entry_point_selector": hex(get_selector_from_name("xxxxxxx")),
                 "calldata": [],
             },
@@ -112,7 +114,7 @@ def test_call_raises_on_invalid_calldata(deploy_info, calldata):
         "starknet_call",
         params={
             "request": {
-                "contract_address": pad_zero(contract_address),
+                "contract_address": rpc_felt(contract_address),
                 "entry_point_selector": hex(get_selector_from_name("get_balance")),
                 "calldata": calldata,
             },
@@ -134,7 +136,7 @@ def test_call_raises_on_incorrect_block_hash(deploy_info):
         "starknet_call",
         params={
             "request": {
-                "contract_address": pad_zero(contract_address),
+                "contract_address": rpc_felt(contract_address),
                 "entry_point_selector": hex(get_selector_from_name("get_balance")),
                 "calldata": [],
             },
diff --git a/test/rpc/test_rpc_class.py b/test/rpc/test_rpc_class.py
index 44fc056c8..447425939 100644
--- a/test/rpc/test_rpc_class.py
+++ b/test/rpc/test_rpc_class.py
@@ -1,13 +1,14 @@
 """
 Tests RPC contract class
 """
+from test.rpc.rpc_utils import rpc_call
+
 import pytest
 from starkware.starknet.services.api.gateway.transaction_utils import decompress_program
 
-from starknet_devnet.blueprints.rpc.utils import BlockId
-from .rpc_utils import rpc_call, pad_zero
+from starknet_devnet.blueprints.rpc.utils import BlockId, rpc_felt
 
-EXPECTED_CONTRACT_CLASS = {
+EXPECTED_ENTRY_POINTS = {
     "CONSTRUCTOR": [
         {
             "offset": "0x35",
@@ -31,18 +32,64 @@
     "L1_HANDLER": [],
 }
 
+# abi from ABI_PATH (test/shared.py), but with all stateMutability omitted and constructor mapped to function
+EXPECTED_ABI = [
+    {
+        "type": "struct",
+        "name": "Point",
+        "size": 2,
+        "members": [
+            {"name": "x", "offset": 0, "type": "felt"},
+            {"name": "y", "offset": 1, "type": "felt"},
+        ],
+    },
+    {
+        "type": "function",
+        "name": "constructor",
+        "inputs": [{"name": "initial_balance", "type": "felt"}],
+        "outputs": [],
+    },
+    {
+        "type": "function",
+        "name": "increase_balance",
+        "inputs": [
+            {"name": "amount1", "type": "felt"},
+            {"name": "amount2", "type": "felt"},
+        ],
+        "outputs": [],
+    },
+    {
+        "type": "function",
+        "name": "get_balance",
+        "inputs": [],
+        "outputs": [{"name": "res", "type": "felt"}],
+    },
+    {
+        "type": "function",
+        "name": "sum_point_array",
+        "inputs": [
+            {"name": "points_len", "type": "felt"},
+            {"name": "points", "type": "Point*"},
+        ],
+        "outputs": [{"name": "res", "type": "Point"}],
+    },
+]
+
 
 @pytest.mark.usefixtures("run_devnet_in_background")
 def test_get_class(class_hash):
     """
     Test get contract class
     """
-    resp = rpc_call("starknet_getClass", params={"class_hash": class_hash})
+    resp = rpc_call(
+        "starknet_getClass", params={"block_id": "latest", "class_hash": class_hash}
+    )
     contract_class = resp["result"]
 
-    assert contract_class["entry_points_by_type"] == EXPECTED_CONTRACT_CLASS
+    assert contract_class["entry_points_by_type"] == EXPECTED_ENTRY_POINTS
     assert isinstance(contract_class["program"], str)
     decompress_program({"contract_class": contract_class}, False)
+    assert contract_class["abi"] == EXPECTED_ABI
 
 
 @pytest.mark.usefixtures("run_devnet_in_background")
@@ -55,7 +102,7 @@ def test_get_class_hash_at(deploy_info, class_hash):
 
     resp = rpc_call(
         "starknet_getClassHashAt",
-        params={"contract_address": pad_zero(contract_address), "block_id": block_id},
+        params={"contract_address": rpc_felt(contract_address), "block_id": block_id},
     )
     rpc_class_hash = resp["result"]
 
@@ -72,10 +119,11 @@ def test_get_class_at(deploy_info):
 
     resp = rpc_call(
         "starknet_getClassAt",
-        params={"contract_address": pad_zero(contract_address), "block_id": block_id},
+        params={"contract_address": rpc_felt(contract_address), "block_id": block_id},
     )
     contract_class = resp["result"]
 
-    assert contract_class["entry_points_by_type"] == EXPECTED_CONTRACT_CLASS
+    assert contract_class["entry_points_by_type"] == EXPECTED_ENTRY_POINTS
     assert isinstance(contract_class["program"], str)
     decompress_program({"contract_class": contract_class}, False)
+    assert contract_class["abi"] == EXPECTED_ABI
diff --git a/test/rpc/test_rpc_estimate_fee.py b/test/rpc/test_rpc_estimate_fee.py
index 1b2cd73e0..63a2d1162 100644
--- a/test/rpc/test_rpc_estimate_fee.py
+++ b/test/rpc/test_rpc_estimate_fee.py
@@ -4,15 +4,27 @@
 
 from __future__ import annotations
 
-import pytest
+from test.account import _get_execute_args, get_nonce
+from test.rpc.rpc_utils import rpc_call_background_devnet
+from test.shared import (
+    PREDEPLOY_ACCOUNT_CLI_ARGS,
+    SUPPORTED_RPC_TX_VERSION,
+    PREDEPLOYED_ACCOUNT_ADDRESS,
+    PREDEPLOYED_ACCOUNT_PRIVATE_KEY,
+    LEGACY_RPC_TX_VERSION,
+)
+from test.test_account import deploy_empty_contract
 
+import pytest
 from starkware.starknet.public.abi import get_selector_from_name
 
-from starknet_devnet.blueprints.rpc.structures.payloads import RpcInvokeTransaction
+from starknet_devnet.blueprints.rpc.structures.payloads import (
+    RpcInvokeTransactionV0,
+    RpcBroadcastedInvokeTxnV0,
+    RpcBroadcastedInvokeTxnV1,
+)
+from starknet_devnet.blueprints.rpc.utils import rpc_felt
 from starknet_devnet.constants import DEFAULT_GAS_PRICE
-from .rpc_utils import rpc_call_background_devnet
-from ..shared import CONTRACT_PATH
-from ..util import deploy
 
 
 def common_estimate_response(response):
@@ -26,20 +38,36 @@ def common_estimate_response(response):
     assert overall_fee == gas_consumed * gas_price
 
 
+def get_execute_args(calls):
+    """Get execute arguments with predeployed account"""
+    return _get_execute_args(
+        calls=calls,
+        account_address=PREDEPLOYED_ACCOUNT_ADDRESS,
+        private_key=PREDEPLOYED_ACCOUNT_PRIVATE_KEY,
+        nonce=0,
+        version=SUPPORTED_RPC_TX_VERSION,
+        max_fee=0,
+    )
+
+
 @pytest.mark.usefixtures("run_devnet_in_background")
 @pytest.mark.parametrize(
-    "run_devnet_in_background", [["--gas-price", str(DEFAULT_GAS_PRICE)]], indirect=True
+    "run_devnet_in_background",
+    [["--gas-price", str(DEFAULT_GAS_PRICE), *PREDEPLOY_ACCOUNT_CLI_ARGS]],
+    indirect=True,
 )
-def test_estimate_happy_path(rpc_invoke_tx_common):
-    """Happy path estimate_fee call"""
-    deploy_info = deploy(CONTRACT_PATH, inputs=["0"])
+def test_estimate_happy_path_v0():
+    """Happy path estimate_fee call with tx v0"""
+    contract_address = deploy_empty_contract()["address"]
 
-    txn: RpcInvokeTransaction = {
-        "contract_address": deploy_info["address"],
+    txn: RpcBroadcastedInvokeTxnV0 = {
+        "contract_address": contract_address,
         "entry_point_selector": hex(get_selector_from_name("sum_point_array")),
         "calldata": ["0x02", "0x01", "0x02", "0x03", "0x04"],
-        # It is not verified and might be removed in next RPC version
-        **rpc_invoke_tx_common,
+        "max_fee": rpc_felt(0),
+        "version": hex(LEGACY_RPC_TX_VERSION),
+        "signature": [],
+        "type": "INVOKE",
     }
     response = rpc_call_background_devnet(
         "starknet_estimateFee", {"request": txn, "block_id": "latest"}
@@ -49,47 +77,80 @@ def test_estimate_happy_path(rpc_invoke_tx_common):
 
 
 @pytest.mark.usefixtures("run_devnet_in_background")
-def test_estimate_fee_with_genesis_block(rpc_invoke_tx_common):
-    """Call without transaction, expect pass with gas_price zero"""
-    txn: RpcInvokeTransaction = {
-        "contract_address": "0x62230ea046a9a5fbc261ac77d03c8d41e5d442db2284587570ab46455fd2488",
-        "entry_point_selector": "0x2f0b3c5710379609eb5495f1ecd348cb28167711b73609fe565a72734550354",
-        "calldata": ["0x0a", "0x014", "0x00"],
-        **rpc_invoke_tx_common,
-    }
+@pytest.mark.parametrize(
+    "run_devnet_in_background",
+    [["--gas-price", str(DEFAULT_GAS_PRICE), *PREDEPLOY_ACCOUNT_CLI_ARGS]],
+    indirect=True,
+)
+def test_estimate_happy_path():
+    """Happy path estimate_fee call"""
+    contract_address = deploy_empty_contract()["address"]
+
+    calls = [(contract_address, "sum_point_array", [2, 10, 20, 30, 40])]
+    signature, execute_calldata = get_execute_args(calls)
+
+    invoke_transaction = RpcBroadcastedInvokeTxnV1(
+        type="INVOKE",
+        max_fee=rpc_felt(0),
+        version=hex(SUPPORTED_RPC_TX_VERSION),
+        signature=[rpc_felt(sig) for sig in signature],
+        nonce=rpc_felt(get_nonce(PREDEPLOYED_ACCOUNT_ADDRESS)),
+        sender_address=rpc_felt(PREDEPLOYED_ACCOUNT_ADDRESS),
+        calldata=[rpc_felt(data) for data in execute_calldata],
+    )
+
     response = rpc_call_background_devnet(
-        "starknet_estimateFee", {"request": txn, "block_id": "latest"}
+        "starknet_estimateFee", {"request": invoke_transaction, "block_id": "latest"}
     )
 
     common_estimate_response(response)
 
 
 @pytest.mark.usefixtures("run_devnet_in_background")
-def test_estimate_fee_with_invalid_call_data(rpc_invoke_tx_common):
+@pytest.mark.parametrize(
+    "run_devnet_in_background",
+    [["--gas-price", str(DEFAULT_GAS_PRICE), *PREDEPLOY_ACCOUNT_CLI_ARGS]],
+    indirect=True,
+)
+def test_estimate_fee_with_invalid_call_data():
     """Call estimate fee with invalid data on body"""
-    deploy_info = deploy(CONTRACT_PATH, inputs=["0"])
-
-    txn: RpcInvokeTransaction = {
-        "contract_address": deploy_info["address"],
-        "entry_point_selector": hex(get_selector_from_name("sum_point_array")),
-        "calldata": ["10", "20"],
-        **rpc_invoke_tx_common,
-    }
+    contract_address = deploy_empty_contract()["address"]
+
+    calls = [(contract_address, "sum_point_array", [2, 10, 20, 30, 40])]
+    signature, execute_calldata = get_execute_args(calls)
+
+    invoke_transaction = RpcBroadcastedInvokeTxnV1(
+        type="INVOKE",
+        max_fee=rpc_felt(0),
+        version=hex(SUPPORTED_RPC_TX_VERSION),
+        signature=[rpc_felt(sig) for sig in signature],
+        nonce=rpc_felt(get_nonce(PREDEPLOYED_ACCOUNT_ADDRESS)),
+        sender_address=rpc_felt(PREDEPLOYED_ACCOUNT_ADDRESS),
+        calldata=[rpc_felt(data) for data in execute_calldata][:-1],
+    )
     ex = rpc_call_background_devnet(
-        "starknet_estimateFee", {"request": txn, "block_id": "latest"}
+        "starknet_estimateFee", {"request": invoke_transaction, "block_id": "latest"}
     )
 
     assert ex["error"] == {"code": 22, "message": "Invalid call data"}
 
 
 @pytest.mark.usefixtures("run_devnet_in_background")
-def test_estimate_fee_with_invalid_contract_address(rpc_invoke_tx_common):
+@pytest.mark.parametrize(
+    "run_devnet_in_background",
+    [["--gas-price", str(DEFAULT_GAS_PRICE), *PREDEPLOY_ACCOUNT_CLI_ARGS]],
+    indirect=True,
+)
+def test_estimate_fee_with_invalid_contract_address():
     """Call estimate fee with invalid data on body"""
-    txn: RpcInvokeTransaction = {
+    txn: RpcInvokeTransactionV0 = {
         "contract_address": "0x01",
         "entry_point_selector": hex(get_selector_from_name("sum_point_array")),
         "calldata": ["0x02", "0x01", "0x02", "0x03", "0x04"],
-        **rpc_invoke_tx_common,
+        "max_fee": rpc_felt(0),
+        "version": hex(LEGACY_RPC_TX_VERSION),
+        "signature": [],
+        "type": "INVOKE",
     }
     ex = rpc_call_background_devnet(
         "starknet_estimateFee", {"request": txn, "block_id": "latest"}
@@ -99,40 +160,21 @@ def test_estimate_fee_with_invalid_contract_address(rpc_invoke_tx_common):
 
 
 @pytest.mark.usefixtures("run_devnet_in_background")
-def test_estimate_fee_with_invalid_message_selector(rpc_invoke_tx_common):
+def test_estimate_fee_with_invalid_message_selector():
     """Call estimate fee with invalid data on body"""
-    deploy_info = deploy(CONTRACT_PATH, inputs=["0"])
+    contract_address = deploy_empty_contract()["address"]
 
-    txn: RpcInvokeTransaction = {
-        "contract_address": deploy_info["address"],
+    txn: RpcInvokeTransactionV0 = {
+        "contract_address": contract_address,
         "entry_point_selector": "0x01",
         "calldata": ["0x02", "0x01", "0x02", "0x03", "0x04"],
-        **rpc_invoke_tx_common,
+        "max_fee": rpc_felt(0),
+        "version": hex(LEGACY_RPC_TX_VERSION),
+        "signature": [],
+        "type": "INVOKE",
     }
     ex = rpc_call_background_devnet(
         "starknet_estimateFee", {"request": txn, "block_id": "latest"}
     )
 
     assert ex["error"] == {"code": 21, "message": "Invalid message selector"}
-
-
-@pytest.mark.usefixtures("run_devnet_in_background")
-@pytest.mark.parametrize(
-    "run_devnet_in_background", [["--gas-price", str(DEFAULT_GAS_PRICE)]], indirect=True
-)
-def test_estimate_fee_with_complete_request_data(rpc_invoke_tx_common):
-    """Estimate fee with complete request data"""
-
-    deploy_info = deploy(CONTRACT_PATH, inputs=["0"])
-
-    txn: RpcInvokeTransaction = {
-        "contract_address": deploy_info["address"],
-        "entry_point_selector": "0x362398bec32bc0ebb411203221a35a0301193a96f317ebe5e40be9f60d15320",
-        "calldata": ["0x0a", "0x014"],
-        **rpc_invoke_tx_common,
-    }
-    response = rpc_call_background_devnet(
-        "starknet_estimateFee", {"request": txn, "block_id": "latest"}
-    )
-
-    common_estimate_response(response)
diff --git a/test/rpc/test_rpc_misc.py b/test/rpc/test_rpc_misc.py
index 1542d528e..64447164d 100644
--- a/test/rpc/test_rpc_misc.py
+++ b/test/rpc/test_rpc_misc.py
@@ -4,28 +4,27 @@
 
 from __future__ import annotations
 
-import pytest
-from starkware.starknet.public.abi import get_storage_var_address
-from starkware.starknet.core.os.class_hash import compute_class_hash
-
-from starknet_devnet.blueprints.rpc.structures.types import BlockHashDict
-from starknet_devnet.blueprints.rpc.utils import rpc_root
-from starknet_devnet.general_config import DEFAULT_GENERAL_CONFIG
-from .test_data.get_events import GET_EVENTS_TEST_DATA
-
-from .rpc_utils import rpc_call, gateway_call, get_block_with_transaction, pad_zero
-
-from ..account import (
-    invoke,
-)
-from ..util import (
-    deploy,
-)
-from ..shared import (
+from test.account import declare, invoke
+from test.rpc.rpc_utils import rpc_call, deploy_and_invoke_storage_contract
+from test.shared import (
+    CONTRACT_PATH,
+    EXPECTED_CLASS_HASH,
+    DEPLOYER_CONTRACT_PATH,
+    EXPECTED_FEE_TOKEN_ADDRESS,
     PREDEPLOYED_ACCOUNT_ADDRESS,
     PREDEPLOYED_ACCOUNT_PRIVATE_KEY,
     EVENTS_CONTRACT_PATH,
 )
+from test.test_account import deploy_empty_contract
+from test.test_state_update import get_class_hash_at_path
+from test.util import assert_transaction, assert_hex_equal, deploy
+from test.rpc.test_data.get_events import GET_EVENTS_TEST_DATA
+
+import pytest
+
+from starkware.starknet.public.abi import get_storage_var_address
+from starknet_devnet.blueprints.rpc.utils import rpc_felt
+from starknet_devnet.general_config import DEFAULT_GENERAL_CONFIG
 
 
 @pytest.fixture(name="input_data")
@@ -44,76 +43,73 @@ def fixture_expected_data(request):
     return request.param
 
 
-# pylint: disable=too-many-locals
-@pytest.mark.usefixtures("run_devnet_in_background")
-def test_get_state_update(deploy_info, invoke_info, contract_class):
-    """
-    Get state update for the block
-    """
-    block_with_deploy = get_block_with_transaction(deploy_info["transaction_hash"])
-    block_with_invoke = get_block_with_transaction(invoke_info["transaction_hash"])
-
-    contract_address: str = deploy_info["address"]
-    block_with_deploy_hash: str = pad_zero(block_with_deploy["block_hash"])
-    block_with_invoke_hash: str = pad_zero(block_with_invoke["block_hash"])
-    block_id_deploy = BlockHashDict(block_hash=block_with_deploy_hash)
-    block_id_invoke = BlockHashDict(block_hash=block_with_invoke_hash)
-    class_hash = pad_zero(hex(compute_class_hash(contract_class)))
-
-    storage = gateway_call(
-        "get_storage_at",
-        contractAddress=contract_address,
-        key=get_storage_var_address("balance"),
-    )
+@pytest.mark.usefixtures("devnet_with_account")
+def test_get_state_update():
+    """Test if declared classes successfully registered"""
 
-    new_root_deploy = rpc_root(
-        gateway_call("get_state_update", blockHash=block_with_deploy_hash)["new_root"]
+    declare_info = declare(
+        contract_path=CONTRACT_PATH,
+        account_address=PREDEPLOYED_ACCOUNT_ADDRESS,
+        private_key=PREDEPLOYED_ACCOUNT_PRIVATE_KEY,
     )
-    new_root_invoke = rpc_root(
-        gateway_call("get_state_update", blockHash=block_with_invoke_hash)["new_root"]
+    contract_class_hash = declare_info["class_hash"]
+    assert_hex_equal(contract_class_hash, EXPECTED_CLASS_HASH)
+
+    resp = rpc_call("starknet_getStateUpdate", params={"block_id": "latest"})
+    diff_after_declare = resp["result"]["state_diff"]
+    assert diff_after_declare["declared_contract_hashes"] == [
+        rpc_felt(contract_class_hash)
+    ]
+
+    # Deploy the deployer - also deploys a contract of the declared class using the deploy syscall
+    initial_balance_in_constructor = "5"
+    deployer_deploy_info = deploy(
+        contract=DEPLOYER_CONTRACT_PATH,
+        inputs=[contract_class_hash, initial_balance_in_constructor],
     )
+    deployer_class_hash = hex(get_class_hash_at_path(DEPLOYER_CONTRACT_PATH))
+    deployer_address = deployer_deploy_info["address"]
 
-    resp = rpc_call("starknet_getStateUpdate", params={"block_id": block_id_deploy})
-    state_update = resp["result"]
+    resp = rpc_call("starknet_getStateUpdate", params={"block_id": "latest"})
+    diff_after_deploy = resp["result"]["state_diff"]
 
-    assert state_update["block_hash"] == block_with_deploy_hash
-    assert state_update["new_root"] == new_root_deploy
-    assert "old_root" in state_update
-    assert isinstance(state_update["old_root"], str)
-    assert state_update["state_diff"] == {
-        "storage_diffs": [],
-        "deployed_contracts": [
-            {
-                "address": pad_zero(contract_address),
-                "class_hash": class_hash,
-            }
-        ],
-        "declared_contracts": [
-            {
-                "class_hash": class_hash,
-            }
-        ],
-        "nonces": [],
-    }
+    deployer_diff = diff_after_deploy["deployed_contracts"][0]
+    assert_hex_equal(deployer_diff["class_hash"], deployer_class_hash)
+    assert_hex_equal(deployer_diff["address"], deployer_address)
+
+    deployed_contract_diff = diff_after_deploy["deployed_contracts"][1]
+    assert_hex_equal(deployed_contract_diff["class_hash"], contract_class_hash)
+    # deployed_contract_diff["address"] is a random value
+
+    # deployer expected to be declared
+    assert diff_after_deploy["declared_contract_hashes"] == [
+        rpc_felt(deployer_class_hash)
+    ]
+
+
+@pytest.mark.usefixtures("devnet_with_account")
+def test_storage_diff():
+    """Test storage diffs in the state update"""
+
+    value = 30
+    contract_address, _ = deploy_and_invoke_storage_contract(value)
 
-    resp = rpc_call("starknet_getStateUpdate", params={"block_id": block_id_invoke})
-    state_update = resp["result"]
+    resp = rpc_call("starknet_getStateUpdate", params={"block_id": "latest"})
+    storage_diffs = resp["result"]["state_diff"]["storage_diffs"]
 
-    assert state_update["block_hash"] == block_with_invoke_hash
-    assert state_update["new_root"] == new_root_invoke
-    assert "old_root" in state_update
-    assert isinstance(state_update["old_root"], str)
-    assert state_update["state_diff"] == {
-        "storage_diffs": [
+    # list can be in different order per test run
+    if storage_diffs[0]["address"] == rpc_felt(contract_address):
+        storage_diffs[0], storage_diffs[1] = storage_diffs[1], storage_diffs[0]
+
+    assert storage_diffs[0]["address"] == rpc_felt(EXPECTED_FEE_TOKEN_ADDRESS)
+    assert storage_diffs[1] == {
+        "address": rpc_felt(contract_address),
+        "storage_entries": [
             {
-                "address": contract_address,
-                "key": pad_zero(hex(get_storage_var_address("balance"))),
-                "value": pad_zero(storage),
+                "key": rpc_felt(get_storage_var_address("storage")),
+                "value": rpc_felt(value),
             }
         ],
-        "deployed_contracts": [],
-        "declared_contracts": [],
-        "nonces": [],
     }
 
 
@@ -180,10 +176,42 @@ def test_get_events(input_data, expected_data):
         )
 
 
-@pytest.mark.usefixtures("run_devnet_in_background")
-def test_call_get_nonce(deploy_info):
-    """
-    Test nonce
-    """
-    ex = rpc_call(method="starknet_getNonce", params=[deploy_info["address"]])
-    assert ex["result"] == "0x0"
+@pytest.mark.usefixtures("devnet_with_account")
+def test_get_nonce():
+    """Test get_nonce"""
+
+    account_address = PREDEPLOYED_ACCOUNT_ADDRESS
+
+    initial_resp = rpc_call(
+        method="starknet_getNonce",
+        params={"block_id": "latest", "contract_address": rpc_felt(account_address)},
+    )
+    assert initial_resp["result"] == "0x00"
+
+    deployment_info = deploy_empty_contract()
+
+    invoke_tx_hash = invoke(
+        calls=[(deployment_info["address"], "increase_balance", [10, 20])],
+        account_address=account_address,
+        private_key=PREDEPLOYED_ACCOUNT_PRIVATE_KEY,
+    )
+    assert_transaction(invoke_tx_hash, "ACCEPTED_ON_L2")
+
+    final_resp = rpc_call(
+        method="starknet_getNonce",
+        params={"block_id": "latest", "contract_address": rpc_felt(account_address)},
+    )
+    assert final_resp["result"] == "0x01"
+
+
+@pytest.mark.usefixtures("devnet_with_account")
+def test_get_nonce_invalid_address():
+    """Test get_nonce with invalid address"""
+
+    account_address = "0x1111"
+
+    ex = rpc_call(
+        method="starknet_getNonce",
+        params={"block_id": "latest", "contract_address": rpc_felt(account_address)},
+    )
+    assert ex["error"] == {"code": 20, "message": "Contract not found"}
diff --git a/test/rpc/test_rpc_storage.py b/test/rpc/test_rpc_storage.py
index f38265e4d..3095c194e 100644
--- a/test/rpc/test_rpc_storage.py
+++ b/test/rpc/test_rpc_storage.py
@@ -2,10 +2,12 @@
 Tests RPC storage
 """
 
+from test.rpc.rpc_utils import rpc_call
+
 import pytest
 from starkware.starknet.public.abi import get_storage_var_address
 
-from .rpc_utils import rpc_call, pad_zero
+from starknet_devnet.blueprints.rpc.utils import rpc_felt
 
 
 @pytest.mark.usefixtures("run_devnet_in_background")
@@ -20,7 +22,7 @@ def test_get_storage_at(deploy_info):
     resp = rpc_call(
         "starknet_getStorageAt",
         params={
-            "contract_address": pad_zero(contract_address),
+            "contract_address": rpc_felt(contract_address),
             "key": key,
             "block_id": block_id,
         },
@@ -63,7 +65,7 @@ def test_get_storage_at_raises_on_incorrect_key(deploy_info):
     response = rpc_call(
         "starknet_getStorageAt",
         params={
-            "contract_address": pad_zero(contract_address),
+            "contract_address": rpc_felt(contract_address),
             "key": "0x00",
             "block_id": "latest",
         },
@@ -84,7 +86,7 @@ def test_get_storage_at_raises_on_incorrect_block_id(deploy_info):
     ex = rpc_call(
         "starknet_getStorageAt",
         params={
-            "contract_address": pad_zero(contract_address),
+            "contract_address": rpc_felt(contract_address),
             "key": key,
             "block_id": "0x0",
         },
diff --git a/test/rpc/test_rpc_transactions.py b/test/rpc/test_rpc_transactions.py
index 0f2d100c2..ec0a84211 100644
--- a/test/rpc/test_rpc_transactions.py
+++ b/test/rpc/test_rpc_transactions.py
@@ -3,30 +3,63 @@
 """
 
 from __future__ import annotations
+
 from typing import List
 
+from test.account import declare, _get_execute_args, get_nonce, _get_signature
+from test.rpc.rpc_utils import (
+    rpc_call,
+    get_block_with_transaction,
+    gateway_call,
+    deploy_and_invoke_storage_contract,
+    is_felt,
+)
+from test.shared import (
+    INCORRECT_GENESIS_BLOCK_HASH,
+    SUPPORTED_RPC_TX_VERSION,
+    PREDEPLOYED_ACCOUNT_ADDRESS,
+    PREDEPLOYED_ACCOUNT_PRIVATE_KEY,
+    CONTRACT_PATH,
+    LEGACY_RPC_TX_VERSION,
+)
+from test.util import deploy, load_contract_class
 import pytest
-from starknet_devnet.blueprints.rpc.structures.payloads import RpcContractClass
-from starknet_devnet.blueprints.rpc.structures.types import rpc_txn_type
-from starknet_devnet.blueprints.rpc.utils import rpc_felt
 
-from .rpc_utils import rpc_call, get_block_with_transaction, pad_zero
-from ..shared import INCORRECT_GENESIS_BLOCK_HASH, SUPPORTED_RPC_TX_VERSION
+from starkware.starknet.core.os.transaction_hash.transaction_hash import (
+    calculate_declare_transaction_hash,
+)
+from starkware.starknet.definitions.general_config import StarknetChainId
+from starkware.starknet.public.abi import (
+    get_storage_var_address,
+    get_selector_from_name,
+)
+from starknet_devnet.blueprints.rpc.structures.types import rpc_txn_type, Signature
+from starknet_devnet.blueprints.rpc.utils import rpc_felt
+from starknet_devnet.blueprints.rpc.structures.payloads import (
+    RpcContractClass,
+    RpcBroadcastedDeclareTxn,
+    EntryPoints,
+    RpcBroadcastedDeployTxn,
+    RpcBroadcastedInvokeTxnV1,
+    RpcBroadcastedInvokeTxnV0,
+)
 
 
-def pad_zero_external_entry_points(contract_class: dict) -> dict:
+def pad_zero_entry_points(entry_points: EntryPoints) -> None:
     """
-    Pad zero every entry point of type EXTERNAL in contract_class
+    Pad zero every selector in entry points in contract_class
     """
-    external_entry_points = contract_class["entry_points_by_type"]["EXTERNAL"]
-    for i, _ in enumerate(external_entry_points):
-        external_entry_points[i]["selector"] = pad_zero(
-            external_entry_points[i]["selector"]
-        )
 
-    contract_class["entry_points_by_type"]["EXTERNAL"] = external_entry_points
+    def pad_selector(entry_point):
+        return {
+            "offset": entry_point["offset"],
+            "selector": rpc_felt(entry_point["selector"]),
+        }
 
-    return contract_class
+    for entry_point_type, entry_point_list in entry_points.items():
+        entry_points[entry_point_type] = [
+            pad_selector(entry_point) for entry_point in entry_point_list
+        ]
 
 
 @pytest.mark.usefixtures("run_devnet_in_background")
@@ -41,94 +74,96 @@ def test_get_transaction_by_hash_deploy(deploy_info):
 
     resp = rpc_call(
         "starknet_getTransactionByHash",
-        params={"transaction_hash": pad_zero(transaction_hash)},
+        params={"transaction_hash": rpc_felt(transaction_hash)},
     )
     transaction = resp["result"]
 
     assert transaction == {
-        "transaction_hash": pad_zero(transaction_hash),
-        "class_hash": pad_zero(block_tx["class_hash"]),
+        "transaction_hash": rpc_felt(transaction_hash),
+        "class_hash": rpc_felt(block_tx["class_hash"]),
         "version": hex(SUPPORTED_RPC_TX_VERSION),
         "type": rpc_txn_type(block_tx["type"]),
-        "contract_address": pad_zero(contract_address),
-        "contract_address_salt": pad_zero(block_tx["contract_address_salt"]),
+        "contract_address": rpc_felt(contract_address),
+        "contract_address_salt": rpc_felt(block_tx["contract_address_salt"]),
         "constructor_calldata": ["0x045"],
     }
 
 
-@pytest.mark.usefixtures("run_devnet_in_background", "deploy_info")
-def test_get_transaction_by_hash_invoke(invoke_info):
+@pytest.mark.usefixtures("devnet_with_account")
+def test_get_transaction_by_hash_invoke():
     """
     Get transaction by hash
     """
-    block = get_block_with_transaction(invoke_info["transaction_hash"])
+    _, invoke_tx_hash = deploy_and_invoke_storage_contract(value=30)
+
+    block = get_block_with_transaction(invoke_tx_hash)
     block_tx = block["transactions"][0]
-    transaction_hash: str = invoke_info["transaction_hash"]
-    contract_address: str = invoke_info["address"]
-    entry_point_selector: str = invoke_info["entry_point_selector"]
-    signature: List[str] = [pad_zero(hex(int(sig))) for sig in invoke_info["signature"]]
-    calldata: List[str] = [pad_zero(hex(int(data))) for data in invoke_info["calldata"]]
+    signature: Signature = [rpc_felt(sig) for sig in block_tx["signature"]]
+    calldata: List[str] = [rpc_felt(data) for data in block_tx["calldata"]]
 
     resp = rpc_call(
         "starknet_getTransactionByHash",
-        params={"transaction_hash": pad_zero(transaction_hash)},
+        params={"transaction_hash": rpc_felt(invoke_tx_hash)},
     )
     transaction = resp["result"]
 
     assert transaction == {
-        "transaction_hash": pad_zero(transaction_hash),
-        "max_fee": pad_zero(block_tx["max_fee"]),
+        "transaction_hash": rpc_felt(invoke_tx_hash),
+        "max_fee": rpc_felt(block_tx["max_fee"]),
         "version": hex(SUPPORTED_RPC_TX_VERSION),
         "signature": signature,
-        "nonce": pad_zero(hex(0)),
+        "nonce": rpc_felt(0),
         "type": rpc_txn_type(block_tx["type"]),
-        "contract_address": contract_address,
-        "entry_point_selector": pad_zero(entry_point_selector),
+        "sender_address": rpc_felt(PREDEPLOYED_ACCOUNT_ADDRESS),
         "calldata": calldata,
     }
 
 
-@pytest.mark.usefixtures("run_devnet_in_background")
-def test_get_transaction_by_hash_declare(declare_info):
+@pytest.mark.usefixtures("devnet_with_account")
+def test_get_transaction_by_hash_declare():
     """
     Get transaction by hash
     """
-    block = get_block_with_transaction(declare_info["transaction_hash"])
+    declare_info = declare(
+        contract_path=CONTRACT_PATH,
+        account_address=PREDEPLOYED_ACCOUNT_ADDRESS,
+        private_key=PREDEPLOYED_ACCOUNT_PRIVATE_KEY,
+    )
+
+    block = get_block_with_transaction(declare_info["tx_hash"])
     block_tx = block["transactions"][0]
-    transaction_hash: str = declare_info["transaction_hash"]
-    signature: List[str] = [
-        pad_zero(hex(int(sig))) for sig in declare_info["signature"]
-    ]
+    transaction_hash: str = declare_info["tx_hash"]
+    signature: Signature = [rpc_felt(sig) for sig in block_tx["signature"]]
 
     resp = rpc_call(
         "starknet_getTransactionByHash",
-        params={"transaction_hash": pad_zero(transaction_hash)},
+        params={"transaction_hash": rpc_felt(transaction_hash)},
     )
     transaction = resp["result"]
 
     assert transaction == {
-        "transaction_hash": pad_zero(transaction_hash),
-        "max_fee": pad_zero(block_tx["max_fee"]),
-        "version": block_tx["version"],
+        "transaction_hash": rpc_felt(transaction_hash),
+        "max_fee": rpc_felt(block_tx["max_fee"]),
+        "version": hex(SUPPORTED_RPC_TX_VERSION),
         "signature": signature,
-        "nonce": pad_zero(block_tx["nonce"]),
+        "nonce": rpc_felt(0),
         "type": rpc_txn_type(block_tx["type"]),
-        "class_hash": pad_zero(block_tx["class_hash"]),
-        "sender_address": pad_zero(block_tx["sender_address"]),
+        "sender_address": rpc_felt(PREDEPLOYED_ACCOUNT_ADDRESS),
+        "class_hash": rpc_felt(block_tx["class_hash"]),
     }
 
 
-@pytest.mark.usefixtures("run_devnet_in_background", "deploy_info")
+@pytest.mark.usefixtures("run_devnet_in_background")
 def test_get_transaction_by_hash_raises_on_incorrect_hash():
     """
     Get transaction by incorrect hash
     """
     ex = rpc_call("starknet_getTransactionByHash", params={"transaction_hash": "0x00"})
 
-    assert ex["error"] == {"code": 25, "message": "Invalid transaction hash"}
+    assert ex["error"] == {"code": 25, "message": "Transaction hash not found"}
 
 
-@pytest.mark.usefixtures("run_devnet_in_background")
+@pytest.mark.usefixtures("devnet_with_account")
 def test_get_transaction_by_block_id_and_index(deploy_info):
     """
     Get transaction by block id and transaction index
@@ -152,13 +187,13 @@ def test_get_transaction_by_block_id_and_index(deploy_info):
     transaction = resp["result"]
 
     assert transaction == {
-        "class_hash": pad_zero(block_tx["class_hash"]),
+        "class_hash": rpc_felt(block_tx["class_hash"]),
         "constructor_calldata": [
-            pad_zero(tx) for tx in block_tx["constructor_calldata"]
+            rpc_felt(tx) for tx in block_tx["constructor_calldata"]
         ],
-        "contract_address": pad_zero(contract_address),
-        "contract_address_salt": pad_zero(block_tx["contract_address_salt"]),
-        "transaction_hash": pad_zero(transaction_hash),
+        "contract_address": rpc_felt(contract_address),
+        "contract_address_salt": rpc_felt(block_tx["contract_address_salt"]),
+        "transaction_hash": rpc_felt(transaction_hash),
         "type": rpc_txn_type(block_tx["type"]),
         "version": hex(SUPPORTED_RPC_TX_VERSION),
     }
@@ -172,12 +207,12 @@ def test_get_transaction_by_block_id_and_index_raises_on_incorrect_block_hash():
     ex = rpc_call(
         "starknet_getTransactionByBlockIdAndIndex",
         params={
-            "block_id": {"block_hash": pad_zero(INCORRECT_GENESIS_BLOCK_HASH)},
+            "block_id": {"block_hash": rpc_felt(INCORRECT_GENESIS_BLOCK_HASH)},
             "index": 0,
         },
     )
 
-    assert ex["error"] == {"code": 24, "message": "Invalid block id"}
+    assert ex["error"] == {"code": 24, "message": "Block not found"}
 
 
 @pytest.mark.usefixtures("run_devnet_in_background")
@@ -192,7 +227,7 @@ def test_get_transaction_by_block_id_and_index_raises_on_incorrect_index(deploy_
         "starknet_getTransactionByBlockIdAndIndex",
         params={
             "block_id": {
-                "block_hash": pad_zero(block_hash),
+                "block_hash": rpc_felt(block_hash),
             },
             "index": 999999,
         },
@@ -214,40 +249,60 @@ def test_get_declare_transaction_receipt(declare_info):
 
     resp = rpc_call(
         "starknet_getTransactionReceipt",
-        params={"transaction_hash": pad_zero(transaction_hash)},
+        params={"transaction_hash": rpc_felt(transaction_hash)},
     )
     receipt = resp["result"]
 
     assert receipt == {
-        "transaction_hash": pad_zero(transaction_hash),
+        "transaction_hash": rpc_felt(transaction_hash),
+        "actual_fee": rpc_felt(0),
         "status": "ACCEPTED_ON_L2",
-        "status_data": None,
-        "actual_fee": pad_zero(hex(0)),
-        "block_hash": pad_zero(block["block_hash"]),
+        "block_hash": rpc_felt(block["block_hash"]),
         "block_number": block["block_number"],
+        "type": "DECLARE",
+        "messages_sent": [],
+        "events": [],
     }
 
 
-@pytest.mark.usefixtures("run_devnet_in_background")
-def test_get_invoke_transaction_receipt(invoke_info):
+@pytest.mark.usefixtures("devnet_with_account")
+def test_get_invoke_transaction_receipt():
     """
     Get transaction receipt
     """
-    transaction_hash: str = invoke_info["transaction_hash"]
+
+    _, invoke_tx_hash = deploy_and_invoke_storage_contract(value=30)
+
+    gateway_receipt = gateway_call(
+        "get_transaction_receipt", transactionHash=invoke_tx_hash
+    )
+    event = gateway_receipt["events"][0]
+
+    block = get_block_with_transaction(invoke_tx_hash)
+    block_tx = block["transactions"][0]
 
     resp = rpc_call(
         "starknet_getTransactionReceipt",
-        params={"transaction_hash": pad_zero(transaction_hash)},
+        params={"transaction_hash": rpc_felt(invoke_tx_hash)},
     )
     receipt = resp["result"]
 
-    # Standard == receipt dict test cannot be done here, because invoke transaction fails since no contracts
-    # are actually deployed on devnet, when running test without run_devnet_in_background fixture
-    assert receipt["transaction_hash"] == pad_zero(transaction_hash)
-    assert receipt["actual_fee"] == pad_zero(hex(0))
-    assert receipt["l1_origin_message"] is None
-    assert receipt["events"] == []
-    assert receipt["messages_sent"] == []
+    assert receipt == {
+        "transaction_hash": rpc_felt(invoke_tx_hash),
+        "actual_fee": rpc_felt(block_tx["max_fee"]),
+        "status": "ACCEPTED_ON_L2",
+        "block_hash": rpc_felt(block["block_hash"]),
+        "block_number": block["block_number"],
+        "type": rpc_txn_type(block_tx["type"]),
+        "messages_sent": [],
+        "events": [
+            {
+                "from_address": rpc_felt(event["from_address"]),
+                "data": [rpc_felt(data) for data in event["data"]],
+                "keys": [rpc_felt(key) for key in event["keys"]],
+            }
+        ],
+    }
 
 
 @pytest.mark.usefixtures("run_devnet_in_background", "deploy_info")
@@ -259,7 +314,7 @@ def test_get_transaction_receipt_on_incorrect_hash():
         "starknet_getTransactionReceipt", params={"transaction_hash": rpc_felt(0)}
     )
 
-    assert ex["error"] == {"code": 25, "message": "Invalid transaction hash"}
+    assert ex["error"] == {"code": 25, "message": "Transaction hash not found"}
 
 
 @pytest.mark.usefixtures("run_devnet_in_background")
@@ -272,100 +327,104 @@ def test_get_deploy_transaction_receipt(deploy_info):
 
     resp = rpc_call(
         "starknet_getTransactionReceipt",
-        params={"transaction_hash": pad_zero(transaction_hash)},
+        params={"transaction_hash": rpc_felt(transaction_hash)},
     )
     receipt = resp["result"]
 
     assert receipt == {
-        "transaction_hash": pad_zero(transaction_hash),
+        "contract_address": rpc_felt(deploy_info["address"]),
+        "transaction_hash": rpc_felt(transaction_hash),
+        "actual_fee": rpc_felt(0),
         "status": "ACCEPTED_ON_L2",
-        "status_data": None,
-        "actual_fee": pad_zero(hex(0)),
-        "block_hash": pad_zero(block["block_hash"]),
+        "block_hash": rpc_felt(block["block_hash"]),
         "block_number": block["block_number"],
+        "type": "DEPLOY",
+        "messages_sent": [],
+        "events": [],
     }
 
 
-@pytest.mark.usefixtures("run_devnet_in_background")
-def test_add_invoke_transaction(invoke_content):
+@pytest.mark.usefixtures("devnet_with_account")
+def test_add_invoke_transaction():
     """
     Add invoke transaction
     """
-    resp = rpc_call(
-        "starknet_addInvokeTransaction",
-        params={
-            "function_invocation": {
-                "contract_address": pad_zero(invoke_content["contract_address"]),
-                "entry_point_selector": pad_zero(
-                    invoke_content["entry_point_selector"]
-                ),
-                "calldata": [
-                    pad_zero(hex(int(data))) for data in invoke_content["calldata"]
-                ],
-            },
-            "signature": [pad_zero(sig) for sig in invoke_content["signature"]],
-            "max_fee": hex(0),
-            "version": hex(SUPPORTED_RPC_TX_VERSION),
-        },
+    initial_balance, amount1, amount2 = 100, 13, 56
+    deploy_dict = deploy(CONTRACT_PATH, [str(initial_balance)])
+    contract_address = deploy_dict["address"]
+
+    calls = [(contract_address, "increase_balance", [amount1, amount2])]
+    signature, execute_calldata = _get_execute_args(
+        calls=calls,
+        account_address=PREDEPLOYED_ACCOUNT_ADDRESS,
+        private_key=PREDEPLOYED_ACCOUNT_PRIVATE_KEY,
+        nonce=0,
+        version=SUPPORTED_RPC_TX_VERSION,
+        max_fee=0,
     )
-    receipt = resp["result"]
-
-    assert set(receipt.keys()) == {"transaction_hash"}
-    assert receipt["transaction_hash"][:3] == "0x0"
 
+    invoke_transaction = RpcBroadcastedInvokeTxnV1(
+        type="INVOKE",
+        max_fee=rpc_felt(0),
+        version=hex(SUPPORTED_RPC_TX_VERSION),
+        signature=[rpc_felt(sig) for sig in signature],
+        nonce=rpc_felt(get_nonce(PREDEPLOYED_ACCOUNT_ADDRESS)),
+        sender_address=rpc_felt(PREDEPLOYED_ACCOUNT_ADDRESS),
+        calldata=[rpc_felt(data) for data in execute_calldata],
+    )
 
-@pytest.mark.usefixtures("run_devnet_in_background")
-def test_add_invoke_transaction_v1(invoke_content_v1):
-    """
-    Add invoke transaction
-    """
     resp = rpc_call(
         "starknet_addInvokeTransaction",
-        params={
-            "function_invocation": {
-                "contract_address": pad_zero(invoke_content_v1["contract_address"]),
-                "calldata": [
-                    pad_zero(hex(int(data))) for data in invoke_content_v1["calldata"]
-                ],
-            },
-            "signature": [pad_zero(sig) for sig in invoke_content_v1["signature"]],
-            "max_fee": hex(2),
-            "version": hex(1),
-            "nonce": hex(1),
-        },
+        params={"invoke_transaction": invoke_transaction},
     )
     receipt = resp["result"]
 
+    storage = gateway_call(
+        "get_storage_at",
+        contractAddress=contract_address,
+        key=hex(get_storage_var_address("balance")),
+    )
+
     assert set(receipt.keys()) == {"transaction_hash"}
-    assert receipt["transaction_hash"][:3] == "0x0"
+    assert is_felt(receipt["transaction_hash"])
+    assert storage == hex(initial_balance + amount1 + amount2)
 
 
 @pytest.mark.usefixtures("run_devnet_in_background")
-def test_add_invoke_transaction_positional_args(invoke_content):
-    """
-    Add invoke transaction
-    """
+def test_add_invoke_transaction_v0():
+    """
+    Add invoke transaction with tx v0
+    """
+    initial_balance, amount1, amount2 = 100, 13, 56
+    deploy_dict = deploy(CONTRACT_PATH, [str(initial_balance)])
+    contract_address = deploy_dict["address"]
+
+    invoke_transaction = RpcBroadcastedInvokeTxnV0(
+        type="INVOKE",
+        max_fee=rpc_felt(0),
+        version=hex(LEGACY_RPC_TX_VERSION),
+        signature=[],
+        nonce=None,
+        contract_address=rpc_felt(contract_address),
+        entry_point_selector=rpc_felt(get_selector_from_name("increase_balance")),
+        calldata=[rpc_felt(amount1), rpc_felt(amount2)],
+    )
+
     resp = rpc_call(
         "starknet_addInvokeTransaction",
-        params=[
-            {
-                "contract_address": pad_zero(invoke_content["contract_address"]),
-                "entry_point_selector": pad_zero(
-                    invoke_content["entry_point_selector"]
-                ),
-                "calldata": [
-                    pad_zero(hex(int(data))) for data in invoke_content["calldata"]
-                ],
-            },
-            [pad_zero(sig) for sig in invoke_content["signature"]],
-            hex(0),
-            hex(SUPPORTED_RPC_TX_VERSION),
-        ],
+        params={"invoke_transaction": invoke_transaction},
     )
     receipt = resp["result"]
 
+    storage = gateway_call(
+        "get_storage_at",
+        contractAddress=contract_address,
+        key=hex(get_storage_var_address("balance")),
+    )
+
     assert set(receipt.keys()) == {"transaction_hash"}
-    assert receipt["transaction_hash"][:3] == "0x0"
+    assert is_felt(receipt["transaction_hash"])
+    assert storage == hex(initial_balance + amount1 + amount2)
 
 
 @pytest.mark.usefixtures("run_devnet_in_background")
@@ -374,49 +433,111 @@ def test_add_declare_transaction_on_incorrect_contract(declare_content):
     Add declare transaction on incorrect class
     """
     contract_class = declare_content["contract_class"]
-    pad_zero_external_entry_points(contract_class=contract_class)
+    pad_zero_entry_points(contract_class["entry_points_by_type"])
 
-    rpc_contract = RpcContractClass(
+    rpc_contract_class = RpcContractClass(
         program="",
         entry_points_by_type=contract_class["entry_points_by_type"],
+        abi=contract_class["abi"],
+    )
+
+    declare_transaction = RpcBroadcastedDeclareTxn(
+        type=declare_content["type"],
+        max_fee=rpc_felt(declare_content["max_fee"]),
+        version=hex(SUPPORTED_RPC_TX_VERSION),
+        signature=[rpc_felt(sig) for sig in declare_content["signature"]],
+        nonce=rpc_felt(declare_content["nonce"]),
+        contract_class=rpc_contract_class,
+        sender_address=rpc_felt(declare_content["sender_address"]),
     )
 
     ex = rpc_call(
         "starknet_addDeclareTransaction",
-        params={
-            "contract_class": rpc_contract,
-            "version": hex(SUPPORTED_RPC_TX_VERSION),
-        },
+        params={"declare_transaction": declare_transaction},
     )
 
     assert ex["error"] == {"code": 50, "message": "Invalid contract class"}
 
 
-@pytest.mark.usefixtures("run_devnet_in_background")
+@pytest.mark.usefixtures("devnet_with_account")
 def test_add_declare_transaction(declare_content):
     """
     Add declare transaction
     """
     contract_class = declare_content["contract_class"]
-    pad_zero_external_entry_points(contract_class=contract_class)
+    pad_zero_entry_points(contract_class["entry_points_by_type"])
 
-    rpc_contract = RpcContractClass(
+    rpc_contract_class = RpcContractClass(
         program=contract_class["program"],
         entry_points_by_type=contract_class["entry_points_by_type"],
+        abi=contract_class["abi"],
+    )
+
+    nonce = get_nonce(PREDEPLOYED_ACCOUNT_ADDRESS)
+    tx_hash = calculate_declare_transaction_hash(
+        contract_class=load_contract_class(CONTRACT_PATH),
+        chain_id=StarknetChainId.TESTNET.value,
+        sender_address=int(PREDEPLOYED_ACCOUNT_ADDRESS, 16),
+        max_fee=0,
+        nonce=nonce,
+        version=SUPPORTED_RPC_TX_VERSION,
+    )
+    signature = _get_signature(tx_hash, PREDEPLOYED_ACCOUNT_PRIVATE_KEY)
+
+    declare_transaction = RpcBroadcastedDeclareTxn(
+        type=declare_content["type"],
+        max_fee=rpc_felt(declare_content["max_fee"]),
+        version=hex(SUPPORTED_RPC_TX_VERSION),
+        signature=[rpc_felt(sig) for sig in signature],
+        nonce=rpc_felt(nonce),
+        contract_class=rpc_contract_class,
+        sender_address=rpc_felt(PREDEPLOYED_ACCOUNT_ADDRESS),
     )
 
     resp = rpc_call(
         "starknet_addDeclareTransaction",
-        params={
-            "contract_class": rpc_contract,
-            "version": hex(SUPPORTED_RPC_TX_VERSION),
-        },
+        params={"declare_transaction": declare_transaction},
+    )
+    receipt = resp["result"]
+
+    assert set(receipt.keys()) == set(["transaction_hash", "class_hash"])
+    assert is_felt(receipt["transaction_hash"])
+    assert is_felt(receipt["class_hash"])
+
+
+@pytest.mark.usefixtures("run_devnet_in_background")
+def test_add_declare_transaction_v0(declare_content):
+    """
+    Add declare transaction with tx v0
+    """
+    contract_class = declare_content["contract_class"]
+    pad_zero_entry_points(contract_class["entry_points_by_type"])
+
+    rpc_contract_class = RpcContractClass(
+        program=contract_class["program"],
+        entry_points_by_type=contract_class["entry_points_by_type"],
+        abi=contract_class["abi"],
+    )
+
+    declare_transaction = RpcBroadcastedDeclareTxn(
+        type=declare_content["type"],
+        max_fee=rpc_felt(declare_content["max_fee"]),
+        version=hex(LEGACY_RPC_TX_VERSION),
+        signature=[],
+        nonce=rpc_felt(0),
+        contract_class=rpc_contract_class,
+        sender_address=rpc_felt(1),
+    )
+
+    resp = rpc_call(
+        "starknet_addDeclareTransaction",
+        params={"declare_transaction": declare_transaction},
     )
     receipt = resp["result"]
 
     assert set(receipt.keys()) == set(["transaction_hash", "class_hash"])
-    assert receipt["transaction_hash"][:3] == "0x0"
-    assert receipt["class_hash"][:3] == "0x0"
+    assert is_felt(receipt["transaction_hash"])
+    assert is_felt(receipt["class_hash"])
 
 
 @pytest.mark.usefixtures("run_devnet_in_background")
@@ -425,53 +546,64 @@ def test_add_deploy_transaction_on_incorrect_contract(deploy_content):
     Add deploy transaction on incorrect class
     """
     contract_definition = deploy_content["contract_definition"]
-    salt = deploy_content["contract_address_salt"]
-    calldata = [rpc_felt(int(data)) for data in deploy_content["constructor_calldata"]]
-    pad_zero_external_entry_points(contract_class=contract_definition)
+    salt = rpc_felt(deploy_content["contract_address_salt"])
+    calldata = [rpc_felt(data) for data in deploy_content["constructor_calldata"]]
+    pad_zero_entry_points(contract_definition["entry_points_by_type"])
 
-    rpc_contract = RpcContractClass(
+    rpc_contract_class = RpcContractClass(
         program="",
         entry_points_by_type=contract_definition["entry_points_by_type"],
+        abi=contract_definition["abi"],
+    )
+
+    deploy_transaction = RpcBroadcastedDeployTxn(
+        contract_class=rpc_contract_class,
+        version=hex(SUPPORTED_RPC_TX_VERSION),
+        type=deploy_content["type"],
+        contract_address_salt=salt,
+        constructor_calldata=calldata,
     )
 
     ex = rpc_call(
         "starknet_addDeployTransaction",
-        params={
-            "contract_address_salt": pad_zero(salt),
-            "constructor_calldata": calldata,
-            "contract_definition": rpc_contract,
-        },
+        params={"deploy_transaction": deploy_transaction},
     )
 
     assert ex["error"] == {"code": 50, "message": "Invalid contract class"}
 
 
 @pytest.mark.usefixtures("run_devnet_in_background")
-def test_add_deploy_transaction(deploy_content):
+@pytest.mark.parametrize("version", [LEGACY_RPC_TX_VERSION, SUPPORTED_RPC_TX_VERSION])
+def test_add_deploy_transaction(deploy_content, version):
     """
     Add deploy transaction
     """
     contract_definition = deploy_content["contract_definition"]
-    salt = deploy_content["contract_address_salt"]
-    calldata = [rpc_felt(int(data)) for data in deploy_content["constructor_calldata"]]
-    pad_zero_external_entry_points(contract_class=contract_definition)
+    pad_zero_entry_points(contract_definition["entry_points_by_type"])
+    salt = rpc_felt(deploy_content["contract_address_salt"])
+    calldata = [rpc_felt(data) for data in deploy_content["constructor_calldata"]]
 
-    rpc_contract = RpcContractClass(
+    rpc_contract_class = RpcContractClass(
         program=contract_definition["program"],
         entry_points_by_type=contract_definition["entry_points_by_type"],
+        abi=contract_definition["abi"],
+    )
+
+    deploy_transaction = RpcBroadcastedDeployTxn(
+        contract_class=rpc_contract_class,
+        version=hex(version),
+        type=deploy_content["type"],
+        contract_address_salt=salt,
+        constructor_calldata=calldata,
     )
 
     resp = rpc_call(
         "starknet_addDeployTransaction",
-        params={
-            "contract_address_salt": pad_zero(salt),
-            "constructor_calldata": calldata,
-            "contract_definition": rpc_contract,
-        },
+        params={"deploy_transaction": deploy_transaction},
     )
     receipt = resp["result"]
 
     assert set(receipt.keys()) == set(["transaction_hash", "contract_address"])
 
-    assert receipt["transaction_hash"][:3] == "0x0"
-    assert receipt["contract_address"][:3] == "0x0"
+    assert is_felt(receipt["transaction_hash"])
+    assert is_felt(receipt["contract_address"])
diff --git a/test/shared.py b/test/shared.py
index 2a75abde9..61150aea0 100644
--- a/test/shared.py
+++ b/test/shared.py
@@ -50,8 +50,10 @@
 INCORRECT_GENESIS_BLOCK_HASH = "0x1"
 DEFAULT_GAS_PRICE = int(1e11)
 
+LEGACY_RPC_TX_VERSION = 0
+
 SUPPORTED_TX_VERSION = 1
-SUPPORTED_RPC_TX_VERSION = 0
+SUPPORTED_RPC_TX_VERSION = 1
 
 PREDEPLOY_ACCOUNT_CLI_ARGS = ("--seed", "42", "--accounts", "1")
 PREDEPLOYED_ACCOUNT_ADDRESS = (