Support RPC v0.2.1

page/docs/guide/json-rpc-api.md

@@ -4,7 +4,7 @@ sidebar_position: 3
 
 # JSON-RPC API
 
-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:
+Devnet also supports JSON-RPC API v0.2.1: [specifications](https://github.com/starkware-libs/starknet-specs/releases/tag/v0.2.1) . It can be reached under `/rpc`. For an example:
 
 ```
 POST /rpc

starknet_devnet/blueprints/rpc/routes.py

@@ -36,6 +36,7 @@
  add_invoke_transaction,
  add_declare_transaction,
  add_deploy_transaction,
+ add_deploy_account_transaction,
 )
 from starknet_devnet.blueprints.rpc.utils import rpc_response, rpc_error
 from starknet_devnet.blueprints.rpc.structures.types import RpcError, RpcErrorCode
@@ -64,6 +65,7 @@
  "addInvokeTransaction": add_invoke_transaction,
  "addDeclareTransaction": add_declare_transaction,
  "addDeployTransaction": add_deploy_transaction,
+ "addDeployAccountTransaction": add_deploy_account_transaction,
 }
 
 rpc = Blueprint("rpc", __name__, url_prefix="/rpc")

starknet_devnet/blueprints/rpc/structures/payloads.py

@@ -21,11 +21,13 @@
  DeclareSpecificInfo,
  L1HandlerSpecificInfo,
  FeeEstimationInfo,
+ DeployAccountSpecificInfo,
 )
 from starkware.starknet.services.api.gateway.transaction import (
  InvokeFunction,
  Declare,
  Deploy,
+ DeployAccount,
 )
 from starkware.starknet.services.api.gateway.transaction_utils import (
  compress_program,
@@ -153,9 +155,20 @@ class RpcBroadcastedDeployTxn(TypedDict):
  constructor_calldata: List[Felt]
 
 
+class RpcBroadcastedDeployAccountTxn(RpcBroadcastedTxnCommon):
+ """TypedDict for BroadcastedDeployAccountTxn"""
+
+ contract_address_salt: Felt
+ constructor_calldata: List[Felt]
+ class_hash: Felt
+
+
 # rpc transaction's representation when it's sent to the sequencer (but not yet in a block)
 RpcBroadcastedTxn = Union[
- RpcBroadcastedDeployTxn, RpcBroadcastedDeclareTxn, RpcBroadcastedInvokeTxn
+ RpcBroadcastedDeployTxn,
+ RpcBroadcastedDeclareTxn,
+ RpcBroadcastedInvokeTxn,
+ RpcBroadcastedDeployAccountTxn,
 ]
 
 
@@ -210,12 +223,21 @@ class RpcDeployTransaction(TypedDict):
  constructor_calldata: List[Felt]
 
 
+class RpcDeployAccountTransaction(RpcTransactionCommon):
+ """TypedDict for rpc deploy account transaction"""
+
+ contract_address_salt: Felt
+ constructor_calldata: List[Felt]
+ class_hash: Felt
+
+
 RpcTransaction = Union[
  RpcInvokeTransactionV0,
  RpcInvokeTransactionV1,
  RpcL1HandlerTransaction,
  RpcDeclareTransaction,
  RpcDeployTransaction,
+ RpcDeployAccountTransaction,
 ]
 
 
@@ -226,6 +248,7 @@ def rpc_transaction(transaction: TransactionSpecificInfo) -> RpcTransaction:
  TransactionType.INVOKE_FUNCTION: rpc_invoke_transaction,
  TransactionType.DECLARE: rpc_declare_transaction,
  TransactionType.L1_HANDLER: rpc_l1_handler_transaction,
+ TransactionType.DEPLOY_ACCOUNT: rpc_deploy_account_transaction,
  }
  return tx_mapping[transaction.tx_type](transaction)
 
@@ -314,6 +337,28 @@ def rpc_deploy_transaction(transaction: DeploySpecificInfo) -> RpcDeployTransact
  return txn
 
 
+def rpc_deploy_account_transaction(
+ transaction: DeployAccountSpecificInfo,
+) -> RpcDeployAccountTransaction:
+ """
+ Convert gateway deploy account transaction to rpc format
+ """
+ txn: RpcDeployAccountTransaction = {
+ "contract_address_salt": rpc_felt(transaction.contract_address_salt),
+ "constructor_calldata": [
+ rpc_felt(data) for data in transaction.constructor_calldata
+ ],
+ "class_hash": rpc_felt(transaction.class_hash),
+ "transaction_hash": rpc_felt(transaction.transaction_hash),
+ "type": rpc_txn_type(transaction.tx_type.name),
+ "max_fee": rpc_felt(transaction.max_fee),
+ "version": hex(transaction.version),
+ "signature": [rpc_felt(value) for value in transaction.signature],
+ "nonce": rpc_felt(transaction.nonce),
+ }
+ return txn
+
+
 def rpc_l1_handler_transaction(
  transaction: L1HandlerSpecificInfo,
 ) -> RpcL1HandlerTransaction:
@@ -438,6 +483,28 @@ def make_deploy(deploy_transaction: RpcDeployTransaction) -> Deploy:
  return deploy_tx
 
 
+def make_deploy_account(
+ deploy_account_transaction: RpcDeployAccountTransaction,
+) -> DeployAccount:
+ """
+ Convert RpcDeployAccountTransaction to DeployAccount
+ """
+ deploy_account_tx = DeployAccount(
+ class_hash=int(deploy_account_transaction["class_hash"], 16),
+ contract_address_salt=int(
+ deploy_account_transaction["contract_address_salt"], 16
+ ),
+ constructor_calldata=[
+ int(data, 16) for data in deploy_account_transaction["constructor_calldata"]
+ ],
+ version=int(deploy_account_transaction["version"], 16),
+ nonce=int(deploy_account_transaction["nonce"], 16),
+ max_fee=int(deploy_account_transaction["max_fee"], 16),
+ signature=[int(sig, 16) for sig in deploy_account_transaction["signature"]],
+ )
+ return deploy_account_tx
+
+
 class EntryPoint(TypedDict):
  """TypedDict for rpc contract class entry point"""
 
@@ -543,20 +610,15 @@ 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,
+ "constructor": function_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)
 
 

starknet_devnet/blueprints/rpc/structures/responses.py

@@ -44,6 +44,13 @@ class RpcDeployTransactionResult(TypedDict):
  contract_address: Felt
 
 
+class RpcDeployAccountTransactionResult(TypedDict):
+ """TypedDict for rpc deploy account transaction result"""
+
+ transaction_hash: TxnHash
+ contract_address: Felt
+
+
 class MessageToL1(TypedDict):
  """TypedDict for rpc message from l2 to l1"""
 
@@ -87,28 +94,34 @@ class RpcBaseTransactionReceipt(TypedDict):
 
 
 class RpcDeployReceipt(RpcBaseTransactionReceipt):
- """TypedDict for rpc declare transaction receipt"""
+ """TypedDict for rpc deploy transaction receipt"""
+
+ contract_address: Felt
+
+
+class RpcDeployAccountReceipt(RpcBaseTransactionReceipt):
+ """TypedDict for rpc deploy account transaction receipt"""
 
  contract_address: Felt
 
 
 def rpc_invoke_receipt(txr: TransactionReceipt) -> RpcInvokeReceipt:
  """
- Convert rpc invoke transaction receipt to rpc format
+ Convert gateway invoke transaction receipt to rpc format
  """
  return rpc_base_transaction_receipt(txr)
 
 
 def rpc_declare_receipt(txr: TransactionReceipt) -> RpcDeclareReceipt:
  """
- Convert rpc declare transaction receipt to rpc format
+ Convert gateway declare transaction receipt to rpc format
  """
  return rpc_base_transaction_receipt(txr)
 
 
 def rpc_deploy_receipt(txr: TransactionReceipt) -> RpcDeployReceipt:
  """
- Convert rpc deploy transaction receipt to rpc format
+ Convert gateway deploy transaction receipt to rpc format
  """
  base_receipt = rpc_base_transaction_receipt(txr)
  transaction = state.starknet_wrapper.transactions.get_transaction(
@@ -122,9 +135,16 @@ def rpc_deploy_receipt(txr: TransactionReceipt) -> RpcDeployReceipt:
  return receipt
 
 
+def rpc_deploy_account_receipt(txr: TransactionReceipt) -> RpcDeployAccountReceipt:
+ """
+ Convert gateway deploy account transaction receipt to rpc format
+ """
+ return rpc_deploy_receipt(txr)
+
+
 def rpc_l1_handler_receipt(txr: TransactionReceipt) -> RpcL1HandlerReceipt:
  """
- Convert rpc l1 handler transaction receipt to rpc format
+ Convert gateway l1 handler transaction receipt to rpc format
  """
  return rpc_base_transaction_receipt(txr)
 
@@ -196,6 +216,7 @@ def rpc_transaction_receipt(txr: TransactionReceipt) -> dict:
  TransactionType.INVOKE_FUNCTION: rpc_invoke_receipt,
  TransactionType.DECLARE: rpc_declare_receipt,
  TransactionType.L1_HANDLER: rpc_l1_handler_receipt,
+ TransactionType.DEPLOY_ACCOUNT: rpc_deploy_account_receipt,
  }
  transaction = state.starknet_wrapper.transactions.get_transaction(
  hex(txr.transaction_hash)

starknet_devnet/blueprints/rpc/structures/types.py

@@ -55,9 +55,7 @@ def rpc_block_status(block_status: str) -> RpcBlockStatus:
 Address = Felt
 NumAsHex = str
 
-# Pending transactions will not be supported since it
-# doesn't make much sense with the current implementation of devnet
-RpcTxnType = Literal["DECLARE", "DEPLOY", "INVOKE", "L1_HANDLER"]
+RpcTxnType = Literal["DECLARE", "DEPLOY", "INVOKE", "L1_HANDLER", "DEPLOY_ACCOUNT"]
 
 
 def rpc_txn_type(transaction_type: str) -> RpcTxnType:
@@ -69,6 +67,7 @@ def rpc_txn_type(transaction_type: str) -> RpcTxnType:
  TransactionType.DECLARE.name: "DECLARE",
  TransactionType.INVOKE_FUNCTION.name: "INVOKE",
  TransactionType.L1_HANDLER.name: "L1_HANDLER",
+ TransactionType.DEPLOY_ACCOUNT.name: "DEPLOY_ACCOUNT",
  }
  if transaction_type not in txn_type_map:
  raise RpcError(

starknet_devnet/blueprints/rpc/transactions.py

@@ -23,12 +23,15 @@
  RpcBroadcastedTxn,
  make_declare,
  make_deploy,
+ make_deploy_account,
+ RpcBroadcastedDeployAccountTxn,
 )
 from starknet_devnet.blueprints.rpc.structures.responses import (
  rpc_transaction_receipt,
  RpcInvokeTransactionResult,
  RpcDeclareTransactionResult,
  RpcDeployTransactionResult,
+ RpcDeployAccountTransactionResult,
 )
 from starknet_devnet.blueprints.rpc.structures.types import (
  TxnHash,
@@ -143,6 +146,33 @@ async def add_deploy_transaction(deploy_transaction: RpcBroadcastedDeployTxn) ->
  )
 
 
+async def add_deploy_account_transaction(
+ deploy_account_transaction: RpcBroadcastedDeployAccountTxn,
+) -> dict:
+ """
+ Submit a new deploy account transaction
+ """
+ deploy_account_tx = make_deploy_account(deploy_account_transaction)
+
+ contract_address, transaction_hash = await state.starknet_wrapper.deploy_account(
+ external_tx=deploy_account_tx
+ )
+
+ status_response = state.starknet_wrapper.transactions.get_transaction_status(
+ hex(transaction_hash)
+ )
+ if (
+ status_response["tx_status"] == "REJECTED"
+ and "is not declared" in status_response["tx_failure_reason"].error_message
+ ):
+ raise RpcError(code=28, message="Class hash not found")
+
+ return RpcDeployAccountTransactionResult(
+ transaction_hash=rpc_felt(transaction_hash),
+ contract_address=rpc_felt(contract_address),
+ )
+
+
 def make_transaction(txn: RpcBroadcastedTxn) -> AccountTransaction:
  """
  Convert RpcBroadcastedTxn to AccountTransaction
@@ -154,6 +184,8 @@ def make_transaction(txn: RpcBroadcastedTxn) -> AccountTransaction:
  return make_declare(txn)
  if txn_type == "DEPLOY":
  return make_deploy(txn)
+ if txn_type == "DEPLOY_ACCOUNT":
+ return make_deploy_account(txn)
  raise NotImplementedError(f"Unexpected type {txn_type}.")