Limit the number of times a static function is called

Question

As far as I am concerned, when a function in a smart contract is defined as pure or view it is possible to invoke it without being charged for the gas consumption that its execution requires. This type of functions do not alter the state of the smart contract and thus not need to be executed and mined as a new block in the blockchain.

However, this behaviour would open the door to abuse. Anyone could try to repeatedly invoke this type of functions on a particular node to put it to work without rewarding it.

So, I would like to know if I am right or wrong in stating:

1. Pure & view functions can be abused because anyone can invoke them without paying for their execution.

2. Pure & view functions are executed off-chain since their execution does not alter the state of the contract.

3. When executing off-chain the function is typically executed on a single node, the one used as provider (e.g., a local geth node or a remote Infura node).

If 1. is correct, is there a way to prevent this from happening? I don't mean a way to to limit long executions but a way to limit multiple invocations of a single function by some accounts. This is something I wanted to clarify since the question was marked as a possible duplicate of View/Pure Gas usage - Cost gas if called internally by another function?

I can think of firewall-based solutions but does Ethereum clients like Geth provide any sort of countermeasure? Can this problem be tackled at solidity level? It comes to my mind making all my functions non-static but this would be detrimental for honest users.

If 2 and 3 are correct, I can think of remote dishonest nodes returning wrong results to the client. So I guess, this is not necessarily true and there is a way to force invocations to pure/view functions to be executed distributedly. In that case, would the execution of the function have any impact on the blockchain if the function is not changing anything on the contract? Would any gas be charged to the client?

Thanks for your comments!

Answer 1

Pure & view functions can be abused because anyone can invoke them without paying for their execution.

Not exactly. If they are invoked from a contract that is executing a state-changing transaction, then they are part of the transaction that every full node has to execute. That's okay, though, because gas accounting applies.

Pure & view functions are executed off-chain since their execution does not alter the state of the contract.

Functions that are view/pure may be executed locally, if the user calls them directly. They can do that as much as they want because they are using their own hardware and their own copy of the chain. If the view/pure function is called by a contract, then everyone has to run it and the sender pays for gas.

When executing off-chain the function is typically executed on a single node, the one used as provider (e.g., a local geth node or a remote Infura node).

An off-chain read-only function is executed locally on the caller's computer. The network isn't even informed.

A more detailed explanation: https://blog.b9lab.com/calls-vs-transactions-in-ethereum-smart-contracts-62d6b17d0bc2

Hope it helps.

Elaboration

pragma solidity 0.5.1;

contract ConstantAndTransaction {

    uint trivial;

    function getTrivial() public view returns(uint) {
        // When called directly, this function is run locally and gas is refunded. 
        // The network is not consulted.     
        return trivial;
    }

    function add(uint x) public {
        // This is normally a state-changing transaction. It relies on inspecting a read-only function. 
        // That means all nodes will run the read-only function and the sender will pay for it. 
        trivial += getTrivial() + x;
    }
}

Answer 2

I assume you mean public nodes. if this is the case publics node will just limit the number of API request per second as Etherscan do, to about 5 request per second.

Hope this helps

Answer 3

Nodes are not designed to be publicly accessible, at least stock implementations such as geth. I believe public nodes such as Infura or MEW do operate behind some sort of reverse proxy that do protect them from spam and unwanted request.

BTW, whether function is read-only (i.e. pure, view, or constant) or read-write, only defines default calling strategy for the function. One may always invoke read-only function on-chain (via myContract.methods.myMethod.send) or non read-only function off-chain (via myContract.methods.myCethod.call). So declaring all functions as non read-only will not protect them from being executed locally.