fix(deploy): accept the key in the shape wallets actually export it

The owner's first mainnet deploy attempt failed on this, and the error was
correct and useless: "vm.envUint: failed parsing $DEPLOYER_PRIVATE_KEY as type
uint256: missing hex prefix (0x)".

vm.envUint requires the prefix. MetaMask - the obvious place an operator gets
the key from - exports it WITHOUT one. So the first attempt fails on a
formatting detail unrelated to the deployment, after the operator has already
typed a private key into a terminal. That is the worst moment to make someone
retry blind, and the second worst to make them re-handle the key.

Read as a string and normalised now. Both shapes work; the key is never
logged, only its length is checked, and a wrong length is refused with a
message that says what is expected.

Everything before it in the trace had already passed, which is the part worth
noting: the governance quorum guard read getThreshold() = 2 and getOwners() =
3 owners off the owner's real Safe and let it through. The guard added earlier
today works against a real Safe on the real chain, not just a mock.

Tested all three shapes: 64 chars bare, 66 with 0x, and garbage refused.

Author: Sent-lab

contracts/script/Deploy.s.sol

@@ -56,7 +56,7 @@ contract Deploy is Script {
 
         _assertSafeForChain(config);
 
-        uint256 deployerKey = vm.envUint("DEPLOYER_PRIVATE_KEY");
+        uint256 deployerKey = _deployerKey();
 
         vm.startBroadcast(deployerKey);
 
@@ -137,6 +137,36 @@ contract Deploy is Script {
     ///      integration test legitimately runs with an EOA holding governance,
     ///      and a check that blocked that would only teach people to comment it
     ///      out — which is worse than not having it.
+    /**
+     * @dev The deployer key, with or without a `0x` prefix.
+     *
+     *      `vm.envUint` requires the prefix and fails with "missing hex prefix"
+     *      when it is absent. That is a correct error and a useless one: every
+     *      wallet this key comes out of exports it WITHOUT the prefix. MetaMask
+     *      does, and it is the obvious place an operator gets it from.
+     *
+     *      So the first attempt at a mainnet deploy fails on a formatting detail
+     *      that has nothing to do with the deployment, after the operator has
+     *      already typed a private key into a terminal — which is exactly the
+     *      moment to not make someone retry blind.
+     *
+     *      Read as a string and normalised instead. The key itself is never
+     *      logged; only its shape is checked.
+     */
+    function _deployerKey() internal view returns (uint256) {
+        string memory raw = vm.envString("DEPLOYER_PRIVATE_KEY");
+        bytes memory b = bytes(raw);
+
+        require(b.length == 64 || b.length == 66, "Deploy: DEPLOYER_PRIVATE_KEY must be 64 hex chars, 0x optional");
+
+        if (b.length == 66) {
+            require(b[0] == "0" && (b[1] == "x" || b[1] == "X"), "Deploy: 66-char key must start with 0x");
+            return vm.parseUint(raw);
+        }
+
+        return vm.parseUint(string.concat("0x", raw));
+    }
+
     function _assertSafeForChain(Config memory config) internal view {
         require(config.governance != address(0), "Deploy: governance is zero");
         require(config.treasury != address(0), "Deploy: treasury is zero");