@sentrix-labs/canonical-contracts 1.1.0

package/contracts/StrategicReserveTimelock.sol

@@ -0,0 +1,104 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity 0.8.24;
+
+import {TimelockController} from "@openzeppelin/contracts/governance/TimelockController.sol";
+
+/// @title StrategicReserveTimelock
+/// @author Sentrix Labs
+/// @notice Holds the Strategic Reserve (10,500,000 SRX) under enforced
+///         timelock. Spends require: SentrixSafe schedules a call → wait
+///         minDelay → SentrixSafe executes.
+/// @dev Thin wrapper over OpenZeppelin's audited TimelockController v5.6.0
+///      (battle-tested in Compound governance, holds $billions). No
+///      custom logic — just constructor that hardcodes Sentrix
+///      configuration:
+///      - minDelay = 24 hours (86400 seconds)
+///      - proposer = SentrixSafe (Authority signer required to schedule)
+///      - executor = SentrixSafe (Authority signer required to execute
+///        post-delay)
+///      - canceller = SentrixSafe (can cancel pending ops)
+///      - admin = address(0) — fully self-administered. Role changes
+///        themselves go through the timelock.
+///
+///      Migration flow (one-time):
+///      1. Deploy this contract.
+///      2. Transfer Strategic Reserve EOA balance (10.5M SRX) to this
+///         contract address.
+///      3. Reserve EOA private key is retired (zero out, never reuse).
+///
+///      Spend flow (recurring):
+///      1. SentrixSafe calls schedule(target, value, data, predecessor,
+///         salt, delay) — operation queued.
+///      2. Wait at least minDelay (24h).
+///      3. SentrixSafe calls execute(target, value, data, predecessor,
+///         salt) — operation runs.
+///      4. Optional: cancel(id) before delay elapses if mistake/coercion
+///         detected.
+///
+///      Cancel flow (operator safety):
+///      - 24-hour window between schedule + execute lets operator catch
+///        wrong amounts, recipients, or proposed-under-coercion spends
+///        and cancel before damage.
+contract StrategicReserveTimelock is TimelockController {
+    /// @notice Construct the timelock with Sentrix's standard config.
+    /// @param sentrixSafe The SentrixSafe address (mainnet
+    ///        0x6272dC0C842F05542f9fF7B5443E93C0642a3b26 / testnet
+    ///        0xc9D7a61D7C2F428F6A055916488041fD00532110). Granted
+    ///        proposer + executor + canceller roles.
+    constructor(address sentrixSafe)
+        TimelockController(
+            // minDelay: 24 hours. Operations cannot be scheduled with
+            // a shorter delay than this — and only the timelock itself
+            // (via timelocked proposal) can change the minDelay.
+            86400,
+            // proposers: SentrixSafe is the only address authorized to
+            // schedule new spend operations.
+            _singletonArray(sentrixSafe),
+            // executors: SentrixSafe is the only address authorized to
+            // execute scheduled operations after the delay elapses.
+            // We deliberately do NOT pass address(0) (which would let
+            // anyone execute) — this keeps the audit trail clean
+            // (every execution is via SentrixSafe execTransaction).
+            _singletonArray(sentrixSafe),
+            // admin: address(0) means no admin role. Role changes go
+            // through timelock itself (proposed, delayed, executed).
+            // This prevents anyone — including the deployer — from
+            // bypassing the timelock to grant new roles.
+            address(0)
+        )
+    {}
+
+    /// @dev Helper: build a single-element address array for the
+    ///      TimelockController constructor.
+    function _singletonArray(address addr)
+        private
+        pure
+        returns (address[] memory)
+    {
+        address[] memory arr = new address[](1);
+        arr[0] = addr;
+        return arr;
+    }
+
+    // Inherits from TimelockController:
+    // - schedule(target, value, data, predecessor, salt, delay)
+    // - scheduleBatch(targets, values, payloads, predecessor, salt, delay)
+    // - execute(target, value, data, predecessor, salt)
+    // - executeBatch(targets, values, payloads, predecessor, salt)
+    // - cancel(id)
+    // - getOperationState(id)
+    // - hasRole(role, account)
+    // - All standard AccessControl methods
+    // - receive() to accept native SRX
+
+    // No custom logic. All security properties come from OZ
+    // TimelockController v5.6.0:
+    // - Time-lock enforcement (operation cannot execute before
+    //   readyTimestamp = scheduleTimestamp + delay)
+    // - Role-based access (only PROPOSER can schedule, only EXECUTOR
+    //   can execute, only CANCELLER can cancel)
+    // - Self-administration (role changes go through timelock)
+    // - Reentrancy-safe (uses internal _execute)
+    // - Predecessor support (operations can require another op to be
+    //   done first, for atomic multi-step flows)
+}

package/contracts/TokenFactory.sol

@@ -0,0 +1,106 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity 0.8.24;
+
+/// @title Sentrix TokenFactory
+/// @author Sentrix Labs
+/// @notice Deploys standard ERC-20 tokens. Single entry point for builders
+///         who want a fungible token without writing Solidity. Initial
+///         supply is minted to the deployer (`msg.sender`).
+/// @dev Tracks deployed-token-by-deployer to make discovery easy.
+contract TokenFactory {
+    event TokenDeployed(address indexed token, address indexed owner, string name, string symbol, uint256 initialSupply);
+
+    /// @dev Caps name/symbol bytes to prevent gas-grief deploys with megabyte
+    ///      strings. Standard ERC20 metadata fits comfortably under both caps.
+    uint256 public constant MAX_NAME_LENGTH = 64;
+    uint256 public constant MAX_SYMBOL_LENGTH = 16;
+
+    mapping(address => address[]) public deployedTokens;
+
+    function deployToken(string calldata name, string calldata symbol, uint256 initialSupply) external returns (address token) {
+        // Reject silly inputs early — a zero-supply or empty-name token is
+        // never useful and burns gas for everyone indexing the event log.
+        require(initialSupply > 0, "TokenFactory: ZERO_SUPPLY");
+        require(bytes(name).length > 0 && bytes(name).length <= MAX_NAME_LENGTH, "TokenFactory: BAD_NAME");
+        require(bytes(symbol).length > 0 && bytes(symbol).length <= MAX_SYMBOL_LENGTH, "TokenFactory: BAD_SYMBOL");
+
+        FactoryToken t = new FactoryToken(name, symbol, initialSupply, msg.sender);
+        token = address(t);
+        deployedTokens[msg.sender].push(token);
+        emit TokenDeployed(token, msg.sender, name, symbol, initialSupply);
+    }
+
+    function tokensOf(address owner) external view returns (address[] memory) {
+        return deployedTokens[owner];
+    }
+
+    function tokenCount(address owner) external view returns (uint256) {
+        return deployedTokens[owner].length;
+    }
+}
+
+/// @notice Minimal ERC-20 deployed by the factory.
+contract FactoryToken {
+    string public name;
+    string public symbol;
+    uint8 public constant decimals = 18;
+    uint256 public totalSupply;
+
+    mapping(address => uint256) public balanceOf;
+    mapping(address => mapping(address => uint256)) public allowance;
+
+    event Transfer(address indexed from, address indexed to, uint256 value);
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+
+    constructor(string memory _name, string memory _symbol, uint256 _initialSupply, address _owner) {
+        // Defense-in-depth: TokenFactory always passes msg.sender so this
+        // can't trigger via the factory path, but a direct deploy with
+        // _owner=0 would trap the entire supply in the zero address. Reject.
+        require(_owner != address(0), "FactoryToken: OWNER_ZERO");
+        name = _name;
+        symbol = _symbol;
+        totalSupply = _initialSupply;
+        balanceOf[_owner] = _initialSupply;
+        emit Transfer(address(0), _owner, _initialSupply);
+    }
+
+    function transfer(address to, uint256 amount) external returns (bool) {
+        return _transfer(msg.sender, to, amount);
+    }
+
+    function approve(address spender, uint256 amount) external returns (bool) {
+        allowance[msg.sender][spender] = amount;
+        emit Approval(msg.sender, spender, amount);
+        return true;
+    }
+
+    function transferFrom(address from, address to, uint256 amount) external returns (bool) {
+        if (from != msg.sender) {
+            uint256 allowed = allowance[from][msg.sender];
+            if (allowed != type(uint256).max) {
+                require(allowed >= amount, "FactoryToken: insufficient allowance");
+                uint256 remaining = allowed - amount;
+                allowance[from][msg.sender] = remaining;
+                // OZ-style: emit Approval on each spend so indexers tracking
+                // allowance state changes (e.g. CoinGecko / explorer ABI
+                // decoders) see the new value without re-reading storage.
+                emit Approval(from, msg.sender, remaining);
+            }
+        }
+        return _transfer(from, to, amount);
+    }
+
+    function _transfer(address from, address to, uint256 amount) internal returns (bool) {
+        // ERC-20 spec says transfers to address(0) are not standard burns —
+        // most token contracts revert. Be explicit so wallets that show a
+        // failed tx instead of an unexpected `Transfer(... 0x0 ...)` log.
+        require(to != address(0), "FactoryToken: TO_ZERO");
+        require(balanceOf[from] >= amount, "FactoryToken: insufficient balance");
+        unchecked {
+            balanceOf[from] -= amount;
+            balanceOf[to] += amount;
+        }
+        emit Transfer(from, to, amount);
+        return true;
+    }
+}

package/contracts/WSRX.sol

@@ -0,0 +1,95 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity 0.8.24;
+
+/// @title Wrapped SRX
+/// @author Sentrix Labs
+/// @notice Wraps native SRX into an ERC-20 token (18 decimals at the EVM
+///         boundary). 1 SRX = 10^10 wei due to native ledger using 8
+///         decimals; conversion is handled by the EVM database adapter,
+///         so `msg.value` here is already the wei amount and `wad` minted
+///         equals `msg.value` 1:1.
+/// @dev Standard wrapped-token pattern (mirror of WETH9). Self-contained,
+///      no external imports - keeps the canonical-contracts repo
+///      dependency-free. Compiles with solc 0.8.24, no SafeMath needed.
+contract WSRX {
+    string public constant name = "Wrapped SRX";
+    string public constant symbol = "WSRX";
+    uint8 public constant decimals = 18;
+
+    uint256 public totalSupply;
+
+    mapping(address => uint256) public balanceOf;
+    mapping(address => mapping(address => uint256)) public allowance;
+
+    event Transfer(address indexed src, address indexed dst, uint256 wad);
+    event Approval(address indexed src, address indexed guy, uint256 wad);
+    event Deposit(address indexed dst, uint256 wad);
+    event Withdrawal(address indexed src, uint256 wad);
+
+    /// @notice Wrap native SRX 1:1 into WSRX by sending value to this contract.
+    receive() external payable {
+        deposit();
+    }
+
+    /// @notice Wrap `msg.value` native SRX 1:1 into WSRX credited to caller.
+    function deposit() public payable {
+        balanceOf[msg.sender] += msg.value;
+        totalSupply += msg.value;
+        emit Deposit(msg.sender, msg.value);
+        emit Transfer(address(0), msg.sender, msg.value);
+    }
+
+    /// @notice Burn `wad` WSRX and return native SRX to caller.
+    /// @param wad Amount in wei (18-decimal). Must not exceed caller's balance.
+    function withdraw(uint256 wad) external {
+        require(balanceOf[msg.sender] >= wad, "WSRX: insufficient balance");
+        balanceOf[msg.sender] -= wad;
+        totalSupply -= wad;
+        (bool ok, ) = msg.sender.call{value: wad}("");
+        require(ok, "WSRX: native transfer failed");
+        emit Withdrawal(msg.sender, wad);
+        emit Transfer(msg.sender, address(0), wad);
+    }
+
+    /// @notice Approve `guy` to spend up to `wad` of caller's WSRX.
+    /// @param guy Spender.
+    /// @param wad Allowance in wei. Pass `type(uint256).max` for infinite allowance.
+    /// @return Always true on success (matches ERC-20 spec).
+    function approve(address guy, uint256 wad) external returns (bool) {
+        allowance[msg.sender][guy] = wad;
+        emit Approval(msg.sender, guy, wad);
+        return true;
+    }
+
+    /// @notice Transfer `wad` WSRX to `dst`.
+    /// @param dst Recipient.
+    /// @param wad Amount in wei.
+    /// @return Always true on success.
+    function transfer(address dst, uint256 wad) external returns (bool) {
+        return _transferFrom(msg.sender, dst, wad);
+    }
+
+    /// @notice Transfer `wad` WSRX from `src` to `dst` using caller's allowance.
+    /// @param src Token holder.
+    /// @param dst Recipient.
+    /// @param wad Amount in wei.
+    /// @return Always true on success.
+    function transferFrom(address src, address dst, uint256 wad) external returns (bool) {
+        if (src != msg.sender) {
+            uint256 allowed = allowance[src][msg.sender];
+            if (allowed != type(uint256).max) {
+                require(allowed >= wad, "WSRX: insufficient allowance");
+                allowance[src][msg.sender] = allowed - wad;
+            }
+        }
+        return _transferFrom(src, dst, wad);
+    }
+
+    function _transferFrom(address src, address dst, uint256 wad) internal returns (bool) {
+        require(balanceOf[src] >= wad, "WSRX: insufficient balance");
+        balanceOf[src] -= wad;
+        balanceOf[dst] += wad;
+        emit Transfer(src, dst, wad);
+        return true;
+    }
+}

package/contracts/interfaces/ISentrixSafe.sol

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity 0.8.24;
+
+/// @title ISentrixSafe
+/// @author Sentrix Labs
+/// @notice Minimal multi-signature wallet interface. Owners sign tx hashes
+///         off-chain; on-chain `execTransaction` verifies threshold + nonce.
+interface ISentrixSafe {
+    event ExecutionSuccess(bytes32 indexed txHash, uint256 nonce);
+    event ExecutionFailure(bytes32 indexed txHash, uint256 nonce);
+    event AddedOwner(address indexed owner);
+    event RemovedOwner(address indexed owner);
+    event ChangedThreshold(uint256 threshold);
+
+    function threshold() external view returns (uint256);
+    function nonce() external view returns (uint256);
+    function isOwner(address owner) external view returns (bool);
+    function getOwners() external view returns (address[] memory);
+
+    /// @notice Execute a tx with `threshold` signatures.
+    /// @param to Target address.
+    /// @param value Native value (wei) to send.
+    /// @param data Calldata.
+    /// @param operation 0 = call, 1 = delegatecall.
+    /// @param signatures Concatenated 65-byte ECDSA signatures, sorted by signer ascending.
+    /// @return success True if the execution succeeded.
+    function execTransaction(
+        address to,
+        uint256 value,
+        bytes calldata data,
+        uint256 operation,
+        bytes calldata signatures
+    ) external returns (bool success);
+
+    function getTransactionHash(
+        address to,
+        uint256 value,
+        bytes calldata data,
+        uint256 operation,
+        uint256 _nonce
+    ) external view returns (bytes32);
+}

package/contracts/interfaces/ITokenFactory.sol

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity 0.8.24;
+
+/// @title ITokenFactory
+/// @author Sentrix Labs
+/// @notice Deploys minimal ERC-20 tokens. One-call factory; emits TokenDeployed.
+interface ITokenFactory {
+    event TokenDeployed(
+        address indexed token,
+        address indexed owner,
+        string name,
+        string symbol,
+        uint256 initialSupply
+    );
+
+    /// @notice Deploy a new ERC-20 with `initialSupply` minted to caller.
+    /// @return token Address of the new ERC-20 contract.
+    function deployToken(string calldata name, string calldata symbol, uint256 initialSupply)
+        external
+        returns (address token);
+
+    /// @notice Returns all tokens deployed by `owner`.
+    function tokensOf(address owner) external view returns (address[] memory);
+
+    /// @notice Number of tokens deployed by `owner`.
+    function tokenCount(address owner) external view returns (uint256);
+}

package/contracts/interfaces/IWSRX.sol

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity 0.8.24;
+
+/// @title IWSRX
+/// @author Sentrix Labs
+/// @notice Wrapped SRX interface — wrap/unwrap native SRX into a 1:1 ERC-20.
+interface IWSRX {
+    event Transfer(address indexed src, address indexed dst, uint256 wad);
+    event Approval(address indexed src, address indexed guy, uint256 wad);
+    event Deposit(address indexed dst, uint256 wad);
+    event Withdrawal(address indexed src, uint256 wad);
+
+    function name() external view returns (string memory);
+    function symbol() external view returns (string memory);
+    function decimals() external view returns (uint8);
+    function totalSupply() external view returns (uint256);
+    function balanceOf(address owner) external view returns (uint256);
+    function allowance(address owner, address spender) external view returns (uint256);
+
+    /// @notice Wrap native SRX 1:1 into WSRX.
+    function deposit() external payable;
+
+    /// @notice Burn WSRX, return native SRX.
+    /// @param wad Amount in wei (18-dec).
+    function withdraw(uint256 wad) external;
+
+    function approve(address guy, uint256 wad) external returns (bool);
+    function transfer(address dst, uint256 wad) external returns (bool);
+    function transferFrom(address src, address dst, uint256 wad) external returns (bool);
+}

package/contracts/mocks/MockERC20.sol

@@ -0,0 +1,60 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity 0.8.24;
+
+/// @title MockERC20
+/// @author Sentrix Labs
+/// @notice Test-only ERC-20 with public mint. Use only in test/.
+contract MockERC20 {
+    string public name;
+    string public symbol;
+    uint8 public immutable decimals;
+    uint256 public totalSupply;
+
+    mapping(address => uint256) public balanceOf;
+    mapping(address => mapping(address => uint256)) public allowance;
+
+    event Transfer(address indexed from, address indexed to, uint256 value);
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+
+    constructor(string memory _name, string memory _symbol, uint8 _decimals) {
+        name = _name;
+        symbol = _symbol;
+        decimals = _decimals;
+    }
+
+    /// @notice Test helper: mint to any address. NEVER use in prod.
+    function mint(address to, uint256 amount) external {
+        balanceOf[to] += amount;
+        totalSupply += amount;
+        emit Transfer(address(0), to, amount);
+    }
+
+    function transfer(address to, uint256 amount) external returns (bool) {
+        return _transfer(msg.sender, to, amount);
+    }
+
+    function approve(address spender, uint256 amount) external returns (bool) {
+        allowance[msg.sender][spender] = amount;
+        emit Approval(msg.sender, spender, amount);
+        return true;
+    }
+
+    function transferFrom(address from, address to, uint256 amount) external returns (bool) {
+        if (from != msg.sender) {
+            uint256 allowed = allowance[from][msg.sender];
+            if (allowed != type(uint256).max) {
+                require(allowed >= amount, "MockERC20: insufficient allowance");
+                allowance[from][msg.sender] = allowed - amount;
+            }
+        }
+        return _transfer(from, to, amount);
+    }
+
+    function _transfer(address from, address to, uint256 amount) internal returns (bool) {
+        require(balanceOf[from] >= amount, "MockERC20: insufficient balance");
+        balanceOf[from] -= amount;
+        balanceOf[to] += amount;
+        emit Transfer(from, to, amount);
+        return true;
+    }
+}

package/contracts/mocks/MockSRX.sol

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity 0.8.24;
+
+/// @title MockSRX
+/// @author Sentrix Labs
+/// @notice Test-only payable contract that simulates a native-SRX holder.
+///         Lets tests send native value into and out of a known contract
+///         without involving the real chain. Use only in test/.
+contract MockSRX {
+    event Received(address indexed from, uint256 amount);
+    event Forwarded(address indexed to, uint256 amount);
+
+    receive() external payable {
+        emit Received(msg.sender, msg.value);
+    }
+
+    /// @notice Forward held native SRX to `to`. Test helper only.
+    function forward(address payable to, uint256 amount) external {
+        require(address(this).balance >= amount, "MockSRX: insufficient");
+        (bool ok, ) = to.call{value: amount}("");
+        require(ok, "MockSRX: forward failed");
+        emit Forwarded(to, amount);
+    }
+
+    function balance() external view returns (uint256) {
+        return address(this).balance;
+    }
+}

package/deployments/7119.json

@@ -0,0 +1,75 @@
+{
+  "_chainId": 7119,
+  "_network": "Sentrix Mainnet",
+  "_note": "Canonical contracts deployed via cast send --create with explicit --nonce per call (forge script forking blocked by Sentrix RPC strict-decode of sha3Uncles; mainnet mempool also enforces strict sequential nonce admission, so each broadcast waited for the prior to mine before sending). Deployer: 0x5acb04058fc4dfa258f29ce318282377cac176fd.",
+  "WSRX": {
+    "address": "0x4693b113e523A196d9579333c4ab8358e2656553",
+    "tx": "0xc5b5016338ba2de65ebb631374724bcc33db63b9a570e77d455d896b40f103fb",
+    "block": 716787,
+    "deployer": "0x5acb04058fc4dfa258f29ce318282377cac176fd",
+    "deployer_nonce": 0,
+    "deployed_at": "2026-04-27"
+  },
+  "Multicall3": {
+    "address": "0xFd4b34b5763f54a580a0d9f7997A2A993ef9ceE9",
+    "tx": "0x64633e100f952d845970590fda32786118cf5e6b29b56c281d8d1e4b8e889f0a",
+    "block": 717078,
+    "deployer": "0x5acb04058fc4dfa258f29ce318282377cac176fd",
+    "deployer_nonce": 1,
+    "deployed_at": "2026-04-27",
+    "_note": "Plain CREATE for v1; canonical CREATE2 address 0xcA11bde05977b3631167028862bE2a173976CA11 not used yet."
+  },
+  "TokenFactory": {
+    "address": "0xc753199b723649ab92c6db8A45F158921CFDEe49",
+    "tx": "0xfda6219d60219e223d049158bca734d77e475c0b6b0c02074beeba0c701be112",
+    "block": 717392,
+    "deployer": "0x5acb04058fc4dfa258f29ce318282377cac176fd",
+    "deployer_nonce": 2,
+    "deployed_at": "2026-04-27"
+  },
+  "SentrixSafe": {
+    "address": "0x6272dC0C842F05542f9fF7B5443E93C0642a3b26",
+    "tx": "0xc67fb31dd135051732a41530e26897fb7c10eaec1fc6cb9334b596073758cb0f",
+    "block": 717618,
+    "deployer": "0x5acb04058fc4dfa258f29ce318282377cac176fd",
+    "deployer_nonce": 3,
+    "deployed_at": "2026-04-27",
+    "owners": [
+      "0x5acb04058fc4dfa258f29ce318282377cac176fd"
+    ],
+    "threshold": 1,
+    "_note": "Bootstrap-mode 1-of-1 with deployer as owner. Transfer to operator multisig owners post-launch via execTransaction(addOwner, removeOwner)."
+  },
+  "TokenFactory_v1_1_0": {
+    "address": "0x53C3838e18703c763564Bb983694CF117B33D366",
+    "tx": "0x74a32557c9455cff3892fbac30da3b77a2cf70808ff314638e0c09808dcb30fd",
+    "deployed_at": "2026-05-01",
+    "signer_label": "Founder v3 (one-shot deploy gas)",
+    "_changes_vs_v1_0": "input validation (ZERO_SUPPLY/BAD_NAME/BAD_SYMBOL); FactoryToken transfer-to-zero reverts (ERC-20 spec)",
+    "_replaces": "0xc753199b723649ab92c6db8A45F158921CFDEe49"
+  },
+  "CoinBlastCurve_CBLAST": {
+    "address": "0x7a2992af0d4979add076347666023d66d29276fc",
+    "token": "0xe1d502b93ce492cbde32a369d5393626e38d55a7",
+    "tx": "0x8a988bea192422d8a6bfd8b8b736ec463857f5c2c8fd82c2680e3451819e13af",
+    "block": 1161074,
+    "deployer": "0x5acb04058fc4dfa258f29ce318282377cac176fd",
+    "deployer_nonce": 6,
+    "deployed_at": "2026-05-01",
+    "params": {
+      "name": "CoinBlast Genesis",
+      "symbol": "CBLAST",
+      "curveSupply": "1000000000000000000000000000",
+      "basePriceNum": 1,
+      "basePriceDen": 10000,
+      "kNum": 1,
+      "kDen": 2,
+      "graduationSrxThreshold": "1000000000000000000000",
+      "feeBps": 100,
+      "feeRecipient": "0xeb70fdefd00fdb768dec06c478f450c351499f14",
+      "router": "0xAb67E171c0DE0Cd6dD6fE87E5E399C091F9c9dE8",
+      "wsrx": "0x4693b113e523A196d9579333c4ab8358e2656553"
+    },
+    "_note": "First on-chain CoinBlastCurve launch. P0 = 1e-4 SRX-wei per token-wei (= 0.0001 SRX per whole token), K = 0.5, graduation at 1000 SRX raised. Fees accrue to Ecosystem Fund. Curve address coincidentally equals testnet TokenFactory v1.0.0 — same deployer EOA, deterministic CREATE-from-nonce alignment."
+  }
+}

package/deployments/7120.json

@@ -0,0 +1,51 @@
+{
+  "_chainId": 7120,
+  "_network": "Sentrix Testnet",
+  "_note": "Canonical contracts deployed via cast send --create (forge script forking blocked by Sentrix RPC strict-decode of sha3Uncles). Deployer: 0x5acb04058fc4dfa258f29ce318282377cac176fd.",
+  "WSRX": {
+    "address": "0x85d5E7694AF31C2Edd0a7e66b7c6c92C59fF949A",
+    "tx": "0xfcfd2e0c1b3b4e61a2166a35cbb780d8370e9d1d6c67f7137aeb66c52260e8b3",
+    "block": 723183,
+    "deployer": "0x5acb04058fc4dfa258f29ce318282377cac176fd",
+    "deployer_nonce": 4,
+    "deployed_at": "2026-04-27"
+  },
+  "Multicall3": {
+    "address": "0x7900826De548425c6BE56caEbD4760AB0155Cd54",
+    "tx": "0x1f8d6749f7ffdcbbaabfad21167d5133593944be6c59025c69c3f6543cb7f6c2",
+    "block": 723191,
+    "deployer": "0x5acb04058fc4dfa258f29ce318282377cac176fd",
+    "deployer_nonce": 5,
+    "deployed_at": "2026-04-27",
+    "_note": "Plain CREATE for v1; canonical CREATE2 address 0xcA11bde05977b3631167028862bE2a173976CA11 not used yet."
+  },
+  "TokenFactory": {
+    "address": "0x7A2992af0d4979aDD076347666023d66d29276Fc",
+    "tx": "0xe68e5553af080a97181e09279782873f884477759656e51c03f522c94cb9da47",
+    "block": 723195,
+    "deployer": "0x5acb04058fc4dfa258f29ce318282377cac176fd",
+    "deployer_nonce": 6,
+    "deployed_at": "2026-04-27"
+  },
+  "SentrixSafe": {
+    "address": "0xc9D7a61D7C2F428F6A055916488041fD00532110",
+    "tx": "0x514863050498a545fa627d696aa82cdd2558bc35470418d7f83af8f1c0a12176",
+    "block": 723511,
+    "deployer": "0x5acb04058fc4dfa258f29ce318282377cac176fd",
+    "deployer_nonce": 7,
+    "deployed_at": "2026-04-27",
+    "owners": [
+      "0x5acb04058fc4dfa258f29ce318282377cac176fd"
+    ],
+    "threshold": 1,
+    "_note": "Bootstrap-mode 1-of-1 with deployer as owner. Transfer to operator multisig owners post-launch via execTransaction(addOwner, removeOwner)."
+  },
+  "TokenFactory_v1_1_0": {
+    "address": "0xaE2a8512f0de635F8E90069e2877098c9e0baEc7",
+    "tx": "0x119ac2ff65361a36b4a7720b39c8a8bd6d2b2d601fdae480f25c5e250cb3ea9e",
+    "deployed_at": "2026-05-01",
+    "signer_label": "testnet faucet (one-shot deploy gas)",
+    "_changes_vs_v1_0": "input validation (ZERO_SUPPLY/BAD_NAME/BAD_SYMBOL); FactoryToken transfer-to-zero reverts (ERC-20 spec)",
+    "_replaces": "0x7A2992af0d4979aDD076347666023d66d29276Fc"
+  }
+}