> ## 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.

# near.function_call

> NEAR function call actions — contract method invocations with arguments.

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 `near.function_call` table contains flattened out details for records in the `actions` table of the `FUNCTION_CALL` type.

## Column Descriptions

| Column                             | Description                                                               | Type                        |
| ---------------------------------- | ------------------------------------------------------------------------- | --------------------------- |
| block\_date                        | The date of the block where the function call occurred.                   | date                        |
| block\_time                        | The time when the block containing the function call was produced.        | timestamp(3) with time zone |
| block\_height                      | The block height at the time of the function call.                        | bigint                      |
| block\_hash                        | The unique hash of the block containing the function call.                | varchar                     |
| chunk\_hash                        | The hash of the chunk where the function call is recorded.                | varchar                     |
| shard\_id                          | Shard ID where the function call was executed.                            | bigint                      |
| tx\_hash                           | The transaction hash containing the function call.                        | varchar                     |
| tx\_from                           | The account that initiated the function call.                             | varchar                     |
| tx\_to                             | The account receiving the function call.                                  | varchar                     |
| tx\_status                         | Status of the function call (success or failure).                         | varchar                     |
| call\_method\_name                 | The method being called in the function call.                             | varchar                     |
| args\_parsed                       | Parsed (decoded) arguments for the function call.                         | varchar                     |
| call\_gas                          | Gas attached to the function call.                                        | bigint                      |
| call\_deposit                      | Amount of NEAR tokens attached to the function call.                      | varchar                     |
| call\_args\_base64                 | Base64 encoded arguments of the function call.                            | varchar                     |
| index\_in\_action\_receipt         | The index of the function call within the receipt.                        | integer                     |
| receipt\_id                        | The receipt ID associated with the function call.                         | varchar                     |
| gas\_price                         | The gas price paid for executing the function call.                       | bigint                      |
| receipt\_predecessor\_account\_id  | The ID of the predecessor account for the receipt.                        | varchar                     |
| receipt\_receiver\_account\_id     | The ID of the receiver account for the receipt.                           | varchar                     |
| receipt\_conversion\_gas\_burnt    | The gas burnt during the conversion of the receipt.                       | bigint                      |
| receipt\_conversion\_tokens\_burnt | The amount of raw NEAR burnt during the conversion of the receipt.        | uint256                     |
| execution\_gas\_burnt              | Amount of gas burnt during the execution of the function call.            | bigint                      |
| execution\_tokens\_burnt           | Amount of raw NEAR token burnt during the execution of the function call. | uint256                     |
| execution\_status                  | The status of the execution outcome of the function call.                 | varchar                     |
| execution\_outcome\_receipt\_ids   | Array of receipt IDs created as a result of the function call.            | array(varchar)              |
| updated\_at                        | The time when this function call record was last updated.                 | timestamp(3) with time zone |
| ingested\_at                       | The time when this function call data was ingested into Dune.             | timestamp(3) with time zone |
| processed\_time                    | The time when the function call was processed.                            | timestamp(3) with time zone |

## Table Sample

<TableSample tableSchema="near" tableName="function_call" />

## Data Manipulation Tips

The `actions` data in NEAR can be complicated and nested, causing it hard to analyze sometimes. So here we give two examples on how to work array and json data to make it easier to analyze.

### Explode array of rows into separate rows with defined fields

When the action type is "DELEGATE\_ACTION", the `action_delegate_delegate_action_actions` becomes an array of size n with rows of fields. We can utilize `CROSS JOIN UNNEST` to first explode the array, then use `.` directly to access the fields in the row.

Reference query [can be found here](https://dune.com/queries/4078275?sidebar=none).

```sql theme={null}
with exploded as (
    select block_date
        , block_height as block_height_executed
        , tx_hash
        , receipt_id -- receipt for this action (there are many actions included in one txn)
        , execution_status
        
        , cardinality(action_delegate_delegate_action_actions) as delegated_action_size -- how many function calls are being delegated
        
        , action_delegate_delegate_action_sender_id as action_from 
        , action_delegate_delegate_action_receiver_id as action_to 
        
    
        -- Explode the array into rows
        , actions.value as action_data
        , actions.index as delegated_action_index
        , action_delegate_delegate_action_actions as raw_delegated_actions -- raw nested list of delegated actions
        
    /* explode by doing cross join unnest here*/    
    from near.actions CROSS JOIN UNNEST(action_delegate_delegate_action_actions) WITH ORDINALITY as actions(value, index)
    where action_kind = 'DELEGATE_ACTION'
        and cardinality(action_delegate_delegate_action_actions) >= 2
        and receipt_id = '6DB2AzkLXzoU9CMj9GKSZi7y8dGxVrqrbtBsfpLVQCQ8'
        and block_date = date('2024-09-17')
        and block_height = 128251854
)

select block_date
    , block_height_executed
    , tx_hash
    , receipt_id 
    , execution_status
    , delegated_action_size -- how many function calls are being delegated
    
    , action_from 
    , action_to 
    
    -- , typeof(action_data) -- row(args varchar, deposit varchar, gas bigint, method_name varchar)
    
    /* below is how you can access the delegated function call info */
    , action_data.args as function_call_args
    , action_data.deposit as function_call_deposit
    , action_data.gas as function_call_gas
    , action_data.method_name as function_call_method_name
    , delegated_action_index
    
    , raw_delegated_actions -- raw nested list of delegated actions
from exploded 

```

### Extract fields from JSON string

When the action type is "FUNCTION\_CALL", the `action_function_call_args_parsed` becomes a JSON string. We can utilize `json_extract` with `$.<field_name>` syntax to extract the fields from the JSON string.

Reference query [can be found here](https://dune.com/queries/4078309?sidebar=none).

```sql theme={null}
select block_date
    , block_height as block_height_executed
    , tx_hash
    , receipt_id -- receipt for this action (there are many actions included in one txn)
    , execution_status
    
    , receipt_predecessor_account_id as action_from
    , receipt_receiver_account_id as action_to
    
    -- , typeof(args_parsed) as data_type 
    /* This is how you can get fields within each parsed function call args 
        - first examine the fields in the args_parsed for the tye of method `call_method_name`
        - then parse accordingly
    */
    , json_extract(args_parsed, '$.receiver_id') AS receiver_id
    , json_extract(args_parsed, '$.amount') AS amount
    , json_extract(args_parsed, '$.memo') AS memo
    
    , call_method_name as call_method_name
    , args_parsed as raw_call_args
    , call_gas as call_gas
    , call_deposit as call_deposit
    , call_args_base64
    
    , *
from near.function_call -- near.actions
where 1=1
    and block_date = date('2023-09-15')
    and call_method_name = 'ft_transfer'
limit 10
```