COMMENT CONSTRUIRE UN TOKEN BRIDGE DÉCENTRALISÉ ENTRE ETHEREUM ET BINANCE SMART CHAIN ​​? | de Ishan Shahzad | Coinmons | février 2022

La technologie Blockchain continue d’évoluer et elle a considérablement changé depuis 2008, lorsque Satoshi Nakamoto a introduit la première crypto-monnaie, Bitcoin, au monde. Bitcoin a apporté la technologie blockchain. Depuis lors, plusieurs plateformes de blockchain ont été lancées. Chaque blockchain a des caractéristiques et des fonctionnalités uniques pour combler le fossé entre la technologie blockchain et ses implications dans le monde réel. Malgré les avantages incroyables de la blockchain, tels que sa nature décentralisée, l’immuabilité des enregistrements, le grand livre distribué et la technologie des contrats intelligents, un obstacle majeur affecte toujours l’adoption massive de la blockchain, à savoir le manque d’interopérabilité.

Bien que les blockchains publiques maintiennent la transparence des données en chaîne, leur nature cloisonnée limite l’utilisation holistique de la blockchain dans la finance décentralisée et de nombreuses autres industries. Les blockchains ont des capacités uniques que les utilisateurs souhaitent souvent utiliser ensemble. Cependant, cela ne semble pas possible puisque ces blockchains fonctionnent indépendamment sur leur écosystème isolé et respectent leurs propres règles de consensus uniques. Les chaînes de blocs indépendantes ne peuvent pas interagir les unes avec les autres pour échanger des informations ou de la valeur.

Ce problème d’interopérabilité devient critique en raison de l’expansion des réseaux de blockchain et de l’augmentation du nombre de projets DeFi inter-chaînes. Pendant ce temps, une telle nature cloisonnée de la blockchain contredit le principe fondamental de la décentralisation, qui consiste à rendre la blockchain accessible à tous. Existe-t-il une solution à ce manque d’interopérabilité ? Comment quelqu’un du réseau Ethereum peut-il accéder aux données et aux ressources disponibles sur une blockchain différente comme Binance ? C’est là que les solutions de pontage ou les ponts blockchain entrent en jeu.

Explorons les solutions de pontage et leurs mécanismes de travail dans cet article. De plus, nous apprendrons également à construire un pont de jetons décentralisé entre Ethereum et Binance Smart Chain, deux chaînes de blocs populaires pour le développement DeFi.

Un pont blockchain permet l’interopérabilité et la connectivité entre deux blockchains uniques qui fonctionnent sous différents mécanismes de consensus. Plus clairement, les ponts blockchain permettent à deux blockchains différentes d’interagir l’une avec l’autre. Les blockchains peuvent partager des instructions d’exécution de contrats intelligents, transférer des jetons et partager des données et des ressources dans les deux sens entre deux blockchains indépendantes car elles ne restent plus limitées par leur origine. Ces blockchains peuvent même accéder aux données hors chaîne, comme l’accès au graphique en direct du marché boursier. Certains des ponts blockchain largement utilisés sont xPollinate, Matic Bridge, Binance Bridge. Les ponts Blockchain offrent les avantages suivants aux utilisateurs :

• Les utilisateurs peuvent tirer parti des avantages de deux blockchains distinctes pour créer des dApps au lieu de se contenter de la blockchain hébergée. Cela signifie qu’un utilisateur peut déployer dApp sur Solana et peut alimenter le dApp avec la technologie de contrat intelligent d’Ethereum.
• Les utilisateurs peuvent transférer des jetons d’une blockchain qui facture des coûts de transaction élevés vers une autre blockchain où les coûts de transaction sont comparativement moins chers.
• Avec la possibilité de transférer des jetons instantanément, les utilisateurs peuvent passer rapidement d’une crypto-monnaie volatile à des Stablecoins sans faire appel à un intermédiaire.
• On peut également héberger des actifs numériques sur une application décentralisée d’une blockchain différente. Par exemple, on peut créer des NFT sur la blockchain Cardano et les héberger sur le marché Ethereum.
• Le pontage permet aux utilisateurs d’exécuter des dAPP sur plusieurs écosystèmes de blockchain.

Pour comprendre le fonctionnement des ponts blockchain, nous devons d’abord savoir combien de types existent. Actuellement, deux types de ponts blockchain sont présents ; un pont fédéré et un pont sans confiance. Maintenant, comprenons leur mécanisme de travail.

Pont fédéré

Un pont fédéré est également appelé pont centralisé. Il s’agit essentiellement d’une sorte d’échange centralisé où les utilisateurs interagissent avec un pool qui peut parfois être une entreprise ou un intermédiaire. Si le transfert de jeton se produit pour Ether et BNB, il y aura deux grands pools ; un contenant du BNB et un autre contenant de l’Ether. Dès que l’expéditeur lance le transfert avec Ether, il est ajouté au pool, et le pool lui envoie une quantité équivalente de BNB à partir du deuxième pool. L’autorité centralisée facture une somme modique pour réglementer ce processus. Cependant, les frais sont un petit montant que les utilisateurs peuvent payer facilement.

Pont sans confiance

Il s’agit du pont purement décentralisé qui élimine le rôle de tout tiers. Les ponts blockchain sans confiance n’utilisent même pas l’API pour administrer le processus de gravure et de frappe du jeton. Au lieu de cela, le contrat intelligent joue ici un rôle clé. Lorsqu’un utilisateur lance le transfert de jetons via le pont sans confiance, le contrat intelligent gèle ses cryptos actuels et lui fournit une copie des jetons équivalents sur le nouveau réseau. Le contrat intelligent frappe ensuite le jeton car il comprend que l’utilisateur a déjà gelé ou brûlé des jetons sur un autre réseau.

Serrure et Menthe

Les jetons ne sont pas vraiment transférés via un pont blockchain. Lorsqu’un utilisateur transfère un jeton vers une autre blockchain, un processus en deux étapes a lieu. Dans un premier temps, les jetons sont gelés sur la blockchain actuelle. Ensuite, un jeton de valeur égale est frappé sur la blockchain réceptrice. Ainsi, si l’utilisateur souhaite racheter les jetons, le pont brûle le jeton équivalent pour déverrouiller la valeur d’origine.

Solution basée sur la confiance

Les ponts blockchain décentralisés basés sur la confiance sont populaires même s’ils incluent un « commerçant » ou un dépositaire de confiance. Le dépositaire contrôle le fonds (jetons) via un portefeuille et facilite le processus de transfert de jetons. Ainsi, une grande flexibilité reste dans de nombreux réseaux blockchain.

Sidechain d’assistance

Alors qu’un pont relie deux blockchains différentes, un pont sidechain connecte une blockchain parente à sa blockchain enfant. Étant donné que la blockchain parent et enfant existe sur des chaînes distinctes, ils ont besoin d’un pont blockchain pour communiquer ou partager des données.

Gestion robuste

Les validateurs de pont agissent en tant qu’opérateurs de réseau. Ces opérateurs émettent des jetons correspondants en échange du jeton qu’ils reçoivent d’un autre réseau via un contrat intelligent spécial.

Garanties inter-chaînes

Les garanties inter-chaînes aident les utilisateurs à déplacer des actifs d’une blockchain de valeur significative à une autre avec des frais peu élevés. Auparavant, les utilisateurs n’étaient autorisés à emprunter des actifs qu’à leur chaîne d’origine. Désormais, ils peuvent tirer parti des emprunts inter-chaînes via un pont blockchain qui nécessite des liquidités supplémentaires.

Efficacité

Les ponts blockchain autorisent la régulation des micro transferts spontanés. Ces transferts se produisent instantanément entre différentes blockchains à des taux réalisables et nominaux.

Voici les trois grandes raisons pour lesquelles un pont blockchain ou une solution de pontage est crucial :

Transfert de jetons multi-blockchain

Le rôle le plus évident mais le plus crucial du pont blockchain est qu’il permet l’échange inter-blockchain. Les utilisateurs peuvent créer instantanément des jetons sur la blockchain souhaitée sans utiliser de processus d’échange coûteux ou fastidieux.

Développement

Les ponts de chaînes de blocs aident diverses chaînes de blocs à se développer en tirant parti des capacités des unes et des autres. Par exemple, les fonctionnalités d’Ethereum ne peuvent pas être disponibles sur BSC. Les solutions de pontage leur permettent de travailler et de grandir ensemble en tant que joueur d’équipe pour résoudre les défis qui se posent dans l’espace blockchain.

Les frais de transaction

La dernière grande raison derrière le besoin d’une solution de transition est les frais de transaction, souvent élevés sur les chaînes de blocs populaires. En revanche, les nouvelles chaînes de blocs n’imposent pas de coûts de transaction élevés, bien qu’elles manquent de sécurité et d’autres fonctionnalités majeures. Ainsi, les ponts permettent aux gens d’accéder à de nouveaux réseaux, de transférer des jetons vers ce réseau et de traiter des transactions à un coût relativement faible.

En utilisant cette procédure étape par étape, vous apprendrez à construire un pont complètement décentralisé entre la chaîne intelligente Ethereum et Binance en utilisant le langage de programmation Solidity. Bien que de nombreux ponts blockchain utilisent des API pour transférer des jetons et des informations, les API sont vulnérables aux piratages et peuvent envoyer de fausses transactions une fois piratées. Nous allons donc rendre le pont entièrement décentralisé en supprimant l’API du mécanisme.

Nous autorisons le script de pont à générer un message signé que le contrat recevra pour frapper les jetons après vérification de la signature. Le contrat garantit également que le message est unique et n’a pas été utilisé auparavant. De cette façon, vous donnez le message signé à l’utilisateur, et il est chargé de le soumettre à la blockchain pour frapper et payer la transaction.

Configurez d’abord un contrat intelligent pour la base du pont en utilisant les fonctions suivantes

import '@openzeppelin/contracts/token/ERC20/IERC20.sol';
import './Itoken.sol';
contract BridgeBase {
address public admin;
IToken public token;
mapping(address => mapping(uint => bool)) public processedNonces;
enum Step { Burn, Mint }
event Transfer(
address from,
address to,
uint amount,
uint date,
uint nonce,
bytes signature,
Step indexed step
);
constructor(address _token) {
admin = msg.sender;
token = IToken(_token);
}
function burn(address to, uint amount, uint nonce, bytes calldata signature) external {
require(processedNonces[msg.sender][nonce] == false, 'transfer already processed');
processedNonces[msg.sender][nonce] = true;
token.burn(msg.sender, amount);
emit Transfer(
msg.sender,
to,
amount,
block.timestamp,
nonce,
signature,
Step.Burn
);
}
function mint(
address from,
address to,
uint amount,
uint nonce,
bytes calldata signature
) external {
bytes32 message = prefixed(keccak256(abi.encodePacked(
from,
to,
amount,
nonce
)));
require(recoverSigner(message, signature) == from , 'wrong signature');
require(processedNonces[from][nonce] == false, 'transfer already processed');
processedNonces[from][nonce] = true;
token.mint(to, amount);
emit Transfer(
from,
to,
amount,
block.timestamp,
nonce,
signature,
Step.Mint
);
}
function prefixed(bytes32 hash) internal pure returns (bytes32) {
return keccak256(abi.encodePacked(
'\x19Ethereum Signed Message:\n32',
hash
));
}
function recoverSigner(bytes32 message, bytes memory sig)
internal
pure
returns (address)
{
uint8 v;
bytes32 r;
bytes32 s;
(v, r, s) = splitSignature(sig);
return ecrecover(message, v, r, s);
}
function splitSignature(bytes memory sig)
internal
pure
returns (uint8, bytes32, bytes32)
{
require(sig.length == 65);
bytes32 r;
bytes32 s;
uint8 v;
assembly {
// first 32 bytes, after the length prefix
r := mload(add(sig, 32))
// second 32 bytes
s := mload(add(sig, 64))
// final byte (first byte of the next 32 bytes)
v := byte(0, mload(add(sig, 96)))
}
return (v, r, s);
}
}

Après avoir construit et déployé le code de base du pont, déployez le pont Binance en utilisant le code suivant

pragma solidity ^0.8.0;
import './BridgeBase.sol';
contract BridgeBsc is BridgeBase {
constructor(address token) BridgeBase(token) {}
}

Ensuite, déployez un autre composant du pont de jetons décentralisé ; le pont de jetons Ethereum en utilisant le code suivant.

pragma solidity ^0.8.0;
import './BridgeBase.sol';
contract BridgeEth is BridgeBase {
constructor(address token) BridgeBase(token) {}
}

Une fois les contrats terminés, fabriquez et gravez l’IToken en utilisant le code suivant :

pragma solidity ^0.8.0;
interface IToken {
function mint(address to, uint amount) external;
function burn(address owner, uint amount) external;
}

Ensuite, après avoir créé et gravé l’IToken, programmez les migrations :

// SPDX-License-Identifier: MIT
pragma solidity >=0.4.22 <0.9.0;
contract Migrations {
address public owner = msg.sender;
uint public last_completed_migration;
modifier restricted() {
require(
msg.sender == owner,
"This function is restricted to the contract's owner"
);
_;
}
function setCompleted(uint completed) public restricted {
last_completed_migration = completed;
}
}

Maintenant, écrivez le contrat intelligent pour la base de jetons.

pragma solidity ^0.8.0;
import '@openzeppelin/contracts/token/ERC20/ERC20.sol';
contract TokenBase is ERC20 {
address public admin;
constructor(string memory name, string memory symbol) ERC20(name, symbol) {
admin = msg.sender;
}
function updateAdmin(address newAdmin) external {
require(msg.sender == admin, 'only admin');
admin = newAdmin;
}
function mint(address to, uint amount) external {
require(msg.sender == admin, 'only admin');
_mint(to, amount);
}
function burn(address owner, uint amount) external {
require(msg.sender == admin, 'only admin');
_burn(owner, amount);
}
}

Une fois la base de jetons déployée, déployez le jeton sur la chaîne intelligente Binance en utilisant le code donné :

pragma solidity ^0.8.0;
import './TokenBase.sol';
contract TokenBsc is TokenBase {
constructor() TokenBase('BSC Token', 'BTK') {}
}

Ensuite, déployez le token sur Ethereum en utilisant le code donné :

pragma solidity ^0.8.0;
import './TokenBase.sol';
contract TokenEth is TokenBase {
constructor() TokenBase('ETH Token', 'ETK') {}
}

Une fois le token déployé sur la smart chain Binance et Ethereum, nous programmerons la fonction de migration :

const Migrations = artifacts.require("Migrations");
module.exports = function (deployer) {
deployer.deploy(Migrations);
};

Maintenant, déployez le pont entre Ethereum et la chaîne intelligente Binance.

const TokenEth = artifacts.require('TokenEth.sol');
const TokenBsc = artifacts.require('TokenBsc.sol');
const BridgeEth = artifacts.require('BridgeEth.sol');
const BridgeBsc = artifacts.require('BridgeBsc.sol');
module.exports = async function (deployer, network, addresses) {
if(network === 'ethTestnet') {
await deployer.deploy(TokenEth);
const tokenEth = await TokenEth.deployed();
await tokenEth.mint(addresses[0], 1000);
await deployer.deploy(BridgeEth, tokenEth.address);
const bridgeEth = await BridgeEth.deployed();
await tokenEth.updateAdmin(bridgeEth.address);
}
if(network === 'bscTestnet') {
await deployer.deploy(TokenBsc);
const tokenBsc = await TokenBsc.deployed();
await deployer.deploy(BridgeBsc, tokenBsc.address);
const bridgeBsc = await BridgeBsc.deployed();
await tokenBsc.updateAdmin(bridgeBsc.address);
}
};

Une fois le pont déployé, déployez le pont décentralisé :

const TokenBsc = artifacts.require('./TokenBsc.sol');
module.exports = async done => {
const [recipient, _] = await web3.eth.getAccounts();
const tokenBsc = await TokenBsc.deployed();
const balance = await tokenBsc.balanceOf(recipient);
console.log(balance.toString());
done();
}

Ensuite, programmez l’API bridge qui écoute les événements de transfert :

const Web3 = require('web3');
const BridgeEth = require('../build/contracts/BridgeEth.json');
const BridgeBsc = require('../build/contracts/BridgeBsc.json');
const web3Eth = new Web3('url to eth node (websocket)');
const web3Bsc = new Web3('https://data-seed-prebsc-1-s1.binance.org:8545');
const adminPrivKey = '';
const { address: admin } = web3Bsc.eth.accounts.wallet.add(adminPrivKey);
const bridgeEth = new web3Eth.eth.Contract(
BridgeEth.abi,
BridgeEth.networks['4'].address
);
const bridgeBsc = new web3Bsc.eth.Contract(
BridgeBsc.abi,
BridgeBsc.networks['97'].address
);
bridgeEth.events.Transfer(
{fromBlock: 0, step: 0}
)
.on('data', async event => {
const { from, to, amount, date, nonce, signature } = event.returnValues;
const tx = bridgeBsc.methods.mint(from, to, amount, nonce, signature);
const [gasPrice, gasCost] = await Promise.all([
web3Bsc.eth.getGasPrice(),
tx.estimateGas({from: admin}),
]);
const data = tx.encodeABI();
const txData = {
from: admin,
to: bridgeBsc.options.address,
data,
gas: gasCost,
gasPrice
};
const receipt = await web3Bsc.eth.sendTransaction(txData);
console.log(Transaction hash: ${receipt.transactionHash});
console.log( Processed transfer: - from ${from} - to ${to} - amount ${amount} tokens - date ${date} - nonce ${nonce} );
});

Maintenant, déployez la fonction de clé privée sur le pont Ethereum.

const BridgeEth = artifacts.require('./BridgeEth.sol');
const privKey = 'priv key of sender';
module.exports = async done => {
const nonce = 1; //Need to increment this for each new transfer
const accounts = await web3.eth.getAccounts();
const bridgeEth = await BridgeEth.deployed();
const amount = 1000;
const message = web3.utils.soliditySha3(
{t: 'address', v: accounts[0]},
{t: 'address', v: accounts[0]},
{t: 'uint256', v: amount},
{t: 'uint256', v: nonce},
).toString('hex');
const { signature } = web3.eth.accounts.sign(
message,
privKey
);
await bridgeEth.burn(accounts[0], amount, nonce, signature);
done();
}

Enfin, programmez la fonction d’équilibrage des jetons pour le pont :

const TokenEth = artifacts.require('./TokenEth.sol');
module.exports = async done => {
const [sender, _] = await web3.eth.getAccounts();
const tokenEth = await TokenEth.deployed();
const balance = await tokenEth.balanceOf(sender);
console.log(balance.toString());
done();
}

Pour déployer un contrat intelligent de pont sur Ethereum, tapez ce code donné dans le réseau de test Ethereum

~ETB/code/screencast/317-eth-bsc-decenrealized-bridge $ truffle migrate --reset --network ethTestnet

Pour déployer un contrat intelligent de pont sur la chaîne intelligente Binance, tapez ce code donné dans le testnet BSC

~ETB/code/screencast/317-eth-bsc-decenrealized-bridge $ truffle migrate --reset --network bscTestnet

L’avènement des ponts blockchain a fait de la blockchain une technologie plus courante. Les solutions de pontage facilitent également la conception des applications DeFi qui permettent le prospectus d’un système décentralisé et financier. En permettant des connexions entre différentes blockchains ou en travaillant ensemble, les ponts de blockchain aident les utilisateurs à se diriger vers le système décentralisé de nouvelle génération. Ainsi, il vise à mettre fin à la souveraineté du système centralisé sur l’écosystème d’affaires. Cependant, la blockchain prévoit d’apporter de nombreux nouveaux paradigmes pour réinventer les ponts existants et promouvoir une plus grande innovation et pertinence technologique.

Rejoindre Coinmonks Chaîne de télégramme et Chaîne Youtube en savoir plus sur le trading de crypto et l’investissement