{
// Load the chain configuration from the JSON file
const chains: ChainsConfig = JSON.parse(
fs.readFileSync(
path.resolve(__dirname, '../deploy-config/chains.json'),
'utf8'
)
);
// Get the Base Sepolia configuration
const baseSepoliaChain = chains.chains.find((chain) =>
chain.description.includes('Base Sepolia testnet')
);
if (!baseSepoliaChain) {
throw new Error('Base Sepolia testnet configuration not found.');
}
// Set up the provider and wallet
const provider = new ethers.JsonRpcProvider(baseSepoliaChain.rpc);
const wallet = new ethers.Wallet(process.env.PRIVATE_KEY, provider);
// Load the ABI and bytecode of the MessageReceiver contract
const messageReceiverJson: MessageReceiverJson = JSON.parse(
fs.readFileSync(
path.resolve(
__dirname,
'../out/MessageReceiver.sol/MessageReceiver.json'
),
'utf8'
)
);
const { abi, bytecode } = messageReceiverJson;
// Create a ContractFactory for MessageReceiver
const MessageReceiver = new ethers.ContractFactory(abi, bytecode, wallet);
// Deploy the contract using the Wormhole Relayer address for Base Sepolia
const receiverContract = await MessageReceiver.deploy(
baseSepoliaChain.wormholeRelayer
);
await receiverContract.waitForDeployment();
console.log('MessageReceiver deployed to:', receiverContract.target); // `target` is the contract address in ethers.js v6
// Update the deployedContracts.json file
const deployedContractsPath = path.resolve(
__dirname,
'../deploy-config/deployedContracts.json'
);
const deployedContracts: DeployedContracts = JSON.parse(
fs.readFileSync(deployedContractsPath, 'utf8')
);
// Retrieve the address of the MessageSender from the deployedContracts.json file
const avalancheSenderAddress = deployedContracts.avalanche?.MessageSender;
if (!avalancheSenderAddress) {
throw new Error('Avalanche MessageSender address not found.');
}
// Define the source chain ID for Avalanche Fuji
const sourceChainId = 6;
// Call setRegisteredSender on the MessageReceiver contract
const tx = await (receiverContract as any).setRegisteredSender(
sourceChainId,
ethers.zeroPadValue(avalancheSenderAddress, 32)
);
await tx.wait();
console.log(
`Registered MessageSender (${avalancheSenderAddress}) for Avalanche chain (${sourceChainId})`
);
deployedContracts.baseSepolia = {
MessageReceiver: receiverContract.target as any,
deployedAt: new Date().toISOString(),
};
fs.writeFileSync(
deployedContractsPath,
JSON.stringify(deployedContracts, null, 2)
);
}
main().catch((error) => {
console.error(error);
process.exit(1);
});
```
### Deploy the Sender Contract
The sender contract will handle quoting and sending messages cross-chain.
1. Run the following command to deploy the sender contract:
```bash
npm run deploy:sender
```
2. Once deployed, the contract address will be displayed. You may check the contract on the [Avalanche Fuji Explorer](https://testnet.snowtrace.io/){target=\_blank}.
npm run deploy:sender
> wormhole-cross-chain@1.0.0 deploy:sender
> node script/deploySender.ts
MessageSender deployed to: 0xf5c474f335fFf617fA6FD04DCBb17E20ee0cEfb1
### Deploy the Receiver Contract
The receiver contract listens for cross-chain messages and logs them when received.
1. Deploy the receiver contract with this command:
```bash
npm run deploy:receiver
```
2. After deployment, note down the contract address. You may check the contract on the [Base Sepolia Explorer](https://sepolia.basescan.org/){target=\_blank}.
## Send a Cross-Chain Message
Now that both the sender and receiver contracts are deployed, let's move on to the next exciting step: sending a cross-chain message from Avalanche Fuji to Base Sepolia.
In this example, we will use the `sendMessage.ts` script to transmit a message from the sender contract on Avalanche to the receiver contract on Base Sepolia. The script uses [Ethers.js](https://docs.ethers.org/v6/){target=\_blank} to interact with the deployed contracts, calculate the cross-chain cost dynamically, and handle the transaction.
Let's break down the script step by step.
1. **Load configuration files**:
1. **`chains.json`**: Contains details about the supported Testnet chains, such as RPC URLs and relayer addresses.
2. **`deployedContracts.json`**: Stores the addresses of the deployed sender and receiver contracts. This file is dynamically updated when contracts are deployed, but users can also manually add their own deployed contract addresses if needed.
```typescript
const chains: ChainsConfig = JSON.parse(
fs.readFileSync(
path.resolve(__dirname, '../deploy-config/chains.json'),
'utf8'
)
);
const deployedContracts: DeployedContracts = JSON.parse(
fs.readFileSync(
path.resolve(__dirname, '../deploy-config/deployedContracts.json'),
'utf8'
)
);
```
2. **Configure the provider and signer**: The script first reads the chain configurations and extracts the contract addresses. One essential step in interacting with a blockchain is setting up a _provider_. A provider is your connection to the blockchain network. It allows your script to interact with the blockchain, retrieve data, and send transactions. In this case, we're using a JSON-RPC provider.
Next, we configure the wallet, which will be used to sign transactions. The wallet is created using the private key and the provider. This ensures that all transactions sent from this wallet are broadcast to the Avalanche Fuji network.
```typescript
const provider = new ethers.JsonRpcProvider(avalancheChain.rpc);
const wallet = new ethers.Wallet(process.env.PRIVATE_KEY, provider);
```
After setting up the wallet, the script loads the ABI for the `MessageSender.sol` contract and creates an instance of it.
```typescript
const messageSenderJson = JSON.parse(
fs.readFileSync(
path.resolve(__dirname, '../out/MessageSender.sol/MessageSender.json'),
'utf8'
)
);
```
3. **Set up the message details**: The next part of the script defines the target chain (Base Sepolia) and the target address (the receiver contract on Base Sepolia).
```typescript
const targetChain = 10004; // Wormhole chain ID for Base Sepolia
const targetAddress = deployedContracts.baseSepolia.MessageReceiver;
```
You can customize the message that will be sent across chains.
```typescript
const message = 'Hello from Avalanche to Base Sepolia!';
```
4. **Estimate cross-chain cost**: Before sending the message, we dynamically calculate the cross-chain cost using the `quoteCrossChainCost` function.
```typescript
const txCost = await MessageSender.quoteCrossChainCost(targetChain);
```
This ensures that the transaction includes enough funds to cover the gas fees for the cross-chain message.
5. **Send a message**: With everything set up, the message is sent using the `sendMessage` function.
```typescript
const tx = await MessageSender.sendMessage(
targetChain,
targetAddress,
message,
{
value: txCost,
}
);
```
After sending, the script waits for the transaction to be confirmed.
```typescript
await tx.wait();
```
6. **Run the script**: To send the message, run the following command:
```bash
npm run send:message
```
If everything is set up correctly, the message will be sent from the Avalanche Fuji Testnet to the Base Sepolia Testnet. You can monitor the transaction and verify that the message was received on Base Sepolia using the [Wormhole Explorer](https://wormholescan.io/#/?network=TESTNET){target=\_blank}.
The console should output something similar to this:
npm run send:message
> wormhole-cross-chain@1.0.0 send:message
> node script/sendMessage.ts
Sender Contract Address: 0xD720BFF42a0960cfF1118454A907a44dB358f2b1
Receiver Contract Address: 0x692550997C252cC5044742D1A2BD91E4f4b46D39
...
Transaction sent, waiting for confirmation...
...
Message sent! Transaction hash:
0x9d359a66ba42baced80062229c0b02b4f523fe304aff3473dcf53117aee13fb6
You may see the transaction status on the Wormhole Explorer:
https://wormholescan.io/#/tx/0x9d359a66ba42baced80062229c0b02b4f523fe304aff3473dcf53117aee13fb6?network=TESTNET
You can find the full code for the `sendMessage.ts` below.
??? code "sendMessage.ts"
```solidity
import { ethers } from 'ethers';
import fs from 'fs';
import path from 'path';
import dotenv from 'dotenv';
import { ChainsConfig, DeployedContracts } from './interfaces';
dotenv.config();
async function main(): Promise {
// Load the chain configuration and deployed contract addresses
const chains: ChainsConfig = JSON.parse(
fs.readFileSync(
path.resolve(__dirname, '../deploy-config/chains.json'),
'utf8'
)
);
const deployedContracts: DeployedContracts = JSON.parse(
fs.readFileSync(
path.resolve(__dirname, '../deploy-config/deployedContracts.json'),
'utf8'
)
);
console.log(
'Sender Contract Address: ',
deployedContracts.avalanche.MessageSender
);
console.log(
'Receiver Contract Address: ',
deployedContracts.baseSepolia.MessageReceiver
);
console.log('...');
// Get the Avalanche Fuji configuration
const avalancheChain = chains.chains.find((chain) =>
chain.description.includes('Avalanche testnet')
);
if (!avalancheChain) {
throw new Error(
'Avalanche testnet configuration not found in chains.json.'
);
}
// Set up the provider and wallet
const provider = new ethers.JsonRpcProvider(avalancheChain.rpc);
const wallet = new ethers.Wallet(process.env.PRIVATE_KEY, provider);
// Load the ABI of the MessageSender contract
const messageSenderJson = JSON.parse(
fs.readFileSync(
path.resolve(__dirname, '../out/MessageSender.sol/MessageSender.json'),
'utf8'
)
);
const abi = messageSenderJson.abi;
// Create a contract instance for MessageSender
const MessageSender = new ethers.Contract(
deployedContracts.avalanche.MessageSender, // Automatically use the deployed address
abi,
wallet
);
// Define the target chain and target address (the Base Sepolia receiver contract)
const targetChain = 10004; // Wormhole chain ID for Base Sepolia
const targetAddress = deployedContracts.baseSepolia.MessageReceiver;
// The message you want to send
const message = 'Hello from Avalanche to Base Sepolia!';
// Dynamically quote the cross-chain cost
const txCost = await MessageSender.quoteCrossChainCost(targetChain);
// Send the message (make sure to send enough gas in the transaction)
const tx = await MessageSender.sendMessage(
targetChain,
targetAddress,
message,
{
value: txCost,
}
);
console.log('Transaction sent, waiting for confirmation...');
await tx.wait();
console.log('...');
console.log('Message sent! Transaction hash:', tx.hash);
console.log(
`You may see the transaction status on the Wormhole Explorer: https://wormholescan.io/#/tx/${tx.hash}?network=TESTNET`
);
}
main().catch((error) => {
console.error(error);
process.exit(1);
});
```
## Conclusion
You're now fully equipped to build cross-chain contracts using the Wormhole protocol! With this tutorial, you've learned how to:
- Deploy sender and receiver contracts on different testnets.
- Send a cross-chain message from one blockchain to another.
- Monitor the status of your cross-chain transactions using Wormholescan and the Wormhole Solidity SDK.
Looking for more? Check out the [Wormhole Tutorial Demo repository](https://github.com/wormhole-foundation/demo-tutorials){target=\_blank} for additional examples.