/*

* Copyright 2025 Circle Internet Group, Inc. All rights reserved.

*

* SPDX-License-Identifier: Apache-2.0

*

* Licensed under the Apache License, Version 2.0 (the "License");

* you may not use this file except in compliance with the License.

* You may obtain a copy of the License at

*

* http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*/

pragma solidity ^0.7.6;

import "forge-std/Script.sol";

import "../src/TokenMessenger.sol";

import "../src/TokenMinter.sol";

import "../src/MessageTransmitter.sol";

import "../src/messages/Message.sol";

contract DeployScript is Script {

address private attesterAddress;

address private usdcContractAddress;

address private usdcRemoteContractAddress;

address private remoteTokenMessengerAddress;

address private tokenControllerAddress;

address private messageTransmitterPauserAddress;

address private tokenMinterPauserAddress;

address private messageTransmitterRescuerAddress;

address private tokenMessengerRescuerAddress;

address private tokenMinterRescuerAddress;

uint32 private messageBodyVersion = 0;

uint32 private version = 0;

uint32 private domain;

uint32 private remoteDomain;

uint32 private maxMessageBodySize = 8192;

uint256 private burnLimitPerMessage;

uint256 private messageTransmitterDeployerPrivateKey;

uint256 private tokenMessengerDeployerPrivateKey;

uint256 private tokenMinterDeployerPrivateKey;

uint256 private tokenControllerPrivateKey;

/**

* @notice deploys Message Transmitter

* @param privateKey Private Key for signing the transactions

* @return MessageTransmitter instance

*/

function deployMessageTransmitter(

uint256 privateKey

) private returns (MessageTransmitter) {

// Start recording transactions

vm.startBroadcast(privateKey);

// Deploy MessageTransmitter

MessageTransmitter messageTransmitter = new MessageTransmitter(

domain,

attesterAddress,

maxMessageBodySize,

version

);

// Add Pauser

messageTransmitter.updatePauser(messageTransmitterPauserAddress);

// Add Rescuer

messageTransmitter.updateRescuer(messageTransmitterRescuerAddress);

// Stop recording transactions

vm.stopBroadcast();

return messageTransmitter;

}

/**

* @notice deploys TokenMessenger

* @param privateKey Private Key for signing the transactions

* @param messageTransmitterAddress Message Transmitter Contract address

* @return TokenMessenger instance

*/

function deployTokenMessenger(

uint256 privateKey,

address messageTransmitterAddress

) private returns (TokenMessenger) {

// Start recording transations

vm.startBroadcast(privateKey);

// Deploy TokenMessenger

TokenMessenger tokenMessenger = new TokenMessenger(

messageTransmitterAddress,

messageBodyVersion

);

// Add Rescuer

tokenMessenger.updateRescuer(tokenMessengerRescuerAddress);

// Stop recording transations

vm.stopBroadcast();

return tokenMessenger;

}

/**

* @notice deploys TokenMinter

* @param privateKey Private Key for signing the transactions

* @param tokenMessengerAddress TokenMessenger Contract address

* @return TokenMinter instance

*/

function deployTokenMinter(

uint256 privateKey,

address tokenMessengerAddress

) private returns (TokenMinter) {

// Start recording transations

vm.startBroadcast(privateKey);

// Deploy TokenMinter

TokenMinter tokenMinter = new TokenMinter(tokenControllerAddress);

// Add Local TokenMessenger

tokenMinter.addLocalTokenMessenger(tokenMessengerAddress);

// Add Pauser

tokenMinter.updatePauser(tokenMinterPauserAddress);

// Add Rescuer

tokenMinter.updateRescuer(tokenMinterRescuerAddress);

// Stop recording transations

vm.stopBroadcast();

return tokenMinter;

}

/**

* @notice add local minter to the TokenMessenger

*/

function addMinterAddressToTokenMessenger(

TokenMessenger tokenMessenger,

uint256 privateKey,

address minterAddress

) private {

// Start recording transations

vm.startBroadcast(privateKey);

tokenMessenger.addLocalMinter(minterAddress);

// Stop recording transations

vm.stopBroadcast();

}

/**

* @notice link current chain and remote chain tokens

*/

function linkTokenPair(

TokenMinter tokenMinter,

uint256 privateKey

) private {

// Start recording transations

vm.startBroadcast(privateKey);

bytes32 remoteUsdcContractAddressInBytes32 = Message.addressToBytes32(

usdcRemoteContractAddress

);

tokenMinter.setMaxBurnAmountPerMessage(

usdcContractAddress,

burnLimitPerMessage

);

tokenMinter.linkTokenPair(

usdcContractAddress,

remoteDomain,

remoteUsdcContractAddressInBytes32

);

// Stop recording transations

vm.stopBroadcast();

}

/**

* @notice add address of TokenMessenger deployed on another chain

*/

function addRemoteTokenMessenger(

TokenMessenger tokenMessenger,

uint256 privateKey

) private {

// Start recording transations

vm.startBroadcast(privateKey);

bytes32 remoteTokenMessengerAddressInBytes32 = Message.addressToBytes32(

remoteTokenMessengerAddress

);

tokenMessenger.addRemoteTokenMessenger(

remoteDomain,

remoteTokenMessengerAddressInBytes32

);

// Stop recording transations

vm.stopBroadcast();

}

/**

* @notice initialize variables from environment

*/

function setUp() public {

messageTransmitterDeployerPrivateKey = vm.envUint(

"MESSAGE_TRANSMITTER_DEPLOYER_KEY"

);

tokenMessengerDeployerPrivateKey = vm.envUint(

"TOKEN_MESSENGER_DEPLOYER_KEY"

);

tokenMinterDeployerPrivateKey = vm.envUint("TOKEN_MINTER_DEPLOYER_KEY");

tokenControllerPrivateKey = vm.envUint("TOKEN_CONTROLLER_DEPLOYER_KEY");

attesterAddress = vm.envAddress("ATTESTER_ADDRESS");

usdcContractAddress = vm.envAddress("USDC_CONTRACT_ADDRESS");

tokenControllerAddress = vm.envAddress("TOKEN_CONTROLLER_ADDRESS");

burnLimitPerMessage = vm.envUint("BURN_LIMIT_PER_MESSAGE");

usdcRemoteContractAddress = vm.envAddress(

"REMOTE_USDC_CONTRACT_ADDRESS"

);

remoteTokenMessengerAddress = vm.envAddress(

"REMOTE_TOKEN_MESSENGER_ADDRESS"

);

domain = uint32(vm.envUint("DOMAIN"));

remoteDomain = uint32(vm.envUint("REMOTE_DOMAIN"));

messageTransmitterPauserAddress = vm.envAddress(

"MESSAGE_TRANSMITTER_PAUSER_ADDRESS"

);

tokenMinterPauserAddress = vm.envAddress("TOKEN_MINTER_PAUSER_ADDRESS");

messageTransmitterRescuerAddress = vm.envAddress(

"MESSAGE_TRANSMITTER_RESCUER_ADDRESS"

);

tokenMessengerRescuerAddress = vm.envAddress(

"TOKEN_MESSENGER_RESCUER_ADDRESS"

);

tokenMinterRescuerAddress = vm.envAddress(

"TOKEN_MINTER_RESCUER_ADDRESS"

);

}

/**

* @notice main function that will be run by forge

*/

function run() public {

// Deploy MessageTransmitter

MessageTransmitter messageTransmitter = deployMessageTransmitter(

messageTransmitterDeployerPrivateKey

);

// Deploy TokenMessenger

TokenMessenger tokenMessenger = deployTokenMessenger(

tokenMessengerDeployerPrivateKey,

address(messageTransmitter)

);

// Deploy TokenMinter

TokenMinter tokenMinter = deployTokenMinter(

tokenMinterDeployerPrivateKey,

address(tokenMessenger)

);

// Add Local Minter

addMinterAddressToTokenMessenger(

tokenMessenger,

tokenMessengerDeployerPrivateKey,

address(tokenMinter)

);

// Link token pair and add remote token messenger

linkTokenPair(tokenMinter, tokenControllerPrivateKey);

addRemoteTokenMessenger(

tokenMessenger,

tokenMessengerDeployerPrivateKey

);

}

}