Sepolia TokenStaking proxy deploy, ExtendedTokenStaking upgrade, and operator setup tooling

contracts/staking/IStaking.sol

@@ -45,6 +45,22 @@ interface IStaking {
     //
     //
 
+    /// @notice Allows the Governance to approve the particular application
+    ///         before individual stake authorizers are able to authorize it.
+    function approveApplication(address application) external;
+
+    /// @notice Increases the authorization of the given staking provider for
+    ///         the given application by the given amount. Can only be called by
+    ///         the given staking provider's authorizer.
+    /// @dev Calls `authorizationIncreased` callback on the given application to
+    ///      notify the application about authorization change.
+    ///      See `IApplication`.
+    function increaseAuthorization(
+        address stakingProvider,
+        address application,
+        uint96 amount
+    ) external;
+
     /// @notice Requests decrease of the authorization for the given staking
     ///         provider on the given application by the provided amount.
     ///         It may not change the authorized amount immediatelly. When

contracts/staking/TokenStaking.sol

@@ -266,6 +266,84 @@ contract TokenStaking is Initializable, IStaking, Checkpoints {
     //
     //
 
+    /// @notice Allows the Governance to approve the particular application
+    ///         before individual stake authorizers are able to authorize it.
+    function approveApplication(address application)
+        external
+        virtual
+        override
+        onlyGovernance
+    {
+        require(application != address(0), "Parameters must be specified");
+        ApplicationInfo storage info = applicationInfo[application];
+        require(
+            info.status == ApplicationStatus.NOT_APPROVED ||
+                info.status == ApplicationStatus.PAUSED,
+            "Can't approve application"
+        );
+
+        if (info.status == ApplicationStatus.NOT_APPROVED) {
+            applications.push(application);
+        }
+        info.status = ApplicationStatus.APPROVED;
+        emit ApplicationStatusChanged(application, ApplicationStatus.APPROVED);
+    }
+
+    /// @notice Increases the authorization of the given staking provider for
+    ///         the given application by the given amount. Can only be called by
+    ///         the given staking provider's authorizer.
+    /// @dev Calls `authorizationIncreased` callback on the given application to
+    ///      notify the application about authorization change.
+    ///      See `IApplication`.
+    function increaseAuthorization(
+        address stakingProvider,
+        address application,
+        uint96 amount
+    ) external virtual override onlyAuthorizerOf(stakingProvider) {
+        require(amount > 0, "Parameters must be specified");
+        ApplicationInfo storage applicationStruct = applicationInfo[
+            application
+        ];
+        require(
+            applicationStruct.status == ApplicationStatus.APPROVED,
+            "Application is not approved"
+        );
+
+        StakingProviderInfo storage stakingProviderStruct = stakingProviders[
+            stakingProvider
+        ];
+        AppAuthorization storage authorization = stakingProviderStruct
+            .authorizations[application];
+        uint96 fromAmount = authorization.authorized;
+        if (fromAmount == 0) {
+            require(
+                authorizationCeiling == 0 ||
+                    stakingProviderStruct.authorizedApplications.length <
+                    authorizationCeiling,
+                "Too many applications"
+            );
+            stakingProviderStruct.authorizedApplications.push(application);
+        }
+
+        uint96 availableTValue = getAvailableToAuthorize(
+            stakingProvider,
+            application
+        );
+        require(availableTValue >= amount, "Not enough stake to authorize");
+        authorization.authorized += amount;
+        emit AuthorizationIncreased(
+            stakingProvider,
+            application,
+            fromAmount,
+            authorization.authorized
+        );
+        IApplication(application).authorizationIncreased(
+            stakingProvider,
+            fromAmount,
+            authorization.authorized
+        );
+    }
+
     /// @notice Called by the application at its discretion to approve the
     ///         previously requested authorization decrease request. Can only be
     ///         called by the application that was previously requested to

contracts/test/TokenStakingTestSet.sol

@@ -212,7 +212,7 @@ contract ExtendedTokenStaking is TokenStaking {
         address stakingProvider,
         address application,
         uint96 amount
-    ) external onlyAuthorizerOf(stakingProvider) {
+    ) external override onlyAuthorizerOf(stakingProvider) {
         require(amount > 0, "Parameters must be specified");
         ApplicationInfo storage applicationStruct = applicationInfo[
             application
@@ -261,7 +261,7 @@ contract ExtendedTokenStaking is TokenStaking {
 
     /// @notice Allows the Governance to approve the particular application
     ///         before individual stake authorizers are able to authorize it.
-    function approveApplication(address application) external {
+    function approveApplication(address application) external override {
         require(application != address(0), "Parameters must be specified");
         ApplicationInfo storage info = applicationInfo[application];
         require(

deploy/07_deploy_token_staking.ts

@@ -15,7 +15,7 @@ const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
 
   // TODO: Consider upgradable deployment also for sepolia.
   let tokenStakingAddress
-  if (hre.network.name == "mainnet") {
+  if (hre.network.name == "mainnet" || hre.network.name == "sepolia") {
     const TokenStaking = await ethers.getContractFactory("TokenStaking")
 
     const tokenStaking = await upgrades.deployProxy(

deploy/54_upgrade_token_staking_extended.ts

@@ -0,0 +1,82 @@
+import { HardhatRuntimeEnvironment } from "hardhat/types"
+import { DeployFunction } from "hardhat-deploy/types"
+
+import { ethers, upgrades } from "hardhat"
+
+/**
+ * Upgrades TokenStaking proxy to ExtendedTokenStaking implementation.
+ * ExtendedTokenStaking adds the stake() function required for native T staking.
+ * The base TokenStaking does not have stake() - it only supports legacy KEEP/NU
+ * migrations. Run this on sepolia (or other testnets) where operators need to
+ * stake T directly.
+ *
+ * From repo root (syncs deployments, upgrades, copies ABI to tbtc-v2):
+ *   bash scripts/upgrade-token-staking-sepolia.sh
+ */
+const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
+  const { deployments, getNamedAccounts } = hre
+  const { log } = deployments
+  const { deployer } = await getNamedAccounts()
+
+  if (hre.network.name !== "sepolia") {
+    log("Skipping TokenStaking upgrade (only for sepolia)")
+    return
+  }
+
+  let proxyAddress: string
+  const existing = await deployments.getOrNull("TokenStaking")
+  if (existing) {
+    proxyAddress = existing.address
+  } else {
+    // 07_deploy_token_staking saves to TokenStaking.json in deployments dir
+    const fs = require("fs")
+    const deploymentPath = `deployments/${hre.network.name}/TokenStaking.json`
+    if (!fs.existsSync(deploymentPath)) {
+      log("TokenStaking not deployed, skipping upgrade")
+      return
+    }
+    const deployment = JSON.parse(fs.readFileSync(deploymentPath, "utf8"))
+    proxyAddress = deployment.address
+  }
+
+  log(`Upgrading TokenStaking at ${proxyAddress} to ExtendedTokenStaking`)
+
+  const T = await deployments.get("T")
+
+  const ExtendedTokenStaking = await ethers.getContractFactory(
+    "ExtendedTokenStaking"
+  )
+
+  const upgraded = await upgrades.upgradeProxy(
+    proxyAddress,
+    ExtendedTokenStaking,
+    {
+      constructorArgs: [T.address],
+      kind: "transparent",
+    }
+  )
+  await upgraded.deployed()
+
+  log(`Upgraded TokenStaking to ExtendedTokenStaking at ${upgraded.address}`)
+
+  // Update deployment JSON with new ABI (includes stake)
+  const implementationInterface = upgraded.interface
+  const jsonAbi = implementationInterface.format(ethers.utils.FormatTypes.json)
+  const tokenStakingDeployment = {
+    address: upgraded.address,
+    abi: JSON.parse(jsonAbi as string),
+  }
+  const fs = require("fs")
+  const deploymentsDir = `deployments/${hre.network.name}`
+  fs.writeFileSync(
+    `${deploymentsDir}/TokenStaking.json`,
+    JSON.stringify(tokenStakingDeployment, null, 2),
+    "utf8"
+  )
+  log(`Updated ${deploymentsDir}/TokenStaking.json with ExtendedTokenStaking ABI`)
+}
+
+export default func
+
+func.tags = ["TokenStakingUpgrade", "UpgradeTokenStaking"]
+func.dependencies = ["T"]