Runtime API Not Being Called

Oct 13, 2025 by miodeya.com 15 views

Introduction

When working with Substrate, adding custom RPC calls can be a powerful way to extend the functionality of your node. However, issues can arise when the result of these custom RPC calls is not as expected. In this article, we will explore a specific issue where the result of a custom RPC call is replaced with default values, and we will delve into the possible causes and solutions.

The Issue

The issue at hand is with the userStorage_getValue RPC call, which is implemented in the UserStorageApi trait. The implementation clearly states that it should return a constant value, but instead, the result is empty, with only the default JSON RPC response: {"jsonrpc":"2.0","id":1,"result":""}. This is despite the presence of print statements that are not being executed.

The Code

Let's take a look at the relevant code snippets to understand the issue better.

UserStorageApi Trait

#[rpc(client, server)]
pub trait UserStorageApi<BlockHash> {
    #[method(name = "userStorage_getValue")]
    fn get_value(&self, account: String, at: Option<BlockHash>) -> RpcResult<String>;
}

UserStorage Implementation

impl<C, B> UserStorageApiServer<<B as BlockT>::Hash> for UserStorage<C, B>
where
    B: BlockT,
    C: Send + Sync + 'static,
    C: ProvideRuntimeApi<B>,
    C: HeaderBackend<B>,
    C::Api: UserStorageRuntimeApi<B, AccountId>,
{

    fn get_value(&self, account: String, at: Option<<B as BlockT>::Hash>) -> RpcResult<String> {
        let api = self.client.runtime_api();
        let at = at.unwrap_or_else(|| self.client.info().best_hash);

        let value = api
            .get_value(at, AccountId::from_str(&account).unwrap())
            .unwrap()
            .unwrap();

        info!("get_value: account: {}, value: {:?}", account, value);

        let res = String::from_utf8_lossy(&value).to_string();

        Ok(res)
    }
}

Runtime API Implementation

impl_runtime_apis! {
....
   impl user_storage_api::UserStorageApi<Block, AccountId> for Runtime
    where AccountId: Decode + Encode
    {
        fn get_value(account: AccountId) -> Result<Vec<u8>, Error> {
          
            let mut mock_vec = Vec::new();
            mock_vec.push(1);
            mock_vec.push(2);
            mock_vec.push(3);
            let result = mock_vec;
            print("get_value");
            Ok(result)

        }
...
}

Possible Causes

Based on the code snippets provided, there are a few possible causes for the issue:

Runtime API Not Being Called: The get_value function in the UserStorage implementation calls the get_value function on the runtime_api object. However, it's possible that this function is not being called, resulting in the default values being returned.
Incorrect Implementation: The get_value function in the UserStorage implementation is not correctly implemented, leading to the default values being returned.
Missing Dependencies: The UserStorage implementation may be missing dependencies, which could cause the get_value function to not be called.

Solutions

To resolve the issue, we need to investigate further and identify the root cause. Here are some steps we can take:

Verify Runtime API Call: We need to verify that the get_value function on the runtime_api object is being called. We can do this by adding print statements or using a debugger to step through the code.
Correct Implementation: We need to ensure that the get_value function in the UserStorage implementation is correctly implemented. We can do this by reviewing the code and making any necessary changes.
Add Dependencies: We need to ensure that the UserStorage implementation has all the necessary dependencies. We can do this by reviewing the code and adding any missing dependencies.

Conclusion

In this article, we explored a specific issue where the result of a custom RPC call is replaced with default values. We identified possible causes and solutions, including verifying the runtime API call, correcting the implementation, and adding dependencies. By following these steps, we can resolve the issue and ensure that our custom RPC calls are working as expected.

Additional Tips

Use Debugging Tools: When debugging issues like this, it's essential to use debugging tools such as print statements or a debugger to step through the code and identify the root cause.
Review Code Thoroughly: When reviewing code, it's essential to be thorough and ensure that all dependencies are met and all functions are correctly implemented.
Test Thoroughly: When testing code, it's essential to test thoroughly and ensure that all scenarios are covered.

Code Snippets

Here are some code snippets related to the article:

UserStorageApi Trait

#[rpc(client, server)]
pub trait UserStorageApi<BlockHash> {
    #[method(name = "userStorage_getValue")]
    fn get_value(&self, account: String, at: Option<BlockHash>) -> RpcResult<String>;
}

UserStorage Implementation

impl<C, B> UserStorageApiServer<<B as BlockT>::Hash> for UserStorage<C, B>
where
    B: BlockT,
    C: Send + Sync + 'static,
    C: ProvideRuntimeApi<B>,
    C: HeaderBackend<B>,
    C::Api: UserStorageRuntimeApi<B, AccountId>,
{

    fn get_value(&self, account: String, at: Option<<B as BlockT>::Hash>) -> RpcResult<String> {
        let api = self.client.runtime_api();
        let at = at.unwrap_or_else(|| self.client.info().best_hash);

        let value = api
            .get_value(at, AccountId::from_str(&account).unwrap())
            .unwrap()
            .unwrap();

        info!("get_value: account: {}, value: {:?}", account, value);

        let res = String::from_utf8_lossy(&value).to_string();

        Ok(res)
    }
}

Runtime API Implementation

impl_runtime_apis! {
....
   impl user_storage_api::UserStorageApi<Block, AccountId> for Runtime
    where AccountId: Decode + Encode
    {
        fn get_value(account: AccountId) -> Result<Vec<u8>, Error> {
          
            let mut mock_vec = Vec::new();
            mock_vec.push(1);
            mock_vec.push(2);
            mock_vec.push(3);
            let result = mock_vec;
            print("get_value");
            Ok(result)

        }
...
}

Commit Messages

Here are some commit message examples related to the article:

fix: resolve issue with custom RPC call result
feat: add custom RPC call implementation
docs: update documentation for custom RPC calls

API Documentation

Here is an example of API documentation for the UserStorageApi trait:

### UserStorageApi Trait

The `UserStorageApi` trait provides a set of methods for interacting with user storage.

#### Methods

*   `get_value(account: String, at: Option<BlockHash>) -> RpcResult<String>`: Retrieves the value associated with the given account at the specified block hash.

#### Errors

*   `RpcError`: An error that occurs when interacting with the RPC API.

Testing

Here is an example of testing code for the UserStorage implementation:

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_get_value() {
        let user_storage = UserStorage::new(client);
        let account = "test_account".to_string();
        let at = Some("test_block_hash".to_string());
        let result = user_storage.get_value(account, at);
        assert!(result.is_ok());
        assert_eq!(result.unwrap(), "test_value");
    }
}
```<br/>
# Substrate Custom RPC Call Result Replaced with Default Values: Q&A

## Introduction

In our previous article, we explored the issue of custom RPC call results being replaced with default values in Substrate. We identified possible causes and solutions, including verifying the runtime API call, correcting the implementation, and adding dependencies. In this Q&A article, we will answer some common questions related to this issue.

## Q: What is the cause of the custom RPC call result being replaced with default values?

A: The cause of the custom RPC call result being replaced with default values can be due to various reasons, including:

*   The runtime API call not being made
*   Incorrect implementation of the custom RPC call
*   Missing dependencies

## Q: How can I verify that the runtime API call is being made?

A: To verify that the runtime API call is being made, you can add print statements or use a debugger to step through the code. This will help you identify if the call is being made and if it's returning the expected result.

## Q: What is the correct implementation of the custom RPC call?

A: The correct implementation of the custom RPC call depends on the specific requirements of your use case. However, in general, you should:

*   Verify that the runtime API call is being made
*   Ensure that the implementation is correct and returns the expected result
*   Add any necessary dependencies

## Q: How can I add dependencies to my custom RPC call?

A: To add dependencies to your custom RPC call, you can:

*   Review the code and identify any missing dependencies
*   Add the necessary dependencies to your `Cargo.toml` file
*   Update your code to use the new dependencies

## Q: What are some common mistakes to avoid when implementing custom RPC calls?

A: Some common mistakes to avoid when implementing custom RPC calls include:

*   Not verifying that the runtime API call is being made
*   Incorrect implementation of the custom RPC call
*   Missing dependencies

## Q: How can I test my custom RPC call?

A: To test your custom RPC call, you can:

*   Use a testing framework such as `test` to write unit tests for your custom RPC call
*   Use a debugger to step through the code and identify any issues
*   Verify that the custom RPC call is returning the expected result

## Q: What are some best practices for implementing custom RPC calls?

A: Some best practices for implementing custom RPC calls include:

*   Verifying that the runtime API call is being made
*   Ensuring that the implementation is correct and returns the expected result
*   Adding any necessary dependencies
*   Testing the custom RPC call thoroughly

## Q: How can I troubleshoot issues with my custom RPC call?

A: To troubleshoot issues with your custom RPC call, you can:

*   Review the code and identify any potential issues
*   Use a debugger to step through the code and identify any issues
*   Verify that the custom RPC call is returning the expected result
*   Test the custom RPC call thoroughly

## Q: What are some common issues that can occur with custom RPC calls?

A: Some common issues that can occur with custom RPC calls include:

*   The runtime API call not being made
*   Incorrect implementation of the custom RPC call
*   Missing dependencies
*   Issues with the custom RPC call returning the expected result

## Q: How can I optimize my custom RPC call for performance?

A: To optimize your custom RPC call for performance, you can:

*   Review the code and identify any potential performance issues
*   Use a profiler to identify any performance bottlenecks
*   Optimize the custom RPC call to return the expected result more efficiently
*   Test the custom RPC call thoroughly to ensure that it is performing well

## Q: What are some best practices for documenting custom RPC calls?

A: Some best practices for documenting custom RPC calls include:

*   Providing clear and concise documentation for the custom RPC call
*   Including examples of how to use the custom RPC call
*   Documenting any potential issues or limitations with the custom RPC call
*   Providing a clear and concise API documentation for the custom RPC call

## Q: How can I ensure that my custom RPC call is secure?

A: To ensure that your custom RPC call is secure, you can:

*   Review the code and identify any potential security issues
*   Use a secure communication protocol such as HTTPS
*   Implement authentication and authorization for the custom RPC call
*   Test the custom RPC call thoroughly to ensure that it is secure

## Q: What are some common security issues that can occur with custom RPC calls?

A: Some common security issues that can occur with custom RPC calls include:

*   Unauthenticated or unauthorized access to the custom RPC call
*   Data tampering or manipulation
*   Denial of service (DoS) attacks
*   Man-in-the-middle (MitM) attacks

## Q: How can I troubleshoot issues with my custom RPC call?

A: To troubleshoot issues with your custom RPC call, you can:

*   Review the code and identify any potential issues
*   Use a debugger to step through the code and identify any issues
*   Verify that the custom RPC call is returning the expected result
*   Test the custom RPC call thoroughly

## Q: What are some best practices for testing custom RPC calls?

A: Some best practices for testing custom RPC calls include:

*   Writing unit tests for the custom RPC call
*   Using a testing framework such as `test` to write unit tests
*   Verifying that the custom RPC call is returning the expected result
*   Testing the custom RPC call thoroughly

## Q: How can I optimize my custom RPC call for performance?

A: To optimize your custom RPC call for performance, you can:

*   Review the code and identify any potential performance issues
*   Use a profiler to identify any performance bottlenecks
*   Optimize the custom RPC call to return the expected result more efficiently
*   Test the custom RPC call thoroughly to ensure that it is performing well

## Q: What are some common issues that can occur with custom RPC calls?

A: Some common issues that can occur with custom RPC calls include:

*   The runtime API call not being made
*   Incorrect implementation of the custom RPC call
*   Missing dependencies
*   Issues with the custom RPC call returning the expected result

## Q: How can I ensure that my custom RPC call is secure?

A: To ensure that your custom RPC call is secure, you can:

*   Review the code and identify any potential security issues
*   Use a secure communication protocol such as HTTPS
*   Implement authentication and authorization for the custom RPC call
*   Test the custom RPC call thoroughly to ensure that it is secure

## Q: What are some best practices for documenting custom RPC calls?

A: Some best practices for documenting custom RPC calls include:

*   Providing clear and concise documentation for the custom RPC call
*   Including examples of how to use the custom RPC call
*   Documenting any potential issues or limitations with the custom RPC call
*   Providing a clear and concise API documentation for the custom RPC call

## Q: How can I troubleshoot issues with my custom RPC call?

A: To troubleshoot issues with your custom RPC call, you can:

*   Review the code and identify any potential issues
*   Use a debugger to step through the code and identify any issues
*   Verify that the custom RPC call is returning the expected result
*   Test the custom RPC call thoroughly

## Q: What are some common security issues that can occur with custom RPC calls?

A: Some common security issues that can occur with custom RPC calls include:

*   Unauthenticated or unauthorized access to the custom RPC call
*   Data tampering or manipulation
*   Denial of service (DoS) attacks
*   Man-in-the-middle (MitM) attacks

## Q: How can I optimize my custom RPC call for performance?

A: To optimize your custom RPC call for performance, you can:

*   Review the code and identify any potential performance issues
*   Use a profiler to identify any performance bottlenecks
*   Optimize the custom RPC call to return the expected result more efficiently
*   Test the custom RPC call thoroughly to ensure that it is performing well

## Q: What are some best practices for testing custom RPC calls?

A: Some best practices for testing custom RPC calls include:

*   Writing unit tests for the custom RPC call
*   Using a testing framework such as `test` to write unit tests
*   Verifying that the custom RPC call is returning the expected result
*   Testing the custom RPC call thoroughly

## Q: How can I ensure that my custom RPC call is secure?

A: To ensure that your custom RPC call is secure, you can:

*   Review the code and identify any potential security issues
*   Use a secure communication protocol such as HTTPS
*   Implement authentication and authorization for the custom RPC call
*   Test the custom RPC call thoroughly to ensure that it is secure

## Q: What are some common issues that can occur with custom RPC calls?

A: Some common issues that can occur with custom RPC calls include:

*   The runtime API call not being made
*   Incorrect implementation of the custom RPC call
*   Missing dependencies
*   Issues with the custom RPC call returning the expected result

## Q: How can I troubleshoot issues with my custom RPC call?

A: To troubleshoot issues with your custom RPC call, you can:

*   Review the code and identify any potential issues
*   Use a debugger to step through the code and identify any issues
*   Verify that the custom RPC call is returning the expected result
*   Test the custom RPC call thoroughly

## Q: What are some