Update EVM -> Substrate Documentation with SDK V3

[saadahmsiddiqui]

Update document contents with:

---

slug: /sdk/examples/erc20/evm-substrate-example
id: examples-erc20-evm-substrate-example
title: EVM To Substrate Token Transfer
description: Section that describes how to perform an EVM to Substrate token transfer.
sidebar_position: 2
draft: false

:::warning
Please be aware that the Rococo-Phala testnet is currently down due to ongoing maintenance by the Phala team as they migrate their testnet to Paseo. Stay tuned for further updates.
:::

EVM-to-Substrate token transfer example

In the following example, we will use the TESTNET environment to perform a cross-chain ERC-20 transfer with 1.00 Sepolia sygUSD sygUSD tokens. The transfer will be initiated on the EVM-side via the Sepolia Ethereum testnet and received on the Substrate-side via the Tangle testnet.

This is an example script that demonstrates the functionality of the Sygma SDK and the wider Sygma ecosystem of relayers and bridge and handler contracts/pallets. The complete example can be found in this repo.

Prerequisites

Before running the script, ensure that you have the following:

• Node.js v18
• Yarn (version 3.4.1 or higher)
• The exported private key of your development wallet
• A Substrate wallet to receive tokens into (the example presets an existing wallet address already)
• Sepolia ETH for gas
• An Ethereum provider (in case the hardcoded RPC within the script does not work)
• A development wallet funded with sygUSD tokens from the Sygma faucet

import App from '../../../../src/Faucet/App';

:::danger
We make use of the dotenv module to manage exported private keys with environment variables. Please note that accidentally committing a .env file containing private keys to a wallet with real funds, onto GitHub, could result in the complete loss of your funds. Never expose your private keys.
:::

Getting started

1. Clone the repository

Clone the sygma-sdk repository into a directory of your choice, and then cd into the folder:

git clone git@github.com:sygmaprotocol/sygma-sdk.git
cd sygma-sdk/

2. Install dependencies

Install the project dependencies by running:

yarn install

3. Build the SDK

Build the SDK by running the following command:

yarn build

4. Usage

This example uses the dotenv module to manage private keys. To run the example, you will need to configure your environment variable to include your test development account's exported private key. A .env.sample is provided as a template.

DO NOT COMMIT PRIVATE KEYS WITH REAL FUNDS TO GITHUB. DOING SO COULD RESULT IN COMPLETE LOSS OF YOUR FUNDS.

Create a .env file in the evm-to-substrate example folder:

cd examples/evm-to-substrate-fungible-transfer
touch .env

Replace between the quotation marks your exported private key:

PRIVATE_KEY="YOUR_PRIVATE_KEY_HERE"

Replace the placeholder value in the script for DESTINATION_ADDRESS with your preferred destination Substrate address.

To send an ERC-20 example transfer from EVM to Substrate, run:

cd examples/evm-to-substrate-fungible-transfer
yarn run transfer

The example will use ethers in conjunction with the Sygma SKD to create a transfer from Sepolia to Rococo-Phala with a sygUSD token. It will be received on Rococo-Phala as the sygUSD token.

Script functionality

This example script performs the following steps:

• Import required libraries from the dependencies.

import { getSygmaScanLink, type Eip1193Provider } from "@buildwithsygma/core";
import {
  createFungibleAssetTransfer,
  FungibleTransferParams,
} from "@buildwithsygma/evm";
import dotenv from "dotenv";
import { Wallet, providers } from "ethers";
import Web3HttpProvider from "web3-providers-http";

• Read contents of the .env file using dotenv. The script throws an error if the private key is not provided

dotenv.config();
const privateKey = process.env.PRIVATE_KEY;
if (!privateKey) throw new Error("Missing environment variable: PRIVATE_KEY");

• Define transfer contants like destination chain ID, source chain ID, recipient address, resource ID and RPC Urls

const SEPOLIA_CHAIN_ID = 11155111;
const TANGLE_CHAIN_ID = 3799;
const RESOURCE_ID =
  "0x0000000000000000000000000000000000000000000000000000000000001100";
const SEPOLIA_RPC_URL =
  process.env.SEPOLIA_RPC_URL || "https://ethereum-sepolia-rpc.publicnode.com";

• Constant and function to retrieve explorer URL (Optional)

const explorerUrls: Record<number, string> = {
  [SEPOLIA_CHAIN_ID]: "https://sepolia.etherscan.io",
};
const getTxExplorerUrl = (params: {
  txHash: string;
  chainId: number;
}): string => `${explorerUrls[params.chainId]}/tx/${params.txHash}`;

• Create Ethereum provider and wallet to be able to send transactions and query data

const web3Provider = new Web3HttpProvider(SEPOLIA_RPC_URL);
const ethersWeb3Provider = new providers.Web3Provider(web3Provider);
const wallet = new Wallet(privateKey ?? "", ethersWeb3Provider);
const sourceAddress = await wallet.getAddress();
const destinationAddress = await wallet.getAddress();

• Prepare fungible token transfer parameters and create a transfer object

const params: FungibleTransferParams = {
  source: SEPOLIA_CHAIN_ID,
  destination: TANGLE_CHAIN_ID,
  sourceNetworkProvider: web3Provider as unknown as Eip1193Provider,
  resource: RESOURCE_ID,
  amount: BigInt(1) * BigInt(1e6),
  recipientAddress: "<destination_substrate_address",
  sourceAddress: "<source_evm_wallet_address>",
};

const transfer = await createFungibleAssetTransfer(params);

• Get and complete approval transactions

const approvals = await transfer.getApprovalTransactions();
for (const approval of approvals) {
  const response = await wallet.sendTransaction(approval);
  await response.wait();
}

• Complete the transfer transaction

const transferTx = await transfer.getTransferTransaction();
const response = await wallet.sendTransaction(transferTx);
await response.wait();