Shubham Rajput (Frontend-Sr. Associate Consultant L2- Frontend Development)

As decentralized apps (dApps) evolve, the need for blockchains to communicate with each other has grown. Polkadot and Substrate make cross-chain smart contract development easy, enabling seamless interaction across different blockchains.

What Are Polkadot and Substrate?

Polkadot
 

Polkadot acts as a "superhighway," connecting various blockchains, known as parachains. It allows them to share data and security, making it easier to scale and collaborate.

Substrate

Substrate is a toolkit for building custom blockchains. It powers Polkadot parachains and simplifies the creation of efficient, flexible blockchains. Think of it as the foundation for your blockchain project.

Also, Read | How to Run and Setup a Full Node on Polkadot

Why Use Cross-Chain Smart Contracts?

With cross-chain smart contracts, you can:

• Leverage data and assets across multiple blockchains.
• Combine the strengths of different blockchains.
• Enhance user experience by connecting separate ecosystems.

For instance, a finance app could enable trading between Ethereum and Binance Smart Chain without requiring users to switch platforms.

You may also like | How to create a dApp on Polkadot

How to Build Cross-Chain Smart Contracts

1. Set Up Your Tools

   
   Here's what you'll need:

   • Rust Programming Language: For Substrate development.
   • Node.js and Yarn: To build user interfaces and connect to your contracts.
   • Substrate Node Template: A starting point for your blockchain project.

   • Polkadot.js: A library for interacting with Polkadot and Substrate.

      

# Install Rust
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# Set up Substrate Node Template
git clone https://github.com/substrate-developer-hub/substrate-node-template.git
cd substrate-node-template
cargo build --release

Also, Discover | Why Develop a DApp (Decentralized Application) on Polkadot

2. Build Your Blockchain (Parachain)

Use Substrate to create a blockchain that can plug into Polkadot. Customize it based on your needs.

Key Steps:

• Add Logic: Decide how your blockchain will handle cross-chain tasks.
• Ensure Security: Set up a reliable way to verify transactions.
• Enable Communication: Use XCM (Cross-Consensus Messaging) to link chains.

3. Write Your Smart Contracts

If you're working with Ethereum for cross-chain functionality, you can use Solidity to write your contracts. Here's a simple example for transferring assets:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract CrossChainTransfer {
    address public owner;

    constructor() {
        owner = msg.sender;
    }

    function transfer(address destination, uint256 amount) public {
        require(msg.sender == owner, "Only the owner can transfer");
        // Logic for cross-chain transfer (to be integrated with Polkadot bridge)
        // Example: Emit an event to signal a cross-chain transfer
        emit TransferInitiated(destination, amount);
    }

    event TransferInitiated(address indexed destination, uint256 amount);
}

You might also like | A Comparison between Ethereum 2.0 and Polkadot

4. Launch Your Blockchain

Register your blockchain with Polkadot's relay chain and ensure it supports XCM for cross-chain communication.

5. Test the Connections

Use Polkadot.js to test how your blockchain interacts with others. For example, you can transfer tokens or check contract states:

const { ApiPromise, WsProvider } = require('@polkadot/api');

const provider = new WsProvider('wss://your-parachain-url');
const api = await ApiPromise.create({ provider });

// Example: Transfer tokens across chains
await api.tx.balances
    .transfer('destination-account', 1000)
    .signAndSend('your-account');

Also, Read | Develop Parachain on Polkadot

Tips for Success

1. Keep Costs Low: Make your smart contracts efficient.
2. Focus on Security: Use multi-signature wallets and audit your code.
3. Leverage Polkadot's Features: Take advantage of shared security and easy connections.
4. Test Thoroughly: Check every possible scenario on a test network.

Final Thoughts

Polkadot and Substrate simplify the creation of cross-chain smart contracts, making them both accessible and powerful. By integrating Solidity-based contracts from Ethereum, you can build dApps that seamlessly connect multiple blockchains, unlocking limitless opportunities. Start exploring today, connect with our solidity developers, and bring your ideas to life!

What is a Multi-Token Crypto Wallet?

A multi-token wallet created using crypto wallet development services lets users hold and manage various Ethereum-based tokens (like ERC-20 tokens) all in one place. Instead of separate wallets for each token, a multi-token wallet displays balances, lets users transfer tokens, and connects with the Ethereum blockchain for real-time data.

To interact with Ethereum, you'll need Web3.js. If you're using Node.js, install it with:

npm install web3

we'll use an Infura endpoint (a popular service for Ethereum APIs).

const Web3 = require('web3');

const web3 = new Web3('https://mainnet.infura.io/v3/YOUR_INFURA_PROJECT_ID');

You may also like | Developing Cross-Platform Crypto Wallet with Web3.js & React

Step 1: Create a Wallet Address

const account = web3.eth.accounts.create();

To use an existing wallet, you can import the private key:

const account = web3.eth.accounts.privateKeyToAccount('YOUR_PRIVATE_KEY');

Step 2: Connect ERC-20 Tokens

To interact with an ERC-20 token, use its contract address and ABI.

const tokenAbi = [ 
// ERC-20 balanceOf function 
{ "constant": true,
"inputs": [{"name": "_owner", "type": "address"}],
"name": "balanceOf",
"outputs": [{"name": "balance", "type": "uint256"}],
"type": "function" },
// ERC-20 decimals function
{ 
"constant": true,
"inputs": [],
"name": "decimals",
"outputs": [{"name": "", "type": "uint8"}],
"type": "function"
}
];
const tokenAddress = 'TOKEN_CONTRACT_ADDRESS';
const tokenContract = new web3.eth.Contract(tokenAbi, tokenAddress);

Also, Read | How to Build a Multi-Chain Account Abstraction Wallet 

Step 3: Check Token Balances

To display token balances, call the token's balanceOf function with the user's address:

async function getTokenBalance(walletAddress) {
const balance = await tokenContract.methods.balanceOf(walletAddress).call();
const decimals = await tokenContract.methods.decimals().call();
return balance / Math.pow(10, decimals);
}
getTokenBalance(account.address).then(console.log);

Step 4: Transfer Tokens

Sending tokens is similar to checking balances. However, this requires a signed transaction with the user's private key.

async function transferTokens(toAddress, amount) {
   const decimals = await tokenContract.methods.decimals().call();
   const adjustedAmount = amount * Math.pow(10, decimals);
   const tx = {
       from: account.address,
       to: tokenAddress,
       gas: 200000,
       data: tokenContract.methods.transfer(toAddress, adjustedAmount).encodeABI()
   };
   const signedTx = await web3.eth.accounts.signTransaction(tx, account.privateKey);
   return web3.eth.sendSignedTransaction(signedTx.rawTransaction);
}
transferTokens('RECIPIENT_ADDRESS', 1).then(console.log);

Also, Read | ERC 4337 : Account Abstraction for Ethereum Smart Contract Wallets

Step 5: Viewing ETH Balance

A multi-token wallet should also show the ETH balance. Use Web3's getBalance function to retrieve it:

async function getEthBalance(walletAddress) {
   const balance = await web3.eth.getBalance(walletAddress);
   return web3.utils.fromWei(balance, 'ether');
}
getEthBalance(account.address).then(console.log);

Conclusion

Building a multi-token crypto wallet with Web3.js is straightforward, allowing you to manage ETH and various ERC-20 tokens in one interface. With Web3's tools, you can create a secure, decentralized wallet that handles multiple tokens, enabling users to view balances, make transfers, and more. If you are to build an advanced crypto wallet, connect with our crypto wallet developers for a thorough consultation and get started.