KryptoAuth: Web DApp for Secure Authentication Built with Java Solidiy

A project for my Bachelor's Degree in Computer Science  at University of Salerno.

Project description and introduction

In this section we introduce context informations for the project.

Introduction

🎓 The Web DApp KryptoAuth is made with the aim of offering greater security during the authentication operation by exploiting the Ethereum Blockchain technology. The system allows any user to register and wait for a administrator gives him the permissions of "User" or "Admin" to carry out the operation of Login.

Documentation

  • Project's javadoc can be found in docs/javaDoc directory and at the following link: Javadoc Link.
  • Documentation can be found in docs/deliverables directory and at the following link: Documentation

Technical informations

Installation guide can be found in docs/deliverables directory and at the following link: User manual

Built With

  • Spring Boot - Framework used to perform code development.
  • Solidity - Object-oriented, high-level language for implementing smart contracts.
  • Web3j - Highly modular, reactive, type safe Java and Android library for working with Smart Contracts and integrating with clients on the Ethereum network.
  • Web3js - A collection of libraries that allow you to interact with a local or remote ethereum node using HTTP, IPC or WebSocket.
  • Ganache - Blockchain based on Ethereum.
  • Metamask - A crypto wallet & gateway to blockchain apps.
  • Truffle - Development environment for Smart Contracts.
  • OpenZeppelin - The standard for secure blockchain applications.

Download details:

Author: Alberto-00
Source code: https://github.com/Alberto-00/Blockchain-Authentication

#spring #springboot #java #solidity #web33 #web3js #ganache #metamask #truffle #openzeppelin #blockchain

KryptoAuth: Web DApp for Secure Authentication Built with Java Solidiy

Building NFT Marketplace using Solidity, Web3, React, Metamask

ERC721 NFT Marketplace

Prototype of a NFT Marketplace based on openZeppelin abstract upgradeable ERC721 contracts and Minting/uploading images to IPFS and integration with Opensea.io

Dependencies

This project relies on NFT Contracts package and NFT Lambda Service for serving the metadata

Functionalities

  1. Buy a pre-minted token.
  2. Sell the token that was bought.
  3. Transferring ETH to the previous token holder;
  4. Adding and removing tokens from the marketplace;
  5. Minting tokens;
  6. Uploading NFT image to IPFS;
  7. Metadata and marketplace on Opensea.io
  8. Metadata and IPFS Lambda functions on AWS

See it live on Rinkeby Network

See my portfolio for more details


ETH-USD Service

It's been transferred to the NFT Lambda Service repository.

Tech-Stack

  • Typescript
  • Solidity
  • React
  • Truffle / Ganache
  • Storybook
  • openZeppelin
  • Metamask (web3)
  • Opensea.io
  • Web3-react
  • IPFS
  • Lambda AWS
  • serverless

.env file

NODE_ENV=development
BROWSER=chrome
REACT_APP_SERVICE_URL=http://localhost:4000/dev
REACT_APP_RPC_URL_1=http://0.0.0.0:7545
REACT_APP_RPC_URL_4=https://rinkeby.infura.io/v3/INFURA_KEY

package.json

{
  "name": "@fluuuid/nft-marketplace",
  "version": "2.0.0",
  "homepage": "https://nft.s2paganini.com",
  "dependencies": {
    "@ethersproject/constants": "^5.4.0",
    "@ethersproject/providers": "^5.4.0",
    "@fluuuid/nft-contracts": "silviopaganini/nft-contracts",
    "@sentry/react": "^6.8.0",
    "@sentry/tracing": "^6.8.0",
    "@testing-library/jest-dom": "^5.14.1",
    "@testing-library/react": "^12.0.0",
    "@testing-library/user-event": "^13.1.9",
    "@types/jest": "^26.0.23",
    "@types/node": "^16.3.0",
    "@types/react": "^17.0.11",
    "@types/react-dom": "^17.0.8",
    "@web3-react/abstract-connector": "^6.0.7",
    "@web3-react/authereum-connector": "^6.2.0",
    "@web3-react/core": "^6.1.9",
    "@web3-react/fortmatic-connector": "^6.1.6",
    "@web3-react/frame-connector": "^6.0.9",
    "@web3-react/injected-connector": "^6.0.7",
    "@web3-react/lattice-connector": "^6.1.9",
    "@web3-react/ledger-connector": "^6.1.9",
    "@web3-react/magic-connector": "^6.1.9",
    "@web3-react/network-connector": "^6.1.9",
    "@web3-react/portis-connector": "^6.1.9",
    "@web3-react/torus-connector": "^6.1.9",
    "@web3-react/trezor-connector": "^6.1.9",
    "@web3-react/walletconnect-connector": "^6.2.0",
    "@web3-react/walletlink-connector": "^6.2.2",
    "ethers": "^5.4.0",
    "jazzicon": "^1.5.0",
    "react": "^17.0.1",
    "react-dom": "^17.0.1",
    "react-router-dom": "^5.2.0",
    "react-scripts": "4.0.3",
    "swr": "^0.5.6",
    "theme-ui": "^0.10.0",
    "typescript": "^4.3.4",
    "web-vitals": "^2.0.1",
    "zustand": "^3.5.5"
  },
  "resolutions": {
    "babel-loader": "8.1.0"
  },
  "scripts": {
    "postinstall": "husky install",
    "start": "react-scripts start",
    "d:start": "doppler run yarn start",
    "build": "react-scripts build",
    "test": "react-scripts test",
    "eject": "react-scripts eject",
    "lint": "prettier --write './**/*.{js,jsx,ts,tsx}'",
    "cp": "./node_modules/create-react-component-folder/lib/index.js -f --typescript --nocss --stories -ns -o src/components",
    "tsc": "tsc --noEmit --skipLibCheck --project tsconfig.json",
    "storybook": "start-storybook -p 6006 -s public",
    "build-storybook": "build-storybook -s public"
  },
  "eslintConfig": {
    "extends": [
      "react-app",
      "react-app/jest"
    ]
  },
  "browserslist": {
    "production": [
      ">0.2%",
      "not dead",
      "not op_mini all"
    ],
    "development": [
      "last 1 chrome version",
      "last 1 firefox version",
      "last 1 safari version"
    ]
  },
  "devDependencies": {
    "@storybook/addon-actions": "^6.3.1",
    "@storybook/addon-essentials": "^6.3.1",
    "@storybook/addon-links": "^6.3.1",
    "@storybook/node-logger": "^6.3.1",
    "@storybook/preset-create-react-app": "^3.1.6",
    "@storybook/react": "^6.3.1",
    "@types/react-router-dom": "^5.1.7",
    "colors": "^1.4.0",
    "create-react-component-folder": "^0.3.7",
    "husky": "^7.0.1",
    "prettier": "^2.3.2",
    "yargs": "^17.0.1"
  }
}

tsconfig.json

{
  "compilerOptions": {
    "target": "es5",
    "lib": [
      "dom",
      "dom.iterable",
      "esnext"
    ],
    "allowJs": true,
    "skipLibCheck": true,
    "esModuleInterop": true,
    "downlevelIteration": true,
    "allowSyntheticDefaultImports": true,
    "strict": true,
    "forceConsistentCasingInFileNames": true,
    "noFallthroughCasesInSwitch": true,
    "module": "esnext",
    "moduleResolution": "node",
    "resolveJsonModule": true,
    "isolatedModules": true,
    "noEmit": true,
    "jsx": "react-jsx"
  },
  "include": [
    "src"
  ]
}

Download details:
 

Author: silviopaganini
Source code: https://github.com/silviopaganini/nft-market
License: MIT license

#solidity #smartcontract #blockchain #ethereum #web3 #openzeppelin #metamask #react 

Building NFT Marketplace using Solidity, Web3, React, Metamask

How to Get Staking Reward in form Of Dapp Tokens Using Solidity, Web3

About the Application

There are 3 Smart Contract in this project, where 2 sol file is for ERC20 tokens, where one of the token is mock Dai or mDai, which is acting as the colateral for this project. The user will have to Deposit the mDai token to TokenFram SmartContract and for depositing our mDai we will get staking reward in form of Dapp Tokens.

Technology Used

  • Solidity
  • Truffle
  • React
  • Web3
  • Ganache
  • Metamask

How to run the Project

  • Start the local Blockchain in Ganache.
  • Connect the Local Blockchain with Metamask and import the second account to meta mask
  • Run Truffle Commands
    • Truffle Compile to compile the smartcontract
    • truffle migrate --reset to migrate your code to blockchain
  • Now start the Front End by npm start the React will run on localhost:3000
  • You can start deposit your mDai from the imported account.
  • Now you can run truffle exec scripts/issue-token.js to distribute the the reward to the investors

Download Details:
Author: 0xdevnet
Source Code: https://github.com/0xdevnet/staking-and-reward
License:

#blockchain #solidity #smartcontract #web3 #metamask #truffle #metamask 

How to Get Staking Reward in form Of Dapp Tokens Using Solidity, Web3

How to Develop Dapp Front End Page using React, Hardhat, MetaMask

hardhat-react

Preface

The important part of developing Dapp is the front end. The sample will use hardhat combined with react and MetaMask to show how to develop Dapp front end page, the process of developing and the calling of interface. Developers will get the point of the sample code when they have ability to use react.

Put your private key in .env for easy access, formatted with "PRIVATE_KEY=xxxx".

Steps

  1. Install dependencies
npm install

2.   Deploy contracts

npx hardhat run scripts/deploy.js --network kovan

3.   Startup react

cd frontend
npm install
npm start

4.   Try to init a ERC20 transaction in the page and watch the change of account tokens balance.

Reference

Link: https://github.com/Dapp-Learning-DAO/Dapp-Learning/tree/main/basic/09-hardhat-react

#dapp #solidity #blockchain #react #hardhat #metamask 

How to Develop Dapp Front End Page using React, Hardhat, MetaMask

Hướng dẫn nhanh cách thêm BSC vào Metamask

Ví Metamask là loại ví tiền điện tử tích hợp vào trình duyệt để giao dịch cực nhanh chóng. Vì lẽ đó mà nó có số lượng người dùng cực kỳ lớn. Tuy nhiên đây lại là ví chuyên dụng dành cho blockchain Ethereum và chỉ có thể lưu trữ token chuẩn ERC-20. Tuy nhiên từ khi Binance cho ra mắt blockchain Binance Smart Chain (BSC) thì mọi vấn đề đã được giải quyết. Vì BSC vừa có thể tương thích với Binance chain vừa có thể tương thích vởi Ethereum blockchain cho nên bạn có thể thêm BSC vào ví Metamask và lưu trữ coin tương thích với blockchain này.

Trong bài viết này mình sẽ hướng dẫn các bạn cách thêm BSC vào Metamask theo 2 cách đơn giản và dễ thực hiện dù là người mới. Tuy nhiên trước khi thêm bạn cần đảm bảo mình có ví Metamask trước.

Cách thêm BSC vào Metamask

Có 2 cách để thêm BSC vào Metamask theo hướng thủ công và tự động. Cách thủ công không có nghĩa là khó hơn nhưng bạn cần có các thông số của mạng BSC mình sẽ cung cấp trong quá trình hướng dẫn. Bạn có thể làm qua cho biết vì nó cũng rất dễ. Thứ 2 là cách tự động cũng khá đơn giản nhưng bạn nên xem 2 cách để cách này không thành công thì làm cách khác.

Cách thêm BSC vào Metamask thủ công

Ví Metamask có mặc định mạng của nó là Ethereum mainet

Đầu tiên bạn vào ví Metamask và mặc định của nó là Ethereum mainet rồi bây giờ bạn chuyển qua Binance smart chain theo các bước sau:

– Nhấp vào biểu tượng hình tròn góc trên cùng bên phải (biểu tượng tài khoản của bạn) rồi chọn mục “Setting”.

Nhấp vào biểu tượng hình tròn góc trên cùng bên phải

– Trong cửa sổ này bạn chọn tab “Networks” cột ngoài cùng bên trái. Tiếp theo bạn chấp vào nút “Add network” bên phải màu xanh.

Chọn tab "Networks" cột ngoài cùng bên trái và chọn Add network

– Tiếp đến bạn điền các thông tin sau vào các ô tương ứng:

  1. Network Name: Binance Smart Chain
  2. New RPC URL: https://bsc-dataseed.binance.org/
  3. ChainID: 56
  4. Currency Symbol (optional): BNB
  5. Block Explorer URL (optional): https://bscscan.com
Cách thêm BSC vào Metamask thủ công

*Lưu ý: Trường hợp bạn thêm BSC testnet Metamask thì bạn điền thông tin là:

  1. Network Name: Binance Smart Chain Testnet
  2. New RPC URL: https://data-seed-prebsc-1-s1.binance.org:8545/
  3. Chain ID: 97
  4. Currency Symbol (optional): BNB
  5. Block Explorer URL (optional): https://testnet.bscscan.com

Khi mà kết nối với BNB testnet các bạn có thể nhận thêm 1 BNB để hỗ trợ mình test dự án trên chuỗi khối. Để nhận 1 BNB thì sau khi kết nối BSC testnet với ví Metamask xong. Bạn vào đường link này https://testnet.binance.org/faucet-smart . Tiếp, bạn sao chép địa chỉ ví BNB của bạn và dán vào ô trong “Input your BSC Address”. Rồi click vào “Give me BNB” là xong.

Bây giờ sau khi đã nhập đầy đủ các thông tin thì các bạn click “Save”. Vậy là ví metamask sẽ tự động chuyển mạng của bạn qua Binance smart chain như hình dưới.

Ví metamask sẽ tự động chuyển mạng của bạn qua Binance smart chain

Cách thêm BSC vào Metamask tự động

Đọc thêm: https://tienaogiatot.com/them-bsc-vao-metamask/

#tienaogiatot #bsc #metamask

Akshara Singh

Akshara Singh

1654776199

Metamask wallet clone script and its fascinating features

Everyone knows this digitalized era is getting familiar and people are adapting to it in a faster manner. Cryptocurrencies are a part of this new emerging era, where it has acquired major of the people’s attention because of their various benefits being offered. Making use of these cryptocurrencies plays a major role in people’s day-to-day lives. Whereas, some are interested in holding them for the long term which requires a sturdy crypto wallet to ensure security. 

Seeing this as an opportunity, some made use of it by initiating their own cryptocurrency wallet business. Wondering how? After a deep analysis, the entrepreneurs figured out the most effective way to establish their own cryptocurrency wallet is ~ the Cryptocurrency wallet clone script. They preferred to deploy a crypto wallet similar to the Metamask wallet using the Metamask wallet clone script, which stood as the most popular one in the crypto industry. 

Thinking of what a Metamask wallet clone script is? Let me explain it. Metamask wallet clone script is the crypto wallet clone software that comprises all existing features of the crypto wallet. This Metamask wallet clone script simplifies the entire development process with its predefined set of features. 

Features

  • Two-factor authentication
  • Multi-currency support
  • Buy crypto with a card
  • Secure backup of data
  • QR-code scanner
  • Password and pin security
  • Optional logout
  • Multi-signature vault
  • Home screen customization
  • Multi-platform compatibility
  • staking
  • Multi-language support
  • Push notifications

 

These are the features that a Metamask wallet clone script must possess, which eradicates the overall effort to be implemented while developing a one. After knowing this advanced technique for establishing a superfine crypto wallet, all you have to do is to seek a professional crypto wallet software provider who will be the main reason for uplifting your overall crypto business growth. 

Since there is a pile of crypto wallet clone software providers widely available in the current industry, filtering out the best one requires a hectic analysis that consumes much of your time and work. Instead, I shall join hands with you by making this entire process simple for you. I’ve done this above-mentioned analysis for my personal reference. Out of the lot, a specific provider grabbed my attention with its immense results and its past history was astonishing. Seeking a provider like them would definitely increase your business’ profile drastically. The provider I was about to reveal is Coinsclone. 

Get to know more about COINSCLONE's accomplishments and uniqueness among the various pile of crypto-exchange software providers in the current crypto market.

If you are interested in making a deal with them for enhancing your business with their Metamask wallet clone script, get in touch with their team of experts and grab your free demo now.

Whatsapp: +91 9500575285

Skype: live:hello_20214

Mail Id: hello@coinsclone.com

For instant live demo >>>>> Metamask wallet clone script

 

#metamask #metamaskwalletclonescript #wallet 

Provider Metamask For Waves Blockchain

ProviderMetamask

Overview

ProviderMetamask

Getting Started

1. Library installation

To install Signer and ProviderMetamask libraries use

npm i @waves/signer @waves/provider-metamask

2. Library initialization

Add library initialization to your app.

  • For Stagenet:
 import { Signer } from '@waves/signer';
 import { ProviderMetamask } from '@waves/provider-metamask';

 const signer = new Signer({
 	// Specify URL of the node on Stagenet
 	NODE_URL: 'https://nodes-stagenet.wavesnodes.com'
 });
 const provider = new ProviderMetamask({
 	wavesConfig: {
 		nodeUrl: 'https://nodes-stagenet.wavesnodes.com',
 		chainId: 'S'.charCodeAt(0)
 	}
 });
 signer.setProvider(provider);
  • For Mainnet:
 import { Signer } from '@waves/signer';
 import { ProviderMetamask } from '@waves/provider-metamask';

 const signer = new Signer();
 const provider = new ProviderMetamask();
 signer.setProvider(provider);

3. Basic example

Now your application is ready to work with Waves Platform. Let's test it by implementing basic functionality. For example, we could try to authenticate user and transfer funds.

const user = await signer.login();
const [transfer] = await signer
  .transfer({
    amount: 1,
    recipient: 'alias:T:merry',
  })
  .broadcast();
const user = await signer.login();
const [invoke] = await signer
  .invoke({
    dApp: "3F4bY4PsS8E1tShx9ruSYthie3uzYiSffSv",
    call:{
         function: "deposit",
         args:[{ type: "string", value: "string" }]
    },
    payment:[]
  })
  .broadcast();

For more information see Signer documentation.

4. How to sign order

Set the order parameters:

  • Omit senderPublicKey.
  • Specify asset IDs in Waves format: 32 bytes in base58. For WAVES use the string WAVES.
const orderData = {
  orderType: 'sell',
  version: 4,
  assetPair: {
    amountAsset: '8KTfWNoWYf9bP3hg1QYBLpkk9tgRb5wiUZnT1HUiNa9r',
    priceAsset: 'WAVES',
  },
  price: 100000,
  amount: 100000,
  timestamp: 1634563969123,
  expiration: 1637069590926,
  matcherFee: 300000,
  matcherFeeAssetId: null,
};
const provider = new ProviderMetamask();
const sign = await provider.signOrder(orderData);

5. How to get Ethereum address

import { ProviderMetamask } from '@waves/provider-metamask';
import { wavesAddress2eth } from '@waves/node-api-js';

const user = await signer.login();
const ethereumAddress = wavesAddress2eth(user.address);

6. How to sign message

const message = 'message text';
const provider = new ProviderMetamask();
const sign = await provider.signMessage(message);

Download Details:
Author: wavesplatform
Source Code: https://github.com/wavesplatform/provider-metamask
License:

#waves  #blockchain  #smartcontract #metamask #typescript 

Provider Metamask For Waves Blockchain

異なるチェーン間でスマートコントラクトを移行する

スマートコントラクトが別のブロックチェーンに移行される理由はいくつかあります。いくつかの明らかな理由は、ガス料金の低下または取引時間の短縮です。契約をデバッグしたり、追加のセキュリティを提供したり、盗難や技術的な問題のために契約にアクセスできなくなった場合に契約へのアクセスを提供したりするために、契約を別のチェーンにシフトすることが理にかなっている場合もあります。

このスマートコントラクト移行ガイドでは、スマートコントラクトをローカル開発チェーンから個々のブロックチェーンに移行する方法と、異なるチェーン間でスマートコントラクトを移行する方法について説明します。この記事では、いくつかのブロックチェーンの概要と、スマートコントラクトの移行に関してそれらがどのように異なるかについても説明します。

前提条件

この記事のチュートリアル部分をフォローするには、次のものがあることを確認してください。

  • ガナッシュをインストール
  • トリュフフレームワークがインストールされています
  • インストールされたノード
  • npmがインストールされました
  • Gitがインストールされました
  • GitHubアカウント
  • VS Code、または選択したコードエディター
  • MetaMaskアカウント

ブロックチェーン間での移行に関する考慮事項

いくつかの要因が、スマートコントラクトをあるブロックチェーンから別のブロックチェーンに移行する決定に影響を与える可能性があります。いくつかの例を見てみましょう。

イーサリアムvs.バイナンススマートチェーン

イーサリアムブロックチェーンは、分散型で透過的で安全なパブリックブロックチェーンです。この記事の執筆時点では、イーサリアムはプルーフオブワークコンセンサスアルゴリズムを使用しています。スマートコントラクトは、イーサリアムネットワーク上で作成できます。

イーサリアムブロックチェーンで行われたすべての操作は、成功したかどうかにかかわらず、ガス料金で支払う必要があります。操作は、あるアカウントから別のアカウントに一定量のイーサリアム(Ethereumの暗号通貨)を送信したり、契約を展開したりする可能性があります。

鉱夫が取引をブロックに追加する前に、ガス料金を支払う必要があります。イーサリアムは、ブロックガス制限と呼ばれるブロックあたりのガスの最大量を強制します。

Binance Smart Chain(BSC)は、プルーフオブステークコンセンサスアルゴリズムを使用します。イーサリアムと同様に、スマートコントラクトの作成をサポートします。

イーサリアムからBSCに移行するためのいくつかのインセンティブは、Binanceのガス料金の削減と取引時間の短縮です。これらの利点により、BSCはイーサリアムよりもスケーラブルになります。イーサリアムスマートコントラクトは、コードへの変更を最小限に抑えるか、まったく変更せずに、BSCプラットフォームに簡単に移行できます。

ただし、BSCには、分散化が少ないなど、いくつかの欠点があります。これは、 Binanceが直接または間接的に所有し、ネットワークのガス料金の削減に責任を持つ21,000ノードの検証ツールなど、いくつかの集中型エンティティがあるためです。

ポリゴン対イーサリアム

BSCと同様に、Polygonブロックチェーンはプルーフオブステークコンセンサスアルゴリズムを使用します。Polygonは、スマートコントラクトの作成をサポートし、ブロックチェーンで開始されたスマートコントラクトの相互通信を可能にすることで相互運用性を実現します。ネットワークのトークンであるMATICは、ガス料金の支払い、ステーキング、投票などのいくつかの機能を提供します。

イーサリアムからポリゴンに移行するためのいくつかのインセンティブは、ポリゴンのより速い取引時間とより低い取引手数料です。ポリゴンの構造により、イーサリアムよりもスケーラブルになります。Polygonネットワーク上のノードの数が増えると、エコシステムが拡張され、ノードが適切に含まれ、それらのトランザクションが処理されます。

それでは、異なるチェーン間でスマートコントラクトを移行する方法を見てみましょう。

デモ:ローカル開発チェーンからのスマートコントラクトの移行

このチュートリアルでは、Solidityで記述され、TuffleSuiteフレームワークにデプロイされたスマートコントラクトを使用します。Truffle Suiteは、他のイーサリアム仮想マシンブロックチェーンと統合され、スマートコントラクトを作成、テスト、コンパイル、および展開するための機能が組み込まれています。

スマートコントラクトをローカル開発チェーンにデプロイした後、それを個々のブロックチェーンにデプロイする方法を示します。アカウントの残高と取引履歴を簡単に確認できるように、デプロイにはMetaMaskを使用します。

スマートコントラクトをGanacheにデプロイする

まず、Truffle環境で構築されたブロックチェーンシミュレーションツールであるGanacheにスマートコントラクトを展開します。これにより、コードが正しくコンパイルされ、デプロイに問題がないことを確認できます。

まず、ターミナルのこのGitHubリポジトリからスマートコントラクトコードのクローンを作成します。次に、プロジェクトのディレクトリで、次のコマンドを実行して依存関係をインストールします。

npm install

先に進む前に、これが使用する開発ブロックチェーンであるため、Ganacheがインストールされていることを確認してください。

次に、以下に示すように、システムでGanacheを実行し、[クイックスタート]をクリックします。

次に、2_deploy_migration.jsファイルで定義された移行を使用してスマートコントラクトをデプロイします。

まず、ターミナルとプロジェクトのディレクトリで、次のコマンドを実行して開発ブロックチェーンを開始します。

truffle develop

これにより、それぞれが100ETHと秘密鍵を含む10個のアドレスで開発ブロックチェーンが開始されます。

次に、次のコマンドを実行してスマートコントラクトをデプロイし、migrationフォルダー内のすべてのコードを実行します。

migrate -reset

端末の出力は、2_deploy_migration.jsファイルがデプロイされていることを示しています。出力には、トランザクションハッシュ、ブロック番号、契約アドレスなどの契約情報も表示されます。

value sentやなどのスマートコントラクト情報の一部はtotal costETH(イーサリアムの通貨)で提供されていることに注意してください。スマートコントラクトを移行するときは、最初にETHにある情報を、コントラクトを移行するブロックチェーンの自国通貨に更新する必要があります。

環境を終了するには、ターミナルでCTRL + Cを2回入力します。

それでは、スマートコントラクトをEthereumブロックチェーンに移行する方法を見てみましょう。

イーサリアムのテストネット(Rinkeby)へのスマートコントラクトの展開

ローカルブロックチェーンからEthereumのRinkebyネットワークにスマートコントラクトをデプロイするには、最初にアドレスが必要です。

アドレスを生成するには、MetaMaskウォレットを開き、Rinkebyテストネットワークに接続します。

無料のエーテルを入手するには、Faucets Chainlinkを使用し、Rinkebyに接続して、ウォレットアドレスをフィールドに貼り付けます。

次に、[リクエストの送信]をクリックします。

以下に示すように、これはあなたの財布に0.1ETHを送るはずです。

次に、Truffleを構成します。コードエディタでtruffle-config.jsファイルを開き、ネットワーク構成を定義します。

truffle-config.js以下を定義しているファイルのドキュメントを確認してください。

/**
* Use this file to configure your truffle project. It's seeded with some
* common settings for different networks and features like migrations,
* compilation and testing. Uncomment the ones you need or modify
* them to suit your project as necessary.
*
* More information about configuration can be found at:
*
* https://trufflesuite.com/docs/truffle/reference/configuration
*
* To deploy via Infura you'll need a wallet provider (like @truffle/hdwallet-provider)
* to sign your transactions before they're sent to a remote public node. Infura accounts
* are available for free at: infura.io/register.
*
* You'll also need a mnemonic - the twelve-word phrase the wallet uses to generate
* public/private key pairs. If you're publishing your code to GitHub make sure you load this
* phrase from a file you've .gitignored so it doesn't accidentally become public.
*
*/

次に、Infuraでアカウントを作成します:infura.io/register次に、新しいプロジェクトを作成し、右上の[プロジェクト設定]をクリックします。

[全般]タブの[キー]で、[エンドポイント]ドロップダウンから[リンケビュー]を選択します。プロジェクトIDとInfuraのノードのURLが表示されます。

注意: ファイルにインストールされている依存関係を使用して 、プロバイダーをMetaMaskの秘密鍵に設定します。@truffle/hdwallet-provider package.json

truffle-config.jsファイルに依存関係を要求し、秘密@truffle/hdwallet-provider鍵を格納する配列を作成します。

const HDWalletProvider = require('@truffle/hdwallet-provider');
const privateKeys = ['<app your private key>'];

次に、[ネットワーク]セクションまで下にスクロールし、開発スクリプトを追加して、providerMetaMaskの秘密鍵とInfuraのノードのURLを設定します。

development: {
     provider: () => new
HDWalletProvider("<Your private key on metamask", `https://rinkeby.infura.io/v3/71acb374b9dd4e1eb06eeb9a75a8cd1a`),
     network_id: 4,       // Any network (default: none)
},

上記のコードで、network_idが4に設定されていることがわかります。これはRinkebyのネットワークIDです。他のイーサリアムネットワークは異なるIDを持っています。

次に、次のコマンドを実行して、移行と構成を実行します。

truffle migrate -network development --reset 

次に、トランザクションハッシュをコピーします。MetaMaskに移動し、Etherscanで[アカウントの表示]をクリックします。トランザクションのリストに、デプロイされたばかりのトランザクションハッシュが表示されます。

詳細を表示するには、個々のトランザクションをクリックしてください。

スマートコントラクトをPolygonのテストネット(ムンバイ)に展開する

スマートコントラクトをPolygonのムンバイネットワークに展開するには、まずMetaMaskウォレットをPolygonに接続します。MetaMaskを開き、[ネットワークの追加]をクリックして、適切なフィールドに以下を追加します。

次に、[保存]をクリックすると、MetaMaskがPolygonに接続します。

契約をPolygonのテストネットに移行するため、トランザクションの支払いにはMATICトークンが必要になります。MATICトークンを取得するには、MetaMaskウォレットを開き、ウォレットアドレスをコピーします。次に、ポリゴンの蛇口に移動し、アドレスをウォレットのアドレスフィールドに貼り付けます。[送信]をクリックし、[確認]をクリックします。

以下に示すように、リクエストが送信されたことの確認が表示されます。

数分で、MetaMaskウォレットにトークンが表示されます。MATICトークンが正常に転送されると、ウォレットの残高に表示されます。

次に、コードエディタでファイルを開きtruffle-config.jsます。ネットワークスクリプトで、イーサリアムのネットワークプロバイダーの下にポリゴンのネットワークプロバイダーを追加します。Polygonのドキュメントで定義されているムンバイテストネットのRPCURLを使用します。

以下に示すRPCリンクをコピーします。https ://rpc-mumbai.matic.today :

次に、RPCリンクをproviderURLとしてコードに貼り付けます。また、chainid(上記)をnetwork_id:としてコードに貼り付けます。

polygonTestnet: {
     provider: () => new HDWalletProvider(privateKeys, `https://rpc-mumbai.matic.today`),
     network_id: 80001,       // Any network (default: none)
   },

次に、ターミナルを開き、次のコマンドを使用してPolygonテストネットへの移行と構成を実行します。

truffle migrate --network polygonTestnet --reset

契約が正常に移行されたことを以下に示します。

次に、トランザクションハッシュをコピーします。MetaMaskアカウントを開き、エクスプローラーで[アカウントの表示]をクリックします。

トランザクションとのデプロイされたコントラクトがPolygonscanブロックチェーンエクスプローラーに表示されるはずです。

スマートコントラクトをBinanceSmartChainにデプロイする

スマートコントラクトをBinanceSmartChainのテストネットにデプロイします。BNBトークン(Binance Smartチェーンのネイティブ通貨)を取得する必要があります。

まず、MetaMaskウォレットをBSCに接続します。MetaMaskを開き、[ネットワークの追加]をクリックします。

次に、適切なフィールドに以下を追加します。

  • ネットワーク名:BSCTestnet
  • RPC URL:https ://rpc-mumbai.matic.today
  • チェーンID:97
  • 通貨記号:BNB

次に、[保存]をクリックすると、MetaMaskがBSCに接続し、BNBトークンをゼロに設定します。

無料のBNBトークンを取得するには、MetaMaskウォレットを開き、ウォレットアドレスをコピーします。次に、Binance SmartChainFaucetに移動します。アドレス入力に、MetaMaskウォレットアドレスを貼り付けます。

次に、 Give me BNBをクリックすると、1つのBNBがMetaMaskウォレットに転送されます。

MetaMaskアカウントの残高を確認することで、トークンが送信されたことを確認できます。

次に、truffle-config.jsコードエディターでファイルを編集し、BinanceSmartChainネットワークの次の構成を追加します。

 bscTestnet: {
     provider: () => new HDWalletProvider(privateKeys, `https://data-seed-prebsc-1-s1.binance.org:8545/`),
     network_id: 97,       // Any network (default: none)
   },

コントラクトをBinanceSmartChainテストネットにデプロイするには、ターミナルを開いて次のコマンドを実行します。

truffle migrate --network bscTestnet --reset

チェーン間のスマートコントラクトの移行

スマートコントラクトをあるブロックチェーンから別のブロックチェーンに移行する決定に影響を与える可能性のあるいくつかの要因について説明しました。それでは、いくつかのスマートコントラクト移行手法を見てみましょう。

パラチェーンを介した移行

Polkadotネットワークは、ブロックチェーンが相互に簡単に相互作用するための使い慣れた安全な環境を提供します。

パラチェーンは、Polkadotエコシステムで相互作用するレイヤー1ブロックチェーンです。パラチェーンは互いに独立していますが、並行して実行されます。それらはネットワークのリレーチェーンによって接続されています。この接続により、チェーン間の相互運用性、つまりデータの通信と共有が可能になります。

Polkadotネットワークは、バリデーターとノミネーターを使用して、プルーフオブステークのコンセンサスメカニズムを活用します。コレーター(下の図に表示)は、ネットワークのトランザクションに関する情報を保持します。

パラチェーンを使用すると、開発者は、トークンをラップおよびアンラップする代わりに、Polkadotのクロスコンセンサスメッセージングフォーマット(XCM)を使用してPolkadotエコシステム内でコントラクトを移行できます(これについては次のセクションで説明します)。

XCMは、チェーン、スマートコントラクト、またはブリッジ間で送信されるメッセージをフォーマットするために使用されます。XCMを使用すると、あるウォレットから別のウォレットにトランザクションを長期間送信するための定義済みの形式が有効になります。

XCMには、垂直メッセージパッシング(VMP)とクロスチェーンメッセージパッシング(XCMP)という異なる機能を持つメッセージに作用するプロトコルがあります。

さらに、XCMはクロスコンセンサス仮想マシン(XCVM)を使用します。これには、プログラムとして実行されるいくつかの命令と転送されるメッセージが含まれています。XCVMの命令は、転送されるメッセージとその宛先で構成されます。

さらに、Polkadotと、EthereumやBinance Smart Chainなどの他のレイヤー1ブロックチェーンとの間にブリッジが存在し、相互運用性を実現します。

トークンのラッピングとアンラッピングによる移行

各ブロックチェーンには、ネイティブのデジタル通貨に従って設計された取引可能なトークンがあります。スマートコントラクトが異なるチェーン間で移行される場合、あるブロックチェーン用に設計されたトークンが別のブロックチェーンで機能する方法が必要です。

これは、別の通貨を使用する国に旅行するようなものです。ただし、ブロックチェーンは通常、あるタイプのトークンを別のタイプのトークンと交換する代わりに、ラッピングとアンラッピングの概念を利用します。

ラッピングは、トークンの値を元の暗号通貨にペギングすることを伴います。ラップされたトークンは基本的に、他のブロックチェーンで使用できるトレード可能なトークンです。例として、いくつかのイーサリアムのERC-20がラップされているとしましょう。それらの値は現在の値に固定されますが、ラップされたエーテル(WETH)と見なされるようになりました。WETHトークンは、MetaMaskウォレットなどで使用され、さまざまなブロックチェーン(BSC、IOTAなど)で相互作用することができます。

トークンをラップすることの最も重要な利点の1つは、元のアセットは保持されますが、ラップされたトークンは新しいブロックチェーンの機能を継承することです。これらの機能のいくつかには、最小化された取引時間と低いガス料金が含まれる可能性があります。

トークンのアンラップとは、トークンを元の暗号通貨に戻すプロセスを指します。たとえば、WETHは元の暗号通貨であるETHにアンラップできます。

これは、 OpenZeppelinERC-20標準を使用したイーサリアムトークンのラッピングとアンラッピングを示すデモです。

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.7.0 <0.9.0;
import https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol;
contract WETH is ERC20 {
    constuctor() ERC20("Wrapped Ether", "WETH") public {};

    // define a mint function to create new wrapped ether token
    function mint() external payable {
        _mint(msg.sender, msg.value); 
    }
    // define a burn function to create an unwrapped token
    function burn(uint amount) external { //specify the amount that you want back
        payable(msg.sender).transfer(amount); // transfers 
        _burn(msg.sender, amount); //sending back the ether to the user
    }
}

上記のコードブロックのコードの個々の行を詳しく見てみましょう。

  • 1行目:Solidityコンパイラに使用されるライセンスを指定します
  • 2行目:Solidityバージョンを指定します
  • 3行目:OpenZeppelinで定義されているERC-20トークン標準をインポートします
  • 4行目:ラップされたトークンとラップされていないトークンを作成するためのコントラクトを定義します
  • constructor``()5行目:コントラクトが実行されるとすぐに、Etherの名前を「WrappedEther」に設定し、そのシンボルを「WETH」に設定する関数を定義します
  • mint()7行目: Etherの値を受け入れ、新しいラップされたEtherトークンを作成する関数を定義します。外部修飾子は、関数を他のコントラクトから呼び出すことができることを意味します。支払い可能な修飾子は、関数がEtherを受け入れて送信できることを示します
  • 9行目:_mintOpenZeppelinコードで定義されている関数を使用しています。トランザクションの呼び出し元のアドレスをとして受け入れ、msg.sender送信されたEtherの値をとして受け入れますmsg.value
  • burn()12行目:ユーザーが必要とする量のトークンを受け取り、ラップされていないトークンを送り返す関数を定義します
  • 13行目:トランザクションの呼び出し元のアドレスをmsg.sender支払い可能な修飾子でラップして、Etherを転送できるようにすることで、転送される金額を指定します。transferOpenZeppelinで定義された関数を使用して、転送される金額を受け入れます
  • 14行目:_burn()OpenZeppelinで定義された関数を使用して、トランザクションの呼び出し元にラップされていないトークン(元のEther)を送信します

結論

この記事では、Ganacheでスマートコントラクトを設定し、MetaMaskを使用してEthereumのRinkebyテストネット、PolygonのMumbaiテストネット、Binance Smart Chain、Polygonに移行する方法を示しました。また、異なるチェーン間でスマートコントラクトを移行するためのさまざまな戦略についても説明しました。トークンのラッピングとアンラッピング、およびパラチェーンです。

元の記事のソース:https ://blog.logrocket.com/migrate-smart-contracts-between-different-chains/

#smartcontract #ganache #metamask #ethereum #polygon 

異なるチェーン間でスマートコントラクトを移行する
Diego  Elizondo

Diego Elizondo

1654102800

Cómo Migrar Contratos inteligentes Entre Diferentes Cadenas

Hay varias razones por las que un contrato inteligente puede migrarse a otra cadena de bloques. Algunas razones obvias son tarifas de gas más bajas o un tiempo de transacción más rápido. También hay casos en los que tiene sentido cambiar un contrato a una cadena diferente para depurar un contrato, brindar seguridad adicional o incluso brindar acceso al contrato si se ha vuelto inaccesible debido a un robo o un problema técnico.

Esta guía de migración de contratos inteligentes demuestra cómo migrar un contrato inteligente de una cadena de desarrollo local a cadenas de bloques individuales y cómo migrar contratos inteligentes entre diferentes cadenas. Este artículo también proporciona una descripción general de varias cadenas de bloques y cómo varían con respecto a la migración de contratos inteligentes.

requisitos previos

Para seguir la parte del tutorial de este artículo, asegúrese de tener lo siguiente:

Consideraciones para migrar entre blockchains

Varios factores podrían influir en la decisión de migrar un contrato inteligente de una cadena de bloques a otra. Echemos un vistazo a algunos ejemplos.

Cadena inteligente de Ethereum frente a Binance

La cadena de bloques de Ethereum es una cadena de bloques pública descentralizada, transparente y segura. En el momento de escribir este artículo, Ethereum utiliza un algoritmo de consenso de Prueba de trabajo . Se pueden crear contratos inteligentes en la red Ethereum.

Cada operación realizada en la cadena de bloques de Ethereum, ya sea exitosa o no, debe pagarse con una tarifa de gas. Una operación podría ser enviar una cantidad de ether (la criptomoneda de Ethereum) de una cuenta a otra o implementar un contrato.

La tarifa de gas debe pagarse antes de que los mineros agreguen la transacción a un bloque. Ethereum impone una cantidad máxima de gas por bloque, denominada límite de gas por bloque .

Binance Smart Chain (BSC ) utiliza un algoritmo de consenso de prueba de participación . Al igual que Ethereum, admite la creación de contratos inteligentes.

Algunos incentivos para migrar de Ethereum a BSC son las tarifas de gas más bajas de Binance y los tiempos de transacción más rápidos. Estos beneficios hacen que BSC sea más escalable que Ethereum. Los contratos inteligentes de Ethereum se pueden migrar fácilmente a la plataforma BSC con cambios mínimos o nulos en el código.

Sin embargo, BSC tiene algunos inconvenientes, incluida una menor descentralización. Esto se debe a que tiene varias entidades centralizadas, como los 21 000 validadores de nodos que pertenecen directa o indirectamente a Binance y son responsables de las tarifas de gas más bajas de la red.

Polígono contra Ethereum

Similar a BSC, la cadena de bloques Polygon utiliza un algoritmo de consenso de prueba de participación. Polygon admite la creación de contratos inteligentes y permite la interoperabilidad al permitir la comunicación cruzada de los contratos inteligentes lanzados en su cadena de bloques. El token de la red, MATIC, ofrece varias funcionalidades, como pagar tarifas de gas, participar y votar.

Algunos incentivos para migrar de Ethereum a Polygon son los tiempos de transacción más rápidos de Polygon y las tarifas de transacción más bajas. La estructura de Polygon también lo hace más escalable que Ethereum. A medida que aumenta la cantidad de nodos en la red Polygon, el ecosistema se expande para contener adecuadamente los nodos y procesar sus transacciones.

Ahora, echemos un vistazo a cómo migrar contratos inteligentes entre diferentes cadenas.

Demostración: Migración de contratos inteligentes desde una cadena de desarrollo local

Para este tutorial, usaremos un contrato inteligente escrito en Solidity e implementado en el marco de Tuffle Suite . Truffle Suite se integra con otras cadenas de bloques de máquinas virtuales de Ethereum y tiene funciones integradas para crear, probar, compilar e implementar contratos inteligentes.

Después de implementar el contrato inteligente en una cadena de desarrollo local, demostraremos cómo implementarlo en cadenas de bloques individuales. Usaremos MetaMask para la implementación a fin de ver fácilmente el saldo de nuestra cuenta y el historial de transacciones.

Implementación del contrato inteligente en Ganache

Comenzaremos implementando el contrato inteligente en Ganache , una herramienta de simulación de cadena de bloques construida en el entorno Truffle. Esto nos permitirá asegurarnos de que el código se compile correctamente y que no haya problemas con la implementación.

Para comenzar, clone el código de contrato inteligente de este repositorio de GitHub en su terminal. Luego, en el directorio del proyecto, ejecute el siguiente comando para instalar las dependencias:

npm install

Antes de continuar, asegúrese de tener Ganache instalado, ya que esta es la cadena de bloques de desarrollo que usará.

Ahora, ejecute Ganache en su sistema y haga clic en INICIO RÁPIDO , como se muestra a continuación:

A continuación, implementaremos el contrato inteligente utilizando las migraciones definidas en el 2_deploy_migration.jsarchivo.

Primero, en su terminal y directorio del proyecto, ejecute el siguiente comando para iniciar la cadena de bloques de desarrollo:

truffle develop

Esto iniciará su cadena de bloques de desarrollo con diez direcciones, cada una de las cuales contiene 100ETH y claves privadas:

A continuación, implemente el contrato inteligente ejecutando el siguiente comando para ejecutar todo el código en la migrationcarpeta:

migrate -reset

La salida del terminal muestra que el 2_deploy_migration.jsarchivo está implementado. La salida también muestra información del contrato, incluido el hash de la transacción, el número de bloque y la dirección del contrato.

Tenga en cuenta que parte de la información del contrato inteligente, como value senty total cost, se proporciona en ETH (moneda de Ethereum). Al migrar el contrato inteligente, primero deberá actualizar la información que está en ETH a la moneda nativa de la cadena de bloques a la que está migrando el contrato.

Para salir del entorno, escriba CTRL + C dos veces en su terminal.

Ahora, veamos cómo migrar el contrato inteligente a la cadena de bloques de Ethereum.

Implementación de un contrato inteligente en la red de prueba de Ethereum (Rinkeby)

Para implementar el contrato inteligente desde la cadena de bloques local a la red Rinkeby de Ethereum, primero debe tener una dirección.

Para generar la dirección, abra su billetera MetaMask y conéctese a la red de prueba Rinkeby.

Para obtener éter gratis, use Faucets Chainlink , conéctese a Rinkeby y pegue la dirección de la billetera en el campo.

Luego, haz clic en Enviar solicitud .

Como se muestra a continuación, esto debería enviar 0.1ETH a su billetera.

A continuación, es hora de configurar Truffle. En su editor de código, abra el truffle-config.jsarchivo para definir sus configuraciones de red.

Revisa la truffle-config.jsdocumentación del expediente donde define lo siguiente:

/**
* Use this file to configure your truffle project. It's seeded with some
* common settings for different networks and features like migrations,
* compilation and testing. Uncomment the ones you need or modify
* them to suit your project as necessary.
*
* More information about configuration can be found at:
*
* https://trufflesuite.com/docs/truffle/reference/configuration
*
* To deploy via Infura you'll need a wallet provider (like @truffle/hdwallet-provider)
* to sign your transactions before they're sent to a remote public node. Infura accounts
* are available for free at: infura.io/register.
*
* You'll also need a mnemonic - the twelve-word phrase the wallet uses to generate
* public/private key pairs. If you're publishing your code to GitHub make sure you load this
* phrase from a file you've .gitignored so it doesn't accidentally become public.
*
*/

A continuación, cree una cuenta en Infura: infura.io/register , luego cree un nuevo proyecto y haga clic en CONFIGURACIÓN DEL PROYECTO en la parte superior derecha.

En la pestaña General, en Claves, seleccione RINKEBY en el menú desplegable Puntos finales. Debería ver el ID de su proyecto, así como la URL de su nodo en Infura.

NB, usará la @truffle/hdwallet-provider dependencia instalada en su package.json archivo para configurar su proveedor en su clave privada en MetaMask

En su truffle-config.jsarchivo, solicite la @truffle/hdwallet-providerdependencia y cree una matriz que almacenará sus claves privadas:

const HDWalletProvider = require('@truffle/hdwallet-provider');
const privateKeys = ['<app your private key>'];

Ahora, desplácese hacia abajo hasta la sección de redes y agregue un script de desarrollo para configurar providersu clave privada en MetaMask y su URL para su nodo en Infura:

development: {
     provider: () => new
HDWalletProvider("<Your private key on metamask", `https://rinkeby.infura.io/v3/71acb374b9dd4e1eb06eeb9a75a8cd1a`),
     network_id: 4,       // Any network (default: none)
},

Notarás en el código anterior que network_idestá establecido en 4; esta es la ID de red para Rinkeby . Otras redes de Ethereum tienen ID diferentes.

A continuación, ejecute la migración y su configuración ejecutando el siguiente comando:

truffle migrate -network development --reset 

Ahora, copie el hash de la transacción. Vaya a MetaMask y haga clic en Ver cuenta en Etherscan . En la lista de transacciones, verá el hash de transacción que acaba de implementar:

Haga clic en una transacción individual para ver más detalles:

Implementación del contrato inteligente en la red de prueba de Polygon (Mumbai)

Para implementar el contrato inteligente en la red de Polygon en Mumbai, comenzará conectando su billetera MetaMask a Polygon. Abra MetaMask y haga clic en Agregar red , luego agregue lo siguiente en los campos correspondientes:

Luego, haga clic en Guardar y MetaMask se conectará a Polygon.

Dado que está migrando el contrato a la red de prueba de Polygon, necesitará tokens MATIC para pagar su transacción. Para obtener tokens MATIC, abra su billetera MetaMask y copie la dirección de su billetera. Luego, navegue hasta el grifo Polygon y pegue la dirección en el campo de dirección de la billetera. Haga clic en Enviar y luego en Confirmar .

Como se muestra a continuación, debería ver la confirmación de que se envió la solicitud.

En unos minutos, debería ver los tokens en su billetera MetaMask. Una vez que los tokens MATIC se transfieran con éxito, aparecerán en el saldo de su billetera.

A continuación, en su editor de código, abra el truffle-config.jsarchivo. En el script de red, agregue un proveedor de red para Polygon debajo del proveedor de red para Ethereum. Utilizará la URL de RPC para la red de pruebas de Mumbai, tal como se define en la documentación de Polygon .

Copie el enlace RPC que se muestra a continuación, https://rpc-mumbai.matic.today :

Luego, pegue el enlace RPC en el código como providerURL. También pegue el chainid (arriba) en el código como network_id:

polygonTestnet: {
     provider: () => new HDWalletProvider(privateKeys, `https://rpc-mumbai.matic.today`),
     network_id: 80001,       // Any network (default: none)
   },

Ahora, abra su terminal y ejecute la migración y configuración a la red de prueba de Polygon con este comando:

truffle migrate --network polygonTestnet --reset

Puede ver a continuación que su contrato se ha migrado con éxito:

Ahora, copie el hash de la transacción. Abra su cuenta MetaMask y haga clic en Ver cuenta en Explorer :

Debería ver el contrato implementado con la transacción en el explorador de blockchain de Polygonscan :

Implementación del contrato inteligente en Binance Smart Chain

Para implementar su contrato inteligente en la red de prueba de Binance Smart Chain. necesitará obtener tokens BNB (que es la moneda nativa de la cadena Binance Smart).

Comenzará conectando su billetera MetaMask a BSC. Abra MetaMask y haga clic en Agregar red:

A continuación, agregue lo siguiente en los campos correspondientes:

Luego, haga clic en Guardar y MetaMask se conectará a BSC y establecerá el token BNB en cero:

Para obtener tokens BNB gratuitos, abra su billetera MetaMask y copie la dirección de su billetera. Luego, navegue hasta Binance Smart Chain Faucet . En la entrada de la dirección, pegue la dirección de su billetera MetaMask.

Ahora, haga clic en Give me BNB y se transferirá 1 BNB a su billetera MetaMask.

Puede confirmar que el token se envió al verificar el saldo de su cuenta MetaMask:

Ahora, edite el truffle-config.jsarchivo en su editor de código y agregue la siguiente configuración para la red Binance Smart Chain:

 bscTestnet: {
     provider: () => new HDWalletProvider(privateKeys, `https://data-seed-prebsc-1-s1.binance.org:8545/`),
     network_id: 97,       // Any network (default: none)
   },

Para implementar su contrato en la red de prueba Binance Smart Chain, abra su terminal y ejecute este comando:

truffle migrate --network bscTestnet --reset

Migración de contratos inteligentes entre cadenas

Discutimos algunos factores que podrían influir en la decisión de migrar un contrato inteligente de una cadena de bloques a otra. Ahora, veamos un par de técnicas de migración de contratos inteligentes.

Migración a través de parachains

La red Polkadot proporciona un entorno familiar y seguro para que las cadenas de bloques interactúen fácilmente entre sí.

Las paracadenas son cadenas de bloques de capa 1 que interactúan en el ecosistema de Polkadot. Las paracadenas son independientes entre sí pero funcionan en paralelo. Están conectados por la cadena de retransmisión de la red . Esta conexión permite la interoperabilidad entre cadenas, o la capacidad de comunicarse y compartir datos .

La red Polkadot aprovecha un mecanismo de consenso de prueba de participación mediante el uso de validadores y nominadores . Los recopiladores (que se muestran en la siguiente ilustración) conservan información sobre las transacciones de la red.

Las paracadenas permiten a los desarrolladores migrar contratos dentro del ecosistema de Polkadot utilizando el formato de Mensajería de consenso cruzado (XCM) de Polkadot en lugar de envolver y desenvolver tokens (lo cual analizaremos en la siguiente sección).

XCM se utiliza para formatear mensajes enviados entre cadenas, contratos inteligentes o puentes. XCM habilita un formato definido para enviar transacciones de una billetera a otra durante un período prolongado.

XCM tiene protocolos que actúan sobre mensajes con distintas funciones: Paso de mensajes verticales (VMP) y Paso de mensajes entre cadenas (XCMP).

Además, XCM utiliza una máquina virtual de consenso cruzado (XCVM), que contiene varias instrucciones que se ejecutan como un programa y los mensajes que se transferirán. Las instrucciones en la XCVM consisten en el mensaje que se transfiere y su destino.

Además, existen puentes entre Polkadot y otras cadenas de bloques de capa 1, como Ethereum y Binance Smart Chain, lo que permite la interoperabilidad.

Migración envolviendo y desenvolviendo tokens

Cada cadena de bloques tiene tokens negociables diseñados de acuerdo con sus monedas digitales nativas. Cuando los contratos inteligentes se migran entre diferentes cadenas, debe haber una forma de que los tokens diseñados para una cadena de bloques funcionen en otra.

Esto es como viajar a un país que usa una moneda diferente. Sin embargo, en lugar de intercambiar un tipo de token por otro, las cadenas de bloques suelen utilizar el concepto de envolver y desenvolver.

La envoltura implica vincular el valor de un token a su criptomoneda original. El token envuelto es básicamente un token negociable que puede usarse en otras cadenas de bloques. Como ejemplo, digamos que algunos ERC-20 de Ethereum están envueltos. Su valor se fijará en su valor actual, pero ahora se consideran éter envuelto (WETH). Los tokens WETH se pueden usar en billeteras MetaMask y otras, para interactuar en varias cadenas de bloques (BSC, IOTA, etc.)

Uno de los beneficios más importantes de envolver un token es que se conserva el activo original, pero el token envuelto hereda las funcionalidades de la nueva cadena de bloques. Algunas de estas funcionalidades podrían incluir un tiempo de transacción minimizado y tarifas de gas bajas.

Desempaquetar tokens se refiere al proceso de revertir el token a la criptomoneda original. Por ejemplo, WETH se puede desenvolver en su criptomoneda original de ETH.

Aquí hay una demostración que muestra cómo envolver y desenvolver un token de Ethereum utilizando el estándar OpenZeppelin ERC-20 :

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.7.0 <0.9.0;
import https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol;
contract WETH is ERC20 {
    constuctor() ERC20("Wrapped Ether", "WETH") public {};

    // define a mint function to create new wrapped ether token
    function mint() external payable {
        _mint(msg.sender, msg.value); 
    }
    // define a burn function to create an unwrapped token
    function burn(uint amount) external { //specify the amount that you want back
        payable(msg.sender).transfer(amount); // transfers 
        _burn(msg.sender, amount); //sending back the ether to the user
    }
}

Echemos un vistazo más de cerca a las líneas individuales de código en el bloque de código anterior:

  • Línea 1: especifica la licencia utilizada para el compilador Solidity
  • Línea 2: especifica la versión de Solidity
  • Línea 3: importa el token estándar ERC-20, tal como se define en OpenZeppelin
  • Línea 4: define el contrato para crear los tokens envueltos y desenvueltos
  • Línea 5: define una constructor``()función que establece el nombre del Ether en "Wrapped Ether" y su símbolo en "WETH" tan pronto como se ejecuta el contrato
  • Línea 7: define una mint()función que acepta un valor de Ether y crea un nuevo token de Ether envuelto; el calificador externo significa que la función puede ser llamada desde otros contratos; el calificador pagadero indica que la función puede aceptar y enviar Ether
  • Línea 9: utiliza la _mintfunción que se define en el código de OpenZeppelin; acepta la dirección de la persona que llama de la transacción msg.sendery el valor del Ether enviado comomsg.value
  • Línea 12: define una burn()función que acepta la cantidad de token que un usuario quiere y devuelve un token sin envolver
  • Línea 13: especifica el monto que se transferirá al incluir la dirección de la persona que llama en la transacción, msg.sender, con el calificador pagadero para permitirle transferir Ether; utiliza la transferfunción definida en OpenZeppelin para aceptar el importe a transferir
  • Línea 14: usa la _burn()función definida en OpenZeppelin para enviar a la persona que llama de la transacción un token sin envolver (el Ether original)

Conclusión

En este artículo, demostramos cómo configurar un contrato inteligente en Ganache y luego migrarlo a la red de prueba Rinkeby de Ethereum, la red de prueba de Mumbai de Polygon, Binance Smart Chain y Polygon usando MetaMask. También discutimos diferentes estrategias para migrar contratos inteligentes entre diferentes cadenas: envolver y desenvolver tokens, así como parachains.

Fuente del artículo original en: https://blog.logrocket.com/migrate-smart-contracts- between- different -chains/ 

#smartcontract #ganache #metamask #ethereum #polygon 

Cómo Migrar Contratos inteligentes Entre Diferentes Cadenas

서로 다른 체인 간에 스마트 계약을 마이그레이션하는 방법

Ganache에서 스마트 계약을 설정한 다음 MetaMask를 사용하여 Ethereum의 Rinkeby 테스트넷, Polygon의 Mumbai 테스트넷, Binance Smart Chain 및 Polygon으로 마이그레이션하는 방법을 배우십시오. 

이 가이드는 로컬 개발 체인에서 개별 블록체인으로, 그리고 서로 다른 체인 간에 스마트 계약을 마이그레이션하는 방법을 보여줍니다.

스마트 계약이 다른 블록체인으로 마이그레이션될 수 있는 몇 가지 이유가 있습니다. 몇 가지 분명한 이유는 낮은 가스 요금 또는 빠른 거래 시간입니다. 또한 계약을 디버그하거나 추가 보안을 제공하거나 도난이나 기술적인 문제로 인해 계약에 액세스할 수 없는 경우 계약에 대한 액세스를 제공하기 위해 계약을 다른 체인으로 이동하는 것이 합리적인 경우도 있습니다.

이 스마트 계약 마이그레이션 가이드는 스마트 계약을 로컬 개발 체인에서 개별 블록체인으로 마이그레이션하는 방법과 다른 체인 간에 스마트 계약을 마이그레이션하는 방법을 보여줍니다. 이 기사는 또한 여러 블록체인에 대한 개요와 스마트 계약 마이그레이션과 관련하여 블록체인이 어떻게 다른지 제공합니다.

  • 전제 ì¡°ê±´
  • 체인 간 마이그레이션 ê³ ë ¤ 사항
    • 이더리움 대 바이낸스 스마트 체인
    • 폴리곤 대 이더리움 블록체인
  • 데모: 로컬 개발 체인에서 스마트 계약 마이그레이션
    • Ganache로 스마트 계약 설정하기
    • Ethereum의 테스트넷(Rinkeby)으로 스마트 계약 마이그레이션
    • Polygon의 테스트넷(뭄바이)으로 스마트 계약 마이그레이션
    • 바이낸스 스마트 체인으로 스마트 계약 마이그레이션
  • 체인 간 스마트 계약 마이그레이션
    • 파라체인
    • 토큰 래핑 및 언래핑

전제 조건

이 문서의 자습서 부분을 따르려면 다음이 있는지 확인하세요.

블록체인 간 마이그레이션 고려 사항

여러 요인이 한 블록체인에서 다른 블록체인으로 스마트 계약을 마이그레이션하는 결정에 영향을 미칠 수 있습니다. 몇 가지 예를 살펴보겠습니다.

이더리움 대 바이낸스 스마트 체인

이더리움 블록체인은 탈중앙화되고 투명하며 안전한 퍼블릭 블록체인입니다. 이 글을 쓰는 시점에서 이더리움은 작업 증명 합의 알고리즘을 사용 합니다. 스마트 계약은 이더리움 네트워크에서 생성될 수 있습니다.

이더리움 블록체인에서 이루어진 모든 작업은 성공 여부에 관계없이 가스 요금을 지불해야 합니다. 작업은 한 계정에서 다른 계정으로 일정량의 이더(이더리움의 암호화폐)를 보내거나 계약을 배포하는 것일 수 있습니다.

채굴자가 블록에 거래를 추가하기 전에 가스 요금을 지불해야 합니다. 이더리움은 블록 가스 제한 이라고 하는 블록당 최대 가스량을 시행합니다 .

바이 낸스 스마트 체인(BSC )은 지분 증명 합의 알고리즘을 사용 합니다. Ethereum과 마찬가지로 스마트 계약 생성을 지원합니다.

이더리움에서 BSC로의 마이그레이션에 대한 몇 가지 인센티브는 바이낸스의 낮은 가스 수수료와 빠른 거래 시간입니다. 이러한 이점으로 인해 BSC는 이더리움보다 확장성이 뛰어납니다. Ethereum 스마트 계약은 코드를 최소한으로 또는 전혀 변경하지 않고도 BSC 플랫폼으로 쉽게 마이그레이션할 수 있습니다.

그러나 BSC에는 덜 분산된 것을 포함하여 몇 가지 단점이 있습니다. 이는 Binance 가 직간접적으로 소유 하고 네트워크의 낮은 가스 비용을 책임지는 21,000개의 노드 검증자와 같은 여러 중앙 집중식 엔티티가 있기 때문입니다.

다각형 대 이더리움

BSC와 유사하게 Polygon 블록체인 은 Proof of Stake 합의 알고리즘을 사용합니다. Polygon은 스마트 계약 생성을 지원하고 블록체인에서 시작된 스마트 계약의 교차 통신을 허용하여 상호 운용성을 가능하게 합니다. 네트워크의 토큰인 MATIC은 가스 요금 지불, 스테이킹 및 투표와 같은 여러 기능을 제공합니다.

이더리움에서 폴리곤으로의 마이그레이션에 대한 몇 가지 인센티브는 폴리곤의 더 빠른 거래 시간과 더 낮은 거래 수수료입니다. Polygon의 구조는 또한 Ethereum보다 확장성을 높입니다. Polygon 네트워크의 노드 수가 증가함에 따라 생태계는 노드를 적절하게 포함하고 트랜잭션을 처리하도록 확장됩니다.

이제 서로 다른 체인 간에 스마트 계약을 마이그레이션하는 방법을 살펴보겠습니다.

데모: 로컬 개발 체인에서 스마트 계약 마이그레이션

이 튜토리얼에서는 Solidity로 작성되고 Tuffle Suite 프레임워크에 배포된 스마트 계약을 사용할 것 입니다. Truffle Suite는 다른 이더리움 가상 머신 블록체인과 통합되며 스마트 계약을 생성, 테스트, 컴파일 및 배포하기 위한 기능이 내장되어 있습니다.

스마트 계약을 로컬 개발 체인에 배포한 후 개별 블록체인에 배포하는 방법을 보여줍니다. 계정 잔액과 거래 내역을 쉽게 볼 수 있도록 MetaMask를 배포에 사용할 것입니다.

Ganache에 스마트 계약 배포

Truffle 환경에 구축된 블록체인 시뮬레이션 도구인 Ganache 에 스마트 계약을 배포하는 것으로 시작하겠습니다 . 이렇게 하면 코드가 올바르게 컴파일되고 배포에 문제가 없는지 확인할 수 있습니다.

시작하려면 터미널의 이 GitHub 리포지토리 에서 스마트 계약 코드를 복제합니다 . 그런 다음 프로젝트의 디렉터리에서 다음 명령을 실행하여 종속성을 설치합니다.

npm install

계속 진행하기 전에 사용할 개발 블록체인이므로 Ganache가 설치되어 있는지 확인하십시오.

이제 시스템에서 Ganache를 실행하고 아래와 같이 QUICKSTART 를 클릭하십시오.

가나슈

다음으로 파일에 정의된 마이그레이션을 사용하여 스마트 계약을 배포 2_deploy_migration.js합니다.

먼저 터미널 및 프로젝트 디렉터리에서 다음 명령을 실행하여 개발 블록체인을 시작합니다.

truffle develop

이것은 각각 100ETH와 개인 키를 포함하는 10개의 주소로 개발 블록체인을 시작합니다.

열 개의 열쇠

migration다음으로 폴더 의 모든 코드를 실행하기 위해 다음 명령을 실행하여 스마트 계약을 배포 합니다.

migrate -reset
마이그레이션
마이그레이션 배포

터미널의 출력은 2_deploy_migration.js파일이 배포되었음을 보여줍니다. 출력에는 트랜잭션 해시, 블록 번호 및 계약 주소를 포함한 계약 정보도 표시됩니다.

value sent및 와 같은 일부 스마트 계약 정보 total cost는 ETH(이더리움의 통화)로 제공됩니다. 스마트 계약을 마이그레이션할 때 먼저 ETH에 있는 모든 정보를 계약을 마이그레이션할 블록체인의 기본 통화로 업데이트해야 합니다.

환경을 종료하려면 터미널에 CTRL + C 를 두 번 입력합니다.

이제 스마트 계약을 이더리움 블록체인으로 마이그레이션하는 방법을 살펴보겠습니다.

Ethereum의 테스트넷(Rinkeby)에 스마트 계약 배포

로컬 블록체인에서 Ethereum의 Rinkeby 네트워크로 스마트 계약을 배포하려면 먼저 주소가 있어야 합니다.

주소를 생성하려면 MetaMask 지갑을 열고 Rinkeby 테스트 네트워크에 연결하십시오.

무료 이더를 얻으려면 Faucet Chainlink 를 사용하고 Rinkeby에 연결하고 지갑 주소를 필드에 붙여넣습니다.

그런 다음 요청 보내기 를 클릭 합니다.

아래와 같이 지갑으로 0.1ETH를 보내야 합니다.

지갑의 ETH

다음으로 Truffle을 구성할 차례입니다. 코드 편집기에서 파일을 열어 truffle-config.js네트워크 구성을 정의합니다.

truffle-config.js다음을 정의하는 파일의 문서를 확인하십시오 .

/**
* Use this file to configure your truffle project. It's seeded with some
* common settings for different networks and features like migrations,
* compilation and testing. Uncomment the ones you need or modify
* them to suit your project as necessary.
*
* More information about configuration can be found at:
*
* https://trufflesuite.com/docs/truffle/reference/configuration
*
* To deploy via Infura you'll need a wallet provider (like @truffle/hdwallet-provider)
* to sign your transactions before they're sent to a remote public node. Infura accounts
* are available for free at: infura.io/register.
*
* You'll also need a mnemonic - the twelve-word phrase the wallet uses to generate
* public/private key pairs. If you're publishing your code to GitHub make sure you load this
* phrase from a file you've .gitignored so it doesn't accidentally become public.
*
*/

다음으로 Infura: infura.io/register 에 계정을 생성한 다음 새 프로젝트를 생성하고 오른쪽 상단의 PROJECT SETTINGS 를 클릭합니다.

프로젝트 설정

일반 탭의 키 아래 끝점 드롭다운에서 RINKEBY 를 선택합니다. Infura의 노드에 대한 URL과 함께 프로젝트 ID가 표시되어야 합니다.

링케비 선택

NB, MetaMask의 개인 키로 공급자를 설정하기 위해 파일에 설치된 종속성 을 사용할 것 입니다. @truffle/hdwallet-provider package.json

truffle-config.js파일에서 종속성을 요구하고 개인 @truffle/hdwallet-provider키를 저장할 배열을 만듭니다.

const HDWalletProvider = require('@truffle/hdwallet-provider');
const privateKeys = ['<app your private key>'];

이제 네트워크 섹션으로 스크롤하여 providerMetaMask의 개인 키로 설정하고 Infura의 노드에 대한 URL을 설정하는 개발 스크립트를 추가합니다.

development: {
     provider: () => new
HDWalletProvider("<Your private key on metamask", `https://rinkeby.infura.io/v3/71acb374b9dd4e1eb06eeb9a75a8cd1a`),
     network_id: 4,       // Any network (default: none)
},

위의 코드 network_id에서 4로 설정되었음을 알 수 있습니다. 이것은 Rinkeby의 네트워크 ID입니다 . 다른 이더리움 네트워크는 다른 ID를 가지고 있습니다.

다음으로 다음 명령을 실행하여 마이그레이션 및 구성을 실행합니다.

truffle migrate -network development --reset 
마이그레이션 배포

이제 트랜잭션 해시를 복사합니다. MetaMask로 이동하여 Etherscan에서 계정 보기 를 클릭 합니다. 트랜잭션 목록에서 방금 배포한 트랜잭션 해시를 볼 수 있습니다.

트랜잭션 해시

자세한 내용을 보려면 개별 거래를 클릭하십시오.

개별 거래

Polygon의 테스트넷(뭄바이)에 스마트 계약 배포

Polygon의 Mumbai 네트워크에 스마트 계약을 배포하려면 먼저 MetaMask 지갑을 Polygon에 연결해야 합니다. MetaMask를 열고 네트워크 추가 를 클릭 한 다음 해당 필드에 다음을 추가합니다.

메타마스크 설정

그런 다음 저장 을 클릭 하면 MetaMask가 Polygon에 연결됩니다.

계약을 Polygon의 테스트넷으로 마이그레이션하기 때문에 거래 비용을 지불하려면 MATIC 토큰이 필요합니다. MATIC 토큰을 얻으려면 MetaMask 지갑을 열고 지갑 주소를 복사하십시오. 그런 다음 Polygon 수도꼭지 로 이동 하여 지갑 주소 필드에 주소를 붙여넣습니다. 제출 을 클릭한 다음 확인 을 클릭합니다 .

세부정보 확인

아래와 같이 요청이 제출되었다는 확인 메시지가 표시되어야 합니다.

제출된 요청

몇 분 안에 MetaMask 지갑에 토큰이 표시됩니다. MATIC 토큰이 성공적으로 전송되면 지갑 잔액에 표시됩니다.

매틱 토큰

다음으로 코드 편집기에서 truffle-config.js파일을 엽니다. 네트워크 스크립트에서 Ethereum용 네트워크 공급자 아래에 Polygon용 네트워크 공급자를 추가합니다. Polygon 문서 에 정의된 대로 Mumbai 테스트넷용 RPC URL을 사용할 것 입니다.

아래 표시된 RPC 링크 ( https://rpc-mumbai.matic.today )를 복사합니다 .

RPC 링크

provider그런 다음 RPC 링크를 URL 로 코드에 붙여넣습니다 . 또한 chainid(위)를 다음과 같이 코드에 붙여넣습니다 network_id.

polygonTestnet: {
     provider: () => new HDWalletProvider(privateKeys, `https://rpc-mumbai.matic.today`),
     network_id: 80001,       // Any network (default: none)
   },

이제 터미널을 열고 다음 명령을 사용하여 Polygon 테스트넷으로 마이그레이션 및 구성을 실행합니다.

truffle migrate --network polygonTestnet --reset

아래에서 계약이 성공적으로 마이그레이션되었음을 확인할 수 있습니다.

성공적인 마이그레이션

이제 트랜잭션 해시를 복사합니다. MetaMask 계정을 열고 Explorer에서 계정 보기 를 클릭합니다 .

메타마스크 계정 보기

Polygonscan 블록체인 탐색기 에 트랜잭션이 있는 배포된 계약이 표시되어야 합니다 .

배포된 계약

바이낸스 스마트 체인에 스마트 계약 배포

바이낸스 스마트 체인의 테스트넷에 스마트 계약을 배포합니다. BNB 토큰(바이낸스 스마트 체인의 기본 통화)을 받아야 합니다.

MetaMask 지갑을 BSC에 연결하여 시작합니다. MetaMask를 열고 네트워크 추가를 클릭합니다.

네트워크 추가

그런 다음 해당 필드에 다음을 추가합니다.

네트워크 추가 페이지

그런 다음 저장 을 클릭 하면 MetaMask가 BSC에 연결되고 BNB 토큰을 0으로 설정합니다.

제로 BNB

무료 BNB 토큰을 받으려면 MetaMask 지갑을 열고 지갑 주소를 복사하십시오. 그런 다음 바이낸스 스마트 체인 수도꼭지 로 이동합니다 . 주소 입력에 MetaMask 지갑 주소를 붙여넣습니다.

스마트 체인 수도꼭지

이제 Give me BNB 를 클릭 하면 1 BNB가 MetaMask 지갑으로 전송됩니다.

자금 요청 수락됨

MetaMask 계정 잔액을 확인하여 토큰이 전송되었음을 확인할 수 있습니다.

메타마스크 밸런스

이제 truffle-config.js코드 편집기에서 파일을 편집하고 Binance Smart Chain 네트워크에 대해 다음 구성을 추가합니다.

 bscTestnet: {
     provider: () => new HDWalletProvider(privateKeys, `https://data-seed-prebsc-1-s1.binance.org:8545/`),
     network_id: 97,       // Any network (default: none)
   },

바이낸스 스마트 체인 테스트넷에 계약을 배포하려면 터미널을 열고 다음 명령을 실행하세요.

truffle migrate --network bscTestnet --reset
마이그레이션 배포

체인 간 스마트 계약 마이그레이션

한 블록체인에서 다른 블록체인으로 스마트 계약을 마이그레이션하는 결정에 영향을 줄 수 있는 몇 가지 요소에 대해 논의했습니다. 이제 몇 가지 스마트 계약 마이그레이션 기술을 살펴보겠습니다.

파라체인을 통한 마이그레이션

Polkadot 네트워크 는 블록체인이 서로 쉽게 상호 작용할 수 있는 친숙하고 안전한 환경을 제공합니다.

Parachain은 Polkadot 생태계에서 상호 작용하는 레이어 1 블록체인입니다. Parachain은 서로 독립적이지만 병렬로 실행됩니다. 그것들은 네트워크의 릴레이 체인 에 의해 연결됩니다 . 이 연결은 체인 간 상호 운용성 또는 데이터 통신 및 공유 기능을 허용합니다 .

Polkadot 네트워크는 검증 자 와 지명자 를 사용하여 지분 증명 합의 메커니즘을 활용합니다 . 콜 레이터 (아래 그림 참조)는 네트워크 트랜잭션에 대한 정보를 유지합니다.

릴레이 체인

Parachains를 통해 개발자는 토큰을 래핑 및 래핑 해제하는 대신 Polkadot의 XCM(교차 합의 메시징)을 사용하여 Polkadot 생태계 내에서 계약을 마이그레이션할 수 있습니다(다음 섹션에서 논의함).

XCM은 체인, 스마트 계약 또는 브리지 간에 전송되는 메시지 형식을 지정하는 데 사용됩니다. XCM은 장기간에 걸쳐 한 지갑에서 다른 지갑으로 트랜잭션을 보내기 위한 정의된 형식을 가능하게 합니다.

XCM에는 VMP( 수직 메시지 전달 ) 및 XCMP( 교차 체인 메시지 전달 )라는 고유한 기능이 있는 메시지에 대해 작동하는 프로토콜이 있습니다.

또한 XCM은 프로그램으로 실행되는 여러 명령과 전송할 메시지가 포함된 XCVM( 교차 합의 가상 머신 )을 사용합니다. XCVM의 지침은 전송되는 메시지와 대상으로 구성됩니다.

또한 Polkadot과 Ethereum 및 Binance Smart Chain과 같은 다른 레이어 1 블록 체인 사이에 브리지가 존재하여 상호 운용성을 가능하게 합니다.

토큰 래핑 및 래핑 해제를 통한 마이그레이션

각 블록체인에는 기본 디지털 통화에 따라 설계된 거래 가능한 토큰이 있습니다. 스마트 계약이 다른 체인 간에 마이그레이션될 때 한 블록체인용으로 설계된 토큰이 다른 블록체인에서 작동할 수 있는 방법이 필요합니다.

이것은 다른 통화를 사용하는 국가로 여행하는 것과 같습니다. 그러나 블록체인은 한 유형의 토큰을 다른 유형으로 교환하는 대신 일반적으로 래핑 및 래핑 해제 개념을 활용합니다.

래핑은 토큰의 가치를 원래 암호 화폐에 고정하는 것을 수반합니다. 래핑된 토큰은 기본적으로 다른 블록체인에서 사용할 수 있는 거래 가능한 토큰입니다. 예를 들어 일부 Ethereum의 ERC-20이 래핑되어 있다고 가정해 보겠습니다. 그들의 가치는 현재 가치로 고정되지만 이제는 포장된 이더(WETH)로 간주됩니다. WETH 토큰은 MetaMask 지갑 등에서 사용되어 다양한 블록체인(BSC, IOTA 등)에서 상호 작용할 수 있습니다.

토큰 래핑의 가장 중요한 이점 중 하나는 원래 자산은 보존되지만 래핑된 토큰은 새 블록체인의 기능을 상속한다는 것입니다. 이러한 기능 중 일부에는 거래 시간 최소화 및 낮은 가스 요금이 포함될 수 있습니다.

Unwrapping 토큰은 토큰을 원래 암호 화폐로 되돌리는 과정을 의미합니다. 예를 들어 WETH는 ETH의 원래 암호 화폐로 풀릴 수 있습니다.

다음은 OpenZeppelin ERC-20 표준 을 사용하여 이더리움 토큰의 래핑 및 언래핑을 보여주는 데모입니다 .

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.7.0 <0.9.0;
import https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol;
contract WETH is ERC20 {
    constuctor() ERC20("Wrapped Ether", "WETH") public {};

    // define a mint function to create new wrapped ether token
    function mint() external payable {
        _mint(msg.sender, msg.value); 
    }
    // define a burn function to create an unwrapped token
    function burn(uint amount) external { //specify the amount that you want back
        payable(msg.sender).transfer(amount); // transfers 
        _burn(msg.sender, amount); //sending back the ether to the user
    }
}

위의 코드 블록에서 개별 코드 줄을 자세히 살펴보겠습니다.

  • 1행: Solidity 컴파일러에 사용되는 라이선스를 지정합니다.
  • 2행: Solidity 버전 지정
  • 3행: OpenZeppelin에 정의된 대로 ERC-20 토큰 표준을 가져옵니다.
  • 4행: 래핑 및 래핑 해제된 토큰을 생성하기 위한 계약을 정의합니다.
  • constructor``()5행: 계약이 실행되는 즉시 Ether의 이름을 "Wrapped Ether"로 설정하고 기호를 "WETH"로 설정 하는 함수를 정의합니다.
  • mint()7행: Ether 값을 받아들이고 새로운 래핑된 Ether 토큰을 생성하는 함수를 정의합니다 . 외부 한정자는 함수가 다른 계약에서 호출될 수 있음을 의미합니다. 지불 한정자는 함수가 Ether를 수락하고 보낼 수 있음을 나타냅니다.
  • 9행: _mintOpenZeppelin 코드에 정의된 함수를 사용합니다. 트랜잭션 호출자의 주소 msg.sender와 보낸 Ether의 값을 다음과 같이 받아들입니다.msg.value
  • burn()12행: 사용자가 원하는 토큰 양을 수락하고 래핑되지 않은 토큰을 다시 보내는 함수를 정의합니다.
  • msg.sender13행: Ether를 전송할 수 있도록 지불 가능한 한정자로 트랜잭션 호출자의 주소를 래핑하여 전송할 금액을 지정합니다 . OpenZeppelin에 정의된 함수를 사용하여 transfer이체할 금액을 수락합니다.
  • 14행: _burn()OpenZeppelin에 정의된 함수를 사용하여 트랜잭션 호출자에게 래핑되지 않은 토큰(원래 Ether)을 보냅니다.

ê²°ë¡ 

이 기사에서는 Ganache에서 스마트 계약을 설정한 다음 MetaMask를 사용하여 Ethereum의 Rinkeby 테스트넷, Polygon의 Mumbai 테스트넷, Binance Smart Chain 및 Polygon으로 마이그레이션하는 방법을 시연했습니다. 우리는 또한 서로 다른 체인 간에 스마트 계약을 마이그레이션하기 위한 다양한 전략에 대해 논의했습니다.

https://blog.logrocket.com 의 원본 기사 출처

#blockchain #smartcontract #ethereum #polygon #metamask #binancesmartchain #binance

서로 다른 체인 간에 스마트 계약을 마이그레이션하는 방법

Cómo migrar contratos inteligentes entre diferentes cadenas

Aprenda cómo configurar un contrato inteligente en Ganache y luego migrarlo a la red de prueba Rinkeby de Ethereum, la red de prueba de Mumbai de Polygon, Binance Smart Chain y Polygon usando MetaMask. 

Esta guía muestra cómo migrar un contrato inteligente de una cadena de desarrollo local a cadenas de bloques individuales, así como también entre diferentes cadenas.

Hay varias razones por las que un contrato inteligente puede migrarse a otra cadena de bloques. Algunas razones obvias son tarifas de gas más bajas o un tiempo de transacción más rápido. También hay casos en los que tiene sentido cambiar un contrato a una cadena diferente para depurar un contrato, brindar seguridad adicional o incluso brindar acceso al contrato si se ha vuelto inaccesible debido a un robo o un problema técnico.

Esta guía de migración de contratos inteligentes demuestra cómo migrar un contrato inteligente de una cadena de desarrollo local a cadenas de bloques individuales y cómo migrar contratos inteligentes entre diferentes cadenas. Este artículo también proporciona una descripción general de varias cadenas de bloques y cómo varían con respecto a la migración de contratos inteligentes.

  • requisitos previos
  • Consideraciones para migrar entre cadenas
    • Cadena inteligente de Ethereum frente a Binance
    • Polígono vs Ethereum blockchain
  • Demostración: Migración de contratos inteligentes desde una cadena de desarrollo local
    • Configuración de un contrato inteligente con Ganache
    • Migración de un contrato inteligente a la red de prueba de Ethereum (Rinkeby)
    • Migración de un contrato inteligente a la red de prueba de Polygon (Mumbai)
    • Migrar un contrato inteligente a Binance Smart Chain
  • Migración de contratos inteligentes entre cadenas
    • Paracadenas
    • Envolver y desenvolver tokens

requisitos previos

Para seguir la parte del tutorial de este artículo, asegúrese de tener lo siguiente:

Consideraciones para migrar entre blockchains

Varios factores podrían influir en la decisión de migrar un contrato inteligente de una cadena de bloques a otra. Echemos un vistazo a algunos ejemplos.

Cadena inteligente de Ethereum frente a Binance

La cadena de bloques de Ethereum es una cadena de bloques pública descentralizada, transparente y segura. En el momento de escribir este artículo, Ethereum utiliza un algoritmo de consenso de Prueba de trabajo . Se pueden crear contratos inteligentes en la red Ethereum.

Cada operación realizada en la cadena de bloques de Ethereum, ya sea exitosa o no, debe pagarse con una tarifa de gas. Una operación podría ser enviar una cantidad de ether (la criptomoneda de Ethereum) de una cuenta a otra o implementar un contrato.

La tarifa de gas debe pagarse antes de que los mineros agreguen la transacción a un bloque. Ethereum impone una cantidad máxima de gas por bloque, denominada límite de gas por bloque .

Binance Smart Chain (BSC ) utiliza un algoritmo de consenso de prueba de participación . Al igual que Ethereum, admite la creación de contratos inteligentes.

Algunos incentivos para migrar de Ethereum a BSC son las tarifas de gas más bajas de Binance y los tiempos de transacción más rápidos. Estos beneficios hacen que BSC sea más escalable que Ethereum. Los contratos inteligentes de Ethereum se pueden migrar fácilmente a la plataforma BSC con cambios mínimos o nulos en el código.

Sin embargo, BSC tiene algunos inconvenientes, incluida una menor descentralización. Esto se debe a que tiene varias entidades centralizadas, como los 21 000 validadores de nodos que pertenecen directa o indirectamente a Binance y son responsables de las tarifas de gas más bajas de la red.

Polígono contra Ethereum

Similar a BSC, la cadena de bloques Polygon utiliza un algoritmo de consenso de prueba de participación. Polygon admite la creación de contratos inteligentes y permite la interoperabilidad al permitir la comunicación cruzada de los contratos inteligentes lanzados en su cadena de bloques. El token de la red, MATIC, ofrece varias funcionalidades, como pagar tarifas de gas, participar y votar.

Algunos incentivos para migrar de Ethereum a Polygon son los tiempos de transacción más rápidos de Polygon y las tarifas de transacción más bajas. La estructura de Polygon también lo hace más escalable que Ethereum. A medida que aumenta la cantidad de nodos en la red Polygon, el ecosistema se expande para contener adecuadamente los nodos y procesar sus transacciones.

Ahora, echemos un vistazo a cómo migrar contratos inteligentes entre diferentes cadenas.

Demostración: Migración de contratos inteligentes desde una cadena de desarrollo local

Para este tutorial, usaremos un contrato inteligente escrito en Solidity e implementado en el marco de Tuffle Suite . Truffle Suite se integra con otras cadenas de bloques de máquinas virtuales de Ethereum y tiene funciones integradas para crear, probar, compilar e implementar contratos inteligentes.

Después de implementar el contrato inteligente en una cadena de desarrollo local, demostraremos cómo implementarlo en cadenas de bloques individuales. Usaremos MetaMask para la implementación a fin de ver fácilmente el saldo de nuestra cuenta y el historial de transacciones.

Implementación del contrato inteligente en Ganache

Comenzaremos implementando el contrato inteligente en Ganache , una herramienta de simulación de cadena de bloques creada en el entorno Truffle. Esto nos permitirá asegurarnos de que el código se compile correctamente y que no haya problemas con la implementación.

Para comenzar, clone el código de contrato inteligente de este repositorio de GitHub en su terminal. Luego, en el directorio del proyecto, ejecute el siguiente comando para instalar las dependencias:

npm install

Antes de continuar, asegúrese de tener Ganache instalado, ya que esta es la cadena de bloques de desarrollo que utilizará.

Ahora, ejecute Ganache en su sistema y haga clic en INICIO RÁPIDO , como se muestra a continuación:

ganache

A continuación, implementaremos el contrato inteligente utilizando las migraciones definidas en el 2_deploy_migration.jsarchivo.

Primero, en su terminal y directorio del proyecto, ejecute el siguiente comando para iniciar la cadena de bloques de desarrollo:

truffle develop

Esto iniciará su cadena de bloques de desarrollo con diez direcciones, cada una de las cuales contiene 100ETH y claves privadas:

Diez llaves

A continuación, implemente el contrato inteligente ejecutando el siguiente comando para ejecutar todo el código en la migrationcarpeta:

migrate -reset
Emigrar
Implementar migración

La salida del terminal muestra que el 2_deploy_migration.jsarchivo está implementado. La salida también muestra información del contrato, incluido el hash de la transacción, el número de bloque y la dirección del contrato.

Tenga en cuenta que parte de la información del contrato inteligente, como value senty total cost, se proporciona en ETH (moneda de Ethereum). Al migrar el contrato inteligente, primero deberá actualizar la información que está en ETH a la moneda nativa de la cadena de bloques a la que está migrando el contrato.

Para salir del entorno, escriba CTRL + C dos veces en su terminal.

Ahora, veamos cómo migrar el contrato inteligente a la cadena de bloques de Ethereum.

Implementación de un contrato inteligente en la red de prueba de Ethereum (Rinkeby)

Para implementar el contrato inteligente desde la cadena de bloques local a la red Rinkeby de Ethereum, primero debe tener una dirección.

Para generar la dirección, abra su billetera MetaMask y conéctese a la red de prueba Rinkeby.

Para obtener éter gratis, use Faucets Chainlink , conéctese a Rinkeby y pegue la dirección de la billetera en el campo.

Luego, haz clic en Enviar solicitud .

Como se muestra a continuación, esto debería enviar 0.1ETH a su billetera.

ETH en billetera

A continuación, es hora de configurar Truffle. En su editor de código, abra el truffle-config.jsarchivo para definir sus configuraciones de red.

Revisa la truffle-config.jsdocumentación del expediente donde define lo siguiente:

/**
* Use this file to configure your truffle project. It's seeded with some
* common settings for different networks and features like migrations,
* compilation and testing. Uncomment the ones you need or modify
* them to suit your project as necessary.
*
* More information about configuration can be found at:
*
* https://trufflesuite.com/docs/truffle/reference/configuration
*
* To deploy via Infura you'll need a wallet provider (like @truffle/hdwallet-provider)
* to sign your transactions before they're sent to a remote public node. Infura accounts
* are available for free at: infura.io/register.
*
* You'll also need a mnemonic - the twelve-word phrase the wallet uses to generate
* public/private key pairs. If you're publishing your code to GitHub make sure you load this
* phrase from a file you've .gitignored so it doesn't accidentally become public.
*
*/

A continuación, cree una cuenta en Infura: infura.io/register , luego cree un nuevo proyecto y haga clic en CONFIGURACIÓN DEL PROYECTO en la parte superior derecha.

Configuración del proyecto

En la pestaña General, en Claves, seleccione RINKEBY en el menú desplegable Puntos finales. Debería ver el ID de su proyecto, así como la URL de su nodo en Infura.

Seleccione Rinkeby

NB, usará la @truffle/hdwallet-provider dependencia instalada en su package.json archivo para configurar su proveedor en su clave privada en MetaMask

En su truffle-config.jsarchivo, solicite la @truffle/hdwallet-providerdependencia y cree una matriz que almacenará sus claves privadas:

const HDWalletProvider = require('@truffle/hdwallet-provider');
const privateKeys = ['<app your private key>'];

Ahora, desplácese hacia abajo hasta la sección de redes y agregue un script de desarrollo para configurar providersu clave privada en MetaMask y su URL para su nodo en Infura:

development: {
     provider: () => new
HDWalletProvider("<Your private key on metamask", `https://rinkeby.infura.io/v3/71acb374b9dd4e1eb06eeb9a75a8cd1a`),
     network_id: 4,       // Any network (default: none)
},

Notarás en el código anterior que network_idestá establecido en 4; esta es la ID de red para Rinkeby . Otras redes de Ethereum tienen ID diferentes.

A continuación, ejecute la migración y su configuración ejecutando el siguiente comando:

truffle migrate -network development --reset 
Implementar migración

Ahora, copie el hash de la transacción. Vaya a MetaMask y haga clic en Ver cuenta en Etherscan . En la lista de transacciones, verá el hash de transacción que acaba de implementar:

Hash de transacción

Haga clic en una transacción individual para ver más detalles:

Transacción individual

Implementación del contrato inteligente en la red de prueba de Polygon (Mumbai)

Para implementar el contrato inteligente en la red de Polygon en Mumbai, comenzará conectando su billetera MetaMask a Polygon. Abra MetaMask y haga clic en Agregar red , luego agregue lo siguiente en los campos correspondientes:

Configuración de metamáscara

Luego, haga clic en Guardar y MetaMask se conectará a Polygon.

Dado que está migrando el contrato a la red de prueba de Polygon, necesitará tokens MATIC para pagar su transacción. Para obtener tokens MATIC, abra su billetera MetaMask y copie la dirección de su billetera. Luego, navegue hasta el grifo Polygon y pegue la dirección en el campo de dirección de la billetera. Haga clic en Enviar y luego en Confirmar .

Confirmar detalles

Como se muestra a continuación, debería ver la confirmación de que se envió la solicitud.

solicitud enviada

En unos minutos, debería ver los tokens en su billetera MetaMask. Una vez que los tokens MATIC se transfieran con éxito, aparecerán en el saldo de su billetera.

Fichas Matic

A continuación, en su editor de código, abra el truffle-config.jsarchivo. En el script de red, agregue un proveedor de red para Polygon debajo del proveedor de red para Ethereum. Utilizará la URL de RPC para la red de pruebas de Mumbai, tal como se define en la documentación de Polygon .

Copie el enlace RPC que se muestra a continuación, https://rpc-mumbai.matic.today :

Enlace RPC

Luego, pegue el enlace RPC en el código como providerURL. También pegue el chainid (arriba) en el código como network_id:

polygonTestnet: {
     provider: () => new HDWalletProvider(privateKeys, `https://rpc-mumbai.matic.today`),
     network_id: 80001,       // Any network (default: none)
   },

Ahora, abra su terminal y ejecute la migración y configuración a la red de prueba de Polygon con este comando:

truffle migrate --network polygonTestnet --reset

Puede ver a continuación que su contrato se ha migrado con éxito:

Migración exitosa

Ahora, copie el hash de la transacción. Abra su cuenta MetaMask y haga clic en Ver cuenta en Explorer :

Ver cuenta Metamask

Debería ver el contrato implementado con la transacción en el explorador de blockchain de Polygonscan :

Contrato implementado

Implementación del contrato inteligente en Binance Smart Chain

Para implementar su contrato inteligente en la red de prueba de Binance Smart Chain. necesitará obtener tokens BNB (que es la moneda nativa de la cadena Binance Smart).

Comenzará conectando su billetera MetaMask a BSC. Abra MetaMask y haga clic en Agregar red:

Agregar red

A continuación, agregue lo siguiente en los campos correspondientes:

Agregar página de red

Luego, haga clic en Guardar y MetaMask se conectará a BSC y establecerá el token BNB en cero:

Cero BNB

Para obtener tokens BNB gratuitos, abra su billetera MetaMask y copie la dirección de su billetera. Luego, navegue hasta Binance Smart Chain Faucet . En la entrada de la dirección, pegue la dirección de su billetera MetaMask.

Grifo de cadena inteligente

Ahora, haga clic en Give me BNB y se transferirá 1 BNB a su billetera MetaMask.

Solicitud de financiación aceptada

Puede confirmar que el token se envió al verificar el saldo de su cuenta MetaMask:

Equilibrio de metamáscara

Ahora, edite el truffle-config.jsarchivo en su editor de código y agregue la siguiente configuración para la red Binance Smart Chain:

 bscTestnet: {
     provider: () => new HDWalletProvider(privateKeys, `https://data-seed-prebsc-1-s1.binance.org:8545/`),
     network_id: 97,       // Any network (default: none)
   },

Para implementar su contrato en la red de prueba Binance Smart Chain, abra su terminal y ejecute este comando:

truffle migrate --network bscTestnet --reset
Implementar migración

Migración de contratos inteligentes entre cadenas

Discutimos algunos factores que podrían influir en la decisión de migrar un contrato inteligente de una cadena de bloques a otra. Ahora, veamos un par de técnicas de migración de contratos inteligentes.

Migración a través de parachains

La red Polkadot proporciona un entorno familiar y seguro para que las cadenas de bloques interactúen fácilmente entre sí.

Las paracadenas son cadenas de bloques de capa 1 que interactúan en el ecosistema de Polkadot. Las paracadenas son independientes entre sí pero funcionan en paralelo. Están conectados por la cadena de retransmisión de la red . Esta conexión permite la interoperabilidad entre cadenas, o la capacidad de comunicarse y compartir datos .

La red Polkadot aprovecha un mecanismo de consenso de prueba de participación mediante el uso de validadores y nominadores . Los recopiladores (que se muestran en la siguiente ilustración) conservan información sobre las transacciones de la red.

Cadena de retransmisión

Las paracadenas permiten a los desarrolladores migrar contratos dentro del ecosistema de Polkadot utilizando el formato de Mensajería de consenso cruzado (XCM) de Polkadot en lugar de envolver y desenvolver tokens (lo que analizaremos en la siguiente sección).

XCM se utiliza para formatear mensajes enviados entre cadenas, contratos inteligentes o puentes. XCM habilita un formato definido para enviar transacciones de una billetera a otra durante un período prolongado.

XCM tiene protocolos que actúan sobre los mensajes con distintas funciones: Paso de mensajes verticales (VMP) y Paso de mensajes entre cadenas (XCMP).

Además, XCM utiliza una máquina virtual de consenso cruzado (XCVM), que contiene varias instrucciones que se ejecutan como un programa y los mensajes que se transferirán. Las instrucciones en la XCVM consisten en el mensaje que se transfiere y su destino.

Además, existen puentes entre Polkadot y otras cadenas de bloques de capa 1, como Ethereum y Binance Smart Chain, lo que permite la interoperabilidad.

Migración envolviendo y desenvolviendo tokens

Cada cadena de bloques tiene tokens negociables diseñados de acuerdo con sus monedas digitales nativas. Cuando los contratos inteligentes se migran entre diferentes cadenas, debe haber una forma de que los tokens diseñados para una cadena de bloques funcionen en otra.

Esto es como viajar a un país que usa una moneda diferente. Sin embargo, en lugar de intercambiar un tipo de token por otro, las cadenas de bloques suelen utilizar el concepto de envolver y desenvolver.

La envoltura implica vincular el valor de un token a su criptomoneda original. El token envuelto es básicamente un token negociable que puede usarse en otras cadenas de bloques. Como ejemplo, digamos que algunos ERC-20 de Ethereum están envueltos. Su valor se fijará en su valor actual, pero ahora se consideran éter envuelto (WETH). Los tokens WETH se pueden usar en billeteras MetaMask y otras, para interactuar en varias cadenas de bloques (BSC, IOTA, etc.)

Uno de los beneficios más importantes de envolver un token es que se conserva el activo original, pero el token envuelto hereda las funcionalidades de la nueva cadena de bloques. Algunas de estas funcionalidades podrían incluir tiempo de transacción minimizado y tarifas de gas bajas.

Desempaquetar tokens se refiere al proceso de revertir el token a la criptomoneda original. Por ejemplo, WETH se puede desenvolver en su criptomoneda original de ETH.

Aquí hay una demostración que muestra cómo envolver y desenvolver un token de Ethereum utilizando el estándar OpenZeppelin ERC-20 :

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.7.0 <0.9.0;
import https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol;
contract WETH is ERC20 {
    constuctor() ERC20("Wrapped Ether", "WETH") public {};

    // define a mint function to create new wrapped ether token
    function mint() external payable {
        _mint(msg.sender, msg.value); 
    }
    // define a burn function to create an unwrapped token
    function burn(uint amount) external { //specify the amount that you want back
        payable(msg.sender).transfer(amount); // transfers 
        _burn(msg.sender, amount); //sending back the ether to the user
    }
}

Echemos un vistazo más de cerca a las líneas individuales de código en el bloque de código anterior:

  • Línea 1: especifica la licencia utilizada para el compilador Solidity
  • Línea 2: especifica la versión de Solidity
  • Línea 3: importa el estándar de token ERC-20, tal como se define en OpenZeppelin
  • Línea 4: define el contrato para crear los tokens envueltos y desenvueltos
  • Línea 5: define una constructor``()función que establece el nombre del Ether en "Wrapped Ether" y su símbolo en "WETH" tan pronto como se ejecuta el contrato
  • Línea 7: define una mint()función que acepta un valor de Ether y crea un nuevo token de Ether envuelto; el calificador externo significa que la función se puede llamar desde otros contratos; el calificador pagadero indica que la función puede aceptar y enviar Ether
  • Línea 9: utiliza la _mintfunción que se define en el código de OpenZeppelin; acepta la dirección de la persona que llama de la transacción msg.sendery el valor del Ether enviado comomsg.value
  • Línea 12: define una burn()función que acepta la cantidad de token que desea un usuario y devuelve un token sin envolver
  • Línea 13: especifica el monto que se transferirá al incluir la dirección de la persona que llama en la transacción, msg.sender, con el calificador pagadero para permitirle transferir Ether; utiliza la transferfunción definida en OpenZeppelin para aceptar el importe a transferir
  • Línea 14: usa la _burn()función definida en OpenZeppelin para enviar a la persona que llama de la transacción un token desenvuelto (el Ether original)

Conclusión

En este artículo, demostramos cómo configurar un contrato inteligente en Ganache y luego migrarlo a la red de prueba Rinkeby de Ethereum, la red de prueba de Mumbai de Polygon, Binance Smart Chain y Polygon usando MetaMask. También discutimos diferentes estrategias para migrar contratos inteligentes entre diferentes cadenas: envolver y desenvolver tokens, así como paracadenas.

Fuente del artículo original en https://blog.logrocket.com

#blockchain #smartcontract #ethereum #polygon #metamask #binancesmartchain #binance

Cómo migrar contratos inteligentes entre diferentes cadenas

Как перенести смарт-контракты между разными цепочками

Узнайте, как настроить смарт-контракт в Ganache, а затем перенести его в тестовую сеть Ethereum Rinkeby, тестовую сеть Polygon Mumbai, Binance Smart Chain и Polygon с помощью MetaMask. 

В этом руководстве показано, как перенести смарт-контракт из локальной цепочки разработки в отдельные блокчейны, а также между разными цепочками.

Есть несколько причин, по которым смарт-контракт может быть перенесен на другой блокчейн. Некоторыми очевидными причинами являются более низкая плата за газ или более быстрое время транзакции. Также есть случаи, когда имеет смысл переместить контракт в другую цепочку, чтобы отладить контракт, обеспечить дополнительную безопасность или даже предоставить доступ к контракту, если он стал недоступен из-за кражи или технической проблемы.

В этом руководстве по миграции смарт-контрактов показано, как перенести смарт-контракт из локальной цепочки разработки в отдельные цепочки блоков и как перенести смарт-контракты между разными цепочками. В этой статье также представлен обзор нескольких блокчейнов и того, как они различаются в отношении миграции смарт-контрактов.

  • Предпосылки
  • Рекомендации по миграции между цепочками
    • Ethereum против Binance Smart Chain
    • Polygon против блокчейна Ethereum
  • Демонстрация: миграция смарт-контрактов из локальной цепочки разработки
    • Настройка смарт-контракта с Ganache
    • Перенос смарт-контракта в тестовую сеть Ethereum (Rinkeby)
    • Миграция смарт-контракта в тестовую сеть Polygon (Мумбаи)
    • Перенос смарт-контракта в Binance Smart Chain
  • Миграция смарт-контрактов между цепочками
    • Парачейны
    • Упаковка и распаковка токенов

Предпосылки

Чтобы следовать учебной части этой статьи, убедитесь, что у вас есть следующее:

Рекомендации по миграции между блокчейнами

Несколько факторов могут повлиять на решение о переносе смарт-контракта с одного блокчейна на другой. Давайте рассмотрим несколько примеров.

Ethereum против Binance Smart Chain

Блокчейн Ethereum — это децентрализованный, прозрачный и безопасный общедоступный блокчейн. На момент написания этой статьи Ethereum использует алгоритм консенсуса Proof of Work . Смарт-контракты могут быть созданы в сети Ethereum.

Каждая операция, выполненная в блокчейне Ethereum, независимо от того, успешна она или нет, должна оплачиваться комиссией за газ. Операцией может быть отправка количества эфира (криптовалюта Ethereum) с одной учетной записи на другую или развертывание контракта.

Плата за газ должна быть оплачена до того, как майнеры добавят транзакцию в блок. Ethereum устанавливает максимальное количество газа на блок, называемое лимитом газа в блоке .

Binance Smart Chain (BSC ) использует алгоритм консенсуса Proof of Stake . Как и Ethereum, он поддерживает создание смарт-контрактов.

Некоторыми стимулами для перехода с Ethereum на BSC являются более низкие комиссии Binance за газ и более быстрое время транзакций. Эти преимущества делают BSC более масштабируемой, чем Ethereum. Смарт-контракты Ethereum можно легко перенести на платформу BSC с минимальными изменениями кода или без них.

Однако у BSC есть некоторые недостатки, в том числе меньшая децентрализация. Это связано с наличием нескольких централизованных объектов, таких как 21 000 валидаторов узлов, которые прямо или косвенно принадлежат Binance и несут ответственность за более низкую комиссию за газ в сети.

Полигон против Эфириума

Подобно BSC, блокчейн Polygon использует алгоритм консенсуса Proof of Stake. Polygon поддерживает создание смарт-контрактов и обеспечивает взаимодействие, обеспечивая перекрестную связь смарт-контрактов, запущенных на его блокчейне. Токен сети MATIC предлагает несколько функций, таких как оплата газа, размещение ставок и голосование.

Некоторыми стимулами для перехода с Ethereum на Polygon являются более быстрое время транзакций Polygon и более низкие комиссии за транзакции. Структура Polygon также делает его более масштабируемым, чем Ethereum. По мере увеличения количества узлов в сети Polygon экосистема расширяется, чтобы адекватно содержать узлы и обрабатывать их транзакции.

Теперь давайте посмотрим, как перенести смарт-контракты между разными цепочками.

Демонстрация: миграция смарт-контрактов из локальной цепочки разработки

В этом руководстве мы будем использовать смарт-контракт, написанный на Solidity и развернутый на платформе Tuffle Suite . Truffle Suite интегрируется с другими блокчейнами виртуальной машины Ethereum и имеет встроенные функции для создания, тестирования, компиляции и развертывания смарт-контрактов.

После развертывания смарт-контракта в локальной цепочке разработки мы продемонстрируем, как развернуть его на отдельных цепочках блоков. Мы будем использовать MetaMask для развертывания, чтобы легко видеть баланс нашего счета и историю транзакций.

Развертывание смарт-контракта в Ganache

Мы начнем с развертывания смарт-контракта в Ganache , инструменте моделирования блокчейна, созданном в среде Truffle. Это позволит нам обеспечить правильную компиляцию кода и отсутствие проблем с развертыванием.

Для начала клонируйте код смарт-контракта из этого репозитория GitHub в свой терминал. Затем в каталоге проекта выполните следующую команду, чтобы установить зависимости:

npm install

Прежде чем продолжить, убедитесь, что у вас установлен Ganache, так как это блокчейн разработки, который вы будете использовать.

Теперь запустите Ganache в своей системе и нажмите БЫСТРЫЙ СТАРТ , как показано ниже:

Ганаш

Далее мы развернем смарт-контракт, используя миграции, определенные в 2_deploy_migration.jsфайле.

Сначала в вашем терминале и каталоге проекта выполните следующую команду, чтобы запустить блокчейн разработки:

truffle develop

Это запустит ваш блокчейн разработки с десятью адресами, каждый из которых содержит 100ETH и закрытые ключи:

Десять ключей

Затем разверните смарт-контракт, выполнив следующую команду для выполнения всего кода в migrationпапке:

migrate -reset
Мигрировать
Развернуть миграцию

Вывод терминала показывает, что 2_deploy_migration.jsфайл развернут. Выходные данные также показывают информацию о контракте, включая хэш транзакции, номер блока и адрес контракта.

Обратите внимание, что некоторая информация о смарт-контрактах, такая как value sentи total cost, предоставляется в ETH (валюта Ethereum). При переносе смарт-контракта вам необходимо сначала обновить любую информацию, которая находится в ETH, до собственной валюты блокчейна, на который вы переносите контракт.

Чтобы выйти из среды, дважды нажмите CTRL + C в терминале.

Теперь давайте посмотрим, как перенести смарт-контракт на блокчейн Ethereum.

Развертывание смарт-контракта в тестовой сети Ethereum (Rinkeby)

Чтобы развернуть смарт-контракт из локальной цепочки блоков в сети Ethereum Rinkeby, вы должны сначала получить адрес.

Чтобы сгенерировать адрес, откройте свой кошелек MetaMask и подключитесь к тестовой сети Rinkeby.

Чтобы получить бесплатный эфир, используйте Faucets Chainlink , подключитесь к Rinkeby и вставьте адрес кошелька в поле.

Затем нажмите Отправить запрос .

Как показано ниже, на ваш кошелек должно быть отправлено 0,1 ETH.

ETH в кошельке

Далее пришло время настроить Truffle. В редакторе кода откройте truffle-config.jsфайл, чтобы определить конфигурации сети.

Проверьте truffle-config.jsдокументацию файла, где он определяет следующее:

/**
* Use this file to configure your truffle project. It's seeded with some
* common settings for different networks and features like migrations,
* compilation and testing. Uncomment the ones you need or modify
* them to suit your project as necessary.
*
* More information about configuration can be found at:
*
* https://trufflesuite.com/docs/truffle/reference/configuration
*
* To deploy via Infura you'll need a wallet provider (like @truffle/hdwallet-provider)
* to sign your transactions before they're sent to a remote public node. Infura accounts
* are available for free at: infura.io/register.
*
* You'll also need a mnemonic - the twelve-word phrase the wallet uses to generate
* public/private key pairs. If you're publishing your code to GitHub make sure you load this
* phrase from a file you've .gitignored so it doesn't accidentally become public.
*
*/

Затем создайте учетную запись на Infura: infura.io/register , затем создайте новый проект и нажмите « НАСТРОЙКИ ПРОЕКТА » в правом верхнем углу.

Настройки проекта

На вкладке «Общие» в разделе «Ключи» выберите RINKEBY в раскрывающемся списке «Конечные точки». Вы должны увидеть идентификатор вашего проекта, а также URL-адрес вашего узла на Infura.

Выберите Ринкеби

NB, вы будете использовать @truffle/hdwallet-provider зависимость, установленную в вашем package.json файле, чтобы настроить вашего провайдера на ваш закрытый ключ в MetaMask.

В вашем truffle-config.jsфайле укажите @truffle/hdwallet-providerзависимость и создайте массив, в котором будут храниться ваши закрытые ключи:

const HDWalletProvider = require('@truffle/hdwallet-provider');
const privateKeys = ['<app your private key>'];

Теперь прокрутите вниз до раздела сетей и добавьте сценарий разработки, чтобы установить providerваш закрытый ключ в MetaMask и ваш URL-адрес для вашего узла в Infura:

development: {
     provider: () => new
HDWalletProvider("<Your private key on metamask", `https://rinkeby.infura.io/v3/71acb374b9dd4e1eb06eeb9a75a8cd1a`),
     network_id: 4,       // Any network (default: none)
},

Вы заметите в приведенном выше коде, что network_idустановлено значение 4; это идентификатор сети для Rinkeby . Другие сети Ethereum имеют другие идентификаторы.

Затем выполните миграцию и конфигурацию, выполнив следующую команду:

truffle migrate -network development --reset 
Развернуть миграцию

Теперь скопируйте хэш транзакции. Перейдите к MetaMask и нажмите View Account on Etherscan . В списке транзакций вы увидите только что развернутый хэш транзакции:

Хэш транзакции

Нажмите на отдельную транзакцию, чтобы увидеть более подробную информацию:

Индивидуальная транзакция

Развертывание смарт-контракта в тестовой сети Polygon (Мумбаи)

Чтобы развернуть смарт-контракт в сети Polygon в Мумбаи, вы начнете с подключения своего кошелька MetaMask к Polygon. Откройте MetaMask и нажмите « Добавить сеть» , затем добавьте в соответствующие поля следующее:

  • Имя сети: PolygonTestnet.
  • URL-адрес RPC: https://rpc-mumbai.matic.today
  • Идентификатор цепочки: 80001
  • Символ валюты: MATIC
  • URL-адрес обозревателя блоков: https://mumbai.polygonscan.com/

Настройки метамаски

Затем нажмите « Сохранить», и MetaMask подключится к Polygon.

Поскольку вы переносите контракт в тестовую сеть Polygon, вам потребуются токены MATIC для оплаты транзакции. Чтобы получить токены MATIC, откройте свой кошелек MetaMask и скопируйте адрес своего кошелька. Затем перейдите к крану Polygon и вставьте адрес в поле адреса кошелька. Нажмите «Отправить », затем нажмите «Подтвердить » .

Подтвердить детали

Как показано ниже, вы должны увидеть подтверждение того, что запрос был отправлен.

Запрос отправлен

Через несколько минут вы должны увидеть токены в своем кошельке MetaMask. Как только токены MATIC будут успешно переведены, они появятся на балансе вашего кошелька.

Матические жетоны

Затем в редакторе кода откройте truffle-config.jsфайл. В сетевом сценарии добавьте сетевого провайдера для Polygon под сетевым провайдером для Ethereum. Вы будете использовать URL-адрес RPC для тестовой сети Mumbai, как указано в документации Polygon .

Скопируйте ссылку RPC , показанную ниже, https://rpc-mumbai.matic.today :

Ссылка RPC

Затем вставьте ссылку RPC в код в качестве providerURL-адреса. Также вставьте chainid (выше) в код как network_id:

polygonTestnet: {
     provider: () => new HDWalletProvider(privateKeys, `https://rpc-mumbai.matic.today`),
     network_id: 80001,       // Any network (default: none)
   },

Теперь откройте свой терминал и запустите миграцию и настройку в тестовую сеть Polygon с помощью этой команды:

truffle migrate --network polygonTestnet --reset

Ниже вы можете увидеть, что ваш контракт был успешно перенесен:

Успешная миграция

Теперь скопируйте хэш транзакции. Откройте свою учетную запись MetaMask и нажмите « Просмотреть учетную запись в проводнике» :

Просмотр учетной записи метамаски

Вы должны увидеть развернутый контракт с транзакцией в обозревателе блокчейна Polygonscan :

Развернутый контракт

Развертывание смарт-контракта в Binance Smart Chain

Чтобы развернуть ваш смарт-контракт в тестовой сети Binance Smart Chain. вам нужно будет получить токены BNB (это собственная валюта сети Binance Smart).

Вы начнете с подключения вашего кошелька MetaMask к BSC. Откройте MetaMask и нажмите « Добавить сеть»:

Добавить сеть

Далее добавьте в соответствующие поля следующее:

  • Сетевое имя: BSCTestnet
  • URL-адрес RPC: https://rpc-mumbai.matic.today
  • Идентификатор цепи: 97
  • Символ валюты: BNB

Добавить сетевую страницу

Затем нажмите « Сохранить», и MetaMask подключится к BSC и установит токен BNB на ноль:

Ноль БНБ

Чтобы получить бесплатные токены BNB, откройте свой кошелек MetaMask и скопируйте адрес своего кошелька. Затем перейдите к сборщику Binance Smart Chain . В поле ввода адреса вставьте адрес своего кошелька MetaMask.

Умный цепной кран

Теперь нажмите Дать мне BNB , и 1 BNB будет переведен на ваш кошелек MetaMask.

Запрос на финансирование принят

Вы можете подтвердить, что токен был отправлен, проверив баланс своей учетной записи MetaMask:

Баланс метамаски

Теперь отредактируйте truffle-config.jsфайл в редакторе кода и добавьте следующую конфигурацию для сети Binance Smart Chain:

 bscTestnet: {
     provider: () => new HDWalletProvider(privateKeys, `https://data-seed-prebsc-1-s1.binance.org:8545/`),
     network_id: 97,       // Any network (default: none)
   },

Чтобы развернуть свой контракт в тестовой сети Binance Smart Chain, откройте терминал и выполните следующую команду:

truffle migrate --network bscTestnet --reset
Развернуть миграцию

Миграция смарт-контрактов между цепочками

Мы обсудили некоторые факторы, которые могут повлиять на решение о переносе смарт-контракта с одного блокчейна на другой. Теперь давайте рассмотрим несколько методов миграции смарт-контрактов.

Миграция через парачейны

Сеть Polkadot обеспечивает знакомую и безопасную среду, позволяющую блокчейнам легко взаимодействовать друг с другом.

Парачейны — это блокчейны уровня 1, которые взаимодействуют в экосистеме Polkadot. Парачейны не зависят друг от друга, но работают параллельно. Они связаны цепочкой ретрансляции сети . Это соединение обеспечивает межсетевое взаимодействие или возможность обмениваться данными .

Сеть Polkadot использует механизм консенсуса Proof of Stake за счет использования валидаторов и номинаторов . Коллаторы (показаны на рисунке ниже) сохраняют информацию о транзакциях в сети.

Релейная цепь

Парачейны позволяют разработчикам переносить контракты в экосистеме Polkadot, используя формат Polkadot Cross-Consensus Messaging (XCM) вместо упаковки и распаковки токенов (о чем мы поговорим в следующем разделе).

XCM используется для форматирования сообщений, отправляемых между цепочками, смарт-контрактами или мостами. XCM позволяет использовать определенный формат для отправки транзакций из одного кошелька в другой в течение длительного периода времени.

XCM имеет протоколы, которые воздействуют на сообщения с различными функциями: вертикальная передача сообщений (VMP) и передача сообщений между цепочками (XCMP).

Кроме того, XCM использует виртуальную машину перекрестного консенсуса (XCVM), которая содержит несколько инструкций, работающих как программа, и сообщения, которые необходимо передать. Инструкции в XCVM состоят из передаваемого сообщения и его адресата.

Кроме того, между Polkadot и другими блокчейнами уровня 1, такими как Ethereum и Binance Smart Chain, существуют мосты, обеспечивающие взаимодействие.

Миграция путем упаковки и распаковки токенов

Каждый блокчейн имеет торгуемые токены, разработанные в соответствии с его родными цифровыми валютами. Когда смарт-контракты переносятся между разными цепочками, должен быть способ, которым токены, разработанные для одной цепочки блоков, могли работать в другой.

Это похоже на путешествие в страну, в которой используется другая валюта. Однако вместо того, чтобы обменивать один тип токена на другой, блокчейны обычно используют концепцию упаковки и развертывания.

Обертывание влечет за собой привязку стоимости токена к его исходной криптовалюте. Обернутый токен — это, по сути, торгуемый токен, который можно использовать в других блокчейнах. В качестве примера предположим, что некоторые ERC-20 Ethereum завернуты. Их стоимость будет привязана к их текущей стоимости, но теперь они считаются обернутым эфиром (WETH). Токены WETH могут использоваться в кошельках MetaMask и других для взаимодействия с различными блокчейнами (BSC, IOTA и т. д.).

Одним из наиболее значительных преимуществ упаковки токена является то, что исходный актив сохраняется, но завернутый токен наследует функциональные возможности нового блокчейна. Некоторые из этих функций могут включать минимизацию времени транзакции и низкую плату за газ.

Развертывание токенов относится к процессу обращения токена к исходной криптовалюте. Например, WETH можно преобразовать в исходную криптовалюту ETH.

Вот демонстрация, показывающая упаковку и распаковку токена Ethereum с использованием стандарта OpenZeppelin ERC-20 :

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.7.0 <0.9.0;
import https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol;
contract WETH is ERC20 {
    constuctor() ERC20("Wrapped Ether", "WETH") public {};

    // define a mint function to create new wrapped ether token
    function mint() external payable {
        _mint(msg.sender, msg.value); 
    }
    // define a burn function to create an unwrapped token
    function burn(uint amount) external { //specify the amount that you want back
        payable(msg.sender).transfer(amount); // transfers 
        _burn(msg.sender, amount); //sending back the ether to the user
    }
}

Давайте подробнее рассмотрим отдельные строки кода в приведенном выше блоке кода:

  • Строка 1: указывает лицензию, используемую для компилятора Solidity.
  • Строка 2: указывает версию Solidity.
  • Строка 3: импорт стандарта токена ERC-20, как определено в OpenZeppelin.
  • Строка 4: определяет контракт для создания обернутых и развернутых токенов.
  • Строка 5: определяет constructor``()функцию, которая устанавливает имя Эфира на «Обернутый Эфир» и его символ на «WETH», как только контракт будет выполнен.
  • Строка 7: определяет mint()функцию, которая принимает значение Ether и создает новый обернутый токен Ether; квалификатор external означает, что функция может быть вызвана из других контрактов; квалификатор payable означает, что функция может принимать и отправлять Ether.
  • Строка 9: использует _mintфункцию, определенную в коде OpenZeppelin; он принимает адрес инициатора транзакции как msg.senderи стоимость отправленного эфира какmsg.value
  • Строка 12: определяет burn()функцию, которая принимает количество токенов, которое хочет пользователь, и отправляет обратно развернутый токен.
  • Строка 13: указывает сумму, которая должна быть переведена, заключая адрес вызывающей стороны транзакции msg.senderс квалификатором payable, чтобы он мог передавать эфир; использует transferфункцию, определенную в OpenZeppelin, для принятия суммы, подлежащей переводу
  • Строка 14: использует _burn()функцию, определенную в OpenZeppelin, для отправки инициатору транзакции развернутого токена (оригинального эфира).

Вывод

В этой статье мы продемонстрировали, как настроить смарт-контракт в Ganache, а затем перенести его в тестовую сеть Ethereum Rinkeby, тестовую сеть Polygon Mumbai, Binance Smart Chain и Polygon с помощью MetaMask. Мы также обсудили разные стратегии переноса смарт-контрактов между разными цепочками: обертывание и разворачивание токенов, а также парачейны.

Оригинальный источник статьи на https://blog.logrocket.com

#blockchain #smartcontract #ethereum #polygon #metamask #binancesmartchain #binance

Как перенести смарт-контракты между разными цепочками

Metamask Provider to Connect Matic Network

metamask-provider

Metamask provider to connect Matic Network. In future, plan is to use mm-plugin to handle multiple networks.

Installation

$ npm install --save @maticnetwork/metamask-provider

Usage

Create network providers by instantiating provider objects.

import MetamaskProvider from "@maticnetwork/metamask-provider"

// enable ethereum metamask
window.ethereum.enable()

// create ropsten provider
const ropstenProvider = new MetamaskProvider(window.ethereum, {
  url: "https://ropsten.infura.io/v3/<your-infura-api-key>"
})

// create matic testnet provider
const maticTestnetProvider = new MetamaskProvider(window.ethereum, {
  url: "https://testnet.matic.network"
})

Use these providers to create Web3 objects to use web3 apis.

Download Details:
Author: maticnetwork
Source Code: https://github.com/maticnetwork/metamask-provider
License: MIT license

#polygon  #blockchain  #smartcontract  #web3  #ethereum #metamask #javascript 

Metamask Provider to Connect Matic Network
Sean Wade

Sean Wade

1654074720

Como migrar contratos inteligentes entre diferentes cadeias

Aprenda como configurar um contrato inteligente no Ganache e depois migrá-lo para a rede de testes Rinkeby da Ethereum, a rede de testes Mumbai da Polygon, a Binance Smart Chain e a Polygon usando MetaMask. 

Este guia mostra como migrar um contrato inteligente de uma cadeia de desenvolvimento local para blockchains individuais, bem como entre diferentes cadeias.

Existem várias razões pelas quais um contrato inteligente pode ser migrado para outro blockchain. Algumas razões óbvias são taxas de gás mais baixas ou tempo de transação mais rápido. Há também casos em que faz sentido mudar um contrato para uma cadeia diferente para depurar um contrato, fornecer segurança adicional ou até mesmo fornecer acesso ao contrato se ele se tornar inacessível devido a roubo ou problema técnico.

Este guia de migração de contrato inteligente demonstra como migrar um contrato inteligente de uma cadeia de desenvolvimento local para blockchains individuais e como migrar contratos inteligentes entre diferentes cadeias. Este artigo também fornece uma visão geral de várias blockchains e como elas variam em relação à migração de contratos inteligentes.

  • Pré-requisitos
  • Considerações para migrar entre cadeias
    • Ethereum vs. Binance Smart Chain
    • Blockchain Polygon vs. Ethereum
  • Demonstração: migração de contrato inteligente de uma cadeia de desenvolvimento local
    • Configurando um contrato inteligente com a Ganache
    • Migrando um contrato inteligente para o testnet da Ethereum (Rinkeby)
    • Migrando um contrato inteligente para o testnet da Polygon (Mumbai)
    • Migrando um contrato inteligente para a Binance Smart Chain
  • Migração de contrato inteligente entre cadeias
    • Parachains
    • Embrulhar e desembrulhar tokens

Pré-requisitos

Para acompanhar a parte do tutorial deste artigo, certifique-se de ter o seguinte:

Considerações para migrar entre blockchains

Vários fatores podem influenciar a decisão de migrar um contrato inteligente de uma blockchain para outra. Vamos dar uma olhada em alguns exemplos.

Ethereum vs. Binance Smart Chain

A blockchain Ethereum é uma blockchain pública descentralizada, transparente e segura. No momento da redação deste artigo, o Ethereum usa um algoritmo de consenso de Prova de Trabalho . Contratos inteligentes podem ser criados na rede Ethereum.

Toda operação feita na blockchain Ethereum, bem sucedida ou não, deve ser paga com uma taxa de gás. Uma operação pode estar enviando uma quantidade de ether (criptomoeda do Ethereum) de uma conta para outra ou implantando um contrato.

A taxa de gás deve ser paga antes que os mineradores adicionem a transação a um bloco. O Ethereum impõe uma quantidade máxima de gás por bloco, conhecido como limite de gás de bloco .

A Binance Smart Chain (BSC ) usa um algoritmo de consenso Proof of Stake . Como o Ethereum, ele suporta a criação de contratos inteligentes.

Alguns incentivos para migrar do Ethereum para o BSC são as taxas de gás mais baixas da Binance e tempos de transação mais rápidos. Esses benefícios tornam o BSC mais escalável que o Ethereum. Os contratos Ethereum Smart podem ser facilmente migrados para a plataforma BSC com mínima ou nenhuma alteração no código.

No entanto, o BSC tem algumas desvantagens, incluindo menos descentralização. Isso se deve ao fato de ter várias entidades centralizadas, como os 21.000 validadores de nós que são de propriedade direta ou indireta da Binance e responsáveis ​​pelas menores taxas de gás da rede.

Polígono vs. Ethereum

Semelhante ao BSC, o blockchain Polygon usa um algoritmo de consenso Proof of Stake. O Polygon suporta a criação de contratos inteligentes e permite a interoperabilidade, permitindo a comunicação cruzada de contratos inteligentes lançados em seu blockchain. O token da rede, MATIC, oferece várias funcionalidades, como pagamento de taxas de gás, staking e votação.

Alguns incentivos para migrar do Ethereum para o Polygon são os tempos de transação mais rápidos do Polygon e as taxas de transação mais baixas. A estrutura do Polygon também o torna mais escalável que o Ethereum. À medida que o número de nós na rede Polygon aumenta, o ecossistema se expande para conter adequadamente os nós e processar suas transações.

Agora, vamos dar uma olhada em como migrar contratos inteligentes entre diferentes cadeias.

Demonstração: migração de contrato inteligente de uma cadeia de desenvolvimento local

Para este tutorial, usaremos um contrato inteligente escrito em Solidity e implantado na estrutura Tuffle Suite . O Truffle Suite se integra a outros blockchains da Ethereum Virtual Machine e possui recursos integrados para criar, testar, compilar e implantar contratos inteligentes.

Depois de implantar o contrato inteligente em uma cadeia de desenvolvimento local, demonstraremos como implantá-lo em blockchains individuais. Usaremos o MetaMask para a implantação para ver facilmente o saldo da nossa conta e o histórico de transações.

Como implantar o contrato inteligente no Ganache

Começaremos implantando o contrato inteligente no Ganache , uma ferramenta de simulação de blockchain construída no ambiente Truffle. Isso nos permitirá garantir que o código seja compilado corretamente e que não haja problemas com a implantação.

Para começar, clone o código do contrato inteligente deste repositório do GitHub em seu terminal. Em seguida, no diretório do projeto, execute o seguinte comando para instalar as dependências:

npm install

Antes de prosseguir, certifique-se de ter o Ganache instalado, pois este é o blockchain de desenvolvimento que você usará.

Agora, execute o Ganache em seu sistema e clique em QUICKSTART , conforme mostrado abaixo:

ganache

Em seguida, implantaremos o contrato inteligente usando as migrações definidas no 2_deploy_migration.jsarquivo.

Primeiro, no diretório do terminal e do projeto, execute o seguinte comando para iniciar o blockchain de desenvolvimento:

truffle develop

Isso iniciará seu blockchain de desenvolvimento com dez endereços, cada um contendo 100ETH e chaves privadas:

Dez Chaves

Em seguida, implante o contrato inteligente executando o seguinte comando para executar todo o código na migrationpasta:

migrate -reset
Migrar
Implantar migração

A saída do terminal mostra que o 2_deploy_migration.jsarquivo foi implantado. A saída também mostra informações do contrato, incluindo o hash da transação, número do bloco e endereço do contrato.

Observe que algumas das informações do contrato inteligente, como value sente total cost, são fornecidas em ETH (moeda do Ethereum). Ao migrar o contrato inteligente, você precisará primeiro atualizar qualquer informação que esteja em ETH para a moeda nativa do blockchain para o qual está migrando o contrato.

Para sair do ambiente, digite CTRL + C duas vezes no seu terminal.

Agora, vamos ver como migrar o contrato inteligente para o blockchain Ethereum.

Implantando um contrato inteligente na rede de testes da Ethereum (Rinkeby)

Para implantar o contrato inteligente da blockchain local na rede Rinkeby da Ethereum, você deve primeiro ter um endereço.

Para gerar o endereço, abra sua carteira MetaMask e conecte-se à rede de teste Rinkeby.

Para obter ether grátis, use o Faucets Chainlink , conecte-se ao Rinkeby e cole o endereço da carteira no campo.

Em seguida, clique em Enviar solicitação .

Como mostrado abaixo, isso deve enviar 0,1 ETH para sua carteira.

ETH na carteira

Em seguida, é hora de configurar o Truffle. Em seu editor de código, abra o truffle-config.jsarquivo para definir suas configurações de rede.

Verifique a truffle-config.jsdocumentação do arquivo onde ele define o seguinte:

/**
* Use this file to configure your truffle project. It's seeded with some
* common settings for different networks and features like migrations,
* compilation and testing. Uncomment the ones you need or modify
* them to suit your project as necessary.
*
* More information about configuration can be found at:
*
* https://trufflesuite.com/docs/truffle/reference/configuration
*
* To deploy via Infura you'll need a wallet provider (like @truffle/hdwallet-provider)
* to sign your transactions before they're sent to a remote public node. Infura accounts
* are available for free at: infura.io/register.
*
* You'll also need a mnemonic - the twelve-word phrase the wallet uses to generate
* public/private key pairs. If you're publishing your code to GitHub make sure you load this
* phrase from a file you've .gitignored so it doesn't accidentally become public.
*
*/

Em seguida, crie uma conta no Infura: infura.io/register , crie um novo projeto e clique em CONFIGURAÇÕES DO PROJETO no canto superior direito.

Configurações do projeto

Na guia Geral, em Chaves, selecione RINKEBY na lista suspensa Endpoints. Você deve ver o ID do seu projeto exibido, bem como o URL do seu nó no Infura.

Selecione Rinkeby

NB, você usará a @truffle/hdwallet-provider dependência instalada em seu package.json arquivo para definir seu provedor para sua chave privada no MetaMask

Em seu truffle-config.jsarquivo, exija a @truffle/hdwallet-providerdependência e crie um array que armazenará suas chaves privadas:

const HDWalletProvider = require('@truffle/hdwallet-provider');
const privateKeys = ['<app your private key>'];

Agora, role para baixo até a seção de redes e adicione um script de desenvolvimento para definir providersua chave privada no MetaMask e sua URL para seu nó no Infura:

development: {
     provider: () => new
HDWalletProvider("<Your private key on metamask", `https://rinkeby.infura.io/v3/71acb374b9dd4e1eb06eeb9a75a8cd1a`),
     network_id: 4,       // Any network (default: none)
},

Você notará no código acima que o network_idestá definido como 4; este é o ID de rede para Rinkeby . Outras redes Ethereum têm IDs diferentes.

Em seguida, execute a migração e sua configuração executando o seguinte comando:

truffle migrate -network development --reset 
Implantar migração

Agora, copie o hash da transação. Navegue até MetaMask e clique em Exibir conta no Etherscan . Na lista de transações, você verá o hash de transação que acabou de ser implantado:

Hash da transação

Clique em uma transação individual para ver mais detalhes:

Transação Individual

Implantando o contrato inteligente na rede de testes da Polygon (Mumbai)

Para implantar o contrato inteligente na rede Polygon's Mumbai, você começará conectando sua carteira MetaMask ao Polygon. Abra o MetaMask e clique em Adicionar rede e adicione o seguinte aos campos apropriados:

Configurações de metamáscara

Em seguida, clique em Salvar e o MetaMask se conectará ao Polygon.

Como você está migrando o contrato para a rede de testes da Polygon, precisará de tokens MATIC para pagar sua transação. Para obter tokens MATIC, abra sua carteira MetaMask e copie seu endereço de carteira. Em seguida, navegue até a torneira Polygon e cole o endereço no campo de endereço da carteira. Clique em Enviar e, em seguida, clique em Confirmar .

Confirmar detalhes

Conforme mostrado abaixo, você deverá ver a confirmação de que a solicitação foi enviada.

Solicitação Enviada

Em alguns minutos, você deverá ver os tokens em sua carteira MetaMask. Assim que os tokens MATIC forem transferidos com sucesso, eles aparecerão no saldo da sua carteira.

Fichas Matic

Em seguida, em seu editor de código, abra o truffle-config.jsarquivo. No script de rede, adicione um provedor de rede para Polygon abaixo do provedor de rede para Ethereum. Você usará a URL RPC para a rede de teste de Mumbai, conforme definido na documentação do Polygon .

Copie o link RPC mostrado abaixo, https://rpc-mumbai.matic.today :

Link RPC

Em seguida, cole o link RPC no código como providerURL. Cole também o chainid (acima) no código como network_id:

polygonTestnet: {
     provider: () => new HDWalletProvider(privateKeys, `https://rpc-mumbai.matic.today`),
     network_id: 80001,       // Any network (default: none)
   },

Agora, abra seu terminal e execute a migração e configuração para o testnet Polygon com este comando:

truffle migrate --network polygonTestnet --reset

Você pode ver abaixo que seu contrato foi migrado com sucesso:

Migração bem-sucedida

Agora, copie o hash da transação. Abra sua conta MetaMask e clique em Visualizar conta no Explorer :

Ver conta de metamáscara

Você deve ver o contrato implantado com a transação no explorador de blockchain Polygonscan :

Contrato implantado

Implantando o contrato inteligente na Binance Smart Chain

Para implantar seu contrato inteligente na rede de teste da Binance Smart Chain. você precisará obter tokens BNB (que é a moeda nativa da cadeia Binance Smart).

Você começará conectando sua carteira MetaMask ao BSC. Abra o MetaMask e clique em Adicionar rede:

Adicionar rede

Em seguida, adicione o seguinte aos campos apropriados:

Adicionar página de rede

Em seguida, clique em Salvar e o MetaMask se conectará ao BSC e definirá o token BNB para zero:

Zero BNB

Para obter tokens BNB gratuitos, abra sua carteira MetaMask e copie o endereço da sua carteira. Em seguida, navegue até Binance Smart Chain Faucet . Na entrada de endereço, cole seu endereço de carteira MetaMask.

Torneira de Corrente Inteligente

Agora, clique em Give me BNB e 1 BNB será transferido para sua carteira MetaMask.

Solicitação de financiamento aceita

Você pode confirmar que o token foi enviado verificando o saldo da sua conta MetaMask:

Saldo de metamáscara

Agora, edite o truffle-config.jsarquivo em seu editor de código e adicione a seguinte configuração para a rede Binance Smart Chain:

 bscTestnet: {
     provider: () => new HDWalletProvider(privateKeys, `https://data-seed-prebsc-1-s1.binance.org:8545/`),
     network_id: 97,       // Any network (default: none)
   },

Para implantar seu contrato na rede de testes da Binance Smart Chain, abra seu terminal e execute este comando:

truffle migrate --network bscTestnet --reset
Implantar migração

Migração de contrato inteligente entre cadeias

Discutimos alguns fatores que podem influenciar a decisão de migrar um contrato inteligente de uma blockchain para outra. Agora, vamos ver algumas técnicas de migração de contrato inteligente.

Migração via parachains

A rede Polkadot fornece um ambiente familiar e seguro para as blockchains interagirem facilmente umas com as outras.

Parachains são blockchains de camada 1 que interagem no ecossistema Polkadot. As paracadeias são independentes umas das outras, mas funcionam em paralelo. Eles são conectados pela Relay Chain da rede . Essa conexão permite a interoperabilidade entre cadeias ou a capacidade de se comunicar e compartilhar dados .

A rede Polkadot aproveita um mecanismo de consenso de Prova de Participação por meio do uso de validadores e nominadores . Os agrupadores (mostrados na ilustração abaixo) retêm informações sobre as transações da rede.

Cadeia de relés

As parachains permitem que os desenvolvedores migrem contratos dentro do ecossistema Polkadot usando o formato Cross-Consensus Messaging (XCM) da Polkadot em vez de encapsular e desempacotar tokens (que discutiremos na próxima seção).

O XCM é usado para formatar mensagens enviadas entre cadeias, contratos inteligentes ou pontes. O XCM permite um formato definido para enviar transações de uma carteira para outra por um período prolongado.

O XCM possui protocolos que atuam nas mensagens com funções distintas: Vertical Message Passing (VMP) e Cross-Chain Message Passing (XCMP).

Além disso, o XCM usa uma Máquina Virtual de Consenso Cruzado (XCVM), que contém várias instruções rodando como um programa e a(s) mensagem(ns) a ser(em) transferida(s). As instruções no XCVM consistem na mensagem que é transferida e seu destino.

Além disso, existem pontes entre o Polkadot e outras blockchains de camada 1, como Ethereum e Binance Smart Chain, permitindo a interoperabilidade.

Migração envolvendo e desempacotando tokens

Cada blockchain possui tokens negociáveis ​​projetados de acordo com suas moedas digitais nativas. Quando os contratos inteligentes são migrados entre diferentes cadeias, é preciso haver uma maneira de os tokens projetados para um blockchain funcionarem em outro.

Isso é como viajar para um país que usa uma moeda diferente. No entanto, em vez de trocar um tipo de token por outro, as blockchains normalmente utilizam o conceito de encapsulamento e desdobramento.

O encapsulamento envolve atrelar o valor de um token à sua criptomoeda original. O token encapsulado é basicamente um token negociável que pode ser usado em outras blockchains. Como exemplo, digamos que alguns ERC-20 da Ethereum estejam empacotados. Seu valor será atrelado ao seu valor atual, mas agora eles são considerados éter encapsulado (WETH). Os tokens WETH podem ser usados ​​em carteiras MetaMask e outras, para interagir em várias blockchains (BSC, IOTA, etc.)

Um dos benefícios mais significativos de encapsular um token é que o ativo original é preservado, mas o token encapsulado herda as funcionalidades do novo blockchain. Algumas dessas funcionalidades podem incluir tempo de transação minimizado e baixas taxas de gás.

Desempacotar tokens refere-se ao processo de reverter o token para a criptomoeda original. Por exemplo, WETH pode ser desembrulhado em sua criptomoeda original de ETH.

Aqui está uma demonstração mostrando o encapsulamento e desdobramento de um token Ethereum usando o padrão OpenZeppelin ERC-20 :

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.7.0 <0.9.0;
import https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol;
contract WETH is ERC20 {
    constuctor() ERC20("Wrapped Ether", "WETH") public {};

    // define a mint function to create new wrapped ether token
    function mint() external payable {
        _mint(msg.sender, msg.value); 
    }
    // define a burn function to create an unwrapped token
    function burn(uint amount) external { //specify the amount that you want back
        payable(msg.sender).transfer(amount); // transfers 
        _burn(msg.sender, amount); //sending back the ether to the user
    }
}

Vamos dar uma olhada nas linhas individuais de código no bloco de código acima:

  • Linha 1: especifica a licença usada para o compilador Solidity
  • Linha 2: especifica a versão do Solidity
  • Linha 3: importa o padrão de token ERC-20, conforme definido no OpenZeppelin
  • Linha 4: define o contrato para criar os tokens encapsulados e não encapsulados
  • Linha 5: define uma constructor``()função que define o nome do Ether para “Wrapped Ether” e seu símbolo para “WETH” assim que o contrato é executado
  • Linha 7: define uma mint()função que aceita um valor de Ether e cria um novo token Ether encapsulado; o qualificador externo significa que a função pode ser chamada de outros contratos; o qualificador pagável denota que a função pode aceitar e enviar Ether
  • Linha 9: usa a _mintfunção que está definida no código OpenZeppelin; ele aceita o endereço do chamador da transação como msg.sendere o valor do Ether enviado comomsg.value
  • Linha 12: define uma burn()função que aceita a quantidade de token que um usuário deseja e envia de volta um token desempacotado
  • Linha 13: especifica o valor a ser transferido envolvendo o endereço do chamador da transação, msg.sender, com o qualificador a pagar para permitir que ele transfira Ether; usa a transferfunção definida no OpenZeppelin para aceitar o valor a ser transferido
  • Linha 14: usa a _burn()função definida no OpenZeppelin para enviar ao chamador da transação um token desempacotado (o Ether original)

Conclusão

Neste artigo, demonstramos como configurar um contrato inteligente no Ganache e depois migrá-lo para a rede de teste Rinkeby da Ethereum, a rede de teste Mumbai da Polygon, a Binance Smart Chain e a Polygon usando MetaMask. Também discutimos diferentes estratégias para migrar contratos inteligentes entre diferentes cadeias: tokens de empacotamento e desempacotamento, bem como parachains.

Fonte do artigo original em https://blog.logrocket.com

#blockchain #smartcontract #ethereum #polygon #metamask #binancemartchain #binance

Como migrar contratos inteligentes entre diferentes cadeias
Hoang  Kim

Hoang Kim

1654071008

Cách di chuyển hợp đồng thông minh giữa các chuỗi khác nhau

Tìm hiểu cách thiết lập hợp đồng thông minh trong Ganache và sau đó di chuyển nó sang mạng thá»­ nghiệm Rinkeby của Ethereum, mạng thá»­ nghiệm Mumbai của Polygon, Chuỗi thông minh Binance và Đa giác bằng MetaMask. 

Hướng dẫn này chỉ ra cách di chuyển một hợp đồng thông minh từ một chuỗi nhà phát triển cục bộ sang các chuỗi khối riêng lẻ, cũng như giữa các chuỗi khác nhau.

Có một số lý do tại sao một hợp đồng thông minh có thể được chuyển sang một blockchain khác. Một số lý do rõ ràng là phí gas thấp hơn hoặc thời gian giao dịch nhanh hơn. Cũng có những trường hợp hợp lý nên chuyển hợp đồng sang một chuỗi khác để gỡ lỗi hợp đồng, để cung cấp bảo mật bổ sung hoặc thậm chí cung cấp quyền truy cập vào hợp đồng nếu không thể truy cập được do trộm cắp hoặc vấn đề kỹ thuật.

Hướng dẫn di chuyển hợp đồng thông minh này trình bày cách di chuyển hợp đồng thông minh từ chuỗi phát triển cục bộ sang các chuỗi khối riêng lẻ và cách di chuyển hợp đồng thông minh giữa các chuỗi khác nhau. Bài viết này cũng cung cấp thông tin tổng quan về một số blockchain và cách chúng thay đổi liên quan đến việc di chuyển hợp đồng thông minh.

  • Điều kiện tiên quyết
  • Cân nhắc khi di chuyển giữa các chuỗi
    • Chuỗi thông minh Ethereum so với Binance
    • Polygon so với Ethereum blockchain
  • Demo: Di chuyển hợp đồng thông minh từ chuỗi phát triển địa phÆ°Æ¡ng
    • Thiết lập hợp đồng thông minh với Ganache
    • Di chuyển hợp đồng thông minh sang testnet của Ethereum (Rinkeby)
    • Di chuyển hợp đồng thông minh sang testnet của Polygon (Mumbai)
    • Di chuyển hợp đồng thông minh sang Chuỗi thông minh Binance
  • Di chuyển hợp đồng thông minh giữa các chuỗi
    • Parachains
    • Gói và mở gói mã thông báo

Điều kiện tiên quyết

Để làm theo phần hướng dẫn của bài viết này, hãy đảm bảo rằng bạn có những điều sau:

  • Ganache đã cài đặt
  • Đã cài đặt khuôn khổ Truffle
  • Đã cài đặt nút
  • npm được cài đặt
  • Git đã được cài đặt
  • Tài khoản GitHub
  • VS Code , hoặc trình soạn thảo mã bạn chọn
  • Tài khoản MetaMask

Cân nhắc khi di chuyển giữa các blockchains

Một số yếu tố có thể ảnh hưởng đến quyết định di chuyển hợp đồng thông minh từ chuỗi khối này sang chuỗi khối khác. Hãy xem một vài ví dụ.

Chuỗi thông minh Ethereum so với Binance

Chuỗi khối Ethereum là một chuỗi khối công cộng phi tập trung, minh bạch và an toàn. Tại thời điểm viết bài này, Ethereum sử dụng thuật toán đồng thuận Proof of Work . Các hợp đồng thông minh có thể được tạo trên mạng Ethereum.

Mọi hoạt động được thực hiện trên chuỗi khối Ethereum, cho dù thành công hay không, đều phải được thanh toán bằng phí gas. Một hoạt động có thể là gửi một lượng ether (tiền điện tử của Ethereum) từ tài khoản này sang tài khoản khác hoặc triển khai hợp đồng.

Phí gas phải được thanh toán trước khi các thợ đào thêm giao dịch vào một khối. Ethereum thực thi lượng khí tối đa trên mỗi khối, được gọi là giới hạn khí khối .

Chuỗi thông minh Binance (BSC ) sử dụng thuật toán đồng thuận Proof of Stake . Giống như Ethereum, nó hỗ trợ việc tạo ra các hợp đồng thông minh.

Một số khuyến khích cho việc chuyển từ Ethereum sang BSC là phí gas của Binance thấp hơn và thời gian giao dịch nhanh hơn. Những lợi ích này làm cho BSC có khả năng mở rộng hơn Ethereum. Các hợp đồng thông minh Ethereum có thể dễ dàng được chuyển sang nền tảng BSC mà không cần thay đổi mã hoặc thay đổi tối thiểu.

Tuy nhiên, BSC có một số hạn chế, bao gồm ít phân quyền hơn. Điều này là do có một số thực thể tập trung, chẳng hạn như 21.000 trình xác thực nút thuộc sở hữu trực tiếp hoặc gián tiếp của Binance và chịu trách nhiệm về phí gas thấp hơn của mạng.

Đa giác so với Ethereum

Tương tự như BSC, chuỗi khối Polygon sử dụng thuật toán đồng thuận Proof of Stake. Polygon hỗ trợ việc tạo các hợp đồng thông minh và cho phép khả năng tương tác bằng cách cho phép giao tiếp chéo các hợp đồng thông minh được khởi chạy trên blockchain của nó. Mã thông báo của mạng, MATIC, cung cấp một số chức năng như thanh toán phí gas, đặt cược và bỏ phiếu.

Một số khuyến khích cho việc chuyển từ Ethereum sang Polygon là thời gian giao dịch của Polygon nhanh hơn và phí giao dịch thấp hơn. Cấu trúc của Polygon cũng làm cho nó có khả năng mở rộng hơn Ethereum. Khi số lượng các nút trên mạng Polygon tăng lên, hệ sinh thái sẽ mở rộng để chứa đầy đủ các nút và xử lý các giao dịch của chúng.

Bây giờ, chúng ta hãy xem cách di chuyển các hợp đồng thông minh giữa các chuỗi khác nhau.

Demo: Di chuyển hợp đồng thông minh từ chuỗi phát triển địa phương

Đối với hướng dẫn này, chúng tôi sẽ sử dụng một hợp đồng thông minh được viết bằng Solidity và được triển khai trên khung Tuffle Suite . Truffle Suite tích hợp với các blockchains Máy ảo Ethereum khác và có các tính năng sẵn có để tạo, thử nghiệm, biên dịch và triển khai các hợp đồng thông minh.

Sau khi triển khai hợp đồng thông minh cho một chuỗi phát triển địa phương, chúng tôi sẽ trình bày cách triển khai nó cho các chuỗi khối riêng lẻ. Chúng tôi sẽ sử dụng MetaMask để triển khai nhằm dễ dàng xem số dư tài khoản và lịch sử giao dịch của chúng tôi.

Triển khai hợp đồng thông minh cho Ganache

Chúng tôi sẽ bắt đầu bằng cách triển khai hợp đồng thông minh cho Ganache , một công cụ mô phỏng blockchain được xây dựng trong môi trường Truffle. Điều này sẽ cho phép chúng tôi đảm bảo mã biên dịch chính xác và không có vấn đề gì khi triển khai.

Để bắt đầu, hãy sao chép mã hợp đồng thông minh từ kho GitHub này trong thiết bị đầu cuối của bạn. Sau đó, trong thư mục của dự án, hãy chạy lệnh sau để cài đặt các phần phụ thuộc:

npm install

Trước khi tiếp tục, hãy đảm bảo rằng bạn đã cài đặt Ganache vì đây là blockchain phát triển mà bạn sẽ sử dụng.

Bây giờ, chạy Ganache trên hệ thống của bạn và nhấp vào QUICKSTART , như được hiển thị bên dưới:

phủ sô cô la

Tiếp theo, chúng tôi sẽ triển khai hợp đồng thông minh bằng cách sử dụng các di chuyển được xác định trong 2_deploy_migration.jstệp.

Đầu tiên, trong thư mục thiết bị đầu cuối và dự án của bạn, hãy chạy lệnh sau để bắt đầu phát triển chuỗi khối:

truffle develop

Điều này sẽ bắt đầu chuỗi phát triển của bạn với mười địa chỉ, mỗi địa chỉ chứa 100ETH và các khóa riêng:

Mười phím

Tiếp theo, triển khai hợp đồng thông minh bằng cách chạy lệnh sau để thực thi tất cả mã trong migrationthư mục:

migrate -reset
Di cÆ°
Triển khai di chuyển

Đầu ra của thiết bị đầu cuối cho thấy rằng 2_deploy_migration.jstệp đã được triển khai. Đầu ra cũng hiển thị thông tin hợp đồng, bao gồm băm giao dịch, số khối và địa chỉ hợp đồng.

Lưu ý rằng một số thông tin hợp đồng thông minh, chẳng hạn như value sentvà total cost, được cung cấp bằng ETH (đơn vị tiền tệ của Ethereum). Khi di chuyển hợp đồng thông minh, trước tiên bạn sẽ phải cập nhật bất kỳ thông tin nào có trong ETH sang đơn vị tiền tệ gốc của chuỗi khối mà bạn đang di chuyển hợp đồng.

Để thoát khỏi môi trường, hãy nhập CTRL + C hai lần trong thiết bị đầu cuối của bạn.

Bây giờ, hãy xem cách di chuyển hợp đồng thông minh sang chuỗi khối Ethereum.

Triển khai hợp đồng thông minh cho testnet của Ethereum (Rinkeby)

Để triển khai hợp đồng thông minh từ blockchain cục bộ đến mạng Rinkeby của Ethereum, trước tiên bạn phải có một địa chỉ.

Để tạo địa chỉ, hãy mở ví MetaMask của bạn và kết nối với mạng thử nghiệm Rinkeby.

Để nhận ether miễn phí, hãy sử dụng Faucets Chainlink , kết nối với Rinkeby và dán địa chỉ ví vào trường.

Sau đó, nhấp vào Gửi yêu cầu .

Như được hiển thị bên dưới, điều này sẽ gửi 0,1ETH vào ví của bạn.

ETH trong ví

Tiếp theo, đã đến lúc cấu hình Truffle. Trong trình soạn thảo mã của bạn, hãy mở truffle-config.jstệp để xác định cấu hình mạng của bạn.

Kiểm tra truffle-config.jstài liệu của tệp nơi nó xác định những điều sau:

/**
* Use this file to configure your truffle project. It's seeded with some
* common settings for different networks and features like migrations,
* compilation and testing. Uncomment the ones you need or modify
* them to suit your project as necessary.
*
* More information about configuration can be found at:
*
* https://trufflesuite.com/docs/truffle/reference/configuration
*
* To deploy via Infura you'll need a wallet provider (like @truffle/hdwallet-provider)
* to sign your transactions before they're sent to a remote public node. Infura accounts
* are available for free at: infura.io/register.
*
* You'll also need a mnemonic - the twelve-word phrase the wallet uses to generate
* public/private key pairs. If you're publishing your code to GitHub make sure you load this
* phrase from a file you've .gitignored so it doesn't accidentally become public.
*
*/

Tiếp theo, tạo một tài khoản trên Infura: infura.io/register , sau đó tạo một dự án mới và nhấp vào CÀI ĐẶT DỰ ÁN ở trên cùng bên phải.

Thiết lập dự án

Trên tab Chung, bên dưới Phím, hãy chọn RINKEBY từ menu Điểm cuối thả xuống. Bạn sẽ thấy ID dự án của mình được hiển thị cũng như URL cho nút của bạn trên Infura.

Chọn Rinkeby

NB, bạn sẽ sử dụng phần @truffle/hdwallet-provider phụ thuộc được cài đặt trong package.json tệp của mình để đặt nhà cung cấp thành khóa cá nhân của bạn trên MetaMask

Trong truffle-config.jstệp của bạn, hãy yêu cầu phần @truffle/hdwallet-providerphụ thuộc và tạo một mảng sẽ lưu trữ các khóa riêng của bạn:

const HDWalletProvider = require('@truffle/hdwallet-provider');
const privateKeys = ['<app your private key>'];

Bây giờ, cuộn xuống phần mạng và thêm tập lệnh phát triển để đặt thành providerkhóa riêng tư của bạn trên MetaMask và URL cho nút của bạn trên Infura:

development: {
     provider: () => new
HDWalletProvider("<Your private key on metamask", `https://rinkeby.infura.io/v3/71acb374b9dd4e1eb06eeb9a75a8cd1a`),
     network_id: 4,       // Any network (default: none)
},

Bạn sẽ nhận thấy trong đoạn mã trên rằng giá trị network_idđược đặt thành 4; đây là ID mạng cho Rinkeby . Các mạng Ethereum khác có các ID khác nhau.

Tiếp theo, thực hiện quá trình di chuyển và cấu hình của bạn bằng cách chạy lệnh sau:

truffle migrate -network development --reset 
Triển khai di chuyển

Bây giờ, sao chép băm giao dịch. Điều hướng đến MetaMask và nhấp vào Xem tài khoản trên Etherscan . Trong danh sách các giao dịch, bạn sẽ thấy hàm băm giao dịch vừa được triển khai:

Giao dịch băm

Nhấp vào một giao dịch riêng lẻ để xem thêm chi tiết:

Giao dịch Cá nhân

Triển khai hợp đồng thông minh tới testnet của Polygon (Mumbai)

Để triển khai hợp đồng thông minh với mạng Mumbai của Polygon, bạn sẽ bắt đầu bằng cách kết nối ví MetaMask của mình với Polygon. Mở MetaMask và nhấp vào Thêm mạng , sau đó thêm thông tin sau vào các trường thích hợp:

Cài đặt Metamask

Sau đó, nhấp vào Lưu và MetaMask sẽ kết nối với Đa giác.

Vì bạn đang di chuyển hợp đồng sang testnet của Polygon, bạn sẽ cần mã thông báo MATIC để thanh toán cho giao dịch của mình. Để nhận mã thông báo MATIC, hãy mở ví MetaMask và sao chép địa chỉ ví của bạn. Sau đó, điều hướng đến vòi Đa giác và dán địa chỉ vào trường địa chỉ ví. Nhấp vào Gửi , sau đó nhấp vào Xác nhận .

Xác nhận chi tiết

Như hình dưới đây, bạn sẽ thấy xác nhận rằng yêu cầu đã được gửi.

Yêu cầu đã được gửi

Trong vài phút, bạn sẽ thấy các mã thông báo trong ví MetaMask của mình. Sau khi mã thông báo MATIC được chuyển thành công, chúng sẽ xuất hiện trong số dư ví của bạn.

Mã thông báo Matic

Tiếp theo, trong trình soạn thảo mã của bạn, hãy mở truffle-config.jstệp. Trong tập lệnh mạng, hãy thêm nhà cung cấp mạng cho Đa giác bên dưới nhà cung cấp mạng cho Ethereum. Bạn sẽ sử dụng URL RPC cho Mumbai testnet như được định nghĩa trong tài liệu Đa giác .

Sao chép liên kết RPC được hiển thị bên dưới, https://rpc-mumbai.matic.today :

Liên kết RPC

Sau đó, dán liên kết RPC vào mã dưới dạng providerURL. Cũng dán chainid (ở trên) vào mã như network_idsau:

polygonTestnet: {
     provider: () => new HDWalletProvider(privateKeys, `https://rpc-mumbai.matic.today`),
     network_id: 80001,       // Any network (default: none)
   },

Bây giờ, hãy mở thiết bị đầu cuối của bạn và chạy quá trình di chuyển và cấu hình tới Polygon testnet bằng lệnh sau:

truffle migrate --network polygonTestnet --reset

Bạn có thể thấy bên dưới rằng hợp đồng của bạn đã được di chuyển thành công:

Di chuyển thành công

Bây giờ, sao chép băm giao dịch. Mở tài khoản MetaMask của bạn và nhấp vào Xem tài khoản trong Explorer :

Xem tài khoản Metamask

Bạn sẽ thấy hợp đồng được triển khai với giao dịch có trong trình khám phá blockchain Polygonscan :

Hợp đồng đã triển khai

Triển khai hợp đồng thông minh cho Chuỗi thông minh Binance

Để triển khai hợp đồng thông minh của bạn với testnet của Binance Smart Chain. bạn sẽ cần nhận mã thông báo BNB (là tiền tệ bản địa của chuỗi Binance Smart).

Bạn sẽ bắt đầu bằng cách kết nối ví MetaMask của mình với BSC. Mở MetaMask và nhấp vào Thêm mạng:

Thêm mạng

Tiếp theo, thêm thông tin sau vào các trường thích hợp:

Thêm trang mạng

Sau đó, nhấp vào Lưu và MetaMask sẽ kết nối với BSC và sẽ đặt mã thông báo BNB thành 0:

Không có BNB

Để nhận mã thông báo BNB miễn phí, hãy mở ví MetaMask và sao chép địa chỉ ví của bạn. Sau đó, điều hướng đến Vòi chuỗi thông minh Binance . Trong phần nhập địa chỉ, hãy dán địa chỉ ví MetaMask của bạn.

Vòi chuỗi thông minh

Bây giờ, hãy nhấp vào Cung cấp cho tôi BNB và 1 BNB sẽ được chuyển vào ví MetaMask của bạn.

Yêu cầu tài trợ được chấp nhận

Bạn có thể xác nhận rằng mã thông báo đã được gửi bằng cách kiểm tra số dư tài khoản MetaMask của mình:

Số dư Metamask

Bây giờ, hãy chỉnh sửa truffle-config.jstệp trong trình chỉnh sửa mã của bạn và thêm cấu hình sau cho mạng Binance Smart Chain:

 bscTestnet: {
     provider: () => new HDWalletProvider(privateKeys, `https://data-seed-prebsc-1-s1.binance.org:8545/`),
     network_id: 97,       // Any network (default: none)
   },

Để triển khai hợp đồng của bạn với mạng thử nghiệm Chuỗi thông minh Binance, hãy mở thiết bị đầu cuối của bạn và chạy lệnh sau:

truffle migrate --network bscTestnet --reset
Triển khai di chuyển

Di chuyển hợp đồng thông minh giữa các chuỗi

Chúng tôi đã thảo luận về một số yếu tố có thể ảnh hưởng đến quyết định di chuyển hợp đồng thông minh từ blockchain này sang blockchain khác. Bây giờ, hãy xem xét một số kỹ thuật di chuyển hợp đồng thông minh.

Di chuyển qua parachains

Mạng Polkadot cung cấp một môi trường quen thuộc và an toàn để các blockchains dễ dàng tương tác với nhau.

Parachains là các blockchain lớp 1 tương tác trong hệ sinh thái Polkadot. Các Parachains độc lập với nhau nhưng chạy song song. Chúng được kết nối với nhau bằng Chuỗi chuyển tiếp của mạng . Kết nối này cho phép khả năng tương tác chuỗi chéo hoặc khả năng giao tiếp và chia sẻ dữ liệu .

Mạng Polkadot tận dụng cơ chế đồng thuận Proof of Stake thông qua việc sử dụng người xác nhận và người đề cử . Những người đối chiếu (được hiển thị trong hình minh họa bên dưới), giữ lại thông tin về các giao dịch của mạng lưới.

Chuỗi chuyển tiếp

Parachains cho phép các nhà phát triển di chuyển các hợp đồng trong hệ sinh thái Polkadot bằng cách sử dụng định dạng Nhắn tin đồng thuận chéo (XCM) của Polkadot thay vì gói và mở gói mã thông báo (mà chúng ta sẽ thảo luận trong phần tiếp theo).

XCM được sử dụng để định dạng tin nhắn được gửi giữa các chuỗi, hợp đồng thông minh hoặc cầu nối. XCM cho phép một định dạng xác định để gửi các giao dịch từ ví này sang ví khác trong một thời gian dài.

XCM có các giao thức hoạt động trên các thông điệp với các chức năng riêng biệt: Truyền thông điệp dọc (VMP) và Truyền thông điệp chuỗi chéo (XCMP).

Ngoài ra, XCM sử dụng Máy ảo đồng thuận chéo (XCVM), chứa một số hướng dẫn đang chạy dưới dạng chương trình và (các) thông báo sẽ được chuyển. Các hướng dẫn trong XCVM bao gồm thông điệp được chuyển và đích của nó.

Ngoài ra, các cầu nối tồn tại giữa Polkadot và các blockchain lớp 1 khác, chẳng hạn như Ethereum và Binance Smart Chain, cho phép khả năng tương tác.

Di chuyển bằng cách gói và mở gói mã thông báo

Mỗi blockchain có các mã thông báo có thể giao dịch được thiết kế theo các loại tiền kỹ thuật số bản địa của nó. Khi các hợp đồng thông minh được di chuyển giữa các chuỗi khác nhau, cần phải có một cách để các mã thông báo được thiết kế cho một chuỗi khối này hoạt động trên một chuỗi khối khác.

Điều này giống như đi du lịch đến một quốc gia sử dụng một loại tiền tệ khác. Tuy nhiên, thay vì trao đổi một loại mã thông báo này cho một loại mã thông báo khác, các blockchain thường sử dụng khái niệm gói và mở.

Việc bao bọc đòi hỏi phải cố định giá trị của mã thông báo với tiền điện tử ban đầu của nó. Mã thông báo được bọc về cơ bản là một mã thông báo có thể giao dịch có thể được sử dụng trên các blockchain khác. Ví dụ, giả sử một số ERC-20 của Ethereum được bao bọc. Giá trị của chúng sẽ được cố định ở giá trị hiện tại, nhưng chúng hiện được coi là Ether được bao bọc (WETH). Mã thông báo WETH có thể được sử dụng trong ví MetaMask và các ví khác, để tương tác trên các blockchain khác nhau (BSC, IOTA, v.v.)

Một trong những lợi ích quan trọng nhất của việc bọc mã thông báo là tài sản ban đầu được bảo toàn nhưng mã thông báo được bọc kế thừa các chức năng của chuỗi khối mới. Một số chức năng này có thể bao gồm thời gian giao dịch được giảm thiểu và phí gas thấp.

Mở gói mã thông báo đề cập đến quá trình đảo ngược mã thông báo thành tiền điện tử ban đầu. Ví dụ: WETH có thể được mở ra khỏi tiền điện tử ban đầu của nó là ETH.

Dưới đây là bản trình diễn cho thấy việc gói và mở mã thông báo Ethereum bằng cách sử dụng tiêu chuẩn OpenZeppelin ERC-20 :

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.7.0 <0.9.0;
import https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol;
contract WETH is ERC20 {
    constuctor() ERC20("Wrapped Ether", "WETH") public {};

    // define a mint function to create new wrapped ether token
    function mint() external payable {
        _mint(msg.sender, msg.value); 
    }
    // define a burn function to create an unwrapped token
    function burn(uint amount) external { //specify the amount that you want back
        payable(msg.sender).transfer(amount); // transfers 
        _burn(msg.sender, amount); //sending back the ether to the user
    }
}

Chúng ta hãy xem xét kỹ hơn các dòng mã riêng lẻ trong khối mã trên:

  • Dòng 1: chỉ định giấy phép được sá»­ dụng cho trình biên dịch Solidity
  • Dòng 2: chỉ định phiên bản Solidity
  • Dòng 3: nhập tiêu chuẩn mã thông báo ERC-20, nhÆ° được định nghÄ©a trong OpenZeppelin
  • Dòng 4: xác định hợp đồng để tạo các mã thông báo được gói và chÆ°a được bọc
  • Dòng 5: xác định một constructor``()hàm đặt tên của Ether thành “Ether được bọc” và biểu tượng của nó thành “WETH” ngay sau khi hợp đồng được thá»±c hiện
  • Dòng 7: xác định một mint()hàm chấp nhận một giá trị của Ether và tạo một mã thông báo Ether được bọc mới; bộ định tính bên ngoài có nghÄ©a là hàm có thể được gọi từ các hợp đồng khác; bộ định tính phải trả biểu thị rằng chức năng có thể chấp nhận và gá»­i Ether
  • Dòng 9: sá»­ dụng _minthàm được xác định trong mã OpenZeppelin; nó chấp nhận địa chỉ của người gọi giao dịch là msg.sendervà giá trị của Ether được gá»­i làmsg.value
  • Dòng 12: xác định một burn()hàm chấp nhận số lượng mã thông báo mà người dùng muốn và gá»­i lại mã thông báo chÆ°a được gói
  • Dòng 13: chỉ định số tiền được chuyển bằng cách bao gồm địa chỉ của người gọi giao dịch msg.sender, với bộ định tính có thể thanh toán để cho phép nó chuyển Ether; sá»­ dụng transferchức năng được xác định trong OpenZeppelin để chấp nhận số tiền được chuyển
  • Dòng 14: sá»­ dụng _burn()chức năng được định nghÄ©a trong OpenZeppelin để gá»­i cho người gọi giao dịch một mã thông báo chÆ°a được bọc (Ether ban đầu)

Sự kết luận

Trong bài viết này, chúng tôi đã trình bày cách thiết lập hợp đồng thông minh trong Ganache và sau đó di chuyển nó sang mạng thử nghiệm Rinkeby của Ethereum, mạng thử nghiệm Mumbai của Polygon, Chuỗi thông minh Binance và Đa giác bằng MetaMask. Chúng tôi cũng đã thảo luận về các chiến lược khác nhau để di chuyển các hợp đồng thông minh giữa các chuỗi khác nhau: mã thông báo gói và mở gói, cũng như các parachains.

Nguồn bài viết gốc tại https://blog.logrocket.com

#blockchain #smartcontract #ethereum #polygon #metamask #binancesmartchain #binance

Cách di chuyển hợp đồng thông minh giữa các chuỗi khác nhau