> ## Documentation Index
> Fetch the complete documentation index at: https://docs.dune.com/llms.txt
> Use this file to discover all available pages before exploring further.

# starknet.calls

> StarkNet internal calls — function call traces within StarkNet transaction execution.

export const TableSample = ({tableName, tableSchema}) => <>
    <div className="hidden dark:block">
      <iframe src={`https://dune.com/embeds/3419983/5785629?table_schema_t6f0df=${tableSchema}&table_name_t6f0df=${tableName}&darkMode=true`} style={{
  width: '100%',
  height: '500px',
  border: 'none',
  marginTop: '10px'
}} />
    </div>
    <div className="dark:hidden">
      <iframe src={`https://dune.com/embeds/3419983/5785629?table_schema_t6f0df=${tableSchema}&table_name_t6f0df=${tableName}`} style={{
  width: '100%',
  height: '500px',
  border: 'none',
  marginTop: '10px'
}} />
    </div>
  </>;

## Table description

The `starknet.calls` table documents the execution trace of the transaction designated by the input hash.

## Table Schema

| Column                                                 | Type                                                                                                 | Description                                                                                    |
| ------------------------------------------------------ | ---------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------- |
| `block_date`                                           | `DATE`                                                                                               | The date of the block containing this call (UTC)                                               |
| `block_time`                                           | `TIMESTAMP`                                                                                          | The timestamp of the block containing this call                                                |
| `block_number`                                         | `BIGINT`                                                                                             | The sequential number of the block containing this call                                        |
| `block_l1_da_mode`                                     | `VARCHAR`                                                                                            | Layer 1 data availability mode (`BLOB` or `CALLDATA`)                                          |
| `block_l1_data_gas_price_in_fri`                       | `UINT256`                                                                                            | L1 data gas price in fri (STRK) for the block                                                  |
| `block_l1_data_gas_price_in_wei`                       | `UINT256`                                                                                            | L1 data gas price in wei (ETH) for the block                                                   |
| `block_l1_gas_price_in_fri`                            | `UINT256`                                                                                            | L1 gas price in fri (STRK) for the block                                                       |
| `block_l1_gas_price_in_wei`                            | `UINT256`                                                                                            | L1 gas price in wei (ETH) for the block                                                        |
| `block_l2_gas_price_in_fri`                            | `UINT256`                                                                                            | L2 gas price in fri (STRK) for the block                                                       |
| `block_l2_gas_price_in_wei`                            | `UINT256`                                                                                            | L2 gas price in wei (ETH) for the block                                                        |
| `block_starknet_version`                               | `VARCHAR`                                                                                            | The Starknet protocol version of the block                                                     |
| `transaction_index`                                    | `INTEGER`                                                                                            | Position of the parent transaction within the block                                            |
| `transaction_type`                                     | `VARCHAR`                                                                                            | Type of the parent transaction (`INVOKE`, `L1_HANDLER`, `DECLARE`, `DEPLOY_ACCOUNT`, `DEPLOY`) |
| `call_type`                                            | `VARCHAR`                                                                                            | Type of function call (`CALL`, `LIBRARY_CALL`, or `DELEGATE`)                                  |
| `context`                                              | `VARCHAR`                                                                                            | Execution context of the call                                                                  |
| `entry_point_type`                                     | `VARCHAR`                                                                                            | Type of entry point invoked (`EXTERNAL`, `L1_HANDLER`, `CONSTRUCTOR`)                          |
| `execution_resources_bitwise_builtin_applications`     | `INTEGER`                                                                                            | Number of bitwise builtin applications consumed                                                |
| `execution_resources_data_availability_l1_gas`         | `UINT256`                                                                                            | L1 gas consumed for data availability                                                          |
| `execution_resources_data_availability_l1_data_gas`    | `UINT256`                                                                                            | L1 data gas consumed for data availability                                                     |
| `execution_resources_data_availability_l2_gas`         | `UINT256`                                                                                            | L2 gas consumed for data availability                                                          |
| `execution_resources_ec_op_builtin_applications`       | `INTEGER`                                                                                            | Number of elliptic curve operation builtin applications consumed                               |
| `execution_resources_ecdsa_builtin_applications`       | `INTEGER`                                                                                            | Number of ECDSA builtin applications consumed                                                  |
| `execution_resources_keccak_builtin_applications`      | `INTEGER`                                                                                            | Number of Keccak builtin applications consumed                                                 |
| `execution_resources_memory_holes`                     | `INTEGER`                                                                                            | Number of memory holes in the execution trace                                                  |
| `execution_resources_pedersen_builtin_applications`    | `INTEGER`                                                                                            | Number of Pedersen hash builtin applications consumed                                          |
| `execution_resources_poseidon_builtin_applications`    | `INTEGER`                                                                                            | Number of Poseidon hash builtin applications consumed                                          |
| `execution_resources_range_check_builtin_applications` | `INTEGER`                                                                                            | Number of range check builtin applications consumed                                            |
| `execution_resources_segment_arena_builtin`            | `INTEGER`                                                                                            | Number of segment arena builtin applications consumed                                          |
| `execution_resources_steps`                            | `INTEGER`                                                                                            | Total number of Cairo VM steps executed                                                        |
| `num_subcalls`                                         | `INTEGER`                                                                                            | Number of nested sub-calls triggered by this call                                              |
| `block_hash`                                           | `VARBINARY`                                                                                          | Hash of the block containing this call                                                         |
| `block_new_root`                                       | `VARBINARY`                                                                                          | New global state root after the block                                                          |
| `block_parent_hash`                                    | `VARBINARY`                                                                                          | Hash of the preceding block                                                                    |
| `block_sequencer_address`                              | `VARBINARY`                                                                                          | Address of the sequencer that produced the block                                               |
| `transaction_hash`                                     | `VARBINARY`                                                                                          | Hash of the parent transaction                                                                 |
| `callstack_index`                                      | `ARRAY(INTEGER)`                                                                                     | Position in the call tree hierarchy                                                            |
| `calldata`                                             | `ARRAY(VARBINARY)`                                                                                   | Input data passed to this call                                                                 |
| `caller_address`                                       | `VARBINARY`                                                                                          | Address of the contract that initiated this call                                               |
| `class_hash`                                           | `VARBINARY`                                                                                          | Class hash of the called contract                                                              |
| `contract_address`                                     | `VARBINARY`                                                                                          | Address of the contract being called                                                           |
| `entry_point_selector`                                 | `VARBINARY`                                                                                          | Selector identifying the function entry point                                                  |
| `events`                                               | `ARRAY(ROW(DATA ARRAY(VARCHAR), KEYS ARRAY(VARCHAR), EVENT_INDEX INTEGER))`                          | Events emitted during this call                                                                |
| `messages`                                             | `ARRAY(ROW(FROM_ADDRESS VARBINARY, PAYLOAD VARBINARY, TO_ADDRESS VARBINARY, MESSAGE_INDEX INTEGER))` | L2-to-L1 messages sent during this call                                                        |
| `result`                                               | `VARBINARY`                                                                                          | Return value of the call                                                                       |
| `revert_reason`                                        | `VARCHAR`                                                                                            | Reason for call failure, if the call reverted                                                  |
| `state_diff`                                           | `VARCHAR`                                                                                            | JSON-encoded state changes resulting from this call                                            |

<Note>
  * Prior to [v3 transactions upgrade](https://www.starknet.io/developers/roadmap/v3-transactions/), fees are denominated in `wei` as users pay gas with ETH. For transactions v3 and later, fees are denominated in `fri` as users pay gas with STRK. Hence here you can see two gas types of gas fields, one for `wei` and one for `fri`.
  * Starting with Starknet v0.13.1, Starknet distinguishes between blocks whose state diffs are sent to L1 as calldata and blocks whose state diffs are sent to L1 as blobs. The `l1_da_mode` property in the Starknet block header contains this information. Values possible are `BLOB` or `CALLDATA`.
  * The `block_status` has possible values `ACCEPTED_ON_L1` or `ACCEPTED_ON_L2`. Read here to learn more about [different transaction status](https://docs.starknet.io/architecture-and-concepts/network-architecture/transaction-life-cycle/#transaction_status).
  * The `transaction_type` fields denotes [different types of transactions](https://docs.starknet.io/architecture-and-concepts/network-architecture/transactions/) supported by Starknet. Possible values are: `INVOKE`, `L1_HANDLER`, `DECLARE`, `DEPLOY_ACCOUNT`, and `DEPLOY`.
  * The `call_type` fields denotes what type of function calls was invoked. Possible values are [`LIBRARY_CALL`](https://docs.starknet.io/architecture-and-concepts/smart-contracts/system-calls-cairo1/#library_call), `CALL`, or `DELEGATE`
  * 'entry\_point\_type': The type of entry point. Possible values includes - `EXTERNAL`, `L1_HANDLER`, `CONSTRUCTOR`
</Note>

## Table Sample

<TableSample tableSchema="starknet" tableName="calls" />
