@across-protocol/contracts 3.0.17 → 3.0.18

package/dist/scripts/svm/executeRebalanceToHubPool.js

@@ -0,0 +1,355 @@
+"use strict";
+/**
+ * Script: Execute USDC Rebalance to Hub Pool
+ *
+ * This script executes a previously proposed root bundle on the Hub Pool to rebalance USDC from the Solana Spoke Pool
+ * to the Ethereum Hub Pool. It handles CCTP attestations, relayer refund leaf execution, and prepares pending
+ * liabilities for bridging back to the Hub Pool.
+ *
+ * Required Environment Variables:
+ * - TESTNET: (Optional) Set to "true" to use Sepolia; defaults to mainnet.
+ * - MNEMONIC: Wallet mnemonic to sign the Ethereum transaction.
+ * - HUB_POOL_ADDRESS: Ethereum address of the Hub Pool.
+ * - NODE_URL_1: Ethereum RPC URL for mainnet (ignored if TESTNET=true).
+ * - NODE_URL_11155111: Ethereum RPC URL for Sepolia (ignored if TESTNET=false).
+ *
+ * Required Arguments:
+ * - `--netSendAmount`: The unscaled amount of USDC to rebalance (e.g., for USDC with 6 decimals, 1 = 0.000001 USDC).
+ * - `--resumeRemoteTx`: (Optional) Hash of a previously submitted remote transaction to resume.
+ *
+ * Example Usage:
+ * TESTNET=true \
+ * NODE_URL_11155111=$NODE_URL_11155111 \
+ * MNEMONIC=$MNEMONIC \
+ * HUB_POOL_ADDRESS=$HUB_POOL_ADDRESS \
+ * anchor run executeRebalanceToHubPool \
+ * --provider.cluster "devnet" \
+ * --provider.wallet $SOLANA_PKEY_PATH \
+ * -- --netSendAmount 7
+ *
+ * Note:
+ * - Ensure all required environment variables are properly configured.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const anchor = __importStar(require("@coral-xyz/anchor"));
+const anchor_1 = require("@coral-xyz/anchor");
+const spl_token_1 = require("@solana/spl-token");
+const web3_js_1 = require("@solana/web3.js");
+// eslint-disable-next-line camelcase
+const ethers_1 = require("ethers");
+const yargs_1 = __importDefault(require("yargs"));
+const helpers_1 = require("yargs/helpers");
+const constants_1 = require("../../utils/constants");
+// eslint-disable-next-line camelcase
+const typechain_1 = require("../../typechain");
+const constants_2 = require("./utils/constants");
+const helpers_2 = require("./utils/helpers");
+const common_1 = require("@uma/common");
+const cctpHelpers_1 = require("../../test/svm/cctpHelpers");
+const utils_1 = require("../../test/svm/utils");
+// Set up Solana provider.
+const provider = anchor_1.AnchorProvider.env();
+anchor.setProvider(provider);
+// Get Solana programs.
+const svmSpokeIdl = require("../../target/idl/svm_spoke.json");
+const svmSpokeProgram = new anchor_1.Program(svmSpokeIdl, provider);
+const messageTransmitterIdl = require("../../target/idl/message_transmitter.json");
+const messageTransmitterProgram = new anchor_1.Program(messageTransmitterIdl, provider);
+const [messageTransmitterState] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("message_transmitter")], messageTransmitterProgram.programId);
+const [authorityPda] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("message_transmitter_authority"), svmSpokeProgram.programId.toBuffer()], messageTransmitterProgram.programId);
+const [selfAuthority] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("self_authority")], svmSpokeProgram.programId);
+const [eventAuthority] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("__event_authority")], svmSpokeProgram.programId);
+// Set up Ethereum provider and signer.
+const nodeURL = process.env.TESTNET === "true" ? (0, common_1.getNodeUrl)("sepolia", true) : (0, common_1.getNodeUrl)("mainnet", true);
+const ethersProvider = new ethers_1.ethers.providers.JsonRpcProvider(nodeURL);
+const ethersSigner = ethers_1.ethers.Wallet.fromMnemonic((0, helpers_2.requireEnv)("MNEMONIC")).connect(ethersProvider);
+// Get the HubPool contract instance.
+const hubPoolAddress = ethers_1.ethers.utils.getAddress((0, helpers_2.requireEnv)("HUB_POOL_ADDRESS"));
+const hubPool = typechain_1.HubPool__factory.connect(hubPoolAddress, ethersProvider);
+// CCTP domains.
+const ethereumDomain = 0; // Ethereum
+// Parse arguments
+const argv = (0, yargs_1.default)((0, helpers_1.hideBin)(process.argv))
+    // Net send amount is always required as we need it to calculate the relayer refund leaf.
+    .option("netSendAmount", { type: "string", demandOption: true, describe: "Net send amount to Hub Pool" })
+    .option("resumeRemoteTx", { type: "string", demandOption: false, describe: "Resume receiving remote tx" }).argv;
+async function executeRebalanceToHubPool() {
+    const resolvedArgv = await argv;
+    const seed = constants_2.SOLANA_SPOKE_STATE_SEED; // Seed is always 0 for the state account PDA in public networks.
+    const netSendAmount = ethers_1.BigNumber.from(resolvedArgv.netSendAmount);
+    const resumeRemoteTx = resolvedArgv.resumeRemoteTx;
+    // Resolve Solana cluster, EVM chain ID, Iris API URL and USDC addresses.
+    let isDevnet;
+    const solanaRpcEndpoint = provider.connection.rpcEndpoint;
+    if (solanaRpcEndpoint.includes("devnet"))
+        isDevnet = true;
+    else if (solanaRpcEndpoint.includes("mainnet"))
+        isDevnet = false;
+    else
+        throw new Error(`Unsupported solanaCluster endpoint: ${solanaRpcEndpoint}`);
+    const solanaCluster = isDevnet ? "devnet" : "mainnet";
+    const solanaChainId = (0, helpers_2.getSolanaChainId)(solanaCluster);
+    const irisApiUrl = isDevnet ? constants_2.CIRCLE_IRIS_API_URL_DEVNET : constants_2.CIRCLE_IRIS_API_URL_MAINNET;
+    const supportedEvmChainId = isDevnet ? constants_1.CHAIN_IDs.SEPOLIA : constants_1.CHAIN_IDs.MAINNET; // Sepolia is bridged to devnet, Ethereum to mainnet in CCTP.
+    const evmChainId = (await ethersProvider.getNetwork()).chainId;
+    if (evmChainId !== supportedEvmChainId) {
+        throw new Error(`Chain ID ${evmChainId} does not match expected Solana cluster ${solanaCluster}`);
+    }
+    const svmUsdc = isDevnet ? constants_2.SOLANA_USDC_DEVNET : constants_2.SOLANA_USDC_MAINNET;
+    const [statePda, _] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("state"), seed.toArrayLike(Buffer, "le", 8)], svmSpokeProgram.programId);
+    const state = await svmSpokeProgram.account.state.fetch(statePda);
+    const [rootBundlePda] = getRootBundlePda(state.rootBundleId, seed);
+    console.log("Executing rebalance to hub pool...");
+    console.table([
+        { Property: "isTestnet", Value: process.env.TESTNET === "true" },
+        { Property: "originChainId", Value: evmChainId.toString() },
+        { Property: "targetChainId", Value: solanaChainId.toString() },
+        { Property: "hubPoolAddress", Value: hubPool.address },
+        { Property: "svmSpokeProgramProgramId", Value: svmSpokeProgram.programId.toString() },
+        { Property: "svmProviderPublicKey", Value: provider.wallet.publicKey.toString() },
+        { Property: "netSendAmount (formatted)", Value: (0, helpers_2.formatUsdc)(netSendAmount) },
+    ]);
+    // Send executeRootBundle call from Ethereum, unless resuming a remote transaction.
+    let remoteTxHash;
+    if (!resumeRemoteTx) {
+        remoteTxHash = await executeRootBalanceOnHubPool(solanaChainId);
+    }
+    else
+        remoteTxHash = resumeRemoteTx;
+    // Fetch attestation from CCTP attestation service.
+    const attestationResponse = await (0, cctpHelpers_1.getMessages)(remoteTxHash, ethereumDomain, irisApiUrl);
+    const { attestation, message } = attestationResponse.messages[0];
+    console.log("CCTP attestation response:", attestationResponse.messages[0]);
+    // Accounts in CCTP message_transmitter receive_message instruction.
+    const nonce = (0, cctpHelpers_1.decodeMessageHeader)(Buffer.from(message.replace("0x", ""), "hex")).nonce;
+    const usedNonces = (await messageTransmitterProgram.methods
+        .getNoncePda({
+        nonce: new anchor_1.BN(nonce.toString()),
+        sourceDomain: ethereumDomain,
+    })
+        .accounts({
+        messageTransmitter: messageTransmitterState,
+    })
+        .view());
+    const receiveMessageAccounts = {
+        payer: provider.wallet.publicKey,
+        caller: provider.wallet.publicKey,
+        authorityPda,
+        messageTransmitter: messageTransmitterState,
+        usedNonces,
+        receiver: svmSpokeProgram.programId,
+        systemProgram: web3_js_1.SystemProgram.programId,
+    };
+    // accountMetas list to pass to remaining accounts when receiving message via CCTP.
+    const remainingAccounts = [];
+    // state in HandleReceiveMessage accounts (used for remote domain and sender authentication).
+    remainingAccounts.push({
+        isSigner: false,
+        isWritable: false,
+        pubkey: statePda,
+    });
+    // self_authority in HandleReceiveMessage accounts, also signer in self-invoked CPIs.
+    remainingAccounts.push({
+        isSigner: false,
+        isWritable: false,
+        pubkey: selfAuthority,
+    });
+    // program in HandleReceiveMessage accounts.
+    remainingAccounts.push({
+        isSigner: false,
+        isWritable: false,
+        pubkey: svmSpokeProgram.programId,
+    });
+    // payer
+    remainingAccounts.push({
+        isSigner: true,
+        isWritable: true,
+        pubkey: provider.wallet.publicKey,
+    });
+    // state in self-invoked CPIs (state can change as a result of remote call).
+    remainingAccounts.push({
+        isSigner: false,
+        isWritable: true,
+        pubkey: statePda,
+    });
+    // root_bundle
+    remainingAccounts.push({
+        isSigner: false,
+        isWritable: true,
+        pubkey: rootBundlePda,
+    });
+    // system_program
+    remainingAccounts.push({
+        isSigner: false,
+        isWritable: false,
+        pubkey: web3_js_1.SystemProgram.programId,
+    });
+    // event_authority in self-invoked CPIs (appended by Anchor with event_cpi macro).
+    remainingAccounts.push({
+        isSigner: false,
+        isWritable: true,
+        pubkey: eventAuthority,
+    });
+    // program
+    remainingAccounts.push({
+        isSigner: false,
+        isWritable: true,
+        pubkey: svmSpokeProgram.programId,
+    });
+    // Receive remote message on Solana.
+    console.log("Receiving message on Solana...");
+    const receiveMessageTx = await messageTransmitterProgram.methods
+        .receiveMessage({
+        message: Buffer.from(message.replace("0x", ""), "hex"),
+        attestation: Buffer.from(attestation.replace("0x", ""), "hex"),
+    })
+        .accounts(receiveMessageAccounts)
+        .remainingAccounts(remainingAccounts)
+        .rpc();
+    console.log("\nReceived remote message");
+    console.log("Your transaction signature", receiveMessageTx);
+    const finalState = await svmSpokeProgram.account.state.fetch(statePda);
+    // The state stores the next root bundle ID, so we need to subtract one to get the last executed root bundle ID.
+    const lastRootBundleId = finalState.rootBundleId - 1;
+    // Reconstruct the merkle tree for the relayer refund leaf.
+    const { merkleTree, leaves } = (0, helpers_2.constructSimpleRebalanceTreeToHubPool)(netSendAmount, solanaChainId, new web3_js_1.PublicKey(svmUsdc));
+    const [rootBundlePdaNew] = getRootBundlePda(lastRootBundleId, seed);
+    console.log(`Executing relayer refund leaf for root bundle ID: ${lastRootBundleId}`);
+    await executeRelayerRefundLeaf(provider.wallet, svmSpokeProgram, statePda, rootBundlePdaNew, leaves[0], merkleTree, new web3_js_1.PublicKey(svmUsdc), lastRootBundleId);
+    console.log("✅ executed relayer refund leaf");
+    const [transferLiability] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("transfer_liability"), new web3_js_1.PublicKey(svmUsdc).toBuffer()], svmSpokeProgram.programId);
+    const liability = await svmSpokeProgram.account.transferLiability.fetch(transferLiability);
+    console.log(`Pending transfer liability: ${(0, helpers_2.formatUsdc)(ethers_1.BigNumber.from(liability.pendingToHubPool.toString()))} USDC`);
+    console.log("You can now send the pending liability to hub pool with bridgeLiabilityToHubPool.ts");
+}
+function getRootBundlePda(rootBundleId, seed) {
+    const rootBundleIdBuffer = Buffer.alloc(4);
+    rootBundleIdBuffer.writeUInt32LE(rootBundleId);
+    return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("root_bundle"), seed.toArrayLike(Buffer, "le", 8), rootBundleIdBuffer], svmSpokeProgram.programId);
+}
+async function executeRootBalanceOnHubPool(solanaChainId) {
+    // Reconstruct the merkle tree for the pool rebalance.
+    const { poolRebalanceLeaf, poolRebalanceTree } = (0, helpers_2.constructEmptyPoolRebalanceTree)(solanaChainId, 0);
+    // Make sure the proposal liveness has passed, it has not been executed and rebalance root matches.
+    const currentRootBundleProposal = await hubPool.connect(ethersSigner).callStatic.rootBundleProposal();
+    if (currentRootBundleProposal.challengePeriodEndTimestamp > (await hubPool.callStatic.getCurrentTime()).toNumber())
+        throw new Error("Not passed liveness");
+    if (!currentRootBundleProposal.claimedBitMap.isZero())
+        throw new Error("Already claimed");
+    if (currentRootBundleProposal.poolRebalanceRoot !== poolRebalanceTree.getHexRoot())
+        throw new Error("Rebalance root mismatch");
+    // Execute the rebalance bundle on the HubPool.
+    const tx = await hubPool.connect(ethersSigner).executeRootBundle(solanaChainId, 0, // groupIndex
+    poolRebalanceLeaf.bundleLpFees, poolRebalanceLeaf.netSendAmounts, poolRebalanceLeaf.runningBalances, poolRebalanceLeaf.leafId, poolRebalanceLeaf.l1Tokens, poolRebalanceTree.getHexProof(poolRebalanceLeaf));
+    console.log(`✅ submitted tx hash: ${tx.hash}`);
+    await tx.wait();
+    console.log("✅ tx confirmed");
+    return tx.hash;
+}
+async function executeRelayerRefundLeaf(signer, program, statePda, rootBundle, relayerRefundLeaf, merkleTree, inputToken, rootBundleId) {
+    // Execute the single leaf
+    const proof = merkleTree.getProof(relayerRefundLeaf).map((p) => Array.from(p));
+    const leaf = relayerRefundLeaf;
+    const vault = (0, spl_token_1.getAssociatedTokenAddressSync)(inputToken, statePda, true, spl_token_1.TOKEN_PROGRAM_ID, spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID);
+    // Derive the transferLiability PDA
+    const [transferLiability] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("transfer_liability"), inputToken.toBuffer()], program.programId);
+    // Load the instruction parameters
+    const proofAsNumbers = proof.map((p) => Array.from(p));
+    console.log("loading execute relayer refund leaf params...");
+    const [instructionParams] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("instruction_params"), signer.publicKey.toBuffer()], program.programId);
+    const staticAccounts = {
+        instructionParams,
+        state: statePda,
+        rootBundle: rootBundle,
+        signer: signer.publicKey,
+        vault: vault,
+        tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+        mint: inputToken,
+        transferLiability,
+        systemProgram: anchor.web3.SystemProgram.programId,
+        // Appended by Acnhor `event_cpi` macro:
+        eventAuthority: web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("__event_authority")], program.programId)[0],
+        program: program.programId,
+    };
+    const refundAccounts = [];
+    // Consolidate all above addresses into a single array for the  Address Lookup Table (ALT).
+    const [lookupTableInstruction, lookupTableAddress] = await web3_js_1.AddressLookupTableProgram.createLookupTable({
+        authority: signer.publicKey,
+        payer: signer.publicKey,
+        recentSlot: await provider.connection.getSlot(),
+    });
+    // Submit the ALT creation transaction
+    await anchor.web3.sendAndConfirmTransaction(provider.connection, new anchor.web3.Transaction().add(lookupTableInstruction), [anchor.AnchorProvider.env().wallet.payer], { skipPreflight: true });
+    const lookupAddresses = [...Object.values(staticAccounts), ...refundAccounts];
+    // Create the transaction with the compute budget expansion instruction & use extended ALT account.
+    // Extend the ALT with all accounts
+    const maxExtendedAccounts = 30; // Maximum number of accounts that can be added to ALT in a single transaction.
+    for (let i = 0; i < lookupAddresses.length; i += maxExtendedAccounts) {
+        const extendInstruction = web3_js_1.AddressLookupTableProgram.extendLookupTable({
+            lookupTable: lookupTableAddress,
+            authority: signer.publicKey,
+            payer: signer.publicKey,
+            addresses: lookupAddresses.slice(i, i + maxExtendedAccounts),
+        });
+        await anchor.web3.sendAndConfirmTransaction(provider.connection, new anchor.web3.Transaction().add(extendInstruction), [anchor.AnchorProvider.env().wallet.payer], { skipPreflight: true });
+    }
+    // Fetch the AddressLookupTableAccount
+    const lookupTableAccount = (await provider.connection.getAddressLookupTable(lookupTableAddress)).value;
+    if (!lookupTableAccount) {
+        throw new Error("AddressLookupTableAccount not fetched");
+    }
+    await (0, utils_1.loadExecuteRelayerRefundLeafParams)(program, signer.publicKey, rootBundleId, leaf, proofAsNumbers);
+    console.log(`loaded execute relayer refund leaf params ${instructionParams}. \nExecuting relayer refund leaf...`);
+    const executeInstruction = await program.methods
+        .executeRelayerRefundLeaf()
+        .accounts(staticAccounts)
+        .remainingAccounts([])
+        .instruction();
+    // Create the versioned transaction
+    const computeBudgetInstruction = web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: 500_000 });
+    const versionedTx = new web3_js_1.VersionedTransaction(new web3_js_1.TransactionMessage({
+        payerKey: signer.publicKey,
+        recentBlockhash: (await provider.connection.getLatestBlockhash()).blockhash,
+        instructions: [computeBudgetInstruction, executeInstruction],
+    }).compileToV0Message([lookupTableAccount]));
+    // Sign and submit the versioned transaction
+    versionedTx.sign([anchor.AnchorProvider.env().wallet.payer]);
+    const tx = await provider.connection.sendTransaction(versionedTx);
+    console.log(`Execute relayer refund leaf transaction sent: ${tx}`);
+    // Close the instruction parameters account
+    console.log("Closing instruction params...");
+    await new Promise((resolve) => setTimeout(resolve, 15000)); // Wait for the previous transaction to be processed.
+    const closeInstructionParamsTx = await program.methods.closeInstructionParams()
+        .accounts({ signer: signer.publicKey, instructionParams: instructionParams })
+        .rpc();
+    console.log(`Close instruction params transaction sent: ${closeInstructionParamsTx}`);
+    // Note we cant close the lookup table account as it needs to be both deactivated and expired at to do this.
+}
+// Run the executeRebalanceToHubPool function
+executeRebalanceToHubPool();

package/dist/scripts/svm/executeRebalanceToSpokePool.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scripts/svm/executeRebalanceToSpokePool.js

@@ -0,0 +1,253 @@
+"use strict";
+// This script executes root bundle on HubPool that rebalances tokens to Solana Spoke Pool. Required environment:
+// - ETHERS_PROVIDER_URL: Ethereum RPC provider URL.
+// - ETHERS_MNEMONIC: Mnemonic of the wallet that will sign the sending transaction on Ethereum
+// - HUB_POOL_ADDRESS: Hub Pool address
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const anchor = __importStar(require("@coral-xyz/anchor"));
+const anchor_1 = require("@coral-xyz/anchor");
+const web3_js_1 = require("@solana/web3.js");
+const spl_token_1 = require("@solana/spl-token");
+// eslint-disable-next-line camelcase
+const constants_1 = require("../../utils/constants");
+const yargs_1 = __importDefault(require("yargs"));
+const helpers_1 = require("yargs/helpers");
+const SvmUtils_1 = require("../../src/SvmUtils");
+const ethers_1 = require("ethers");
+// eslint-disable-next-line camelcase
+const typechain_1 = require("../../typechain");
+const constants_2 = require("./utils/constants");
+const poolRebalanceTree_1 = require("./utils/poolRebalanceTree");
+const cctpHelpers_1 = require("../../test/svm/cctpHelpers");
+// Set up Solana provider.
+const provider = anchor_1.AnchorProvider.env();
+anchor.setProvider(provider);
+// Get Solana programs.
+const svmSpokeIdl = require("../../target/idl/svm_spoke.json");
+const svmSpokeProgram = new anchor_1.Program(svmSpokeIdl, provider);
+const messageTransmitterIdl = require("../../target/idl/message_transmitter.json");
+const messageTransmitterProgram = new anchor_1.Program(messageTransmitterIdl, provider);
+const tokenMessengerMinterIdl = require("../../target/idl/token_messenger_minter.json");
+const tokenMessengerMinterProgram = new anchor_1.Program(tokenMessengerMinterIdl, provider);
+// Set up Ethereum provider.
+if (!process.env.ETHERS_PROVIDER_URL) {
+    throw new Error("Environment variable ETHERS_PROVIDER_URL is not set");
+}
+const ethersProvider = new ethers_1.ethers.providers.JsonRpcProvider(process.env.ETHERS_PROVIDER_URL);
+if (!process.env.ETHERS_MNEMONIC) {
+    throw new Error("Environment variable ETHERS_MNEMONIC is not set");
+}
+const ethersSigner = ethers_1.ethers.Wallet.fromMnemonic(process.env.ETHERS_MNEMONIC).connect(ethersProvider);
+// Get the HubPool contract instance.
+if (!process.env.HUB_POOL_ADDRESS) {
+    throw new Error("Environment variable HUB_POOL_ADDRESS is not set");
+}
+const hubPoolAddress = ethers_1.ethers.utils.getAddress(process.env.HUB_POOL_ADDRESS);
+const hubPool = typechain_1.HubPool__factory.connect(hubPoolAddress, ethersProvider);
+// CCTP domains.
+const remoteDomain = 0; // Ethereum
+// Parse arguments
+const argv = (0, yargs_1.default)((0, helpers_1.hideBin)(process.argv))
+    .option("netSendAmount", { type: "string", demandOption: false, describe: "Net send amount to spoke" })
+    .option("resumeRemoteTx", { type: "string", demandOption: false, describe: "Resume receiving remote tx" })
+    .check((argv) => {
+    if (argv.netSendAmount !== undefined && argv.resumeRemoteTx !== undefined) {
+        throw new Error("Options --netSendAmount and --resumeRemoteTx are mutually exclusive");
+    }
+    if (argv.netSendAmount === undefined && argv.resumeRemoteTx === undefined) {
+        throw new Error("One of the options --netSendAmount or --resumeRemoteTx is required");
+    }
+    return true;
+}).argv;
+async function executeRebalanceToSpokePool() {
+    const resolvedArgv = await argv;
+    const seed = new anchor_1.BN(0); // Seed is always 0 for the state account PDA in public networks.
+    const netSendAmount = resolvedArgv.netSendAmount ? ethers_1.BigNumber.from(resolvedArgv.netSendAmount) : ethers_1.BigNumber.from(0);
+    const resumeRemoteTx = resolvedArgv.resumeRemoteTx;
+    // Resolve Solana cluster, EVM chain ID, Iris API URL and USDC addresses.
+    let isDevnet;
+    const solanaRpcEndpoint = provider.connection.rpcEndpoint;
+    if (solanaRpcEndpoint.includes("devnet"))
+        isDevnet = true;
+    else if (solanaRpcEndpoint.includes("mainnet"))
+        isDevnet = false;
+    else
+        throw new Error(`Unsupported solanaCluster endpoint: ${solanaRpcEndpoint}`);
+    const solanaCluster = isDevnet ? "devnet" : "mainnet";
+    const solanaChainId = ethers_1.BigNumber.from(BigInt(ethers_1.ethers.utils.keccak256(ethers_1.ethers.utils.toUtf8Bytes(`solana-${solanaCluster}`))) & BigInt("0xFFFFFFFFFFFFFFFF"));
+    const irisApiUrl = isDevnet ? constants_2.CIRCLE_IRIS_API_URL_DEVNET : constants_2.CIRCLE_IRIS_API_URL_MAINNET;
+    const supportedEvmChainId = isDevnet ? constants_1.CHAIN_IDs.SEPOLIA : constants_1.CHAIN_IDs.MAINNET; // Sepolia is bridged to devnet, Ethereum to mainnet in CCTP.
+    const evmChainId = (await ethersProvider.getNetwork()).chainId;
+    if (evmChainId !== supportedEvmChainId) {
+        throw new Error(`Chain ID ${evmChainId} does not match expected Solana cluster ${solanaCluster}`);
+    }
+    const l1TokenAddress = constants_1.TOKEN_SYMBOLS_MAP.USDC.addresses[evmChainId];
+    const solanaTokenKey = isDevnet ? new web3_js_1.PublicKey(constants_2.SOLANA_USDC_DEVNET) : new web3_js_1.PublicKey(constants_2.SOLANA_USDC_MAINNET);
+    console.log("Executing rebalance pool bundle to spoke...");
+    console.table([
+        { Property: "originChainId", Value: evmChainId.toString() },
+        { Property: "targetChainId", Value: solanaChainId.toString() },
+        { Property: "hubPoolAddress", Value: hubPool.address },
+        { Property: "l1TokenAddress", Value: l1TokenAddress },
+        { Property: "solanaTokenKey", Value: solanaTokenKey.toString() },
+        { Property: "svmSpokeProgramProgramId", Value: svmSpokeProgram.programId.toString() },
+        { Property: "providerPublicKey", Value: provider.wallet.publicKey.toString() },
+        { Property: "netSendAmount", Value: netSendAmount.toString() },
+    ]);
+    // Send executeRootBundle call from Ethereum, unless resuming a remote transaction.
+    let remoteTxHash;
+    if (!resumeRemoteTx) {
+        remoteTxHash = await executeRebalanceOnHubPool(l1TokenAddress, netSendAmount, solanaChainId);
+    }
+    else
+        remoteTxHash = resumeRemoteTx;
+    // Get Solana accounts required to receive tokens over CCTP.
+    const [statePda] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("state"), seed.toArrayLike(Buffer, "le", 8)], svmSpokeProgram.programId);
+    const vault = (0, spl_token_1.getAssociatedTokenAddressSync)(solanaTokenKey, statePda, true);
+    const [messageTransmitterState] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("message_transmitter")], messageTransmitterProgram.programId);
+    const [authorityPda] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("message_transmitter_authority"), tokenMessengerMinterProgram.programId.toBuffer()], messageTransmitterProgram.programId);
+    const [tokenMessengerAccount] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("token_messenger")], tokenMessengerMinterProgram.programId);
+    const [remoteTokenMessengerKey] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("remote_token_messenger"), Buffer.from(remoteDomain.toString())], tokenMessengerMinterProgram.programId);
+    const [tokenMinterAccount] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("token_minter")], tokenMessengerMinterProgram.programId);
+    const [localToken] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("local_token"), solanaTokenKey.toBuffer()], tokenMessengerMinterProgram.programId);
+    const [tokenPair] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("token_pair"), Buffer.from(remoteDomain.toString()), (0, SvmUtils_1.evmAddressToPublicKey)(l1TokenAddress).toBuffer()], tokenMessengerMinterProgram.programId);
+    const [custodyTokenAccount] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("custody"), solanaTokenKey.toBuffer()], tokenMessengerMinterProgram.programId);
+    const [tokenMessengerEventAuthority] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("__event_authority")], tokenMessengerMinterProgram.programId);
+    // Fetch attestation from CCTP attestation service.
+    const attestationResponse = await (0, cctpHelpers_1.getMessages)(remoteTxHash, remoteDomain, irisApiUrl);
+    const { attestation, message } = attestationResponse.messages[0];
+    console.log("CCTP attestation response:", attestationResponse.messages[0]);
+    // Accounts in CCTP message_transmitter receive_message instruction.
+    const nonce = (0, cctpHelpers_1.decodeMessageHeader)(Buffer.from(message.replace("0x", ""), "hex")).nonce;
+    const usedNonces = (await messageTransmitterProgram.methods
+        .getNoncePda({
+        nonce: new anchor_1.BN(nonce.toString()),
+        sourceDomain: remoteDomain,
+    })
+        .accounts({
+        messageTransmitter: messageTransmitterState,
+    })
+        .view());
+    const receiveMessageAccounts = {
+        payer: provider.wallet.publicKey,
+        caller: provider.wallet.publicKey,
+        authorityPda,
+        messageTransmitter: messageTransmitterState,
+        usedNonces,
+        receiver: tokenMessengerMinterProgram.programId,
+        systemProgram: web3_js_1.SystemProgram.programId,
+    };
+    // accountMetas list to pass to remaining accounts when receiving token bridge message via CCTP.
+    const remainingAccounts = [];
+    remainingAccounts.push({
+        isSigner: false,
+        isWritable: false,
+        pubkey: tokenMessengerAccount,
+    });
+    remainingAccounts.push({
+        isSigner: false,
+        isWritable: false,
+        pubkey: remoteTokenMessengerKey,
+    });
+    remainingAccounts.push({
+        isSigner: false,
+        isWritable: true,
+        pubkey: tokenMinterAccount,
+    });
+    remainingAccounts.push({
+        isSigner: false,
+        isWritable: true,
+        pubkey: localToken,
+    });
+    remainingAccounts.push({
+        isSigner: false,
+        isWritable: false,
+        pubkey: tokenPair,
+    });
+    remainingAccounts.push({
+        isSigner: false,
+        isWritable: true,
+        pubkey: vault,
+    });
+    remainingAccounts.push({
+        isSigner: false,
+        isWritable: true,
+        pubkey: custodyTokenAccount,
+    });
+    remainingAccounts.push({
+        isSigner: false,
+        isWritable: false,
+        pubkey: spl_token_1.TOKEN_PROGRAM_ID,
+    });
+    remainingAccounts.push({
+        isSigner: false,
+        isWritable: false,
+        pubkey: tokenMessengerEventAuthority,
+    });
+    remainingAccounts.push({
+        isSigner: false,
+        isWritable: false,
+        pubkey: tokenMessengerMinterProgram.programId,
+    });
+    // Receive tokens on Solana.
+    console.log(`Receiving ${netSendAmount.toString()} tokens on Solana...`);
+    const receiveMessageTx = await messageTransmitterProgram.methods
+        .receiveMessage({
+        message: Buffer.from(message.replace("0x", ""), "hex"),
+        attestation: Buffer.from(attestation.replace("0x", ""), "hex"),
+    })
+        .accounts(receiveMessageAccounts)
+        .remainingAccounts(remainingAccounts)
+        .rpc();
+    console.log("\nReceived remote message");
+    console.log("Your transaction signature", receiveMessageTx);
+}
+async function executeRebalanceOnHubPool(l1TokenAddress, netSendAmount, solanaChainId) {
+    // Reconstruct the merkle tree for the pool rebalance.
+    const { poolRebalanceTree, poolRebalanceLeaf } = (0, poolRebalanceTree_1.constructSimpleRebalanceTree)(l1TokenAddress, netSendAmount, solanaChainId);
+    // Make sure the proposal liveness has passed, it has not been executed and rebalance root matches.
+    const currentRootBundleProposal = await hubPool.connect(ethersSigner).callStatic.rootBundleProposal();
+    if (currentRootBundleProposal.challengePeriodEndTimestamp > (await hubPool.callStatic.getCurrentTime()).toNumber())
+        throw new Error("Not passed liveness");
+    if (!currentRootBundleProposal.claimedBitMap.isZero())
+        throw new Error("Already claimed");
+    if (currentRootBundleProposal.poolRebalanceRoot !== poolRebalanceTree.getHexRoot())
+        throw new Error("Rebalance root mismatch");
+    // Execute the rebalance bundle on the HubPool.
+    console.log(`Executing ${netSendAmount.toString()} rebalance to spoke pool:`);
+    const tx = await hubPool
+        .connect(ethersSigner)
+        .executeRootBundle(poolRebalanceLeaf.chainId, poolRebalanceLeaf.groupIndex, poolRebalanceLeaf.bundleLpFees, poolRebalanceLeaf.netSendAmounts, poolRebalanceLeaf.runningBalances, poolRebalanceLeaf.leafId, poolRebalanceLeaf.l1Tokens, poolRebalanceTree.getHexProof(poolRebalanceLeaf));
+    console.log(`✔️ submitted tx hash: ${tx.hash}`);
+    await tx.wait();
+    console.log(`✔️ tx confirmed`);
+    return tx.hash;
+}
+// Run the executeRebalanceToSpokePool function
+executeRebalanceToSpokePool();

package/dist/scripts/svm/proposeRebalanceToHubPool.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Script: Propose Root Bundle for USDC Rebalance to Hub Pool
+ *
+ * Submits a root bundle proposal on the Hub Pool to rebalance USDC from the Solana Spoke Pool to the Ethereum Hub Pool.
+ * After submission and the liveness period, the rebalance can be executed with `executeRebalanceToHubPool.ts`.
+ *
+ * Required Environment Variables:
+ * - TESTNET: (Optional) Set to "true" to use Sepolia; defaults to mainnet.
+ * - MNEMONIC: Wallet mnemonic to sign the Ethereum transaction.
+ * - HUB_POOL_ADDRESS: Ethereum address of the Hub Pool.
+ * - NODE_URL_1: Ethereum RPC URL for mainnet (ignored if TESTNET=true).
+ * - NODE_URL_11155111: Ethereum RPC URL for Sepolia (ignored if TESTNET=false).
+ *
+ * Required Argument:
+ * - `--netSendAmount`: The unscaled amount of USDC to rebalance. (e.g., for USDC with 6 decimals, 1 = 0.000001 USDC).
+ *
+ * Example Usage:
+ * TESTNET=true \
+ * NODE_URL_11155111=$NODE_URL_11155111 \
+ * MNEMONIC=$MNEMONIC \
+ * HUB_POOL_ADDRESS=$HUB_POOL_ADDRESS \
+ * anchor run proposeRebalanceToHubPool -- --netSendAmount 7
+ *
+ * Note:
+ * Ensure the required environment variables are set before running this script.
+ */
+export {};