How To Create An EVM Compatible Blockchain Bridge - Chainstack (2024)

How To Create An EVM Compatible Blockchain Bridge - Chainstack (1)

Blockchains are siloed systems. If you have some tokens or NFTs in your Ethereum wallet, they are not available for you to use or spend on Avalanche, Solana, Harmony, or any other blockchain. Interoperability between blockchains is one of the biggest problems that the industry is trying to solve, and one of the solutions we currently have is cross-chain bridges.

Bridges allow users to “send” these tokens from one blockchain to another. This seems like an easy task but it actually involves multiple pieces of code and smart contracts. In addition, production-ready bridges have to control any errors that could arise when sending tokens across in order to avoid losing them into the ether 😉

In this article, we’re going to build a basic bridge between two EVM-compatible blockchains. And which better than the most popular, Ethereum, and the latest one supported by Chainstack, Harmony 😊

This project will help us get an overview of how bridges work behind the scenes.

Requirements

You’ll need access to blockchain nodes on both sides of the bridge. To get started, check out the following links:

  1. Sign up with Chainstack.
  2. Deploy a node.
  3. Get the node RPC endpoints.

In addition, you’ll need some tokens for your target networks to pay for the smart contract deployments and the bridge transactions. This bridge was tested with the Ethereum Ropsten and Harmony testnets. You can get Ropsten ETH here and Harmony testnet ONE here.

Blockchain bridge overview

Our bridge will be very simple:

  • When the bridge wallet receives tokens from the Ethereum side of the bridge, it should mint new tokens in the Harmony side and send them to the same user.
  • When the bridge wallet receives tokens from the Harmony side of the bridge, it should burn those tokens and transfer back the same amount of tokens from the bridge wallet to the user.

The project is divided into three parts:

  1. Smart contracts: we need two ERC20 token contracts, one in each blockchain that we’re going to bridge. To create and deploy the smart contracts, I’m going to use Hardhat.
  2. Web app: the frontend that users will interact with to actually send their tokens accross. I’ll create it with Vue.js and use ethers.js to interact with the smart contracts.
  3. Backend job: we also need a process listening to tokens received in the bridge wallet. This job will be written in JavaScript to keep it simple. It’ll use web3.js to interact with our blockchain nodes and smart contracts.

You can find all the code of this project in the following repository in GitHub.

Steps overview

  1. Create an ERC20 token contract for the Ethereum chain.
  2. Create an ERC20Burnable token contract for the destination chain.
    • Override the mint and burnFrom methods with onlyBridge modifier.
  3. Deploy contracts to the Ropsten and Harmony testnets.
  4. Create frontend to transfer tokens from user’s wallet to the bridge.
  5. Create a backend job that listens for Transfer events in both token contracts.
    • Store the bridge wallet private key in the server.
    • Methods to send mint, burnFrom and transfer transactions from the server.

Create the ERC20 tokens

As mentioned, I’ll use Hardhat to create the contracts. I created a solidity folder to hold the Hardhat project. Run npx hardhat and select the Create sample project option to scaffold the project. It’ll generate a test contract and script for you. We’ll use standard ERC20 tokens on both sides of the bridge, so we have to install OpenZeppelin contracts with npm install @openzeppelin/contracts.

With all the dependencies installed, we can create the contract files inside the solidity/contracts folder. I created two files: OriginToken.sol and DestinationToken.sol.

  • OriginToken.sol: is a standard ERC20 token for the Ethereum side of the bridge. It mints all tokens once it’s deployed. In the constructor, we have to send a token name, symbol and an initial supply. I named this contract ChainstackDollars with the symbol CHSD.
// SPDX-License-Identifier: MITpragma solidity ^0.8.4;import "hardhat/console.sol";// Import ERC20import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";contract ChainstackDollars is ERC20 { // create the token passing the name and symbol constructor( string memory _name, string memory _symbol, uint256 _initialSupply ) ERC20(_name, _symbol) { // mint all tokens and send them to the deployer's wallet _mint(msg.sender, _initialSupply * (10**uint256(18))); console.log("Tokens minted %s", _initialSupply); console.log("Deployed! Tokens sent to %s", msg.sender); }}

Note: we’re minting the initial supply received multiplied by 10**18, as the ERC20 token has 18 decimals by default.

  • DestinationToken.sol: is an ERC20 and ERC20Burnable token for the Harmony side of the bridge. This means we can use the mint and burnFrom methods to create and destroy tokens. Instead of using the default mint() and burnFrom() methods, we’ll override them to add the onlyBridge modifier which will prevent any other sender, except the bridge, to call these methods. I named this token DChainstackDollars with symbol D-CHSD.
// SPDX-License-Identifier: MITpragma solidity ^0.8.4;import "hardhat/console.sol";// Import ERC20import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";import {ERC20Burnable} from "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";contract DChainstackDollars is ERC20, ERC20Burnable { address bridge; constructor(address _bridge) ERC20("DChainstackDollars", "D-CHSD") { bridge = _bridge; } modifier onlyBridge() { require( bridge == msg.sender, "DChainstackDollars: only the bridge can trigger this method!" ); _; } // @dev called from the bridge when tokens are locked on ETH side function mint(address _recipient, uint256 _amount) public virtual onlyBridge { _mint(_recipient, _amount); console.log("Tokens minted for %s", _recipient); } // @dev called from the bridge when tokens are received // on Harmony side function burnFrom(address _account, uint256 _amount) public virtual override(ERC20Burnable) onlyBridge { super.burnFrom(_account, _amount); console.log("Tokens burned from %s", _account); }}

Note: this contract has no initial supply as it will only be minted when users bridge some ChainstackDollar tokens from the ETH side of the bridge.

Deploying the ERC20 token contracts

To deploy the contracts we first need to get Ropsten ETH from here and Harmony testnet ONE from here.

Once we have the “money”, we need to configure our target networks and account in the hardhat.config.js file. In my case, I created an .env file and loaded the values from it like this (you’ll have to install dotenv (npm i dotenv) for that):

require('@nomiclabs/hardhat-waffle')//load env filerequire('dotenv').config()//....module.exports = { solidity: '0.8.4', paths: { sources: './contracts', artifacts: '../web/src/artifacts', tests: './test', }, networks: { hardhat: { chainId: 1337, }, ganache: { chainId: 5777, url: 'http://127.0.0.1:7545', }, // Eth side of the bridge origin: { url: process.env.DEPLOY_ENDPOINT_ORIGIN, accounts: [process.env.DEPLOY_ACC_KEY], }, // Harmony side of the bridge destination: { url: process.env.DEPLOY_ENDPOINT_DESTINATION, accounts: [process.env.DEPLOY_ACC_KEY], }, },}

The URLs (DEPLOY_ENDPOINT_ORIGIN and DEPLOY_ENDPOINT_DESTINATION) are the HTTPS endpoint from your nodes, which you can get from the Chainstack console. The account is the private key of your wallet. Make sure you do not upload that private key to a repository or share it!

To deploy the contracts, I created two script files: solidity/scripts/deployOrigin.js and solidity/scripts/deployDestination.js:

They’re both pretty similar, the only difference is that in deployOrigin.js we have to pass a few parameters to the constructor: the token name, the symbol, and the supply while the deployDestination.js does not need those.

// File: solidity/scripts/deployOrigin.jsconst main = async () => { const [deployer] = await hre.ethers.getSigners() const accountBalance = await deployer.getBalance() console.log('Deploying contracts with account: ', deployer.address) console.log('Account balance: ', accountBalance.toString()) let contractFactory = await hre.ethers.getContractFactory('ChainstackDollars') let contract = await contractFactory.deploy( 'ChainstackDollars', 'CHSD', 1000000 ) await contract.deployed() console.log( 'contract ChainstackDollars deployed to address: ', contract.address )}const runMain = async () => { try { await main() process.exit(0) } catch (error) { console.error(error) process.exit(1) }}runMain()

To execute the scripts and deploy the contracts, we need to run npx hardhat run ./scripts/deployOrigin.js --network origin and npx hardhat run ./scripts/deployDestination.js --network destination.

If everything goes well, you’ll see something like this in the console:

> contract ChainstackDollars deployed to address: 0xASDF1234ASDF1234ASDF1234

Remember to run both scripts and save the contract addresses as we’ll need those in the frontend and backend job.

Building the frontend

I’ll not explain step-by-step how I created the web app, but I’ll go through the main concepts.

I created a Vue.js application with two pages: Origin.vue and Destination.vue.

Each page has a form in which users can enter the number of tokens they want to bridge:

How To Create An EVM Compatible Blockchain Bridge - Chainstack (2)

When the user clicks the Bridge to… button, MetaMask asks the user to authorize the transaction and the tokens are transferred to our bridge wallet. Here is the code from the Origin.vue file that triggers the transfer:

import ChainstackDollars from '@/artifacts/contracts/OriginToken.sol/ChainstackDollars.json'const bridgeWallet = import.meta.env.VITE_BRIDGE_WALLETconst originTokenAddress = import.meta.env.VITE_ORIGIN_TOKEN_ADDRESSconst provider = new ethers.providers.Web3Provider(window.ethereum)// get the account that will pay for the trasactionconst signer = provider.getSigner()let contract = new ethers.Contract( originTokenAddress, ChainstackDollars.abi, signer)const sendTokens = async function () { const amountFormatted = ethers.utils.parseUnits(amount.value, 18) if (typeof window.ethereum !== 'undefined') { trxInProgress.value = true try { const transaction = await contract.transfer( bridgeWallet, amountFormatted.toString() ) console.log('transaction :>> ', transaction) // wait for the transaction to actually settle // in the blockchain await transaction.wait() bridgedOk.value = true amount.value = '' trxInProgress.value = false } catch (error) { console.error(error) trxInProgress.value = false } }}

As you can see, there are a lot of variables that we need to pre-load, like the contract address (VITE_ORIGIN_TOKEN_ADDRESS), the bridge wallet address (VITE_BRIDGE_WALLET), and the contract ABI. Again, I decided to load them from an .env file and provided an example in the repository.

The transfer method will transfer the indicated amount of CHSD tokens from the user’s wallet to the bridge wallet. The Destination.vue file is similar although it transfers the D-CHSD tokens instead.

Create the backend process

Now that we’re able to transfer tokens from the user’s wallets to the bridge wallet, we need a job that listens to those transfers and reacts accordingly. Remember:

  • When the bridge wallet receives CHSD tokens from the ETH side of the bridge, it should mint new tokens in the Harmony side and send them to the same user.
  • When the bridge wallet receives D-CHSD tokens from the Harmony side of the bridge, it should burn those tokens and transfer back CHSD tokens from the bridge wallet to the user.

The code for the backend job is stored in the backend folder and, as the rest of the pieces, requires some variables to be configured in an .env file like:

  • WebSocket endpoints: we can get these from our Chainstack dashboard.
  • Token contract addresses: we need the token addresses to listen to the events emitted by them and to transfer, mint, and burn tokens.
  • Bridge wallet: all transactions will be signed and sent from our bridge wallet, so we need to have the private key stored in the backend.

You can find an example env file for the backend in the repository.

ERC20 tokens emit a Transfer event that we can monitor to identify bridge transactions. Here is the part of the event-watcher.js file that starts a Transfer event listener:

const CHSD_ABIJSON = require('./ChainstackDollars.json')const BRIDGE_WALLET = process.env.BRIDGE_WALLETconst BRIDGE_WALLET_KEY = process.env.BRIDGE_PRIV_KEYconst ORIGIN_TOKEN_CONTRACT_ADDRESS = process.env.ORIGIN_TOKEN_CONTRACT_ADDRESSconst originWebSockerProvider = new Web3(process.env.ORIGIN_WSS_ENDPOINT)// adds account to sign transactionsoriginWebSockerProvider.eth.accounts.wallet.add(BRIDGE_WALLET_KEY)const oriNetworkId = await originWebSockerProvider.eth.net.getId()const originTokenContract = new originWebSockerProvider.eth.Contract( CHSD_ABIJSON.abi, ORIGIN_TOKEN_CONTRACT_ADDRESS)let options = {}originTokenContract.events .Transfer(options) .on('data', async (event) => { await handleEthEvent( event, destinationWebSockerProvider, destinationTokenContract ) }) .on('error', (err) => { console.error('Error: ', err) })console.log(`Waiting for Transfer events on ${ORIGIN_TOKEN_CONTRACT_ADDRESS}`)

We need to listen to the Transfer events of both token contracts and check if the destination address of the transfer is our bridge wallet address. If that’s the case, we can proceed with the bridge operations of minting, burning, or transferring tokens.

When the bridge wallet receives CHSD on the ETH side of the bridge, we need to mint the same amount of D-CHSD tokens in the Harmony side of the bridge and send them to the same user. To do so, I created the mintTokens method:

const BRIDGE_WALLET = process.env.BRIDGE_WALLETconst ORIGIN_TOKEN_CONTRACT_ADDRESS = process.env.ORIGIN_TOKEN_CONTRACT_ADDRESSconst DESTINATION_TOKEN_CONTRACT_ADDRESS = process.env.DESTINATION_TOKEN_CONTRACT_ADDRESSconst mintTokens = async (provider, contract, amount, address) => { try { const trx = contract.methods.mint(address, amount) const gas = await trx.estimateGas({ from: BRIDGE_WALLET }) console.log('gas :>> ', gas) const gasPrice = await provider.eth.getGasPrice() console.log('gasPrice :>> ', gasPrice) const data = trx.encodeABI() console.log('data :>> ', data) const nonce = await provider.eth.getTransactionCount(BRIDGE_WALLET) console.log('nonce :>> ', nonce) const trxData = { // trx is sent from the bridge wallet from: BRIDGE_WALLET, // destination of the transaction is the ERC20 token address to: DESTINATION_TOKEN_CONTRACT_ADDRESS, data, gas, gasPrice, nonce, } console.log('Transaction ready to be sent') const receipt = await provider.eth.sendTransaction(trxData) console.log(`Transaction sent, hash is ${receipt.transactionHash}`) console.log( `mintTokens > You can see this transaction in ${process.env.DESTINATION_EXPLORER}${receipt.transactionHash}` ) } catch (error) { console.error('Error in mintTokens >', error) return false }}

As you can see, creating a valid transaction manually requires a lot of data. We need to get the gas price and amount, obtain the wallet’s transaction count (or nonce) and finally, send it and wait for it to be added to a block.

When the bridge receives D-CHSD tokens in the Harmony side of the bridge, the operation is more complex as we need to:

  1. Call approveBurn() to authorise burning the tokens in the Harmony side.
  2. Call burnFrom() to actually burn the tokens in the Harmony side.
  3. Call transfer() to transfer tokens in the ETH side of the bridge.

For this, I created three different methods that you can review in this file of the repository.

Wrapping up

To test the bridge, you just need to start the backed process with npm start and the web app with npm run dev. The web should be available on localhost:3000, where you can send some tokens between chains. In addition, you should be able to see some logs in the backend terminal.

This bridge is a simplified version and it does not handle all possible errors when minting or burning tokens, but I hope it helps you understand how they work behind the scenes.

Have you already explored what you can achieve with Chainstack? Get started for free today.

I'm an enthusiast and expert in blockchain technology, with a deep understanding of various blockchain networks and their interoperability challenges. My knowledge encompasses the technical aspects of smart contracts, token creation, and the development of decentralized applications. I've hands-on experience in deploying and interacting with smart contracts on Ethereum and Harmony blockchains.

Now, let's delve into the concepts discussed in the provided article about building a basic bridge between two EVM-compatible blockchains, Ethereum, and Harmony.

  1. Blockchains and Siloed Systems:

    • The article starts by addressing the issue of blockchains being siloed systems, meaning assets like tokens or NFTs on one blockchain are not directly usable on another. This lack of interoperability is a significant challenge in the blockchain industry.
  2. Interoperability and Cross-Chain Bridges:

    • Interoperability is highlighted as one of the industry's major challenges, and cross-chain bridges are introduced as solutions. These bridges enable the transfer of assets (tokens) from one blockchain to another.
  3. Bridge Functionality:

    • The article describes the functionality of the bridge: when tokens are received on one side, the bridge should mint equivalent tokens on the other side and vice versa. This involves using smart contracts and code to manage these transactions.
  4. Components of the Bridge:

    • The project is divided into three parts:
      • Smart Contracts: Two ERC20 token contracts are needed, one for each blockchain. The article uses Hardhat to create these contracts.
      • Web App: A frontend using Vue.js is introduced for users to interact with the bridge. It utilizes ethers.js to interact with the smart contracts.
      • Backend Job: A JavaScript process is set up to listen for tokens received in the bridge wallet. It uses web3.js to interact with blockchain nodes and smart contracts.
  5. Requirements:

    • The article lists the requirements for the project, including access to blockchain nodes on both sides of the bridge, signing up with Chainstack, deploying nodes, and obtaining RPC endpoints. Tokens are also needed for smart contract deployments and bridge transactions.
  6. Testing and Deployment:

    • The article provides steps for deploying ERC20 token contracts on Ropsten (Ethereum testnet) and Harmony testnet. It covers obtaining testnet tokens for Ropsten ETH and Harmony ONE.
  7. Frontend Development:

    • The frontend is built using Vue.js, with separate pages for each blockchain. Users can enter the number of tokens they want to bridge, and MetaMask is used for transaction authorization.
  8. Backend Process:

    • A backend job is created to listen for Transfer events in both token contracts. The backend interacts with blockchain nodes, monitors events, and triggers actions based on received tokens.
  9. Bridge Operations:

    • The article explains the operations performed by the bridge when receiving tokens:
      • Minting new tokens on the destination blockchain when receiving tokens on the source blockchain.
      • Burning tokens on the source blockchain when receiving tokens on the destination blockchain.
  10. Transaction Handling:

    • Detailed information is provided on handling transactions, estimating gas, obtaining gas prices, and sending transactions between blockchains.
  11. Wrap-Up:

    • The article concludes by emphasizing that the provided bridge is a simplified version and may not handle all possible errors. It encourages readers to explore how bridges work behind the scenes.
  12. Chainstack Promotion:

    • The article includes promotional content for Chainstack, highlighting its Web3 development platform and competitive pricing for various blockchain networks.

In summary, the article provides a comprehensive guide to building a basic bridge between Ethereum and Harmony blockchains, covering smart contract development, frontend and backend implementation, and the overall mechanics of cross-chain transactions.

How To Create An EVM Compatible Blockchain Bridge - Chainstack (2024)

FAQs

How to build an EVM bridge? ›

Workflow of the Bridge​
  1. Users deposit token on the Bridge contract.
  2. Bridge contract asks Handler contract to perform deposit action.
  3. Handler contract locks the deposited token in the token safe.
  4. Bridge contract emits Deposit event.
  5. Relayer receives the Deposit event from the source chain.

How to create a bridge in blockchain? ›

A blockchain bridge operates by either using a Wrapped Asset Method or a Liquidity Pool Method. The Wrapped Asset Method involves representing an asset from one blockchain as a token on another blockchain, maintaining its original value.

What is an EVM bridge? ›

This critical infrastructure, known as the XRPL EVM Bridge, extends its functionality beyond mere connectivity between XRPL and its EVM Sidechain, facilitating interoperability with any Ethereum Virtual Machine (EVM) compatible network.

Is ERC20 EVM compatible? ›

ERC20 is one of the most popular token standards, using the Ethereum Virtual Machine (EVM) compatible networks. It allows the creation of fungible tokens, meaning that each token will have the exact same function and value.

What blockchains are compatible with EVM? ›

EVM compatibility is a good stepping-stone in solving this issue, proven by some of the most used blockchains currently: Avalanche, Binance Smart Chain, Fantom Opera, and Polygon.

Which programming language is EVM compatible? ›

Solidity (Ethereum and EVM-compatible platforms)

Solidity is the most popular crypto coding language in the world. It's the default option for smart contract programming on Ethereum and all EVM (Ethereum Virtual Machine) chains, including Polygon, Arbitrum, Optimism, Binance Smart Chain, Avalanche, and others.

What is an example of a blockchain bridge? ›

For example, a user on one blockchain may want to send a digital asset you're managing, such as a cryptocurrency, to a user on another blockchain. A bridge can facilitate this transfer by allowing the asset to be "wrapped" in a form that can be recognized and transferred between the two networks.

What is the best bridge between blockchains? ›

1. Synapse Protocol - The best crypto bridge platform overall. Synapse Protocol is a network that enables communication between different blockchains.

Is EVM a blockchain? ›

The Ethereum Virtual Machine (EVM) is the computation engine for Ethereum that manages the state of the blockchain and enables smart contract functionality.

What is an EVM example? ›

Earned value management example – 1. Let's imagine we are building a wind power plant. The project is set to be completed in 10 months with an estimated cost of $500,000. The project has been running for 5 months now, the team has spent $220,000 and completed an amount of work worth $255,000.

Is Chainlink an EVM? ›

Aside from Ethereum, the Chainlink network services most EVM-compatible chains, which are blockchains that adopted Ethereum's virtual machine as their operating system, as well as the Solana network.

Which wallet supports EVM? ›

Coinbase is an EVM compatible software wallet. Apex wallet is a new Ethereum digital wallet used to store digital assets. 1inch is a DEX aggregator powering flexible swaps and trades through their native protocol. Cryptocurrency wallet that also lets users manage their DeFi and NFT portfolios.

Is stacks EVM compatible? ›

RSK is also EVM-compatible, where Stacks uses Clarity and the Clarity VM.

Is MetaMask an EVM wallet? ›

And remember — MetaMask is made to be your wallet no matter the EVM-compatible chain you're on. For instructions on adding a new network, see here.

How do you build a bridge in 5 steps? ›

5 Steps to Build a Beam Bridge
  1. Step 1 – Survey the bridge location. Before doing any construction, make sure you study the location. ...
  2. Step 2 – Build the beam bridge foundation. ...
  3. Step 3 – Secure beams to foundation. ...
  4. Step 4 – Add planks to the bridge. ...
  5. Step 5 – Test the weight capacity.
Sep 4, 2019

How do you implement EVM? ›

How to Implement Earned Value Management?
  1. Define Scope and Objectives. ...
  2. Create a Work Breakdown Structure (WBS) ...
  3. Assign Budgets to Work Packages. ...
  4. Develop a Project Schedule. ...
  5. Determine the Earned Value (EV) ...
  6. Track Actual Costs (Actual Cost or AC) ...
  7. Calculate Cost Variance (CV) ...
  8. Calculate Schedule Variance (SV)
5 days ago

How to build a Golden Bridge? ›

Building A Golden Bridge
  1. Have everyone involved in the building/writing the agreement. ...
  2. Look beyond the obvious interests (i.e. money) to include other, not-so-obvious interests. ...
  3. Saving face. ...
  4. Keep it simple.
Mar 9, 2009

Top Articles
How Long Should a Workout Last?
Types of Anime: Shonen | Milford Library |
Spn 1816 Fmi 9
Craigslist Niles Ohio
Trabestis En Beaumont
Valley Fair Tickets Costco
Southeast Iowa Buy Sell Trade
America Cuevas Desnuda
Craigslist Free Stuff Appleton Wisconsin
Hotels Near 500 W Sunshine St Springfield Mo 65807
Www Thechristhospital Billpay
Knaben Pirate Download
Sams Gas Price Fairview Heights Il
Slope Unblocked Minecraft Game
Dumb Money
Los Angeles Craigs List
The Banshees Of Inisherin Showtimes Near Regal Thornton Place
Amazing deals for DKoldies on Goodshop!
Danforth's Port Jefferson
Ubg98.Github.io Unblocked
Leccion 4 Lesson Test
Program Logistics and Property Manager - Baghdad, Iraq
Jenna Ortega’s Height, Age, Net Worth & Biography
Ford F-350 Models Trim Levels and Packages
Riversweeps Admin Login
Southland Goldendoodles
Myql Loan Login
Mals Crazy Crab
Klsports Complex Belmont Photos
Cardaras Funeral Homes
Meta Carevr
Rugged Gentleman Barber Shop Martinsburg Wv
3 Ways to Drive Employee Engagement with Recognition Programs | UKG
Paradise Point Animal Hospital With Veterinarians On-The-Go
Astro Seek Asteroid Chart
Busch Gardens Wait Times
10 Best Quotes From Venom (2018)
FREE Houses! All You Have to Do Is Move Them. - CIRCA Old Houses
Craigslist Maryland Baltimore
Nacogdoches, Texas: Step Back in Time in Texas' Oldest Town
Manuel Pihakis Obituary
Google Chrome-webbrowser
Nearest Ups Office To Me
My Locker Ausd
Craigslist Freeport Illinois
Umiami Sorority Rankings
Best Haircut Shop Near Me
Richard Mccroskey Crime Scene Photos
53 Atms Near Me
Assignation en paiement ou injonction de payer ?
Latest Posts
Article information

Author: Manual Maggio

Last Updated:

Views: 5773

Rating: 4.9 / 5 (49 voted)

Reviews: 80% of readers found this page helpful

Author information

Name: Manual Maggio

Birthday: 1998-01-20

Address: 359 Kelvin Stream, Lake Eldonview, MT 33517-1242

Phone: +577037762465

Job: Product Hospitality Supervisor

Hobby: Gardening, Web surfing, Video gaming, Amateur radio, Flag Football, Reading, Table tennis

Introduction: My name is Manual Maggio, I am a thankful, tender, adventurous, delightful, fantastic, proud, graceful person who loves writing and wants to share my knowledge and understanding with you.