Anfängliche Bereitstellung des ERC20-Tokens, aufgeteilt in 2 oder mehr fest codierte Adressen

Ich weiß nicht, ob mir jemand helfen kann, aber lassen Sie mich mein Problem erklären. Für mehr Transparenz in meinem ERC20-Token-Generierungs-Smart-Vertrag möchte ich den Team-Pool (0xA) und den Crowdfunding-Pool (0xB) mit Zuweisungsbeträgen fest codieren, nur als Beispiel.

constructor() public {
    symbol = "STT";
    name = "Sample Token";
    decimals = 18; 

    totalSupply_ = 500000000 * (10 ** uint256(decimals));
    // Now we need to split the total supply into 2 hardcoded addresses
}

//my pseudo code idea 
function allocate() public {
    allocations[0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA] = 250000000 * (10 ** uint256(decimals));
    allocations[0xBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB] = 250000000 * (10 ** uint256(decimals)); 
}

Bedeutet, dass nach der Bereitstellung der gesamte Vorrat an zwei Ethereum-Adressen verteilt wird.

Kann mich bitte jemand anleiten und wie die Beträge während der Bereitstellung gesendet werden. ? Der Rest des Codes basiert auf https://github.com/OpenZeppelin/openzeppelin-solidity BasicToken ohne Mint oder Burn

Vielen Dank im Voraus

Beifall

contract SampleToken is PausableToken {
    string public constant name = "Sample Token"; 
    string public constant symbol = "STT";
    uint256 public constant decimals = 18;

    mapping (address => uint256) freezes;

    /* This notifies clients about the amount burnt */
    event Burn(address indexed from, uint256 value);

    /* This notifies clients about the amount frozen */
    event Freeze(address indexed from, uint256 value);

    /* This notifies clients about the amount unfrozen */
    event Unfreeze(address indexed from, uint256 value);

    constructor() public {
        totalSupply_ = 500000000 * (10 ** uint256(decimals));
        balances[msg.sender] = totalSupply_;
        // we need to split the total supply to two or more addresses 
    }

    function freezeOf(address _owner) public view returns (uint256) {
        return freezes[_owner];
    }

    function burn(uint256 _value) whenNotPaused public returns (bool) {
        require(_value <= balances[msg.sender]);

        balances[msg.sender] = balances[msg.sender].sub(_value);
        totalSupply_ = totalSupply_.sub(_value);
        emit Burn(msg.sender, _value);
        return true;
    }

    function freeze(uint256 _value) whenNotPaused public returns (bool) {
        require(_value <= balances[msg.sender]);

        balances[msg.sender] = balances[msg.sender].sub(_value);
        freezes[msg.sender] = freezes[msg.sender].add(_value);
        emit Freeze(msg.sender, _value);
        return true;
    }

    function unfreeze(uint256 _value) whenNotPaused public returns (bool) {
        require(_value <= freezes[msg.sender]);

        freezes[msg.sender] = freezes[msg.sender].sub(_value);
        balances[msg.sender] = balances[msg.sender].add(_value);
        emit Unfreeze(msg.sender, _value);
        return true;
    }

    /**
    * @dev Allows the current owner to transfer control of the contract to a newOwner.
    * @param newOwner The address to transfer ownership to.
    */
    function transferOwnership(address newOwner) onlyOwner whenNotPaused public {
        super.transferOwnership(newOwner);
    }

    /**
    * The fallback function.
    */
    function() payable external {
        revert();
    }
}