The contracts in this repository are Proof of Concepts of cross-chain bridging solutions. We've implemented a simple mock af the AlloV2 allocate method and created an adapter contract to support the Connext donation flow.

The process involves:

• The user: the person who wants to donate tokens.
• The bridge: the contract that will receive the tokens and send them to the recipient on another chain.
• The round: a round instance on the AlloV2 protocol.
• The recipient: the person who will receive the tokens on another chain as part of the grants round they're participating in.
• The source chain: the chain where the tokens are currently located.
• The target chain: the chain where the recipient is participating in a grants round.
• The adapter contract: a Connext specific contract that executes validations and supports custom logic.

When executing a cross-chain donation vote, the following steps are taken:

• The user specifies the amount of tokens to donate, the address of the token to donate, and the address of the recipient.
• The user creates a donation vote transaction using the API of the bridging solution.
• The user signs the transaction with their wallet and sends it to the bridge.
• The bridge receives the transaction and verifies the signature.
• The bridge receives the tokens and sends them to the target contract on the target chain.

On the target chain, the flow is different between the different bridging solutions.

In the case of Connext, the adapter contract is the CrossChainDonationAdapter contract which receives the tokens and the calldata.

• The bridge sends the tokens to the adapter contract.
• The adapter contract receives the tokens and the calldata, validates the data and executes the custom logic on the Allo contract.
• Tokens are received by the adapter contract and relayed to the recipient via the Allo contract.

In the case of LiFi and Decent, there is no adapter contract and the bridge could execute calls directly onto the Allo contract.

• The bridge sends the tokens to the Allo contract.
• The Allo contract receives the tokens and the calldata, validates the data and executes the custom logic.

This has the caveat that the tokens will be owned by Allo and should be routed out of the Allo contract to the recipient.

• CrossChainDonationAdapter: the adapter contract that receives the tokens and the calldata, validates the data and executes the custom logic on the Allo contract.
• MockAllo: a mock of the AlloV2 contract that implements the allocate method.

• Forge: compile, test, fuzz, format, and deploy smart contracts
• Forge Std: collection of helpful contracts and cheatcodes for testing
• PRBTest: modern collection of testing assertions and logging utilities
• Prettier: code formatter for non-Solidity files
• Solhint: linter for Solidity code

Click the Use this template button at the top of the page to create a new repository with this repo as the initial state.

Or, if you prefer to install the template manually:

$ mkdir my-project
$ cd my-project
$ forge init --template PaulRBerg/foundry-template
$ bun install # install Solhint, Prettier, and other Node.js deps

If this is your first time with Foundry, check out the installation instructions.

This template builds upon the frameworks and libraries mentioned above, so please consult their respective documentation for details about their specific features.

For example, if you're interested in exploring Foundry in more detail, you should look at the Foundry Book. In particular, you may be interested in reading the Writing Tests tutorial.

This template comes with a set of sensible default configurations for you to use. These defaults can be found in the following files:

├── .editorconfig
├── .gitignore
├── .prettierignore
├── .prettierrc.yml
├── .solhint.json
├── foundry.toml
└── remappings.txt

This template is IDE agnostic, but for the best user experience, you may want to use it in VSCode alongside Nomic Foundation's Solidity extension.

For guidance on how to integrate a Foundry project in VSCode, please refer to this guide.

This template comes with GitHub Actions pre-configured. Your contracts will be linted and tested on every push and pull request made to the main branch.

You can edit the CI script in .github/workflows/ci.yml.

Foundry typically uses git submodules to manage dependencies, but this template uses Node.js packages because submodules don't scale.

This is how to install dependencies:

1. Install the dependency using your preferred package manager, e.g. bun install dependency-name
   • Use this syntax to install from GitHub: bun install github:username/repo-name
2. Add a remapping for the dependency in remappings.txt, e.g. dependency-name=node_modules/dependency-name

Note that OpenZeppelin Contracts is pre-installed, so you can follow that as an example.

To write a new test contract, you start by importing PRBTest and inherit from it in your test contract. PRBTest comes with a pre-instantiated cheatcodes environment accessible via the vm property. If you would like to view the logs in the terminal output you can add the -vvv flag and use console.log.

This template comes with an example test contract Foo.t.sol

This is a list of the most frequently needed commands.

Build the contracts:

$ forge build

Delete the build artifacts and cache directories:

$ forge clean

Compile the contracts:

$ forge build

Get a test coverage report:

$ forge coverage

Deploy to Anvil:

$ forge script script/Deploy.s.sol --broadcast --fork-url http://localhost:8545

For this script to work, you need to have a MNEMONIC environment variable set to a valid BIP39 mnemonic.

For instructions on how to deploy to a testnet or mainnet, check out the Solidity Scripting tutorial.

Format the contracts:

$ forge fmt

Get a gas report:

$ forge test --gas-report

Lint the contracts:

$ bun run lint

Run the tests:

$ forge test

Generate test coverage and output result to the terminal:

$ bun run test:coverage

Generate test coverage with lcov report (you'll have to open the ./coverage/index.html file in your browser, to do so simply copy paste the path):

$ bun run test:coverage:report

• abigger87/femplate
• cleanunicorn/ethereum-smartcontract-template
• foundry-rs/forge-template
• FrankieIsLost/forge-template

This project is licensed under MIT.