Provided by US Fintech, LLC for Del Norte
US Fintech is CTO to Del Norte under the technical leadership of Ken Silverman

             Controller   (pointed to)
              ---------------------
             

              ▲                 ▲
              │                 │
              │                 │
abstract contract ElasticTrsHub        abstract contract ElasticTrsSpoke
   (address controller)               (address controller)
   -----------------------       -----------------------
              ▲                 ▲
              └──────┬─────────┘
                       ▼
     contract Token              contract SalesContract    
        is ElasticTreasHub          is ETreasHub, ElasticTreasSpoke            
          ---------------------

 +-------------------+
|   Token Contract  |
|       (Hub)       |
+---------+---------+
|
--------------------------------------------
|                         |                         |
+----------------------+  +---------------------+  +----------------------+
|   Sales Contract     |  |  Vesting Contract   |  |  Liquidity Contract  |
|  treasuryReceive()   |  |  treasuryReceive()  |  |  treasuryReceive()   |
|  treasuryReclaim()   |  |  treasuryReclaim()  |  |  treasuryReclaim()   |
+----------------------+  +---------------------+  +----------------------+

Each spoke maintains internal records tracking amounts received from and reclaimed by the Token Contract.

---
##   Data Structures
###  ElasticTreasuryHub   (such as Token Contract and Sales Contract)
 

// Represents treasury tracking state for each token type (ERC20 or ETH)
struct SingleCoinTreasuryState {
   string label;                           // Label for the single token treasury state
   uint256 totalTransferred;               // Total transferred out to spoke
   uint256 totalReclaimed;                 // Total reclaimed back from spoke
   uint256 totalTimesTransferred;          // Total number of successful transfers
   uint256 totalTimesReclaimed;            // Total successful reclaim actions
   uint256[] failedReclaimAttemptAmounts;  // Attempted amounts that exceeded totalTransferred
   uint256[] bouncedReclaimAmounts;        // Reclaim attempts exceeding reclaimable balance
}
// Treasury structure for all coins (ERC20 + ETH) managed by a specific Spoke

struct AllCoinTreasury {
   mapping(address => SingleCoinTreasuryState) tokenTreasury; // ERC20 tokens mapped by token address
   SingleCoinTreasuryState ethTreasury;                       // Dedicated ETH treasury state
   string label;                                              // Label unique at the Spoke level
}

// Main mapping: Spoke Smart Contract address => AllCoinTreasury
mapping(address => AllCoinTreasury) public treasury;

struct SpokeTreasuryEntry {
   uint256 totalReceived;      // Tokens received from the Hub Contract
   uint256 totalReclaimed;     // Tokens reclaimed by the Hub Contract
}
mapping(address => SpokeTreasuryEntry) public spokeTreasury;
address public hubTokenAddress;        // Address of Token Contract (Hub)

Treasury Diagram  - classes
Controller (deployed with an intialAdmin address. Pointed to by:

|--> abstract ElasticTreasuryHub
|      |
|      |--> TokenContract
|      |--> SalesContract (also a spoke)
|
|--> abstract ElasticTreasurySpoke
      |
      |--> SalesContract (also a hub)
      |--> VestingContract
      |--> LiquidityContract

ElasticTreasuryHub (inherits BaseTreasury)
│
└─ treasury (mapping of spoke smart contract addresses)
    │
    ├─ AllCoinTreasury [Label must be unique per spoke contract]
    │    ├── label: "Sales", "Vesting", etc. [checked for uniqueness at spoke-level]
    │    │
    │    ├── ethTreasury (SingleCoinTreasuryState)
    │    │    ├── label: unrestricted (but immutable once set)
    │    ├── totalTransferred, totalReclaimed, etc.
    │
    │    └── tokenTreasury (mapping tokenContract addresses)
    │          ├── SingleCoinTreasuryState
    │          │      ├── label: set once, checked on subsequent transfers
    │          │      ├── totalTransferred, totalReclaimed, etc.
    │          │
    │          └── SingleCoinTreasuryState (other token address)
    │
    └─ Another SpokeContract...

TOTAL_LEFT_TO_REFUND = TOTAL_SENT - TOTAL_REVERSED
REFUND_AMOUNT = TOTAL_LEFT_TO_REFUND

 struct ReversibleUserBalance {
       uint256 totalReceivedThatIsReversible;
       uint256 totalReversed;
       uint256 totalReversals;
 }

/ SPDX-License-Identifier: Copyright 2025
// OFFICIAL DEL NORTE NETWORK COMPONENT
// Designed and coded by: Ken Silverman
//   implementation help by Tony Sparks
pragma solidity ^0.8.20;

interface IController {
   struct OfficialEntity {
       string fullNameOfEntityOrLabel;
       string nationalIdOfEntity;
       address pubAddress;
       bool active;
       uint256 blockNumber;
   }

   function addOfficialEntity(string memory, address, string memory, string memory) external returns (bool);
   function addOfficialEntityNow(string memory, address, string memory, string memory) external returns (bool);
   function removeOfficialEntity(string memory, address) external returns (bool);
   function isOfficialEntity(string memory, address) external view returns (bool);
   function isOfficialEntityFast(bytes32, address) external view returns (bool);
   function isOfficialDoubleEntity(string calldata, address, string calldata, address, bool) external view returns (bool);

    function isOfficialTripleEntity(string calldata, address, string calldata, address, string calldata, address, bool)

                                    external view returns (bool);
   function getOfficialEntity(string calldata, address) external view returns (OfficialEntity memory);
   function getAllOfficialEntities(string calldata) external view returns (OfficialEntity[] memory);

    function init(address officialSmartContractAddress);
}

// SPDX-License-Identifier: Copyright 2025

// OFFICIAL DEL NORTE NETWORK COMPONENT

// Designed and coded by: Ken Silverman

//   implementation help by Tony Sparks

pragma solidity ^0.8.20;

interface IElasticTreasurySpoke {

    function treasuryReceive(address tokenAddress, uint256 amount) external;

    function treasuryReceiveETH() external payable;

    function treasuryReclaim(address tokenAddress, uint256 amount) external returns (bool);

    function treasuryReclaimETH(uint256 amount) external;

}

// SPDX-License-Identifier: Copyright 2025
// OFFICIAL DEL NORTE NETWORK COMPONENT
// Designed and coded by: Ken Silverman
// Implementation help by Tony Sparks
pragma solidity ^0.8.20;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "./IController.sol"; //   // ⇐ for method signatures only to allow casting during compilation.
import "./IElasticTreasurySpoke.sol";
import "./Recoverable.sol";

abstract contract ElasticTreasuryHub is Recoverable {

   event HubTreasuryEvent(address adminCaller, string msg, bool success,address smartContractTarget, uint256 amount, address tokenOrZero);
   event HubExecutiveTokensWithdrawalEvent(address adminCaller, address receiver, uint256 amt, string note, address tokenSC);
   event HubExecutiveEthWithdrawalEvent(address adminCaller, address receiver, uint256 amt, string note);

   struct SingleCoinTreasuryState {
       string label;
       uint256 totalTransferred;
       uint256 totalReclaimed;
       uint256 totalTimesTransferred;
       uint256 totalTimesReclaimed;
       uint256[] failedReclaimAttemptAmounts;
       uint256[] bouncedReclaimAmounts;
   }

   struct AllCoinTreasury {
       mapping(address => SingleCoinTreasuryState) tokenTreasury;
       SingleCoinTreasuryState ethTreasury;
       string label;
   }

   mapping(address => AllCoinTreasury) public treasury;

   // Declare this outside the functions, in your contract
   bytes32 private constant KECCAK_TREASURY_ADMIN = keccak256("TreasuryAdmin");
   // Declare this outside the functions, in your contract
   bytes32 private constant KECCAK_SMART_CONTRACT = keccak256("SmartContract");

   uint256 constant DUST = 0.01 ether;
    // elastic treasury events with gas that fail without reversion or require
 
   // controller reference is NOW stored in Recoverable

  // if somehow anyone managed a call to a spoke reclaim, (in theory they can't) but if they did,  then
  // that SC would have the authority to call the reclaim here as a SC exec.
  // therefore we require BOTH SC as spoke AND tx.origin to be Treas on reclaim
   modifier onlyTreas()  {
       require(IController(controller).isOfficialEntityFast(KECCAK_TREASURY_ADMIN,msg.sender), "Unauthorized access");
       _;  // run the code block referencing this modifier
   }

   // masterHub can no longer exist because BaseTreasury is a SINGLE entity, not inherited anymore.
   // in other words, the ENTIRE Del Norte system uses ONE Base Treasury instance as CONTROL PANEL.
   // Controller already has an initial admin, so do not add any more here.
   // Admin can call addEntity to add more. (controller has option to receive more in init() but not necessary.
   constructor(address _controllerAddress)  Recoverable(_controllerAddress) {
         IController(_controllerAddress).init(address(this));
   }

   // EMERGENCY withdraw for admin controlled DIRECT withdrawals to a PERSON (not a smart contract)
   // this can ONLY happen for example, when the company wants to send some USDC or ETH from the Sales contract
   // to an EXECUTIVE of the company for the purposes of exchanging to USDC, as an example.
   // Such USDC can be spent on a capital expense or manually passed into the vesting pool.
   // ONLY HUBS can do this. For example, only contracts GENERATING or expected to RECEIVE
   // ETH or tokens from an external event (not from a HUB)  should be declared as HUBS.
   function executiveWithdrawETH(address personAddress, uint256 amt, string memory note) external onlyTreas {
       emit HubExecutiveEthWithdrawalEvent(msg.sender,personAddress,amt,note);
   }
   function executiveWithdrawTokens(address personAddress, uint256 amt, address tokenSCAddress,
                                   string memory note) external onlyTreas {
       emit HubExecutiveTokensWithdrawalEvent(msg.sender,personAddress,amt,note,tokenSCAddress);
   }


   function treasuryTransfer(address SCAddress, string memory allCoinLabel, address tokenAddress, string memory tokenLabel,
                             uint256 amount) external onlyTreas returns (bool) {
       // SELF is added as official SC in parent constructor - and same for spoke
       AllCoinTreasury storage coinTreasury = treasury[SCAddress];
       if (bytes(coinTreasury.label).length != 0) {
            require(keccak256(bytes(coinTreasury.label)) == keccak256(bytes(allCoinLabel)),
                                "AllCoinTreasury label mismatch");
       }
       else {
           coinTreasury.label = allCoinLabel;
       }
       SingleCoinTreasuryState storage tokenState = coinTreasury.tokenTreasury[tokenAddress];
       if (bytes(tokenState.label).length != 0 && bytes(tokenLabel).length != 0) {
           require(keccak256(bytes(tokenState.label)) == keccak256(bytes(tokenLabel)),
                                   "Token label mismatch");
       }
       else if (bytes(tokenState.label).length == 0 && bytes(tokenLabel).length != 0) {
           tokenState.label = tokenLabel;
       }
       require(isContract(SCAddress), "Invalid contract");
       tokenState.totalTransferred += amount;
       tokenState.totalTimesTransferred++;
       // works on self?  If tokenAddress is same as THIS contract's address will this work?
       IERC20(tokenAddress).transfer(SCAddress, amount);
       IElasticTreasurySpoke(SCAddress).treasuryReceive(SCAddress,amount);  // ⇐ makes spoke aware of transfer
       // Add to smartContractAdmins array if not already included
       // Spoke already added, this is in case spoke used different master (see BaseTreasury)
       IController(controller).addOfficialEntity("SmartContract",SCAddress,allCoinLabel,"Spoke SC");
       emit HubTreasuryEvent(msg.sender,"Amount transferred to SC",true,SCAddress,amount,address(0));
       return true;
   }

   function treasuryTransferETH(address payable SCAddress, string memory allCoinLabel,
       string memory ethLabel, uint256 amount) external onlyTreas returns (bool) {
       AllCoinTreasury storage coinTreasury = treasury[SCAddress];
       if (bytes(coinTreasury.label).length != 0) {
           require(keccak256(bytes(coinTreasury.label)) == keccak256(bytes(allCoinLabel)),
                                    "AllCoinTreasury label mismatch");
       }
       else {
           coinTreasury.label = allCoinLabel;
       }
       SingleCoinTreasuryState storage ethState = coinTreasury.ethTreasury;
       if (bytes(ethState.label).length != 0 && bytes(ethLabel).length != 0) {
           require(keccak256(bytes(ethState.label)) == keccak256(bytes(ethLabel)),
                                            "ETH label mismatch");
       }
       else if (bytes(ethState.label).length == 0 && bytes(ethLabel).length != 0) {
           ethState.label = ethLabel;
       }
       require(address(this).balance >= amount, "Insufficient ETH balance");
       ethState.totalTransferred += amount;
       ethState.totalTimesTransferred++;
       // DO NOT USE THIS ⇒ (bool success,) = SCAddress.call{value: amount}("");
       // DO NOT USE THIS ⇒ require(success, "ETH Transfer failed");
       // treasRcvEth is PAYABLE!!! So ...
       // DO NOT CALL transfer DO NOT USE "call" and
       // DO NOT have receive() method IN the SPOKE
       IElasticTreasurySpoke(SCAddress).treasuryReceiveETH{value: amount}();  // ⇐ TRANSFERS TO SPOKE
       // Add to smartContractAdmins array if not already included
       IController(controller).addOfficialEntity("SmartContract",SCAddress,allCoinLabel,"Spoke SC"); //⇐ NOT in MASTER
       emit HubTreasuryEvent(msg.sender,"Amount transferred to SC",true,SCAddress,amount,address(0));
       return true;
   }




// ETH reclaim receiver
function treasuryReceiveReclaimedETH() external payable returns (bool) {
   AllCoinTreasury storage coinTreasury = treasury[msg.sender];
   require(bytes(coinTreasury.label).length != 0, "Treasury entry does not exist for caller as SPOKE");
   require(IController(controller).isOfficialDoubleEntity("SmartContract",msg.sender,
                                                               "TreasuryAdmin",tx.origin,true),
       "Originator must be treas and sender must be an official smart contract.");
   SingleCoinTreasuryState storage ethState = coinTreasury.ethTreasury;
   ethState.totalReclaimed += msg.value;
   ethState.totalTimesReclaimed++;
   emit HubTreasuryEvent(msg.sender, "ETH reclaimed", true,  msg.sender,msg.value,address(0));
   return true;
}

// Token reclaim notifier
function treasuryReceiveReclaimedTokens(address tokenAddress, uint256 amt) external returns (bool) {
   AllCoinTreasury storage coinTreasury = treasury[msg.sender];
   require(bytes(coinTreasury.label).length != 0, "Treasury entry does not exist");
   require(IController(controller).isOfficialDoubleEntity("SmartContract",msg.sender,
                                                               "TreasuryAdmin",tx.origin,true),
       "Originator must be treas and sender must be an official smart contract.");
   SingleCoinTreasuryState storage tokenState = coinTreasury.tokenTreasury[tokenAddress];
   tokenState.totalReclaimed += amt;
   tokenState.totalTimesReclaimed++;
   emit HubTreasuryEvent(msg.sender, "Token reclaimed", true, address(this),amt,tokenAddress);
   return true;
}




function treasuryReclaimRequest(address SCAddress, address tokenAddress,
                               uint256 amount) external onlyTreas returns (bool) {
       uint256 availableToReclaim = treasury[SCAddress].tokenTreasury[tokenAddress].totalTransferred -
                                    treasury[SCAddress].tokenTreasury[tokenAddress].totalReclaimed;
       if (amount > treasury[SCAddress].tokenTreasury[tokenAddress].totalTransferred) {
           treasury[SCAddress].tokenTreasury[tokenAddress].failedReclaimAttemptAmounts.push(amount);
           emit HubTreasuryEvent(msg.sender, "Reclaim request exceeds total transferred", false, address(this),amount,address(0));
           return false;
       }
       if (amount > availableToReclaim) {
           treasury[SCAddress].tokenTreasury[tokenAddress].bouncedReclaimAmounts.push(amount);
           amount = availableToReclaim - DUST;
           emit HubTreasuryEvent(msg.sender, "Reclaim request bounce, too high", false, address(this),amount,address(0));
           return false;
       }
       // if this fails, whole thing will revert, but the idea is if we passed
       // the above checks, than the corresponding state in the spoke should match.
       // In other words a revert should never happen if we get to this point.
       // if it does there is a state mismatch that the web manager will have to
       // warn about for manual reconciliation.
       // eth logs on chain should group msg.sender so when reclaim succeeds the message
       // will follow this event message herein 'request submitted'.  If however,
       // the transfer fails due to rejection at the spoke,
       // the below log entry will never be entered.
       IElasticTreasurySpoke(SCAddress).treasuryReclaim(tokenAddress, amount);
       treasury[SCAddress].tokenTreasury[tokenAddress].totalReclaimed += amount;
       treasury[SCAddress].tokenTreasury[tokenAddress].totalTimesReclaimed++;
       emit HubTreasuryEvent(msg.sender, "Reclaim TOKEN request submitted to SPOKE", true,SCAddress,amount,tokenAddress);
       return true;
   }

   function treasuryReclaimRequestETH(address payable SCAddress,
                                      uint256 amount) external onlyTreas returns (bool) {
       uint256 availableToReclaim = treasury[SCAddress].ethTreasury.totalTransferred -
                                    treasury[SCAddress].ethTreasury.totalReclaimed;
       if (amount > treasury[SCAddress].ethTreasury.totalTransferred) {
           treasury[SCAddress].ethTreasury.failedReclaimAttemptAmounts.push(amount);
           emit HubTreasuryEvent(msg.sender, "ETH Reclaim exceeds total transferred", false,SCAddress,amount,address(0));
           return false;
       }
       if (amount > availableToReclaim) {
           treasury[SCAddress].ethTreasury.bouncedReclaimAmounts.push(amount);
           amount = availableToReclaim - DUST;
           emit HubTreasuryEvent(msg.sender, "ETH Reclaim request bounce, too high", false,SCAddress,amount,address(0));
           return false;
       }
       IElasticTreasurySpoke(SCAddress).treasuryReclaimETH(amount);
       treasury[SCAddress].ethTreasury.totalReclaimed += amount;
       treasury[SCAddress].ethTreasury.totalTimesReclaimed++;
       emit HubTreasuryEvent(msg.sender, "ETH reclaim request submitted", true,SCAddress,amount,address(0));
       return true;
   }

   // PURCHASERS on the SALES contract or any other contract which acts as its own HUB
   // should not  accidently get ETH sent to this contract unless the child implements a receive()
   // or fallback or other payable - NOT a good idea (except buy and other planned custom methods) !
   // There should be no way to receive ETH (or tokens if it were possible) outside of SALES or other means
   // Sales contract has its own payable for example after a purchase is verified by whitelist etc ...
   // function customReceiveETH internal virtual payable {  do NOT implement

 function isContract(address account) internal view returns (bool) {
   return account.code.length > 0;
 }

}

// SPDX-License-Identifier: Copyright 2025
// OFFICIAL DEL NORTE NETWORK COMPONENT
// Designed and coded by: Ken Silverman
// Implementation help by Tony Sparks
pragma solidity ^0.8.20;

interface IElasticTreasuryHub {
  function withdrawETHToPerson(address personAddress, uint256 amt, string calldata note) external;
  function withdrawTokensToPerson(address personAddress, uint256 amt, address tokenSCAddress, string calldata note) external;
  function treasuryTransfer(address SCAddress, string calldata allCoinLabel, address tokenAddress, string calldata tokenLabel, uint256 amount) external returns (bool);
  function treasuryTransferETH(address payable SCAddress, string calldata allCoinLabel, string calldata ethLabel, uint256 amount) external returns (bool);
  function treasuryReceiveReclaimedETH() external payable returns (bool);
  function treasuryReceiveReclaimedTokens(address tokenAddress, uint256 amt) external returns (bool);
  function treasuryReclaimRequest(address SCAddress, address tokenAddress, uint256 amount) external returns (bool);
  function treasuryReclaimRequestETH(address payable SCAddress, uint256 amount) external returns (bool);
}

// SPDX-License-Identifier: Copyright 2025
// OFFICIAL DEL NORTE NETWORK COMPONENT
// Designed and coded by: Ken Silverman
// Implementation help by Tony Sparks
pragma solidity ^0.8.20;
import "./IController.sol";
import "./IElasticTreasuryHub.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "./Recoverable.sol";

contract ElasticTreasurySpoke is Recoverable {

   event SpokeReceivedEth(address sender, uint256 amount);
   event SpokeReceivedTokens(address sender, uint256 amount, address tokenSCAddress);
   event SpokeReclaimEthEvent(address origin, address hubContract, string msg, uint256 amount);
   event SpokeReclaimTokensEvent(address origin, address hubContract, address tokenAddress, string msg, uint256 amount);

   address public hubTokenAddress;

   struct SpokeTreasuryEntry {
       uint256 totalReceived;
       uint256 totalReclaimed;
   }


   mapping(address => SpokeTreasuryEntry) public spokeTreasury; // tokenAddress => SpokeTreasuryEntry
   SpokeTreasuryEntry public spokeTreasuryETH;                   // ETH treasury entry explicitly

   // Controller already has an initial admin, so do not add any more here.
   constructor(address _controller, address _hubTokenAddress) Recoverable(_controller) {
       IController(controller).init(address(0));
       hubTokenAddress = _hubTokenAddress;
   }


   function treasuryReceive(address tokenAddress, uint256 amount) external {
       require(msg.sender == hubTokenAddress, "sender must be HUB");
       spokeTreasury[tokenAddress].totalReceived += amount;
       // explicitly tracks ERC20 tokens received from treasuryTransfer
   }

   // ETH transfers automatically trigger receive() only if no data is sent.
   // Here, we're explicitly defining a method (treasuryReceiveETH)
   // that's explicitly called by the hub to transfer ETH and record this separately
   //  treasury-related ETH separately from ONE CALL to THIS METHOD. NO PRIOR TRANSFER!
   function treasuryReceiveETH() external payable {  // ⇐ MUST DIRECTLY RECEIVE NOW
       require(msg.sender == hubTokenAddress,"sender must be HUB");
       // confirm amount actually equals msg.value
       spokeTreasuryETH.totalReceived += msg.value;
       emit SpokeReceivedEth(msg.sender,msg.value);
   }

   // DO NOT USE ⇒ receive() external payable {   // NO NO NO NO receive method! Do NOT allow incoming ETH
   //    emit SpokeReceivedEth(msg.sender,msg.value);  // except by treasRcvETH
   // }

    // ANY address that this contract has deployed as its HUB is 100% trusted.
   // because caller must be hub and HUB is only accessible by TREAS.
   function treasuryReclaim(address tokenAddress, uint256 amount) external returns (bool) {
       require(spokeTreasury[tokenAddress].totalReceived >= amount, "Low balance to reclaim on");
       require(hubTokenAddress == msg.sender);
       spokeTreasury[tokenAddress].totalReclaimed += amount;
      IERC20(tokenAddress).transfer(msg.sender, amount);
       IElasticTreasuryHub(msg.sender).treasuryReceiveReclaimedTokens(tokenAddress,amount);
       emit SpokeReclaimTokensEvent(tx.origin, msg.sender, tokenAddress, "Spoke sent Reclaim Tokens back to HUB", amount);
       return true;
   }

   // msg.sender must be the HUB contract address here.  For safety, verify that.
   // no officialSmartContract entity is required here, HUB is 100% trusted as caller.
   // because HUB can only be called by TREAS.
   function treasuryReclaimETH(uint256 amount) external  {
       require(spokeTreasuryETH.totalReceived >= amount, "Insufficient received balance");
       require(hubTokenAddress == msg.sender);
       spokeTreasuryETH.totalReclaimed += amount;
       IElasticTreasuryHub(payable(msg.sender)).treasuryReceiveReclaimedETH{value : amount}(); // ⇐MAKES TRANSFER
       emit SpokeReclaimEthEvent(tx.origin, msg.sender, "Spoke sent Reclaim ETH back to HUB", amount);
   }
}

contract TokenContract is ElasticTreasuryHub {
  // For token contract, no initialAdmin necessary. It is already defined in

   // Controller at deploy.  Just pass controllerAddress.

   //
    constructor(address controllerAddress)ElasticTreasuryHub (controllerAddress,address[0]) {}
}

contract SalesContract is ElasticTreasuryHub, ElasticTreasurySpoke {

    // master gets passed up the chain to Controller via the  

    // hub and spoke contract constructors respectively.
   constructor(address _controllerAddress, address _hubContract)
       ElasticTreasuryHub(_controllerAddress);
       ElasticTreasurySpoke(_hubContract,_controllerAddress)
   {}

    // hub and spoke methods fully implemented in HUB and SPOKE

}

Registrar Name

AcmeCorp

The registrar's name.

Registrar ID

12345

Unique identifier for the registrar.

Country Code

USA

ISO 3166-1 alpha-3 country code (e.g., "USA" for the United States).

Approval Limit

50000

Maximum approval amount in USD.

Permission Level

2

Indicates the user is an accredited investor in the US.

Reserved Byte

00

Reserved for future functionality.

// SPDX-License-Identifier: Copyright 2025

// OFFICIAL DEL NORTE NETWORK COMPONENT

// Designed and coded by: Ken Silverman

// Implementation help by Tony Sparks

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";

import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Permit.sol";

import "./ElasticTreasuryHub.sol";

import "./IController.sol";

contract DelNorteToken is ERC20, ERC20Burnable, ElasticTreasuryHub {

    event RegistrarEvent(address indexed registrar, uint256 blockNumber, string action, uint256 numUsers);

    struct WhitelistEntry {

        address user;

        string note;

    }

    uint256 public constant MAX_SUPPLY = 850_000_000 * 10**18;

    bool public gatingActive = true;

   mapping(address => string) public whitelistedUsers;

   mapping(address => bool)   public isUserRestricted;

   address[] public whitelistedUserList;

    // if masterHub is 00000000000 it means SELF (pass it up the line)

   // address baseTreasuryAddress, address intialAdmin

    constructor(address _controller, address initialAdmin)

        ERC20("Del Norte Token", "DTV")

        ERC20Permit("Del Norte Token");

        ElasticTreasuryHub(_controller)

    {

        require(_controller != address(0), "Controller address cannot be zero");

        bool areLords = IController(_controller).isOfficialEntity("TreasuryAdmin",initialAdmin);

        require(areLords, "First token admin (multi-sig execs) must be initial Controller TreasAdmin.");

        _mint(address(this), MAX_SUPPLY);

        // Can we as admins be registrar? Yes if we provide KYC

        // BaseTreasury must mark this SC as SmartContract already

        // These calls assume controller is of type IController or castable

        IController(controller).addOfficialEntityNow("Registrar", initialAdmin,

                                  "ExecGrp", "acting Registrar");

        IController(controller).addOfficialEntityNow("TokenAdmin", initialAdmin,

                                  "ExecGrp", "initTknAdmin");

    }

    modifier onlyTokenExecutives() {

        require(IController(controller).isOfficialEntity("TokenAdmin",msg.sender),

                              "NotTknExec");

        _;

    }

    // no LP or other retrieval to any non-registered user. Only Non-US can register.

    function isRestricted(address sender, address receiver) public view returns (bool) {

        if (

            !gatingActive ||

            IController(controller).isOfficialTripleEntity("TreasuryAdmin", sender,"SmartContract", sender,

                                        "SmartContract", receiver,false)

        ) {

            return false;

        }

        return !isUnrestrictedWhitelistedUser(receiver);

    }

    function isUnrestrictedWhitelistedUser(address user) public view returns (bool) {

        return bytes(whitelistedUsers[user]).length > 0 && !isUserRestricted[user];

    }

    function transfer(address recipient, uint256 amount) public override returns (bool) {

        require(!isRestricted(msg.sender, recipient), "Transfer restricted");

        return super.transfer(recipient, amount);

    }

    function transferFrom(address sender, address recipient, uint256 amount)

                          public override returns (bool) {

        require(!isRestricted(sender, recipient), "Transfer restricted");

        return super.transferFrom(sender, recipient, amount);

    }

    function removeGating() external {

        require(IController(controller).isOfficialEntity("TokenAdmin",msg.sender));

        gatingActive = false;

    }

     // NOT just for sales but for regular users who are registered

     function addWhitelistedUser(address user, string memory registrationNote) external {

         require(IController(controller).isOfficialEntity("Registrar", msg.sender), "Not Registrar");

         whitelistedUsers[user] = registrationNote;

         whitelistedUserList.push(user);

         emit RegistrarEvent(msg.sender, block.number, "Added a User", 1);

     }

    function deleteWhitelistedUser(address user) external {

        require(IController(controller).isOfficialEntity("Registrar",msg.sender));

        delete whitelistedUsers[user];

        emit RegistrarEvent(msg.sender, block.number, "Deleted a User", 1);

    }

    function getAllWhitelistedUsers() external view returns (address[] memory) {

       return whitelistedUserList;

    }

    function addWhitelistedUsers(WhitelistEntry[] calldata entries) external {

        require(IController(controller).isOfficialEntity("Registrar", msg.sender), "Not Registrar!");

        uint256 numUsers = 0;

        for (uint256 i = 0; i < entries.length; ++i) {

            address user = entries[i].user;

            if (bytes(whitelistedUsers[user]).length == 0) {

                whitelistedUserList.push(user);

                numUsers++;

            }

            whitelistedUsers[user] = entries[i].note;

        }

        emit RegistrarEvent(msg.sender, block.number, "Added Users", numUsers);

    }

    function restrictWhitelistedUsers(address[] calldata users) external {

        require(IController(controller).isOfficialEntity("Registrar", msg.sender), "Not Registrar");

        uint256 numUsers = 0;

        for (uint256 i = 0; i < users.length; ++i) {

            address user = users[i];

            if (bytes(whitelistedUsers[user]).length != 0 && !isUserRestricted[user]) {

                isUserRestricted[user] = true;

                numUsers++;

            }

        }

        emit RegistrarEvent(msg.sender, block.number, "Users Restricted", numUsers);

    }

    function reactivateWhitelistedUsers(address[] calldata users) external {

        require(IController(controller).isOfficialEntity("Registrar", msg.sender), "Not Registrar");

        uint256 numUsers = 0;

        for (uint256 i = 0; i < users.length; ++i) {

            address user = users[i];

            if (bytes(whitelistedUsers[user]).length != 0 && isUserRestricted[user]) {

                isUserRestricted[user] = false;

                numUsers++;

            }

        }

        emit RegistrarEvent(msg.sender, block.number, "Users Reactivated", numUsers);

    }

    function getActiveWhitelistedUsers() external view returns (address[] memory) {

        uint256 activeCount = 0;

        for (uint256 i = 0; i < whitelistedUserList.length; ++i) {

            if (!isUserRestricted[whitelistedUserList[i]]) {

                activeCount++;

            }

        }

        address[] memory activeUsers = new address[](activeCount);

        uint256 j = 0;

        for (uint256 i = 0; i < whitelistedUserList.length; ++i) {

            address user = whitelistedUserList[i];

            if (!isUserRestricted[user]) {

                activeUsers[j++] = user;

            }

        }

        return activeUsers;

    }

    /**

     * @notice Allows a user to self-register (whitelist themselves) using an off-chain signature

     *         provided by an approved Registrar. The registrar signs a hashed message consisting of:

     *

     *         keccak256(abi.encodePacked(userAddress + "_" + thisTokencontractAddress))

     *

     *         - The registration note (string) passed to this function is NOT part of the signed message.

     *           It is for reference and display only and can be spoofed. All actual verification (e.g., KYC,

     *           ISO country code, etc.) is done off-chain by registrar, details stored off-chain by address.

     *

     *         - The registrar's address must be registered in the controller as an official entity

     *           of type "Registrar".     registrarSignature = regKey

     *         - The user (msg.sender) pays the gas and must be the subject of the signed message.

     */

    function whitelistUserWithRegKey(address registrarAddress, string calldata registrationNote, bytes calldata registrarSignature) external {

        require(bytes(whitelistedUsers[msg.sender]).length == 0, "User already registered");

        // Message hash format: keccak256(user + this contract) // removed underscore fixed length 160

        bytes32 messageHash = keccak256(abi.encodePacked(msg.sender, address(this)));

        // removed underscore because addresseses are fixed length and this we we can avoid use of hextostring

        //bytes memory rawMessage = abi.encodePacked(Strings.toHexString(uint160(msg.sender), 20),

        //  "_",Strings.toHexString(uint160(address(this)), 20));

        //bytes32 messageHash = keccak256(rawMessage);

        // Ethereum signed message format

        bytes32 ethSignedMessageHash = keccak256(

            abi.encodePacked("\x19Ethereum Signed Message:\n32", messageHash)

        );

        // Recover signer

        address recoveredSigner = recoverSigner(ethSignedMessageHash, registrarSignature);

        require(recoveredSigner == registrarAddress, "Signature not from registrar");

        require(IController(controller).isOfficialEntity("Registrar", registrarAddress), "Registrar not approved");

        // Whitelist the user

        whitelistedUsers[msg.sender] = registrationNote;

        whitelistedUserList.push(msg.sender);

        emit RegistrarEvent(registrarAddress, block.number, "User Self-Registered", 1);

    }

    // Internal helper to recover the signer from signature

    function recoverSigner(bytes32 hash, bytes memory signature) internal pure returns (address) {

        require(signature.length == 65, "Invalid signature length");

        bytes32 r;

        bytes32 s;

        uint8 v;

        assembly {

            r := mload(add(signature, 32))

            s := mload(add(signature, 64))

            v := byte(0, mload(add(signature, 96)))

        }

        if (v < 27) {

            v += 27;

        }

        require(v == 27 || v == 28, "Invalid v value");

        return ecrecover(hash, v, r, s);

    }

}

// SPDX-License-Identifier: All code Copyright 2025  US Fintech LLC and Del Norte Holdings jointly.

// OFFICIAL DEL NORTE NETWORK COMPONENT or pre-registration Del Norte membership token.

// Provides immediate membership access to the DelNorte dev platform at different levels.

// Required Non US or accredited US registration to swap to DTV token.

// Registration available within 180 days per terms.delnorte.io .

// swappableContracts added require isWhitelisted() method and expect a ReleaseManager to addSchedule().

// This component is minimally tested. Use at your own risk.  

// Designed by Ken Silverman as part of his ElasticTreasury (HUB and SPOKE),

// PeerTreasury and Controller model.  

// This deployment is for Trueviewchain Inc. a Panama entity and Del Norte El Salvador S.A  a subsidiary of Del Norte Holdings, Delaware USA.  

// Compilation help from Maleeha Naveed. Deployed by Maleeha Naveed on behalf of Del Norte.

pragma solidity ^0.8.17;

/*
   Part 1: SALE Contract (Professional-Grade)
   ------------------------------------------
   Key Features:
    - Pre-minted tokens held by this contract.
    - Whitelisting via ECDSA signature (off-chain KYC).
    - Reentrancy guard for secure buy functions.
    - Minimal gas usage for end-user purchases.
*/

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
// ECDSA needed only to verify Registrar
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./ElasticTreasuryHub.sol";
import "./ElasticTreasurySpoke.sol";
import "./Recovery.sol";

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

// Import base contracts (assumed to be located in the same directory)
import "./ElasticTreasuryHub.sol";
import "./PeerTreasury.sol";

/* ========== INTERFACES ========== */

// Minimal ERC20 interface.
interface IERC20 {
   function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
}

// ERC20 metadata interface to read symbol and decimals.
interface IERC20Metadata is IERC20 {
   function symbol() external view returns (string memory);
   function decimals() external view returns (uint8);
}

// Interface for the release manager that creates vesting schedules.
// Here the release manager is assumed to internally know which token to release.
interface IReleaseManager {
   function addSchedule(
       address recipient,
       uint256 startBlock,         // The block number when vesting (cliff) starts.
       uint256 numberOfPayments,
       uint256 amountPerPayment
   ) external;
}

// The controller verifies official entities (such as swappable tokens and treasury admins).
interface IController {
   function isOfficialEntity(string calldata entityType, address entity) external view returns (bool);
   function addOfficialEntity(string memory, address, string memory, string memory) external returns (bool);
}

// Interface for the swap-to token contract that includes a whitelist function.
interface ISwapToToken {
   function isWhitelisted(address user) external view returns (bool);
}

// Interface for a Chainlink price aggregator (e.g. ETH/USD).
interface AggregatorV3Interface {
   function latestRoundData() external view returns (
       uint80 roundId,
       int256 answer,
       uint256 startedAt,
       uint256 updatedAt,
       uint80 answeredInRound
   );
}

/* ========== CONSTANTS ========== */
// Minimum purchase is $300 worth of tokens. For a fixed price of $0.05 per token,
// this equals 6000 tokens (6000 * 1e18 in 18-decimal form)
uint256 constant MIN_TOKEN_AMOUNT = 6000 * 1e18;
// The vesting schedule is defined as 10 equal payments.
uint256 constant NUMBER_OF_PAYMENTS = 10;

// USDC decimals retrieved in the constructor for gas efficiency.
uint8 public usdcDecimals;

/* ========== MAIN CONTRACT ========== */

/**
* @title TokenSaleAndSwap
* @dev This contract implements both a token swap and token sale mechanism.
*
* The constructor accepts:
*   - _swapToTokenAddress: The address of the token that users ultimately receive.
*       (For example, think of this as a "DTV" token -- here referred to generically as the swap-to token.)
*   - _swapToTokenSymbol: The expected symbol of that token (used as a sanity check against address typos).
*   - _releaseManager: The release manager contract address that handles vesting schedules.
*   - _controller: The controller contract address (used for official entity checks).  
*       This is now passed up to the ElasticTreasuryHub base contract.
*   - _usdcAddress: The USDC token contract address.
*   - _ethUsdPriceFeed: The Chainlink ETH/USD price feed address.
*
* The swapToSchedule() method allows a user to swap an official swappable token (passed as input)
* for a vesting schedule of the swap-to token.
*
* The buy methods (buyWithUSDC and buyWithETH) let a whitelisted user purchase the swap-to token
* at a price set in USD (default $0.05 per token). The USDC purchase method automatically scales amounts
* (from USDC's 6 decimals up to 18). Both purchase methods require a minimum purchase equivalent to $300.
*
* Administrative methods:
*   - setSaleActive(bool): Only a TreasuryAdmin (verified via the controller) may change sale status.
*   - setPurchasePriceInUSD(uint256): Only a TreasuryAdmin may update the purchase price per token.
*
* IMPORTANT: For swapToSchedule() and buyWithUSDC(), the user must first call approve() on the respective pre-reg token
* so that this contract is allowed to transfer the given amount.

 * swap will reject if user is not whitelisted on the swappable token contract via isWhitelisted
*/
contract TokenSaleAndSwap is ElasticTreasuryHub, PeerTreasury {
   // Address of the token that users ultimately receive (swap-to token).
   address public immutable swapToTokenAddress;
   // Expected symbol of the swap-to token (used as a sanity check).
   string public immutable swapToTokenSymbol;
   // Address of the USDC token contract.
   address public immutable usdcAddress;
   // Release manager contract that handles vesting schedules.
   IReleaseManager public releaseManager;
   // Controller contract for verifying official entities.
   IController public controller;
   // Chainlink price feed for ETH/USD.
   AggregatorV3Interface public ethUsdPriceFeed;

   // Sale status--if false, purchases are rejected.
   bool public saleActive;
   // Purchase price per token in USD (18 decimals); initially set to $0.05 per token.
   uint256 public purchasePriceInUSD;

   // Overall total of tokens swapped or purchased (in swap-to token units, 18 decimals).
   uint256 public totalTokensSwapped;
   // Mapping to track totals per payment token: use usdcAddress for USDC, and address(0) for ETH.
   mapping(address => uint256) public tokensSwappedFrom;

 
 
   /* ========== EVENTS ========== */

// Emitted when a user successfully schedules a token swap vesting schedule.
event SwapScheduled(
   address indexed user,
   address indexed swappableToken,
   uint256 amount,
   uint256 startBlock,
   uint256 numberOfPayments,
   uint256 amountPerPayment
);

// Emitted when a user successfully purchases tokens (via USDC or ETH).
event TokenPurchased(
   address indexed user,
   address indexed paymentToken, // For USDC, use its token address; for ETH, use address(0)
   uint256 paymentAmount,
   uint256 tokenAmount,
   uint256 startBlock,
   uint256 numberOfPayments,
   uint256 amountPerPayment
);

// Emitted when a token purchase fails (for example, due to lack of whitelist status).
event TokenPurchaseFailure(
   address indexed user,
   string reason
);

// Emitted when the sale status is changed (enabled or disabled).
event SaleStatusChanged(
   bool newStatus
);

// Emitted when the purchase price per token is updated.
event PurchasePriceChanged(
   uint256 newPrice
);

// Emitted when a new swappable token is added via the admin function.
event SwappableTokenAdded(
   address indexed token
);

// Emitted when a swappable token is removed via the admin function.
event SwappableTokenRemoved(
   address indexed token
);

   /* ========== CONSTRUCTOR ========== */
   /**
    * @dev Constructor.
    * @param _swapToTokenAddress The address of the token users receive.
    * @param _swapToTokenSymbol The expected symbol of the swap-to token.
    * @param _releaseManager The release manager contract address.
    * @param _controller The controller contract address.
    *        This value is also passed to ElasticTreasuryHub.
    * @param _usdcAddress The USDC token contract address.
    * @param _ethUsdPriceFeed The Chainlink ETH/USD price feed address.
    */
   constructor(
       address _swapToTokenAddress,
       string memory _swapToTokenSymbol,
       address _releaseManager,
       address _controller,
       address _usdcAddress,
       address _ethUsdPriceFeed
   )
       ElasticTreasuryHub(_controller) // Pass the controller up to ElasticTreasuryHub.
   {
       // Sanity check: the token at _swapToTokenAddress should return the expected symbol.
       require(
           keccak256(bytes(IERC20Metadata(_swapToTokenAddress).symbol())) ==
               keccak256(bytes(_swapToTokenSymbol)),
           "Incorrect swap-to token address provided; symbol mismatch"
       );
       swapToTokenAddress = _swapToTokenAddress;
       swapToTokenSymbol = _swapToTokenSymbol;
       releaseManager = IReleaseManager(_releaseManager);
       controller = IController(_controller);
       usdcAddress = _usdcAddress;
       ethUsdPriceFeed = AggregatorV3Interface(_ethUsdPriceFeed);
       // Retrieve and store USDC decimals (e.g. should be 6 for USDC) to avoid extra external calls.
       usdcDecimals = IERC20Metadata(_usdcAddress).decimals();
       // Set an initial purchase price of $0.05 per token (in 18 decimals).
       purchasePriceInUSD = 5e16; // 0.05 * 1e18
       // Initially, sale is inactive.
       saleActive = false;



       
   }

   /* ========== ADMIN FUNCTIONS ========== */
   /**
    * @notice Enable or disable the token sale.
    * @param _active True to enable the sale, false to disable.
    *
    * Requirements:
    * - Caller must be an official TreasuryAdmin.
    */
   function setSaleActive(bool _active) external {
       require(
           controller.isOfficialEntity("TreasuryAdmin", msg.sender),
           "Only TreasuryAdmin can change sale status"
       );
       saleActive = _active;
       emit SaleStatusChanged(_active);
   }

   /**
    * @notice Set the purchase price per token in USD (18 decimals).
    * @param newPrice The new price per token (e.g., 5e16 for $0.05).
    *
    * Requirements:
    * - Caller must be an official TreasuryAdmin.
    */
   function setPurchasePriceInUSD(uint256 newPrice) external {
       require(
           controller.isOfficialEntity("TreasuryAdmin", msg.sender),
           "Only TreasuryAdmin can change purchase price"
       );
       purchasePriceInUSD = newPrice;
       emit PurchasePriceChanged(newPrice);
   }

   /* ========== CORE FUNCTIONS ========== */

   /**
    * @notice Swap an approved swappable token for a vesting schedule of the swap-to token.
    * @param swappableToken The address of the token being swapped (must be an official swappable token).
    * @param amount The amount of swappable token to swap.
    *
    * Requirements:
    * - The sale must be active.
    * - The caller must be whitelisted by the swap-to token contract.
    * - The provided token must be officially recognized as swappable.
    * - The user must have pre-approved this contract to transfer their tokens.
    * - Vesting schedule: 10 equal payments starting ~90 days (block numbers) in the future.
    */
   function swapToSchedule(address swappableToken, uint256 amount) external {
       require(saleActive, "Token sale is not active");

       // Verify that the caller is whitelisted via the swap-to token contract.
       require(
           ISwapToToken(swapToTokenAddress).isWhitelisted(msg.sender),
           "Swap failed: caller is not whitelisted"
       );

       // Verify that the swappable token is officially recognized.
       require(
           controller.isOfficialEntity("SwappableToken", swappableToken),
           "Swap failed: token is not officially recognized as swappable"
       );

       // Transfer the swappable tokens from the user to this contract.
       // NOTE: The user must first call approve() on the token contract.
       require(
           IERC20(swappableToken).transferFrom(msg.sender, address(this), amount),
           "Swap failed: token transfer failed -- ensure you have approved the contract"
       );

       // Set up vesting schedule: 10 equal payments starting ~90 days in the future.
       uint256 amountPerPayment = amount / NUMBER_OF_PAYMENTS;
       uint256 startBlock = block.number + (90 * 6500); // Approximate block number for 90 days ahead.

       // Create the vesting schedule via the release manager.
       releaseManager.addSchedule(msg.sender, startBlock, NUMBER_OF_PAYMENTS, amountPerPayment);

       // Update tracking.
       totalTokensSwapped += amount;
       tokensSwappedFrom[swappableToken] += amount;

       emit SwapScheduled(msg.sender, swappableToken, amount, startBlock, NUMBER_OF_PAYMENTS, amountPerPayment);
   }

   /**
    * @notice Purchase the swap-to token by paying with USDC.
    * @param usdcAmount The amount of USDC the user is paying.
    *
    * Requirements:
    * - The sale must be active.
    * - The caller must be whitelisted by the swap-to token contract.
    * - The USDC amount (converted to 18 decimals) must be at least $300.
    * - The user must have approved this contract to spend USDC.
    *
    * The token amount purchased is calculated based on the purchase price (in USD, 18 decimals),
    * and a vesting schedule is set for 10 equal payments starting ~90 days in the future.
    */
   function buyWithUSDC(uint256 usdcAmount) external {
       require(saleActive, "Token sale is not active");
       if (!ISwapToToken(swapToTokenAddress).isWhitelisted(msg.sender)) {
           emit TokenPurchaseFailure(msg.sender, "Caller is not whitelisted");
           revert("Caller is not whitelisted");
       }
       // Use the stored usdcDecimals value to convert USDC amounts to 18-decimal format.
       uint256 usdcAmount18 = usdcAmount;
       if (usdcDecimals < 18) {
           usdcAmount18 = usdcAmount * (10 ** (18 - usdcDecimals));
       } else if (usdcDecimals > 18) {
           usdcAmount18 = usdcAmount / (10 ** (usdcDecimals - 18));
       }
       require(usdcAmount18 >= 300e18, "Minimum purchase is $300 in USDC");
       // Calculate token amount purchased at the current purchase price.
       // tokenAmount = (usdcAmount18 * 1e18) / purchasePriceInUSD.
       uint256 tokenAmount = (usdcAmount18 * 1e18) / purchasePriceInUSD;
       // Transfer USDC from the user to this contract.
       require(
           IERC20(usdcAddress).transferFrom(msg.sender, address(this), usdcAmount),
           "USDC transfer failed -- ensure you have approved the contract"
       );
       uint256 amountPerPayment = tokenAmount / NUMBER_OF_PAYMENTS;
       uint256 startBlock = block.number + (90 * 6500);
       // Create the vesting schedule.
       releaseManager.addSchedule(msg.sender, startBlock, NUMBER_OF_PAYMENTS, amountPerPayment);
       totalTokensSwapped += tokenAmount;
       tokensSwappedFrom[usdcAddress] += tokenAmount;
       emit TokenPurchased(msg.sender, usdcAddress, usdcAmount, tokenAmount, startBlock, NUMBER_OF_PAYMENTS, amountPerPayment);
   }

   /**
    * @notice Purchase the swap-to token by paying with ETH.
    *
    * The ETH amount sent is converted to USD using Chainlink.
    * The USD value must be at least $300.
    * The token amount purchased is determined based on the current purchase price.
    * A vesting schedule is set for 10 equal payments starting ~90 days in the future.
    */
   function buyWithETH() external payable {
       require(saleActive, "Token sale is not active");
       if (!ISwapToToken(swapToTokenAddress).isWhitelisted(msg.sender)) {
           emit TokenPurchaseFailure(msg.sender, "Caller is not whitelisted");
           revert("Caller is not whitelisted");
       }
       (, int256 price, , ,) = ethUsdPriceFeed.latestRoundData();
       require(price > 0, "Invalid price from oracle");
       // Convert ETH (msg.value) to USD (18 decimals):
       // Chainlink price has 8 decimals; multiply by 1e10.
       uint256 usdValue = (msg.value * uint256(price) * 1e10) / 1e18;
       require(usdValue >= 300e18, "Minimum purchase is $300 in ETH equivalent");
       uint256 tokenAmount = (usdValue * 1e18) / purchasePriceInUSD;
       uint256 amountPerPayment = tokenAmount / NUMBER_OF_PAYMENTS;
       uint256 startBlock = block.number + (90 * 6500);
       // Create the vesting schedule.
       releaseManager.addSchedule(msg.sender, startBlock, NUMBER_OF_PAYMENTS, amountPerPayment);
       totalTokensSwapped += tokenAmount;
       tokensSwappedFrom[address(0)] += tokenAmount;
       emit TokenPurchased(msg.sender, address(0), msg.value, tokenAmount, startBlock, NUMBER_OF_PAYMENTS, amountPerPayment);
   }

   function addSwappableToken(address token) external {
       // should fail if the sender is not a TreasuryAdmin
       require(super.isContract(token),"token must be a contract address");
       IController(controller).addOfficialEntity("SwappableToken",token,"A PreRegToken","");
       emit SwappableTokenAdded(token);
   }
   function removeSwappableToken(address token) external {
       require(super.isContract(token),"token must be a contract address");
       // should fail if the sender is not a TreasuryAdmin
       IController(controller).removeOfficialEntity("SwappableToken",token,"preRegToken",);
       emit SwappableTokenRemoved(token);
   }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "./IController.sol";


// New! Tracked Peer Treasury transfers between OfficialEntity Smart Contracts for ETH and ERC20 tokens
contract PeerTreasury {
   event PeerTreasuryReceivedETH(address indexed sender, uint256 amount);
   event PeerTreasuryReceivedTokens(address indexed sender, address indexed token, uint256 amount);
   event PeerTreasuryTransferredETH(address indexed to, uint256 amount);
   event PeerTreasuryTransferredTokens(address indexed to, address indexed token, uint256 amount);

   struct TreasuryEntry {
       uint256 totalReceived;
        uint256 totalWithdrawn;
   }

   address public controller;
   mapping(address => TreasuryEntry) public tokenPeerTreasury;
   TreasuryEntry public ethPeerTreasury;

   modifier onlyTreasuryAdmin() {
       require(
           IController(controller).isOfficialDoubleEntity("TreasuryAdmin", msg.sender, "SmartContract", msg.sender, false),
           "Unauthorized"
       );
       _;
   }

   constructor(address _controller) {
       controller = _controller;
   }

   /// @notice Receive ETH from any source and track it
   function peerTreasuryReceiveETH() external payable {
       require(msg.value > 0, "No ETH sent");
       ethPeerTreasury.totalReceived += msg.value;
       emit PeerTreasuryReceivedETH(msg.sender, msg.value);
   }

   /// @notice Transfer ETH to another peer contract (OfficialEntity SmartContract)
   function peerTreasuryTransferETH(address payable to, uint256 amount) external onlyTreasuryAdmin {
       require(address(this).balance >= amount, "Insufficient contract ETH balance");
       require(controller.isOfficialEntity("SmartContract", to), "Recipient not an official SmartContract");

       ethPeerTreasury.totalWithdrawn += amount;
       PeerTreasury(to).peerTreasuryReceiveETH{value: amount}();
       emit PeerTreasuryTransferredETH(to, amount);
   }

   /// @notice Receive ERC20 tokens and track source
   function peerTreasuryReceiveTokens(address token, uint256 amount) external {
       require(amount > 0, "Zero amount");
       require(IERC20(token).transferFrom(msg.sender, address(this), amount), "Transfer failed");
       tokenPeerTreasury[token].totalReceived += amount;
       emit PeerTreasuryReceivedTokens(msg.sender, token, amount);
   }

   /// @notice Transfer ERC20 tokens to another peer contract (OfficialEntity SmartContract)
   function peerTreasuryTransferTokens(address token, address to, uint256 amount) external onlyTreasuryAdmin {
       require(IERC20(token).balanceOf(address(this)) >= amount, "Insufficient token balance");
       require(controller.isOfficialEntity("SmartContract", to), "Recipient not an official SmartContract");

       tokenPeerTreasury[token].totalWithdrawn += amount;
       require(IERC20(token).approve(to, amount), "Approve failed");
       PeerTreasury(to).peerTreasuryReceiveTokens(token, amount);
       emit PeerTreasuryTransferredTokens(to, token, amount);
   }

   /// @notice Check ETH available (total received - total withdrawn)
   function peerETHAvailable() external view returns (uint256) {
       return ethPeerTreasury.totalReceived - ethPeerTreasury.totalWithdrawn;
   }

   /// @notice Check token available (total received - total withdrawn)
   function peerTokenAvailable(address token) external view returns (uint256) {
       TreasuryEntry storage e = tokenPeerTreasury[token];
       return e.totalReceived - e.totalWithdrawn;
   }
} // End PeerTreasury

Elastic Treasury Spoke (of Token for DTV and Sales for USDC (cannot have two hubs yet, so USDC will get into vesting by ExternalTreasury calls, sales and vesting need both extend ExternalTreasury)
       |
       +-------------------+
       |  Vesting Contract |
       |-------------------|
       | treasuryReceive() |
       | treasuryReclaim() |
       +-------------------+

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.20;

import "./IController.sol";

import "./IElasticTreasuryHub.sol";

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

import "./ElasticTreasurySpoke.sol";

import "./ExternalTreasury.sol"; // New! External Treasury for tracked ETH/token inflows/outflows

contract ReleaseScheduleManager is ElasticTreasurySpoke, PeerTreasury {

    struct Schedule {

        uint256 singlePayAmount;

        uint256 numPayments;

        uint256 totalPayments;

        uint256 totalValue;

        uint256 totalLeftToPay;

        uint256 startBlockNum;

        uint256 lastClaimedBlock;

        uint256 totalPaidOut;

        bool isRevokable;

    }

    struct BeneficiarySchedule {

        address beneficiary;

        Schedule schedule;

    }

    mapping(address => mapping(address => Schedule)) public schedules;

    mapping(address => Schedule) public ethSchedules;

    mapping(address => address[]) private tokenScheduleBeneficiaries;

    uint256 public globalAmountOwed;

    constructor(address _controller, address _hub)

        ElasticTreasurySpoke(_controller, _hub)

        ExternalTreasury(_controller)

    {}

    modifier onlyTreasuryAdminOrContract() {

        require(

            IController(controller).isOfficialDoubleEntity("TreasuryAdmin", msg.sender, "SmartContract", msg.sender, false),

            "Unauthorized caller"

        );

        _;

    }

    /// @notice Add a new vesting schedule or merge/overwrite an existing one depending on flags

    function addReleaseSchedule(

        address tokenContractAddress,

        address beneficiary,

        uint256 singlePayAmount,

        uint256 numPayments,

        uint256 totalPayments,

        uint256 startBlockOffset,

        bool isRevokable,

        bool isMerge,

        bool ignoreRevokableCheck

    ) public onlyTreasuryAdminOrContract returns (bool added) {

        Schedule storage existing = schedules[tokenContractAddress][beneficiary];

        uint256 newTotal = singlePayAmount * numPayments;

        uint256 startBlock = block.number + startBlockOffset;

        if (existing.totalValue > 0) {

            if (isMerge) {

                require(existing.startBlockNum == startBlock, "Start block mismatch on merge");

                require(existing.isRevokable, "Cannot merge into non-revokable schedule");

                globalAmountOwed = globalAmountOwed + newTotal - existing.totalValue;

                existing.singlePayAmount += singlePayAmount;

                existing.numPayments += numPayments;

                existing.totalPayments = totalPayments;

                existing.totalValue += newTotal;

                existing.totalLeftToPay += newTotal;

                existing.isRevokable = existing.isRevokable && isRevokable;

                added = true;

            } else {

                require(existing.isRevokable || ignoreRevokableCheck, "Schedule already exists and is not revokable");

                globalAmountOwed = globalAmountOwed + newTotal - existing.totalValue;

                schedules[tokenContractAddress][beneficiary] = Schedule({

                    singlePayAmount: singlePayAmount,

                    numPayments: numPayments,

                    totalPayments: totalPayments,

                    totalValue: newTotal,

                    totalLeftToPay: newTotal,

                    startBlockNum: startBlock,

                    lastClaimedBlock: 0,

                    totalPaidOut: 0,

                    isRevokable: isRevokable

                });

                added = true;

            }

        } else {

            require(IERC20(tokenContractAddress).balanceOf(address(this)) >= newTotal, "Insufficient tokens for new schedule");

            schedules[tokenContractAddress][beneficiary] = Schedule({

                singlePayAmount: singlePayAmount,

                numPayments: numPayments,

                totalPayments: totalPayments,

                totalValue: newTotal,

                totalLeftToPay: newTotal,

                startBlockNum: startBlock,

                lastClaimedBlock: 0,

                totalPaidOut: 0,

                isRevokable: isRevokable

            });

            tokenScheduleBeneficiaries[tokenContractAddress].push(beneficiary);

            globalAmountOwed += newTotal;

            added = true;

        }

    }

    /// @notice Batch add schedules using a flattened 6-tuple array

    function addReleaseScheduleList(

        address tokenContractAddress,

        address[6][] calldata scheduleData

    ) external onlyTreasuryAdminOrContract returns (uint256 addedCount) {

        for (uint i = 0; i < scheduleData.length; i++) {

            (address b, uint256 s, uint256 n, uint256 t, uint256 o, uint256 r) = (

                scheduleData[i][0],

                scheduleData[i][1],

                scheduleData[i][2],

                scheduleData[i][3],

                scheduleData[i][4],

                scheduleData[i][5]

            );

            if (

                addReleaseSchedule(tokenContractAddress, b, s, n, t, o, r > 0, false, false)

            ) {

                addedCount++;

            }

        }

    }

    /// @notice Claims all available payments up to the current block for the caller

    function claim(address tokenContractAddress) external {

        Schedule storage sch = schedules[tokenContractAddress][msg.sender];

        require(block.number >= sch.startBlockNum, "Not started yet");

        uint256 paymentsEligible = (block.number - sch.startBlockNum);

        uint256 totalEligible = paymentsEligible * sch.singlePayAmount;

        uint256 amountToPay = totalEligible - sch.totalPaidOut;

        require(amountToPay > 0 && sch.totalLeftToPay >= amountToPay, "Nothing to claim");

        sch.totalPaidOut += amountToPay;

        sch.totalLeftToPay -= amountToPay;

        sch.lastClaimedBlock = block.number;

        globalAmountOwed -= amountToPay;

        require(IERC20(tokenContractAddress).transfer(msg.sender, amountToPay), "Transfer failed");

    }

    /// @notice Removes a single revokable schedule

    function removeSchedule(address tokenContractAddress, address beneficiary) external onlyTreasuryAdminOrContract returns (bool removed) {

        Schedule storage s = schedules[tokenContractAddress][beneficiary];

        if (s.isRevokable) {

            globalAmountOwed -= s.totalLeftToPay;

            delete schedules[tokenContractAddress][beneficiary];

            removed = true;

        }

    }

    /// @notice Removes multiple revokable schedules in one call

    function removeMultipleSchedules(address tokenContractAddress, address[] calldata beneficiaries) external onlyTreasuryAdminOrContract returns (uint256 removedCount) {

        for (uint i = 0; i < beneficiaries.length; i++) {

            if (removeSchedule(tokenContractAddress, beneficiaries[i])) {

                removedCount++;

            }

        }

    }

    /// @notice Returns all schedules for a token type

    function getAllSchedulesByToken(address tokenContractAddress) external view returns (BeneficiarySchedule[] memory) {

        address[] memory benes = tokenScheduleBeneficiaries[tokenContractAddress];

        BeneficiarySchedule[] memory results = new BeneficiarySchedule[](benes.length);

        for (uint i = 0; i < benes.length; i++) {

            results[i] = BeneficiarySchedule({

                beneficiary: benes[i],

                schedule: schedules[tokenContractAddress][benes[i]]

            });

        }

        return results;

    }

    /// @notice Returns a single schedule if it exists

    function getSchedule(address tokenContractAddress, address beneficiary) external view returns (BeneficiarySchedule memory) {

        Schedule memory sch = schedules[tokenContractAddress][beneficiary];

        require(sch.totalValue > 0, "Schedule does not exist");

        return BeneficiarySchedule({

            beneficiary: beneficiary,

            schedule: sch

        });

    }

    // CHANGED: removed receive() fallback — ETH funding now handled by ExternalTreasury

}