chore: sync with main

.github/workflows/claude-code-review.yml

@@ -0,0 +1,56 @@
+name: Claude Code Review
+
+on:
+  pull_request:
+    types: [opened, synchronize]
+    # Optional: Only run on specific file changes
+    # paths:
+    #   - "src/**/*.ts"
+    #   - "src/**/*.tsx"
+    #   - "src/**/*.js"
+    #   - "src/**/*.jsx"
+
+jobs:
+  claude-review:
+    # Optional: Filter by PR author
+    # if: |
+    #   github.event.pull_request.user.login == 'external-contributor' ||
+    #   github.event.pull_request.user.login == 'new-developer' ||
+    #   github.event.pull_request.author_association == 'FIRST_TIME_CONTRIBUTOR'
+
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      pull-requests: write
+      issues: read
+      id-token: write
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
+
+      - name: Run Claude Code Review
+        id: claude-review
+        uses: anthropics/claude-code-action@v1
+        with:
+          claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
+          prompt: |
+            REPO: ${{ github.repository }}
+            PR NUMBER: ${{ github.event.pull_request.number }}
+
+            Please review this pull request and provide feedback on:
+            - Code quality and best practices
+            - Potential bugs or issues
+            - Performance considerations
+            - Security concerns
+            - Test coverage
+
+            Use the repository's CLAUDE.md for guidance on style and conventions. Be constructive and helpful in your feedback.
+
+            Use `gh pr comment` with your Bash tool to leave your review as a comment on the PR.
+
+          # See https://github.com/anthropics/claude-code-action/blob/main/docs/usage.md
+          # or https://code.claude.com/docs/en/cli-reference for available options
+          claude_args: '--allowed-tools "Bash(gh issue view:*),Bash(gh search:*),Bash(gh issue list:*),Bash(gh pr comment:*),Bash(gh pr diff:*),Bash(gh pr view:*),Bash(gh pr list:*)"'

.github/workflows/claude.yml

@@ -0,0 +1,49 @@
+name: Claude Code
+
+on:
+  issue_comment:
+    types: [created]
+  pull_request_review_comment:
+    types: [created]
+  issues:
+    types: [opened, assigned]
+  pull_request_review:
+    types: [submitted]
+
+jobs:
+  claude:
+    if: |
+      (github.event_name == 'issue_comment' && contains(github.event.comment.body, '@claude')) ||
+      (github.event_name == 'pull_request_review_comment' && contains(github.event.comment.body, '@claude')) ||
+      (github.event_name == 'pull_request_review' && contains(github.event.review.body, '@claude')) ||
+      (github.event_name == 'issues' && (contains(github.event.issue.body, '@claude') || contains(github.event.issue.title, '@claude')))
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      pull-requests: write
+      issues: read
+      id-token: write
+      actions: read # Required for Claude to read CI results on PRs
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
+
+      - name: Run Claude Code
+        id: claude
+        uses: anthropics/claude-code-action@v1
+        with:
+          claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
+
+          # This is an optional setting that allows Claude to read CI results on PRs
+          additional_permissions: |
+            actions: read
+
+          # Optional: Give a custom prompt to Claude. If this is not specified, Claude will perform the instructions specified in the comment that tagged it.
+          # prompt: 'Update the pull request description to include a summary of changes.'
+
+          # Optional: Add claude_args to customize behavior and configuration
+          # See https://github.com/anthropics/claude-code-action/blob/main/docs/usage.md
+          # or https://code.claude.com/docs/en/cli-reference for available options
+          # claude_args: '--allowed-tools Bash(gh pr:*)'

script/DeployPendlePTAmortizedOracle.s.sol

@@ -0,0 +1,193 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity >=0.8.30;
+
+import { PendlePTAmortizedOracleScriptBase } from "./PendlePTAmortizedOracleScriptBase.s.sol";
+import { PendlePTAmortizedOracle } from "../src/oracles/vaults/PendlePTAmortizedOracle.sol";
+import { console2 } from "forge-std/console2.sol";
+
+/// @title DeployPendlePTAmortizedOracle
+/// @notice Deployment script for PendlePTAmortizedOracle - amortized cost pricing for Pendle PT positions
+/// @dev Deploys across multiple chains with deterministic addresses
+/// @dev Initially grants all roles to DEPLOYER for operational flexibility, then transfers to SUPER_GOVERNOR later
+contract DeployPendlePTAmortizedOracle is PendlePTAmortizedOracleScriptBase {
+    /*//////////////////////////////////////////////////////////////
+                            MAIN FUNCTIONS
+    //////////////////////////////////////////////////////////////*/
+
+    /// @notice Deploy PendlePTAmortizedOracle on a single chain
+    /// @dev Grants all roles (DEFAULT_ADMIN_ROLE, MANAGER_ROLE) to DEPLOYER
+    /// @param env Environment (0 = prod, 1 = vnet, 2 = staging)
+    /// @param chainId Chain ID to deploy on
+    /// @param branchName Branch name for vnet deployments (required when env == 1, ignored otherwise)
+    function run(uint256 env, uint64 chainId, string calldata branchName) external broadcast(env) {
+        _validateEnvAndBranchName(env, branchName);
+        // Use DEPLOYER as admin - will be transferred to SUPER_GOVERNOR_ADDRESS later
+        address admin = DEPLOYER;
+        _deploy(env, chainId, admin, branchName);
+    }
+
+    /// @notice Deploy PendlePTAmortizedOracle on multiple chains
+    /// @dev Grants all roles (DEFAULT_ADMIN_ROLE, MANAGER_ROLE) to DEPLOYER
+    /// @param env Environment (0 = prod, 1 = vnet, 2 = staging)
+    /// @param chainIds Array of chain IDs to deploy on
+    /// @param branchName Branch name for vnet deployments (required when env == 1, ignored otherwise)
+    function runMultiChain(uint256 env, uint64[] calldata chainIds, string calldata branchName) external broadcast(env) {
+        _validateEnvAndBranchName(env, branchName);
+        // Use DEPLOYER as admin - will be transferred to SUPER_GOVERNOR_ADDRESS later
+        address admin = DEPLOYER;
+
+        console2.log("====== Deploying PendlePTAmortizedOracle (Multi-Chain) ======");
+        console2.log("Environment:", env);
+        if (env == 1) {
+            console2.log("Branch Name:", branchName);
+        }
+        console2.log("Admin (DEPLOYER):", admin);
+        console2.log("Number of chains:", chainIds.length);
+        console2.log("");
+
+        for (uint256 i = 0; i < chainIds.length; i++) {
+            _deploy(env, chainIds[i], admin, branchName);
+            console2.log("");
+        }
+
+        console2.log("====== Multi-Chain Deployment Complete ======");
+    }
+
+    /// @notice Check if PendlePTAmortizedOracle is deployed
+    /// @param env Environment (0 = prod, 1 = vnet, 2 = staging)
+    /// @param chainId Chain ID to check
+    /// @param branchName Branch name for vnet deployments (required when env == 1, ignored otherwise)
+    function runCheck(uint256 env, uint64 chainId, string calldata branchName) external broadcast(env) {
+        _validateEnvAndBranchName(env, branchName);
+        _setBaseConfiguration(env, branchName);
+
+        // Check with DEPLOYER as admin (initial deployment)
+        address admin = DEPLOYER;
+
+        console2.log("====== PendlePTAmortizedOracle Deployment Check ======");
+        console2.log("Chain ID:", chainId);
+        console2.log("Environment:", env);
+        if (env == 1) {
+            console2.log("Branch Name:", branchName);
+        }
+        console2.log("Admin (DEPLOYER):", admin);
+        console2.log("SUPER_GOVERNOR_ADDRESS:", SUPER_GOVERNOR_ADDRESS);
+        console2.log("");
+
+        address oracleAddr = _computeOracleAddress(env, admin);
+        bool isDeployed = oracleAddr.code.length > 0;
+
+        console2.log("Computed address:", oracleAddr);
+        console2.log("Is deployed:", isDeployed);
+
+        if (isDeployed) {
+            PendlePTAmortizedOracle oracle = PendlePTAmortizedOracle(oracleAddr);
+            console2.log("");
+            console2.log("=== Oracle Role Status ===");
+            console2.log("DEPLOYER has DEFAULT_ADMIN_ROLE:", oracle.hasRole(oracle.DEFAULT_ADMIN_ROLE(), admin));
+            console2.log("DEPLOYER has MANAGER_ROLE:", oracle.hasRole(oracle.MANAGER_ROLE(), admin));
+            console2.log("");
+            console2.log("SUPER_GOVERNOR has DEFAULT_ADMIN_ROLE:", oracle.hasRole(oracle.DEFAULT_ADMIN_ROLE(), SUPER_GOVERNOR_ADDRESS));
+            console2.log("SUPER_GOVERNOR has MANAGER_ROLE:", oracle.hasRole(oracle.MANAGER_ROLE(), SUPER_GOVERNOR_ADDRESS));
+        }
+
+        console2.log("");
+        console2.log("====== Check Complete ======");
+    }
+
+    /*//////////////////////////////////////////////////////////////
+                          INTERNAL FUNCTIONS
+    //////////////////////////////////////////////////////////////*/
+
+    /// @notice Internal deployment function
+    /// @dev Grants all roles (DEFAULT_ADMIN_ROLE, MANAGER_ROLE) to admin
+    /// @param env Environment (0 = prod, 1 = vnet, 2 = staging)
+    /// @param chainId Chain ID to deploy on
+    /// @param admin Admin address (DEPLOYER)
+    /// @param branchName Branch name for vnet deployments
+    function _deploy(uint256 env, uint64 chainId, address admin, string calldata branchName) internal {
+        _setBaseConfiguration(env, branchName);
+
+        console2.log("====== Deploying PendlePTAmortizedOracle ======");
+        console2.log("Chain ID:", chainId);
+        console2.log("Environment:", env);
+        if (env == 1) {
+            console2.log("Branch Name:", branchName);
+        }
+        console2.log("Admin (DEPLOYER):", admin);
+        console2.log("");
+
+        // Validate inputs
+        require(admin != address(0), "INVALID_ADMIN");
+
+        // Get bytecode from generated artifacts
+        bytes memory bytecode = __getBytecode(ORACLE_KEY, env);
+        require(bytecode.length > 0, "BYTECODE_NOT_FOUND");
+
+        // Deploy - constructor grants DEFAULT_ADMIN_ROLE and MANAGER_ROLE to admin
+        address oracleAddr = __deployContract(
+            ORACLE_KEY,
+            chainId,
+            __getSalt(ORACLE_KEY),
+            abi.encodePacked(bytecode, abi.encode(admin))
+        );
+
+        // Verify deployment
+        PendlePTAmortizedOracle oracle = PendlePTAmortizedOracle(oracleAddr);
+        require(oracle.hasRole(oracle.DEFAULT_ADMIN_ROLE(), admin), "ADMIN_ROLE_MISMATCH");
+        require(oracle.hasRole(oracle.MANAGER_ROLE(), admin), "MANAGER_ROLE_MISMATCH");
+
+        console2.log("");
+        console2.log("=== Deployment Verification ===");
+        console2.log("PendlePTAmortizedOracle deployed at:", oracleAddr);
+        console2.log("Admin verified:", admin);
+        console2.log("Has DEFAULT_ADMIN_ROLE:", true);
+        console2.log("Has MANAGER_ROLE:", true);
+
+        // Write JSON output
+        _writeOracleJson(env, chainId, oracleAddr, branchName);
+
+        console2.log("");
+        console2.log("====== Deployment Complete ======");
+    }
+
+    /// @notice Merge PendlePTAmortizedOracle address into {ChainName}-latest.json
+    /// @param env Environment (0 = prod, 1 = vnet, 2 = staging)
+    /// @param chainId Chain ID
+    /// @param oracleAddr Deployed oracle address
+    /// @param branchName Branch name for vnet deployments
+    function _writeOracleJson(
+        uint256 env,
+        uint64 chainId,
+        address oracleAddr,
+        string calldata branchName
+    )
+        internal
+    {
+        string memory root = vm.projectRoot();
+        string memory envFolder;
+        if (env == 0) {
+            envFolder = "prod";
+        } else if (env == 1) {
+            envFolder = branchName;
+        } else {
+            envFolder = "staging";
+        }
+
+        string memory chainName = chainNames[chainId];
+        string memory outputFolder =
+            string(abi.encodePacked(root, "/script/output/", envFolder, "/", vm.toString(uint256(chainId)), "/"));
+
+        // Create directory if it doesn't exist
+        vm.createDir(outputFolder, true);
+
+        string memory outputPath = string(abi.encodePacked(outputFolder, chainName, "-latest.json"));
+
+        // Merge PendlePTAmortizedOracle address into existing JSON
+        // vm.writeJson with path selector will create file if it doesn't exist or update existing
+        vm.writeJson(vm.toString(oracleAddr), outputPath, ".PendlePTAmortizedOracle");
+
+        console2.log("");
+        console2.log("PendlePTAmortizedOracle merged into:", outputPath);
+    }
+}

script/DeploySuperVaultBatchOperator.s.sol

@@ -98,16 +98,6 @@ contract DeploySuperVaultBatchOperator is DeployV2Base {
         console2.log("====== Check Complete ======");
     }
 
-    /// @notice Validate environment and branchName combination
-    /// @param env Environment (0 = prod, 1 = vnet, 2 = staging)
-    /// @param branchName Branch name (required for vnet)
-    function _validateEnvAndBranchName(uint256 env, string calldata branchName) internal pure {
-        require(env == 0 || env == 1 || env == 2, "INVALID_ENV");
-        if (env == 1) {
-            require(bytes(branchName).length > 0, "BRANCH_NAME_REQUIRED_FOR_VNET");
-        }
-    }
-
     /// @notice Get operator address based on environment
     /// @param env Environment (0 = prod, 1 = vnet, 2 = staging)
     function _getOperatorForEnv(uint256 env) internal pure returns (address) {

script/DeployV2Base.s.sol

@@ -47,6 +47,20 @@ abstract contract DeployV2Base is Script, ConfigBase {
         }
     }
 
+    /*//////////////////////////////////////////////////////////////
+                          ENV VALIDATION
+    //////////////////////////////////////////////////////////////*/
+
+    /// @notice Validate environment and branchName combination
+    /// @param env Environment (0 = prod, 1 = vnet, 2 = staging)
+    /// @param branchName Branch name (required for vnet)
+    function _validateEnvAndBranchName(uint256 env, string calldata branchName) internal pure {
+        require(env == 0 || env == 1 || env == 2, "INVALID_ENV");
+        if (env == 1) {
+            require(bytes(branchName).length > 0, "BRANCH_NAME_REQUIRED_FOR_VNET");
+        }
+    }
+
     function _getContract(uint64 chainId, string memory contractName) internal view returns (address) {
         return contractAddresses[chainId][contractName];
     }

script/PendlePTAmortizedOracleScriptBase.s.sol

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity >=0.8.30;
+
+import { DeployV2Base } from "./DeployV2Base.s.sol";
+import { DeterministicDeployerLib } from "lib/v2-core/src/vendor/nexus/DeterministicDeployerLib.sol";
+
+/// @title PendlePTAmortizedOracleScriptBase
+/// @notice Shared base contract for PendlePTAmortizedOracle deployment and ownership scripts
+/// @dev Contains common constants and utility functions
+abstract contract PendlePTAmortizedOracleScriptBase is DeployV2Base {
+    /*//////////////////////////////////////////////////////////////
+                              CONSTANTS
+    //////////////////////////////////////////////////////////////*/
+
+    /// @notice Contract key for PendlePTAmortizedOracle
+    string internal constant ORACLE_KEY = "PendlePTAmortizedOracle";
+
+    /*//////////////////////////////////////////////////////////////
+                          INTERNAL FUNCTIONS
+    //////////////////////////////////////////////////////////////*/
+
+    /// @notice Compute the deterministic address for PendlePTAmortizedOracle
+    /// @param env Environment (0 = prod, 1 = vnet, 2 = staging)
+    /// @param admin Admin address used during deployment
+    /// @return The computed deterministic address
+    function _computeOracleAddress(uint256 env, address admin) internal view returns (address) {
+        bytes memory bytecode = __getBytecode(ORACLE_KEY, env);
+        require(bytecode.length > 0, "BYTECODE_NOT_FOUND");
+        return DeterministicDeployerLib.computeAddress(
+            abi.encodePacked(bytecode, abi.encode(admin)),
+            __getSalt(ORACLE_KEY)
+        );
+    }
+}