Designing a Kakarot-specific Precompile to call into a generic Cairo contract from EVM execution

[Eikix]

Hi all!

Context:

• Desire to partner with Pragma Oracle on Testnet for a push (and then pull) based Oracle!
• Pragma Oracle is a Cairo contract, Kakarot executes EVM SC -> a priori incompatibility
• Need to be able to call Pragma using a Chainlink compatible API, from within an EVM context
• Good occasion to design an extensible system to call into cairo contracts from Kakarot!

Idea:

• Design an API to call into a Cairo contract from within Kakarot execution using EVM precompiles, and a standardized API.

Tasks:

1. Design a standard and extensible API to call any Cairo contract with arbitrary calldata from Kakarot zkEVM
2. Design a library to call this precompile from Solidity / Vyper
3. Design a library specifically for Pragma to call specific entrypoints from the Pragma contract with specific calldata, this library should reproduce 1-to-1 chainlink API

Good examples:
Moonbeam docs: https://docs.moonbeam.network/builders/pallets-precompiles/precompiles/identity/

cc @ClementWalter for scoping

[Eikix]

Addition from @swetshaw for scoping the Pragma interaction

[ClementWalter]

My proposed design is

• fix a precompile address for calling starknet call_contract syscall, let’s say 0xabde1

• Define an interface ICairo.sol where we have

  interface ICairo {
  	function call_contract(
  		uint256 contractAddress,
  		uin256 functionSelector,
  		bytes calldata data
  	) returns (bytes)
  }

• we update the is_precompile.cairo to check 0xabde1 and in this case, do a regular call_contract with the given args

  • ⚠️ the syscall cannot raise
    • we need to register whiteliste starknet address because any dev could call directly ICairo.call_contract to a non-existing contract
    • deployed cairo contracts in our network should be triple checked to remove any dangerous assert

• for integrating Pragma, we deploy a solidity contract filling the pyth (or whatever target oracle interface we want to follow) and in this contract, we actually do

  function oracleFunction1(...) ... {
  	bytes memory result = ICairo.call_contract(...)
  	// parse the result
  	// return expected value to match the Oracle interface
  }

[bajpai244]

I like this idea!

Also great pointing out the need for a whitelist! Great second order thinking :)

[enitrat]

⚠️ the syscall cannot raise

Not only that but you'd need to whitelist all selectors for a given contract as well. As there's no default fallback in C1 contracts, you can't assume that if a call doesn't land on an existing selector, you'd just be able to land on the default entrypoint and return an empty array with success = false.

[swetshaw]

Here is a very naive approach to implement the above - https://gist.github.com/swetshaw/04d97c718193e6da3fcba17314fa64dc

Would love everyone's thought on if there's something wrong or should be modified.

Apart from that, I have a doubt - how should the implementation for Cairo.sol (the precompile) that will actually implement the call_contract method should look like. Basically I do not have clarity on how to do the below from a solidity contract:

do a regular call_contract with the given args

fix a precompile address for calling starknet call_contract syscall, let’s say 0xabde1

Is there something that I could refer for better understanding ?