[Reposted from FVM Forum] How we deployed our custom payment channel smart contracts to an FEVM chain

[trruckerfling]

[Reposted from OP @geoknee, Oct 2022]

As of Jan 2022, the FVM Forum will be merging into the Filecoin Community Discussion here, as FVM and Filecoin often go hand-in-hand for builders

TLDR

FEVM is midway through development towards its ultimate goal. Each week, a newly improved iteration with more and more features is deployed to a public FEVM testnet called wallaby. The testnet has a faucet, block explorer and burner wallet. Today, we managed to deploy our on-chain smart contracts (just a singleton contract called NitroAdjudicator) to wallaby, and also invoke a couple of functions! Here’s how we did it:

Context

Hello from team Magmo! We are a research and development team inside of Consensys Mesh, and are developing a new payment channel system for the Filecoin retrieval market, allowing off-chain payments from retrieval clients to retrieval providers.

Since the beginning of this project, it has been uncertain how the on-chain component of our system would be deployed.

In the early days, we considered the option of forking lotus (the main Filecoin blockchain node implementation), replacing or adding to the existing paych built-in actor.

Then we heard about the Filecoin Virtual Machine, and the possibility of deploying user-defined actors to Filecoin. We got interested in this idea because it mirrored they way we have deployed our system to Ethereum and other Ethereum Virtual Machine networks in the past.

We spent some time tinkering with writing actors in Rust, compiling them to wasm and deploying them to a local “devnet” running an experimental fvm branch of lotus.

Then, we heard about the Filecoin Ethereum Virtual Machine (FEVM), and learnt that some day soon, we could simply reuse both our solidity source code and the Ethereum tooling we were already familiar with to deploy actors to Filecoin!

How we did it

Reusing our existing tooling, we compiled our source code using hardhat (which in turn of course calls solc). This gives us an JSON artifact with a bytecode (encoded as a hexadecimal string). We copy-pasted this string into a file called nitro-adjudicator.bin, and removed the 0x prefix.

We then installed Jim Pick’s wallaby-fevm-msg-signer CLI tool (v 0.0.9) using npm. We went ahead and generated a seed phrase at https://wallet.glif.io/?network=wallaby 1, saved the phrase and then got some FIL at https://wallaby.network/#faucet using the public key /address corresponding to the generated seed phrase.

Creating the actor

Next, we executed this command:

➜  test-filecoin git:(fvm) ✗ wallaby-fevm-msg-signer create-evm-actor nitro-adjudicator.bin --seed-phrase <seedphrase here>
         Actor install may fail if wallaby testnet has been updated.
From Address: t1b4x64cf6mzbgjmgfaydjyb23pextngjurysa4iy
EVM Actor CID: bafk2bzaceby6fqurr4yzveyu4rchso36gdytfrezdrjgae4aef45z3dh42wrc
✔ Sending message to GLIF gateway
Message CID: bafy2bzacectsu3aes2jleqfkubpdrogqgtj6qn5jgzexnta77u4v4g2lmouqk
GLIF Explorer: https://explorer-calibration.glif.link/message/?network=wallaby&cid=bafy2bzacectsu3aes2jleqfkubpdrogqgtj6qn5jgzexnta77u4v4g2lmouqk
✔ Waiting for message to appear on chain.............
Message Executed at Height: 6593
Gas Used: 56702988
ID Address: t01028
Robust Address: t2dv7qentn4btx4kbtcpt5ymdbizfmnkth7nvhupq

For an explainer about actor addresses, see here https://docs.filecoin.io/about-filecoin/how-filecoin-works/#robust-addresses-versus-id-addresses

Invoking the actor

To invoke the actor, we need the 4 byte sighash to select the adjudicator method we want to call. Since this is abstracted away in a lot of the Ethereum tooling, we went ahead and used https://playground.ethers.org/ to quickly calculate sighashes.

First up, we wanted to try out a method called addressToBytes32, which zero-pads a 20 byte address to 32 bytes. The source code in solidity is:

function addressToBytes32(address participant) public pure returns (bytes32) {
        return bytes32(uint256(participant));
    }

On the ethers playground, we executed:

new utils.Interface(["function addressToBytes32(address)"]).getSighash('addressToBytes32')
"0x82c947b7"

With the sighash in hand, we tried invoking this method:

> wallaby-fevm-msg-signer invoke-evm-actor \
   t01028 \ # IDAddress of the deployed 
   82c947b7 \ # sighash to specify the target method  
   00000000000000000000000000000000deadbeef \ # method argument data
   --seed-phrase <seedphrase here> # for transaction signing

Which produced the following result:

➜  test-filecoin git:(fvm) ✗ wallaby-fevm-msg-signer invoke-evm-actor t01028 82c947b7 00000000000000000000000000000000deadbeef --seed-phrase <seedphrase here>
From Address: t1b4x64cf6mzbgjmgfaydjyb23pextngjurysa4iy
⠇ Sending message to GLIF gatewayinvoke-evm-actor error: JsonRpcError: estimating gas used: message execution failed: exit 27, reason: message failed with backtrace:
00: f01028 (method 2) -- contract reverted (27)
 (RetCode=27)
    at new JsonRpcError (/Users/georgeknee/.nvm/versions/node/v16.16.0/lib/node_modules/@jimpick/wallaby-fevm-msg-signer/dist/index.js:48731:28)
    at HttpJsonRpcConnector.<anonymous> (/Users/georgeknee/.nvm/versions/node/v16.16.0/lib/node_modules/@jimpick/wallaby-fevm-msg-signer/dist/index.js:48906:35)
    at step (/Users/georgeknee/.nvm/versions/node/v16.16.0/lib/node_modules/@jimpick/wallaby-fevm-msg-signer/dist/index.js:48827:23)
    at Object.next (/Users/georgeknee/.nvm/versions/node/v16.16.0/lib/node_modules/@jimpick/wallaby-fevm-msg-signer/dist/index.js:48808:53)
    at fulfilled (/Users/georgeknee/.nvm/versions/node/v16.16.0/lib/node_modules/@jimpick/wallaby-fevm-msg-signer/dist/index.js:48799:58)
    at processTicksAndRejections (node:internal/process/task_queues:96:5) {
  code: 1,
  data: undefined
}

We got an error because our input was malformed. We are used to using ethers.js to connect to contracts, which would have taken the 20 byte (40 hexit) 00000000000000000000000000000000deadbeef and abi encoded it for us, padding it to 32 bytes. Realising this, we did that step manually:

test-filecoin git:(fvm) ✗ wallaby-fevm-msg-signer invoke-evm-actor t01028 82c947b7 00000000000000000000000000000000000000000000000000000000deadbeef --seed-phrase <seedphrase here>
From Address: t1b4x64cf6mzbgjmgfaydjyb23pextngjurysa4iy
✔ Sending message to GLIF gateway
Message CID: bafy2bzaceabsaii2uqg7tsrdxlv44e5r3z5kojgtvlda6je2jqafng5kodcxm
GLIF Explorer: https://explorer-calibration.glif.link/message/?network=wallaby&cid=bafy2bzaceabsaii2uqg7tsrdxlv44e5r3z5kojgtvlda6je2jqafng5kodcxm
✔ Waiting for message to appear on chain.............
Message Executed at Height: 6637
Gas Used: 4488040
Decoded Result (hex): 00000000000000000000000000000000000000000000000000000000deadbeef

Next up, we wanted to try something more interesting, since this example ended up just returning the input. So we repeated the exercise for the following function which checks a 32 byte word to see if the 12 leading bytes are all zero:

function isExternalDestination(bytes32 destination) public pure returns (bool) {
    return uint96(bytes12(destination)) == 0;
}

Now back to the ethers playground to get the sighash:

new utils.Interface(["function isExternalDestination(bytes32)"]).getSighash('isExternalDestination')
"0xc2f5bec6"

and using Jim Pick’s tool again:

➜  test-filecoin git:(fvm) ✗ wallaby-fevm-msg-signer invoke-evm-actor t01028 c2f5bec6 00000000000000000000000000000000000000000000000000000000deadbeef --seed-phrase <seedphrase here>
From Address: t1b4x64cf6mzbgjmgfaydjyb23pextngjurysa4iy
✔ Sending message to GLIF gateway
Message CID: bafy2bzacecnau3gskewiyboey3bmhnk2o7ljek5iq4wkwzdby6khxk24mbafo
GLIF Explorer: https://explorer-calibration.glif.link/message/?network=wallaby&cid=bafy2bzacecnau3gskewiyboey3bmhnk2o7ljek5iq4wkwzdby6khxk24mbafo
✔ Waiting for message to appear on chain..............
Message Executed at Height: 6644
Gas Used: 4389304
Decoded Result (hex): 0000000000000000000000000000000000000000000000000000000000000001
➜  test-filecoin git:(fvm) ✗ wallaby-fevm-msg-signer invoke-evm-actor t01028 c2f5bec6 000a0000000000000000000000000000000000000000000000000000deadbeef --seed-phrase <seedphrase here>
From Address: t1b4x64cf6mzbgjmgfaydjyb23pextngjurysa4iy
✔ Sending message to GLIF gateway
Message CID: bafy2bzaceabrxrbrlu52rruqqiedyuygrzvlsmetjq3q6fsoq4gdqgtyw5sjo
GLIF Explorer: https://explorer-calibration.glif.link/message/?network=wallaby&cid=bafy2bzaceabrxrbrlu52rruqqiedyuygrzvlsmetjq3q6fsoq4gdqgtyw5sjo
✔ Waiting for message to appear on chain.............
Message Executed at Height: 6653
Gas Used: 4387148
Decoded Result (hex): 0000000000000000000000000000000000000000000000000000000000000000

You can see that the result is hex encoded true for 00000000000000000000000000000000000000000000000000000000deadbeef and false for 000a0000000000000000000000000000000000000000000000000000deadbeef .

This is pretty good evidence that we successfully deployed and invoked our smart contract 🎉!

What’s next?

We are going to keep a close eye on the wallaby upgrades and maturing developer tooling. The ultimate goal for us is to run some of our existing payment channel integration tests against an adjudicator deployed to wallaby.

Some minor milestones along the way might be:

• deposit some FIL or ERC20-style tokens to the adjudicator contract
  • the ERC20 deposit involves interaction with other contracts
• withdraw some FIL or ERC20-style tokens from the adjudicator contract
• call a method with a more complicated signature, such as one with nested structs
• call a non-pure method, and/or one which results in a deeper call stack
• investigate the gas consumption and compare this against a regular EVM chain consumption

We would also love to contribute to the developer tooling (including Jim’s CLI tool) as it evolves.

Other references:

See also this awesome twitch stream from Matt Hamilton, which walks through using the same CLI tool: Twitch.

[geoknee]

Thanks @trruckerfling . Just want to echo the comment I put on the original thread -- that these instructions are very much out of date now and folks looking to deploy to a FEVM testnet can find more recent instructions on how to do so elsewhere. For example https://www.youtube.com/watch?v=FJK2RDFtSUw .