Using different signing methods#

By default, an Account uses the signing method of OpenZeppelin’s account contract. If for any reason you want to use a different signing algorithm, it is possible to create Account with custom Signer implementation.

from import Account
from import FullNodeClient
from import StarknetChainId, Transaction
from import BaseSigner
from starknet_py.utils.typed_data import TypedData

# Create a custom signer class implementing BaseSigner interface
class CustomSigner(BaseSigner):
    def public_key(self) -> int:
        return 0x123

    def sign_transaction(self, transaction: Transaction) -> List[int]:
        return [0x0, 0x1]

    def sign_message(
        self, typed_data: TypedData, account_address: int
    ) -> List[int]:
        return [0x0, 0x1]

# Create an Account instance with the signer you've implemented
custom_signer = CustomSigner()
client = FullNodeClient(node_url="your.node.url")
account = Account(
# Now you can use Account as you'd always do

Signing off-chain messages#

Account lets you sign an off-chain message by using encoding standard proposed here. You can also verify a message, which is done by a call to is_valid_signature endpoint in the account’s contract (e.g. OpenZeppelin’s account contract).

from import Account
from import FullNodeClient
from import StarknetChainId
from import KeyPair
from starknet_py.utils.typed_data import TypedData

# Create a TypedData dictionary
typed_data = {
    "types": {
        "StarkNetDomain": [
            {"name": "name", "type": "felt"},
            {"name": "version", "type": "felt"},
            {"name": "chainId", "type": "felt"},
        "Person": [
            {"name": "name", "type": "felt"},
            {"name": "wallet", "type": "felt"},
        "Mail": [
            {"name": "from", "type": "Person"},
            {"name": "to", "type": "Person"},
            {"name": "contents", "type": "felt"},
    "primaryType": "Mail",
    "domain": {"name": "StarkNet Mail", "version": "1", "chainId": 1},
    "message": {
        "from": {
            "name": "Cow",
            "wallet": "0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826",
        "to": {
            "name": "Bob",
            "wallet": "0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB",
        "contents": "Hello, Bob!",

# Create an Account instance
client = FullNodeClient(node_url="your.node.url")
account = Account(
    key_pair=KeyPair(private_key=123, public_key=456),

# Sign the message
signature = account.sign_message(typed_data=typed_data)

# Verify the message
verify_result = account.verify_message(typed_data=typed_data, signature=signature)

# Or if just a message hash is needed
data = TypedData.from_dict(typed_data)
message_hash = data.message_hash(account.address)

Signing for fee estimation#

Account allows signing transactions for the purpose of fee estimation. Transactions signed for fee estimation use a transaction version that makes them non-executable on Starknet. If a transaction like this was to be intercepted in transport, it could not be executed without the user consent.


Conventionally signed transactions can still be used to estimate fee. They however don’t offer the extra security of signing specifically for the purpose of fee estimation.

When manually estimating fee for transactions, always prefer estimation specific signing.

# Create a transaction
call = map_contract.functions["put"].prepare_invoke_v1(key=10, value=20)
transaction = await account.sign_invoke_v1(calls=call, max_fee=0)

# Re-sign a transaction for fee estimation
estimate_transaction = await account.sign_for_fee_estimate(transaction)

# Transaction uses a version that cannot be executed on Starknet
assert estimate_transaction.version == 1 + 2**128
assert estimate_transaction.signature != transaction.signature

# Get a fee estimation
estimate = await account.client.estimate_fee(transaction)
assert estimate.overall_fee > 0

# Use a new fee in original transaction
transaction = await account.sign_invoke_v1(calls=call, max_fee=estimate.overall_fee)

# Send a transaction
result = await account.client.send_transaction(transaction)
await account.client.wait_for_tx(result.transaction_hash)