Confused about what triggers fallback in openzeppelin's proxy abstract contract

[viktrified]

Please can someone explain to me why every call made to this contract will trigger its fallback `// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (proxy/Proxy.sol)

pragma solidity ^0.8.20;

/**

• @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM

• instruction delegatecall. We refer to the second contract as the implementation behind the proxy, and it has to

• be specified by overriding the virtual {_implementation} function.

• Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a

• different contract through the {_delegate} function.

• The success and return data of the delegated call will be returned back to the caller of the proxy.
  /
  abstract contract Proxy {
  /*

  • @dev Delegates the current call to implementation.

  • This function does not return to its internal call site, it will return directly to the external caller.
    */
    function _delegate(address implementation) internal virtual {
    assembly {
    // Copy msg.data. We take full control of memory in this inline assembly
    // block because it will not return to Solidity code. We overwrite the
    // Solidity scratch pad at memory position 0.
    calldatacopy(0, 0, calldatasize())

     // Call the implementation.
     // out and outsize are 0 because we don't know the size yet.
     let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)
    
     // Copy the returned data.
     returndatacopy(0, 0, returndatasize())
    
     switch result
     // delegatecall returns 0 on error.
     case 0 {
         revert(0, returndatasize())
     }
     default {
         return(0, returndatasize())
     }
    

    }
    }

  /**

  • @dev This is a virtual function that should be overridden so it returns the address to which the fallback
  • function and {_fallback} should delegate.
    */
    function _implementation() internal view virtual returns (address);

  /**

  • @dev Delegates the current call to the address returned by _implementation().
  • This function does not return to its internal call site, it will return directly to the external caller.
    */
    function _fallback() internal virtual {
    _delegate(_implementation());
    }

  /**

  • @dev Fallback function that delegates calls to the address returned by _implementation(). Will run if no other
  • function in the contract matches the call data.
    */
    fallback() external payable virtual {
    _fallback();
    }
    }`

[EngrPips]

It is. a proxy contract, and it doesn't contain any implementation logic, so it is designed to always trigger the fallback function to make a delegate call function to the contract address that contains the implementation logic.

[Blockchain-Oracle]

Yeah, that's the purpose of delegatecall — it's similar to call, but the implementation is executed in the context of the calling contract.

and fallback function get called when function selector on the calling address/contract is not found
I hope this helps

[EngrPips]

Yeah, that's the purpose of delegatecall — it's similar to call, but the implementation is executed in the context of the calling contract.

and fallback function get called when function selector on the calling address/contract is not found I hope this helps

Phenomenal heads-up.