@mapprotocol/common-contracts 0.3.1 → 0.4.0

package/README.md

@@ -12,7 +12,7 @@ npm install @mapprotocol/common-contracts
 
 ### BaseImplementation
 
-Abstract base for all upgradeable protocol contracts. Combines UUPS proxy, pausable, and access control in one inheritance.
+Abstract base for all upgradeable protocol contracts (UUPS + Pausable + AccessManaged).
 
 ```solidity
 import "@mapprotocol/common-contracts/contracts/base/BaseImplementation.sol";
@@ -24,12 +24,6 @@ contract MyContract is BaseImplementation {
 }
 ```
 
-**Includes:**
-- `UUPSUpgradeable` — proxy upgrade pattern
-- `PausableUpgradeable` — emergency pause via `trigger()`
-- `AccessManagedUpgradeable` — role-based function access
-- `getImplementation()` — read current implementation address
-
 ### AuthorityManager
 
 Extended `AccessManager` with enumerable role members. One instance per chain controls all protocol contracts.
@@ -38,82 +32,49 @@ Extended `AccessManager` with enumerable role members. One instance per chain co
 import "@mapprotocol/common-contracts/contracts/AuthorityManager.sol";
 ```
 
-**Key functions:**
-- `grantRole(roleId, account, delay)` — assign role
-- `revokeRole(roleId, account)` — remove role
-- `setTargetFunctionRole(target, selectors, roleId)` — restrict contract functions to a role
-- `getRoleMembers(roleId)` — list all members of a role
-
 ## TypeScript Utilities
 
-### Deployment
-
 ```typescript
-import { getDeploymentByKey, saveDeployment, resolveDeploymentEnv } from "@mapprotocol/common-contracts/utils/deployment";
-
-// Read deployed address (defaults to <cwd>/deployments/deploy.json)
-const addr = await getDeploymentByKey("Bsc", "Gateway");
-
-// With custom suffix and path
-const addr = await getDeploymentByKey("Bsc", "Gateway", { suffix: "main", basePath: "./my-deployments" });
-
-// Save deployment
-await saveDeployment("Bsc", "Gateway", "0x...");
+import { createDeployer } from "@mapprotocol/common-contracts/utils/deployer";
+import { getDeploymentByKey, saveDeployment } from "@mapprotocol/common-contracts/utils/deployRecord";
+import { TronClient, tronToHex, tronFromHex } from "@mapprotocol/common-contracts/utils/tronHelper";
+import { verify } from "@mapprotocol/common-contracts/utils/verifier";
+import { addressToHex } from "@mapprotocol/common-contracts/utils/addressCodec";
 ```
 
-### Tron Interaction
+### Quick Start
 
 ```typescript
-import { createTronWeb, tronDeploy, getTronContract, tronToHex, tronFromHex } from "@mapprotocol/common-contracts/utils/tronHelper";
-
-// Address conversion (pure, no RPC needed)
-const hex = tronToHex("TXyz...");        // -> "0x..."
-const base58 = tronFromHex("0x...");     // -> "TXyz..."
-
-// Deploy contract on Tron
-const tronWeb = createTronWeb({ rpcUrl: "https://api.trongrid.io", privateKey: "..." });
-const addr = await tronDeploy(tronWeb, artifacts, "MyContract", [arg1, arg2]);
-
-// Read-only (no privateKey needed)
-const readOnly = createTronWeb({ rpcUrl: "https://api.trongrid.io" });
-const contract = await getTronContract(readOnly, artifacts, "MyContract", addr);
+// Unified deployer — auto-routes EVM / Tron
+const deployer = createDeployer(hre, { autoVerify: true });
+let result = await deployer.deploy("Gateway", [bridge, owner, wtoken]);
+let proxy  = await deployer.deployProxy("Gateway", [admin]);
+
+// Deploy record
+const addr = getDeploymentByKey("Bsc", "Gateway", { env: "prod" });
+saveDeployment("Bsc", "Gateway", "0x...", { env: "prod" });
+
+// Tron client
+let client = TronClient.fromHre(hre);
+let gw = await client.getContract(hre.artifacts, "Gateway", addr);
+await gw.setWtoken(client.toHex(wtoken)).sendAndWait();
+let val = await gw.wToken().call();
 ```
 
-### Address Encoding
-
-```typescript
-import { addressToHex, isTronAddress, isSolanaChain } from "@mapprotocol/common-contracts/utils/addressCodec";
-
-// Auto-detect format and convert to hex
-addressToHex("0xAbC...");              // EVM -> lowercase hex
-addressToHex("TXyz...");              // Tron -> extract 20-byte address
-addressToHex("So11111...");           // Solana -> full base58 decode
-
-// Type checks
-isTronAddress("TXyz...");             // true (validates 0x41 prefix byte)
-isSolanaChain("Sol");                 // true
-```
+See JSDoc in each module's source for full API details and edge cases.
 
 ## Forge Script Base
 
-For monorepo projects, `script/Base.s.sol` provides deployment primitives:
-
 ```solidity
-import {BaseScript} from "../../common/script/Base.s.sol";
+import {BaseScript} from "@mapprotocol/common-contracts/script/base/Base.s.sol";
 
 contract MyDeploy is BaseScript {
     function run() public broadcast {
-        // CREATE2 factory deployment (deterministic address)
+        (address proxy, address impl) = deployProxy(type(MyContract).creationCode, initData);
         address addr = deployByFactory("my_salt", type(MyContract).creationCode, abi.encode(arg));
-
-        // Check factory availability
-        require(isFactoryAvailable(), "no factory on this chain");
-
-        // UUPS proxy upgrade
-        upgradeProxy(proxyAddr, newImplAddr);
-
-        // Deploy new impl + upgrade in one step
         deployAndUpgrade(proxyAddr, type(MyContractV2).creationCode);
+        address relay = readDeployment("Relay");
+        saveDeployment("Gateway", addr);
     }
 }
 ```
@@ -121,43 +82,12 @@ contract MyDeploy is BaseScript {
 ## Development
 
 ```bash
-# Build
-forge build                  # Foundry
-npm run build:hardhat        # Hardhat + TypeChain
-
-# Test
-forge test
-forge test --gas-report
-
-# Format
-forge fmt
-
-# Publish
-npm run prepublishOnly       # clean + build + typecheck
-npm publish
+forge build && forge test          # Solidity
+npm run build:hardhat              # Hardhat + TypeChain
+npm run build:utils                # TypeScript utilities
+npm run prepublishOnly && npm publish
 ```
 
-## Package Contents
-
-| Path | Description |
-|------|-------------|
-| `contracts/**/*.sol` | Solidity source files |
-| `artifacts/**/*.json` | Compiled ABI + bytecode |
-| `typechain-types/**/*` | TypeChain generated types |
-| `utils/*.ts` | Shared TypeScript utilities |
-
-## Requirements
-
-- Solidity ^0.8.20
-- Node.js >= 18
-- OpenZeppelin Contracts 5.4.0
-
 ## License
 
 MIT
-
-## Links
-
-- [Repository](https://github.com/mapprotocol/mapo-contracts-v2/tree/main/common)
-- [Issues](https://github.com/mapprotocol/mapo-contracts-v2/issues)
-- [MAP Protocol](https://mapprotocol.io)

package/package.json

@@ -1,15 +1,29 @@
 {
   "name": "@mapprotocol/common-contracts",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "Common contracts for MAP Protocol",
   "main": "typechain-types/index.js",
   "types": "typechain-types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./typechain-types/index.d.ts",
+      "default": "./typechain-types/index.js"
+    },
+    "./utils/*": {
+      "types": "./utils/dist/*.d.ts",
+      "default": "./utils/dist/*.js"
+    },
+    "./contracts/*": "./contracts/*",
+    "./script/*": "./script/*"
+  },
   "files": [
     "contracts/**/*.sol",
     "artifacts/contracts/**/*.json",
     "!artifacts/contracts/**/*.dbg.json",
     "typechain-types/**/*",
     "utils/**/*.ts",
+    "utils/dist/**/*",
+    "script/base/**/*.sol",
     "README.md"
   ],
   "repository": {
@@ -31,12 +45,13 @@
     "test": "forge test",
     "test:hardhat": "hardhat test",
     "format": "forge fmt",
-    "clean": "forge clean && hardhat clean && rm -rf typechain-types",
+    "build:utils": "cd utils && tsc",
+    "clean": "forge clean && hardhat clean && rm -rf typechain-types utils/dist",
     "compile": "hardhat compile",
     "typecheck": "tsc --noEmit",
     "gas-report": "forge test --gas-report",
     "coverage": "forge coverage",
-    "prepublishOnly": "npm run clean && npm run build:hardhat && npm run typecheck"
+    "prepublishOnly": "npm run clean && npm run build:hardhat && npm run build:utils && npm run typecheck"
   },
   "keywords": [
     "solidity",

package/script/base/Base.s.sol

@@ -0,0 +1,231 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import {Script, stdJson, console} from "forge-std/Script.sol";
+import {ERC1967Proxy} from "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol";
+import {IFactory} from "./interfaces/IFactory.sol";
+
+/**
+ * @title BaseScript
+ * @notice Base contract for deployment scripts with full lifecycle support
+ * @dev Inherit this in your deployment scripts.
+ *
+ * Features:
+ *   - Private key management (mainnet / testnet)
+ *   - Direct deployment and CREATE2 factory deployment
+ *   - Proxy deployment (implementation + ERC1967Proxy)
+ *   - UUPS proxy upgrade
+ *   - deploy.json record read/write
+ *
+ * Usage:
+ *   contract MyDeploy is BaseScript {
+ *       function run() public broadcast {
+ *           // Direct deploy
+ *           address impl = deployDirect(type(MyContract).creationCode, abi.encode(arg));
+ *
+ *           // Factory deploy (deterministic address)
+ *           address addr = deployByFactory("my_salt", type(MyContract).creationCode, abi.encode(arg));
+ *
+ *           // Proxy deploy (impl + proxy)
+ *           (address proxy, address impl) = deployProxy(type(MyContract).creationCode, initData);
+ *           (address proxy, address impl) = deployProxyByFactory("my_salt", type(MyContract).creationCode, initData);
+ *
+ *           // Upgrade
+ *           upgradeProxy(proxy, newImplAddr);
+ *           address newImpl = deployAndUpgrade(proxy, type(MyContractV2).creationCode);
+ *
+ *           // Deploy record
+ *           address relay = readDeployment("Relay");
+ *           saveDeployment("Gateway", addr);
+ *       }
+ *   }
+ */
+abstract contract BaseScript is Script {
+    IFactory constant private FACTORY = IFactory(0x6258e4d2950757A749a4d4683A7342261ce12471);
+    using stdJson for string;
+
+    address internal broadcaster;
+    uint256 private broadcasterPK;
+
+    constructor() {
+        uint256 privateKey;
+        if (block.chainid == 212) {
+            privateKey = vm.envUint("TESTNET_PRIVATE_KEY");
+        } else {
+            privateKey = vm.envUint("PRIVATE_KEY");
+        }
+        broadcaster = vm.addr(privateKey);
+        broadcasterPK = privateKey;
+    }
+
+    modifier broadcast() {
+        vm.startBroadcast(broadcasterPK);
+        _;
+        vm.stopBroadcast();
+    }
+
+    // ============================================================
+    // Factory (CREATE2) deployment
+    // ============================================================
+
+    /// @notice Deploy contract via CREATE2 factory with deterministic address
+    function deployByFactory(
+        string memory salt,
+        bytes memory creationCode,
+        bytes memory constructorArgs
+    ) internal returns (address addr) {
+        require(address(FACTORY).code.length > 0, "factory not deployed on this chain");
+        bytes32 saltHash = keccak256(bytes(salt));
+        addr = FACTORY.getAddress(saltHash);
+        if (addr.code.length > 0) revert("already deployed");
+        bytes memory code = abi.encodePacked(creationCode, constructorArgs);
+        FACTORY.deploy(saltHash, code, 0);
+    }
+
+    /// @notice Deploy implementation + proxy via CREATE2 factory
+    function deployProxyByFactory(
+        string memory salt,
+        bytes memory implCreationCode,
+        bytes memory initData
+    ) internal returns (address proxy, address impl) {
+        impl = deployDirect(implCreationCode, bytes(""));
+        proxy = deployByFactory(salt, type(ERC1967Proxy).creationCode, abi.encode(impl, initData));
+        console.log("Proxy:", proxy);
+        console.log("Implementation:", impl);
+    }
+
+    /// @notice Check if the CREATE2 factory is available on this chain
+    function isFactoryAvailable() internal view returns (bool) {
+        return address(FACTORY).code.length > 0;
+    }
+
+    /// @notice Get the predicted address for a given salt
+    function getFactoryAddress(string memory salt) internal view returns (address) {
+        require(isFactoryAvailable(), "factory not deployed on this chain");
+        return FACTORY.getAddress(keccak256(bytes(salt)));
+    }
+
+    /// @notice Check if a contract is already deployed at the factory address
+    function isFactoryDeployed(string memory salt) internal view returns (bool) {
+        if (!isFactoryAvailable()) return false;
+        return FACTORY.getAddress(keccak256(bytes(salt))).code.length > 0;
+    }
+
+    // ============================================================
+    // Direct deployment
+    // ============================================================
+
+    /// @notice Deploy a new contract directly (non-deterministic address)
+    function deployDirect(
+        bytes memory creationCode,
+        bytes memory constructorArgs
+    ) internal returns (address addr) {
+        bytes memory code = abi.encodePacked(creationCode, constructorArgs);
+        assembly {
+            addr := create(0, add(code, 0x20), mload(code))
+        }
+        require(addr != address(0), "deploy failed");
+    }
+
+    /// @notice Deploy implementation + proxy directly
+    function deployProxy(
+        bytes memory implCreationCode,
+        bytes memory initData
+    ) internal returns (address proxy, address impl) {
+        impl = deployDirect(implCreationCode, bytes(""));
+        ERC1967Proxy p = new ERC1967Proxy(impl, initData);
+        proxy = address(p);
+        console.log("Proxy:", proxy);
+        console.log("Implementation:", impl);
+    }
+
+    // ============================================================
+    // Upgrade
+    // ============================================================
+
+    /// @notice Upgrade a UUPS proxy to a new implementation
+    function upgradeProxy(address proxy, address newImpl) internal {
+        address oldImpl = _getImplementation(proxy);
+        (bool success,) = proxy.call(
+            abi.encodeWithSignature("upgradeToAndCall(address,bytes)", newImpl, bytes(""))
+        );
+        require(success, "upgrade failed");
+        console.log("Upgraded:", oldImpl, "->", newImpl);
+    }
+
+    /// @notice Deploy new implementation and upgrade proxy in one step
+    function deployAndUpgrade(address proxy, bytes memory implCreationCode) internal returns (address newImpl) {
+        newImpl = deployDirect(implCreationCode, bytes(""));
+        upgradeProxy(proxy, newImpl);
+    }
+
+    // ============================================================
+    // Deploy record (deploy.json) read/write
+    // ============================================================
+
+    /// @notice Read a deployed address from deployments/deploy.json
+    function readDeployment(string memory key) internal view returns (address) {
+        (string memory env, string memory chain) = _resolveDeploymentPath();
+        return _readDeploymentByPath(env, chain, key);
+    }
+
+    /// @notice Read a deployed address for a specific env and chain
+    function _readDeploymentByPath(string memory env, string memory chain, string memory key) internal view returns (address addr) {
+        string memory filePath = "deployments/deploy.json";
+        if (!vm.exists(filePath)) {
+            revert(string(abi.encodePacked("deploy.json not found: ", filePath)));
+        }
+        string memory json = vm.readFile(filePath);
+        // JSON path: .prod.Bsc.Gateway
+        string memory jsonPath = string(abi.encodePacked(".", env, ".", chain, ".", key));
+        addr = json.readAddress(jsonPath);
+    }
+
+    /// @notice Save a deployed address to deployments/deploy.json
+    function saveDeployment(string memory key, address addr) internal {
+        (string memory env, string memory chain) = _resolveDeploymentPath();
+        string memory filePath = "deployments/deploy.json";
+        // JSON path: .prod.Bsc.Gateway
+        string memory jsonPath = string(abi.encodePacked(".", env, ".", chain, ".", key));
+        string memory json = vm.readFile(filePath);
+        bool exists = vm.keyExistsJson(json, jsonPath);
+        if (!exists) {
+            revert(string(abi.encodePacked("key not found: ", env, ".", chain, ".", key)));
+        }
+        vm.writeJson(vm.toString(addr), filePath, jsonPath);
+    }
+
+    // ============================================================
+    // Internal helpers
+    // ============================================================
+
+    /// @notice Resolve deployment path (env, chain) based on chainId and NETWORK_ENV
+    /// @return env "prod", "main", or "test"
+    /// @return chain "Mapo", "Bsc", etc.
+    function _resolveDeploymentPath() internal view returns (string memory env, string memory chain) {
+        uint256 chainId = block.chainid;
+        env = vm.envString("NETWORK_ENV"); // required: test/prod/main
+
+        if (chainId == 212 || chainId == 22776) chain = "Mapo";
+        else if (chainId == 11155111 || chainId == 1) chain = "Eth";
+        else if (chainId == 97 || chainId == 56) chain = "Bsc";
+        else if (chainId == 8453) chain = "Base";
+        else if (chainId == 42161) chain = "Arb";
+        else if (chainId == 10) chain = "Op";
+        else if (chainId == 130) chain = "Uni";
+        else if (chainId == 137) chain = "Pol";
+        else if (chainId == 196) chain = "Xlayer";
+        else revert("unknown chain");
+    }
+
+    /// @notice Read current implementation address from a UUPS proxy
+    function _getImplementation(address proxy) internal view returns (address) {
+        (bool success, bytes memory data) = proxy.staticcall(
+            abi.encodeWithSignature("getImplementation()")
+        );
+        if (success && data.length == 32) {
+            return abi.decode(data, (address));
+        }
+        return address(0);
+    }
+}

package/script/base/interfaces/IFactory.sol

@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+interface IFactory {
+    function getAddress(bytes32 salt) external view returns (address);
+    function deploy(bytes32 salt, bytes memory creationCode, uint256 value) external;
+}

package/utils/deployer.ts

@@ -13,12 +13,17 @@ import { verify as _verify } from "./verifier";
  */
 
 export interface DeployerOptions {
-    autoVerify?: boolean;   // auto verify after deploy/upgrade, defaults to false
+    /**
+     * Auto-verify contracts after deploy/upgrade.
+     * Failures are logged as warnings, never thrown — call deployer.verify() for explicit error handling.
+     * Defaults to false.
+     */
+    autoVerify?: boolean;
 }
 
 export interface DeployResult {
-    address: string;       // primary address (0x hex for EVM, base58 for Tron)
-    hex?: string;          // 0x hex (Tron only, EVM same as address)
+    address: string;       // EVM: 0x hex address. Tron: base58 (T...) address.
+    hex?: string;          // Tron only: 0x hex address. Undefined on EVM.
 }
 
 export interface DeployProxyResult {
@@ -29,9 +34,16 @@ export interface DeployProxyResult {
 }
 
 export interface Deployer {
+    /**
+     * Deploy a contract.
+     * @param contractName - artifact name
+     * @param args - constructor arguments as raw values
+     * @param salt - "" or omitted = direct deploy; non-empty string = CREATE2 factory (deterministic address)
+     */
     deploy(contractName: string, args?: any[], salt?: string): Promise<DeployResult>;
     deployProxy(contractName: string, initArgs?: any[], salt?: string): Promise<DeployProxyResult>;
     upgrade(contractName: string, proxyAddr: string): Promise<DeployResult>;
+    /** Verify explicitly (throws on failure, unlike autoVerify which only warns). */
     verify(contractName: string, address: string, constructorArgs?: any[], contractPath?: string): Promise<void>;
     isTron: boolean;
     network: string;

package/utils/dist/addressCodec.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Convert any address format to hex bytes.
+ * - EVM address (0x prefix): return as-is lowercase
+ * - Tron address (T prefix, 34 chars, 0x41 byte): convert via tronToHex
+ * - Solana/other base58 address: base58 decode to full bytes
+ * @param addr - address in any supported format
+ */
+export declare function addressToHex(addr: string): string;
+/** Check if a string is valid base58 encoding. */
+export declare function isBase58(addr: string): boolean;
+/** Check if address is Tron format (T prefix, 34 chars, 0x41 first byte after decode). */
+export declare function isTronAddress(addr: string): boolean;
+/** Check if chain name is Solana. */
+export declare function isSolanaChain(chainName: string): boolean;

package/utils/dist/addressCodec.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addressToHex = addressToHex;
+exports.isBase58 = isBase58;
+exports.isTronAddress = isTronAddress;
+exports.isSolanaChain = isSolanaChain;
+/**
+ * Multi-chain address encoding — converts EVM, Tron, and Solana addresses to hex bytes.
+ */
+const bs58_1 = __importDefault(require("bs58"));
+const tronHelper_1 = require("./tronHelper");
+/**
+ * Convert any address format to hex bytes.
+ * - EVM address (0x prefix): return as-is lowercase
+ * - Tron address (T prefix, 34 chars, 0x41 byte): convert via tronToHex
+ * - Solana/other base58 address: base58 decode to full bytes
+ * @param addr - address in any supported format
+ */
+function addressToHex(addr) {
+    if (addr.startsWith("0x")) {
+        return addr.toLowerCase();
+    }
+    if (isTronAddress(addr)) {
+        return (0, tronHelper_1.tronToHex)(addr);
+    }
+    if (isBase58(addr)) {
+        const decoded = bs58_1.default.decode(addr);
+        return "0x" + Buffer.from(decoded).toString("hex");
+    }
+    throw new Error(`Unknown address format: ${addr}`);
+}
+/** Check if a string is valid base58 encoding. */
+function isBase58(addr) {
+    const base58Chars = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+    for (const char of addr) {
+        if (!base58Chars.includes(char)) {
+            return false;
+        }
+    }
+    return true;
+}
+/** Check if address is Tron format (T prefix, 34 chars, 0x41 first byte after decode). */
+function isTronAddress(addr) {
+    if (!addr.startsWith("T") || addr.length !== 34 || !isBase58(addr))
+        return false;
+    try {
+        const decoded = bs58_1.default.decode(addr);
+        // Tron: 0x41 (1 byte) + address (20 bytes) + checksum (4 bytes) = 25 bytes
+        return decoded.length === 25 && decoded[0] === 0x41;
+    }
+    catch {
+        return false;
+    }
+}
+/** Check if chain name is Solana. */
+function isSolanaChain(chainName) {
+    return chainName === "Sol" || chainName === "sol_test";
+}

package/utils/dist/codeHash.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Get codeHash for a contract deployment.
+ * @param artifacts - hardhat artifacts (hre.artifacts)
+ * @param contractName - contract name (e.g. "Gateway", "AuthorityManager")
+ * @param args - constructor arguments array
+ */
+export declare function getCodeHash(artifacts: any, contractName: string, args?: any[]): Promise<string>;
+/**
+ * Get codeHash for an ERC1967Proxy deployment.
+ * @param artifacts - hardhat artifacts (hre.artifacts)
+ * @param implAddress - implementation address
+ * @param implName - implementation contract name (for encoding initData)
+ * @param initArgs - arguments for initialize() function
+ */
+export declare function getProxyCodeHash(artifacts: any, implAddress: string, implName: string, initArgs?: any[]): Promise<string>;
+/**
+ * Get codeHash for a custom proxy deployment.
+ * @param artifacts - hardhat artifacts (hre.artifacts)
+ * @param proxyName - proxy contract name (e.g. "MyCustomProxy")
+ * @param implAddress - implementation address
+ * @param implName - implementation contract name (for encoding initData)
+ * @param initArgs - arguments for initialize() function
+ */
+export declare function getCustomProxyCodeHash(artifacts: any, proxyName: string, implAddress: string, implName: string, initArgs?: any[]): Promise<string>;

package/utils/dist/codeHash.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCodeHash = getCodeHash;
+exports.getProxyCodeHash = getProxyCodeHash;
+exports.getCustomProxyCodeHash = getCustomProxyCodeHash;
+/**
+ * Calculate creationCode hash for CREATE2 address prediction.
+ */
+const { keccak256, Interface } = require("ethers");
+/**
+ * Get codeHash for a contract deployment.
+ * @param artifacts - hardhat artifacts (hre.artifacts)
+ * @param contractName - contract name (e.g. "Gateway", "AuthorityManager")
+ * @param args - constructor arguments array
+ */
+async function getCodeHash(artifacts, contractName, args = []) {
+    const artifact = await artifacts.readArtifact(contractName);
+    let bytecode = artifact.bytecode;
+    if (!bytecode.startsWith("0x"))
+        bytecode = "0x" + bytecode;
+    if (args.length > 0) {
+        const iface = new Interface(artifact.abi);
+        const encoded = iface.encodeDeploy(args);
+        return keccak256(bytecode + encoded.slice(2));
+    }
+    return keccak256(bytecode);
+}
+/**
+ * Get codeHash for an ERC1967Proxy deployment.
+ * @param artifacts - hardhat artifacts (hre.artifacts)
+ * @param implAddress - implementation address
+ * @param implName - implementation contract name (for encoding initData)
+ * @param initArgs - arguments for initialize() function
+ */
+async function getProxyCodeHash(artifacts, implAddress, implName, initArgs = []) {
+    return getCustomProxyCodeHash(artifacts, "ERC1967Proxy", implAddress, implName, initArgs);
+}
+/**
+ * Get codeHash for a custom proxy deployment.
+ * @param artifacts - hardhat artifacts (hre.artifacts)
+ * @param proxyName - proxy contract name (e.g. "MyCustomProxy")
+ * @param implAddress - implementation address
+ * @param implName - implementation contract name (for encoding initData)
+ * @param initArgs - arguments for initialize() function
+ */
+async function getCustomProxyCodeHash(artifacts, proxyName, implAddress, implName, initArgs = []) {
+    const proxyArtifact = await artifacts.readArtifact(proxyName);
+    let bytecode = proxyArtifact.bytecode;
+    if (!bytecode.startsWith("0x"))
+        bytecode = "0x" + bytecode;
+    let initData = "0x";
+    if (initArgs.length > 0) {
+        const implArtifact = await artifacts.readArtifact(implName);
+        const iface = new Interface(implArtifact.abi);
+        initData = iface.encodeFunctionData("initialize", initArgs);
+    }
+    const { AbiCoder } = require("ethers");
+    const constructorArgs = AbiCoder.defaultAbiCoder().encode(["address", "bytes"], [implAddress, initData]);
+    return keccak256(bytecode + constructorArgs.slice(2));
+}