Created using remix-ide: Realtime Ethereum Contract Compiler and Runtime. Load this file by pasting this gists URL or ID at https://remix.ethereum.org/#version=soljson-v0.5.17+commit.d19bba13.js&optimize=true&gist=

balancerForwarder.sol

pragma solidity ^0.5.0;
pragma experimental ABIEncoderV2;

import "./EIP712.sol";
import "./ERC20.sol";
import "./dsProxy.sol";

contract DsaForwarder is DSAuth, EIP712 {
    bytes32 executeSig = bytes32(bytes4(keccak256("execute(address,bytes)")));

    struct Signature {
        bytes32 r;
        bytes32 s;
        uint8 v;
    }

    mapping(address => mapping(address => mapping(bytes4 => bool))) acl;

    function canCall(
        address src,
        address dst,
        bytes4 sig
    ) external view returns (bool) {
        bytes32 _sig = bytes32(sig);
        return src == address(this) && executeSig == _sig ? true : false;
    }

    function forward(
        address signer,
        Signature calldata signature,
        address to,
        bytes calldata data,
        uint256 value,
        address inputToken,
        address outputToken
    ) external {
        // Authentication check
        DSAuth auth = DSAuth(to);
        require(auth.owner() == signer, "Auth Failed");

        bytes32 digest = keccak256(
            abi.encodePacked(
                "\x19\x01",
                DOMAIN_SEPARATOR,
                keccak256(
                    abi.encode(
                        META_TRANSACTION_TYPEHASH,
                        signer,
                        nonces[signer]
                    )
                )
            )
        );

        require(signer != address(0), "invalid-address-0");
        require(
            signer == ecrecover(digest, signature.v, signature.r, signature.s),
            "invalid-signatures"
        );

        _call(signer, to, data, inputToken, value, outputToken);

        nonces[signer]++;
    }

    function _call(
        address signer,
        address to,
        bytes memory data,
        address _inputToken,
        uint256 _value,
        address _outputToken
    ) internal {
        ERC20 erc20 = ERC20(_inputToken);
        erc20.transferFrom(signer, address(this), _value);
        erc20.approve(to, _value);
        (bool success, ) = to.call(data);
        if (!success) {
            assembly {
                let returnDataSize := returndatasize()
                returndatacopy(0, 0, returnDataSize)
                revert(0, returnDataSize)
            }
        } else {
            ERC20 outputToken = ERC20(_outputToken);
            outputToken.transfer(signer, outputToken.balanceOf(address(this)));
        }
    }
}

 
// call args 
// "0x36eC99A4CA6F1a3E3299aEB94587F34A9E6adA1f","0x185b0Eec4Fd74DA335702207f77999181d0eFb1c","0x1cff79cd00000000000000000000000002efdb542b9390ae7c1620b29674e02f9c0d86cc00000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000084c1762b1500000000000000000000000031670617b85451e5e3813e50442eed3ce3b68d19000000000000000000000000d0a1e359811322d97991e03f863a0c30c2cf029c00000000000000000000000000000000000000000000000001aa535d3d0c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000","0xd0A1E359811322d97991E03f863a0C30C2cF029C","120000000000000000","0x31670617b85451e5e3813e50442eed3ce3b68d19"

bunch.sol

pragma solidity ^0.5.0;
pragma experimental ABIEncoderV2;

import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v2.4.0/contracts/token/ERC20/IERC20.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v2.4.0/contracts/token/ERC20/SafeERC20.sol";

 

contract Bunch {
  
  using SafeERC20 for IERC20;
  
address ethAddress = address(0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE); 

    function multiToken(address _target,address payable _address,uint _value) internal  {
        
            if(_target == ethAddress){
                address(_address).transfer(_value);
            }else{
             IERC20 erc20 = IERC20(_target);
             erc20.safeTransfer(_address,_value);
            }
        
    }   
    


    function execute(
       address[] calldata tokenAddresses,
       address payable[] calldata addresses,
       uint[] calldata values
    )
    external
    payable
    {
        
        for (uint i = 0; i < tokenAddresses.length; i++) {
            multiToken(tokenAddresses[i], addresses[i],values[i]);
        }
        
    }
}

ds-guard.sol

// guard.sol -- simple whitelist implementation of DSAuthority

// Copyright (C) 2017  DappHub, LLC

// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.





pragma solidity ^0.4.13;

contract DSAuthority {
    function canCall(
        address src, address dst, bytes4 sig
    ) public view returns (bool);
}

contract DSAuthEvents {
    event LogSetAuthority (address indexed authority);
    event LogSetOwner     (address indexed owner);
}

contract DSAuth is DSAuthEvents {
    DSAuthority  public  authority;
    address      public  owner;

    function DSAuth() public {
        owner = msg.sender;
        LogSetOwner(msg.sender);
    }

    function setOwner(address owner_)
        public
        auth
    {
        owner = owner_;
        LogSetOwner(owner);
    }

    function setAuthority(DSAuthority authority_)
        public
        auth
    {
        authority = authority_;
        LogSetAuthority(authority);
    }

    modifier auth {
        require(isAuthorized(msg.sender, msg.sig));
        _;
    }

    function isAuthorized(address src, bytes4 sig) internal view returns (bool) {
        if (src == address(this)) {
            return true;
        } else if (src == owner) {
            return true;
        } else if (authority == DSAuthority(0)) {
            return false;
        } else {
            return authority.canCall(src, this, sig);
        }
    }
}

contract DSGuardEvents {
    event LogPermit(
        bytes32 indexed src,
        bytes32 indexed dst,
        bytes32 indexed sig
    );

    event LogForbid(
        bytes32 indexed src,
        bytes32 indexed dst,
        bytes32 indexed sig
    );
}

contract DSGuard is DSAuth, DSAuthority, DSGuardEvents {
    bytes32 constant public ANY = bytes32(uint(-1));

    mapping (bytes32 => mapping (bytes32 => mapping (bytes32 => bool))) acl;

    function canCall(
        address src_, address dst_, bytes4 sig
    ) public view returns (bool) {
        var src = bytes32(src_);
        var dst = bytes32(dst_);

        return acl[src][dst][sig]
            || acl[src][dst][ANY]
            || acl[src][ANY][sig]
            || acl[src][ANY][ANY]
            || acl[ANY][dst][sig]
            || acl[ANY][dst][ANY]
            || acl[ANY][ANY][sig]
            || acl[ANY][ANY][ANY];
    }

    function permit(bytes32 src, bytes32 dst, bytes32 sig) public auth {
        acl[src][dst][sig] = true;
        LogPermit(src, dst, sig);
    }

    function forbid(bytes32 src, bytes32 dst, bytes32 sig) public auth {
        acl[src][dst][sig] = false;
        LogForbid(src, dst, sig);
    }

    function permit(address src, address dst, bytes32 sig) public {
        permit(bytes32(src), bytes32(dst), sig);
    }
    function forbid(address src, address dst, bytes32 sig) public {
        forbid(bytes32(src), bytes32(dst), sig);
    }

}

contract DSGuardFactory {
    mapping (address => bool)  public  isGuard;

    function newGuard() public returns (DSGuard guard) {
        guard = new DSGuard();
        guard.setOwner(msg.sender);
        isGuard[guard] = true;
    }
}

dsProxy.sol

// proxy.sol - execute actions atomically through the proxy's identity

// Copyright (C) 2017  DappHub, LLC

// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.






pragma solidity 0.5.12;

interface DSAuthority {
    function canCall(
        address src, address dst, bytes4 sig
    ) external view returns (bool);
}

contract DSAuthEvents {
    event LogSetAuthority (address indexed authority);
    event LogSetOwner     (address indexed owner);
}

contract DSAuth is DSAuthEvents {
    DSAuthority  public  authority;
    address      public  owner;

    constructor() public {
        owner = msg.sender;
        emit LogSetOwner(msg.sender);
    }

    function setOwner(address owner_)
        public
        auth
    {
        owner = owner_;
        emit LogSetOwner(owner);
    }

    function setAuthority(DSAuthority authority_)
        public
        auth
    {
        authority = authority_;
        emit LogSetAuthority(address(authority));
    }

    modifier auth {
        require(isAuthorized(msg.sender, msg.sig), "ds-auth-unauthorized");
        _;
    }

    function isAuthorized(address src, bytes4 sig) internal view returns (bool) {
        if (src == address(this)) {
            return true;
        } else if (src == owner) {
            return true;
        } else if (authority == DSAuthority(0)) {
            return false;
        } else {
            return authority.canCall(src, address(this), sig);
        }
    }
}

contract DSNote {
    event LogNote(
        bytes4   indexed  sig,
        address  indexed  guy,
        bytes32  indexed  foo,
        bytes32  indexed  bar,
        uint256           wad,
        bytes             fax
    ) anonymous;

    modifier note {
        bytes32 foo;
        bytes32 bar;
        uint256 wad;

        assembly {
            foo := calldataload(4)
            bar := calldataload(36)
            wad := callvalue()
        }

        _;

        emit LogNote(msg.sig, msg.sender, foo, bar, wad, msg.data);
    }
}






// DSProxy
// Allows code execution using a persistant identity This can be very
// useful to execute a sequence of atomic actions. Since the owner of
// the proxy can be changed, this allows for dynamic ownership models
// i.e. a multisig
contract DSProxy is DSAuth, DSNote {
    DSProxyCache public cache;  // global cache for contracts

    constructor(address _cacheAddr) public {
        setCache(_cacheAddr);
    }

    function() external payable {
    }

    // use the proxy to execute calldata _data on contract _code
    function execute(bytes memory _code, bytes memory _data)
        public
        payable
        returns (address target, bytes memory response)
    {
        target = cache.read(_code);
        if (target == address(0)) {
            // deploy contract & store its address in cache
            target = cache.write(_code);
        }

        response = execute(target, _data);
    }

    function execute(address _target, bytes memory _data)
        public
        auth
        note
        payable
        returns (bytes memory response)
    {
        require(_target != address(0), "ds-proxy-target-address-required");

        // call contract in current context
        assembly {
            let succeeded := delegatecall(sub(gas, 5000), _target, add(_data, 0x20), mload(_data), 0, 0)
            let size := returndatasize

            response := mload(0x40)
            mstore(0x40, add(response, and(add(add(size, 0x20), 0x1f), not(0x1f))))
            mstore(response, size)
            returndatacopy(add(response, 0x20), 0, size)

            switch iszero(succeeded)
            case 1 {
                // throw if delegatecall failed
                revert(add(response, 0x20), size)
            }
        }
    }

    //set new cache
    function setCache(address _cacheAddr)
        public
        auth
        note
        returns (bool)
    {
        require(_cacheAddr != address(0), "ds-proxy-cache-address-required");
        cache = DSProxyCache(_cacheAddr);  // overwrite cache
        return true;
    }
}

// DSProxyFactory
// This factory deploys new proxy instances through build()
// Deployed proxy addresses are logged
contract DSProxyFactory {
    event Created(address indexed sender, address indexed owner, address proxy, address cache);
    mapping(address=>bool) public isProxy;
    DSProxyCache public cache;

    constructor() public {
        cache = new DSProxyCache();
    }

    // deploys a new proxy instance
    // sets owner of proxy to caller
    function build() public returns (address payable proxy) {
        proxy = build(msg.sender);
    }

    // deploys a new proxy instance
    // sets custom owner of proxy
    function build(address owner) public returns (address payable proxy) {
        proxy = address(new DSProxy(address(cache)));
        emit Created(msg.sender, owner, address(proxy), address(cache));
        DSProxy(proxy).setOwner(owner);
        isProxy[proxy] = true;
    }
}

// DSProxyCache
// This global cache stores addresses of contracts previously deployed
// by a proxy. This saves gas from repeat deployment of the same
// contracts and eliminates blockchain bloat.

// By default, all proxies deployed from the same factory store
// contracts in the same cache. The cache a proxy instance uses can be
// changed.  The cache uses the sha3 hash of a contract's bytecode to
// lookup the address
contract DSProxyCache {
    mapping(bytes32 => address) cache;

    function read(bytes memory _code) public view returns (address) {
        bytes32 hash = keccak256(_code);
        return cache[hash];
    }

    function write(bytes memory _code) public returns (address target) {
        assembly {
            target := create(0, add(_code, 0x20), mload(_code))
            switch iszero(extcodesize(target))
            case 1 {
                // throw if contract failed to deploy
                revert(0, 0)
            }
        }
        bytes32 hash = keccak256(_code);
        cache[hash] = target;
    }
}

EIP712.sol

pragma solidity ^0.5.0;

contract EIP712 {
    
mapping(address => uint256) public nonces;

struct EIP712Domain {
    string name;
    string version;
    uint256 chainId;
    address verifyingContract;
  }
  
struct MetaTransaction {
    address holder;
    uint256 nonce;
  }
  
bytes32 internal constant EIP712_DOMAIN_TYPEHASH = keccak256(bytes("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"));
bytes32 internal constant META_TRANSACTION_TYPEHASH = keccak256(bytes("MetaTransaction(address holder,uint256 nonce)"));
bytes32 internal  DOMAIN_SEPARATOR = keccak256(abi.encode(
    EIP712_DOMAIN_TYPEHASH,
    keccak256(bytes("balancer")),
    keccak256(bytes("1")),
    42, // Kovan
    address(this)
  ));

}

ens.sol

pragma solidity ^0.5.0;
pragma experimental ABIEncoderV2;

import "https://github.com/ensdomains/ens/blob/master/contracts/ENSRegistryWithFallback.sol";

ERC20.sol

 pragma solidity ^0.5.0; 

interface ERC20 {
    function totalSupply() external view returns (uint supply);
    function balanceOf(address _owner) external view returns (uint balance);
    function transfer(address _to, uint _value) external returns (bool success);
    function transferFrom(address _from, address _to, uint _value) external returns (bool success);
    function approve(address _spender, uint _value) external returns (bool success);
    function allowance(address _owner, address _spender) external view returns (uint remaining);
    function decimals() external view returns(uint digits);
    event Approval(address indexed _owner, address indexed _spender, uint _value);
}

hash.sol

pragma solidity 0.5.0;

contract HashMyFunction{
     function hashMe(address[] memory targets,address payable[] memory addresses,uint[] memory values) public pure returns(bytes memory){
             return abi.encodeWithSignature("multiToken(address[],address[],uint256[])",targets,addresses,values);
        }
        
        
    function test() external pure returns (bytes memory){
            return abi.encodeWithSelector(bytes4(keccak256('setAuthority(address)')));
        }
        
        
        function ens() external pure returns (bytes32){
            return bytes32(keccak256('apple'));
        }
        
                
        function ens1() external pure returns (bytes32){
            return bytes32(keccak256('banana'));
        }
                
        function ens2() external pure returns (bytes32){
            return bytes32(keccak256('cat'));
        }
                
        function ens3() external pure returns (bytes32){
            return bytes32(keccak256('dog'));
        }
                
        function ens4() external pure returns (bytes32){
            return bytes32(keccak256('eye'));
        }
}


 

multiSender.sol

pragma solidity ^0.5.0; 

 import "./ParcelStorage.sol";
 import "./ERC20.sol";
 


contract MultiSender is ParcelStorage{
    
    function multiToken(address[] memory targets,address payable[] memory addresses,uint[] memory values) public payable {
        
        for (uint i = 0; i < addresses.length; i++) {
            if(targets[i] == ethAddress){
                address(addresses[i]).transfer(values[i]);
            }else{
             ERC20 erc20 = ERC20(targets[i]);
             erc20.transfer(addresses[i],values[i]);
            }
        }
    }   
    

        
    function hashMe(address[] memory targets,address payable[] memory addresses,uint[] memory values) public pure returns(bytes memory){
             return abi.encodeWithSignature("multiToken(address[],address[],uint256[])",targets,addresses,values);
        }
        
        
    function() external payable {
        
        }
}

parcelFactory.sol

 
pragma solidity ^0.5.0;

import "parcelProxy.sol";

interface ENS {

    // Logged when the owner of a node assigns a new owner to a subnode.
    event NewOwner(bytes32 indexed node, bytes32 indexed label, address owner);

    // Logged when the owner of a node transfers ownership to a new account.
    event Transfer(bytes32 indexed node, address owner);

    // Logged when the resolver for a node changes.
    event NewResolver(bytes32 indexed node, address resolver);

    // Logged when the TTL of a node changes
    event NewTTL(bytes32 indexed node, uint64 ttl);

    // Logged when an operator is added or removed.
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    function setRecord(bytes32 node, address owner, address resolver, uint64 ttl) external;
    function setSubnodeRecord(bytes32 node, bytes32 label, address owner, address resolver, uint64 ttl) external;
    function setSubnodeOwner(bytes32 node, bytes32 label, address owner) external returns(bytes32);
    function setResolver(bytes32 node, address resolver) external;
    function setOwner(bytes32 node, address owner) external;
    function setTTL(bytes32 node, uint64 ttl) external;
    function setApprovalForAll(address operator, bool approved) external;
    function owner(bytes32 node) external view returns (address);
    function resolver(bytes32 node) external view returns (address);
    function ttl(bytes32 node) external view returns (uint64);
    function recordExists(bytes32 node) external view returns (bool);
    // function isApprovedForAll(address owner, address operator) external view returns (bool);
}




contract ParcelRegistry {
    mapping(address => address) public registered;
    ENS ENSRegistry = ENS(0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e);
    address public publicResolverAddr = 0xf6305c19e814d2a75429Fd637d01F7ee0E77d615;
    PublicResolver ENSResolver =  PublicResolver(publicResolverAddr);

    // modifier oneAccount {
    //     require(registered[msg.sender] == address(0), "account exists");
    //     _;
    // }
    function changeENSOwner(bytes32 _node, address _newOwner)external {
        ENSRegistry.setOwner(_node,_newOwner);
    } 


    function createSubDomain(bytes32 _node, bytes32 _label, address _ownerOfSubdomain) external {
        ENSRegistry.setSubnodeOwner(_node,_label,_ownerOfSubdomain);
    }
    
    function createSubnodeOwner(bytes32 _node, bytes32 _label, address _ownerOfSubdomain) external {
        ENSRegistry.setSubnodeRecord(_node,_label,_ownerOfSubdomain,publicResolverAddr,0);
    }


function setAdd(bytes32 _ownerNode , address _owner) external {
     ENSResolver.setAddr(_ownerNode,_owner);
}







    function register(bytes32 _node, bytes32 _label, bytes32 _ownerNode) external payable  returns (address) {
       
        
        ENSRegistry.setSubnodeRecord(_node,_label,address(this),publicResolverAddr,0);
        ENSResolver.setAddr(_ownerNode,address(this));
        
        ParcelProxy newAccount = new ParcelProxy(msg.sender);
        registered[msg.sender] = address(newAccount);
        
        ENSRegistry.setSubnodeOwner(_node,_label,address(newAccount));
        
        
        PublicResolver myAccount = PublicResolver(address(newAccount));
        myAccount.setAddr(_ownerNode,address(newAccount));
        
        return address(newAccount);
    }
}

// Public resolver :  0xf6305c19e814d2a75429fd637d01f7ee0e77d615

 
// parcelpay.eth namehash
// 0x80fcc19e84f9861048b415dfeb3aadd7737e20ab244c3fd19e572d92ecc65617

parcelProxy.sol

 
pragma solidity ^0.5.0;
pragma experimental ABIEncoderV2;

import "./parcelStorage.sol";

interface PublicResolver{
    function setAddr(bytes32 node, address addr) external;
}
contract ParcelProxy is ParcelStorage {
    
    address public publicResolverAddr = 0xf6305c19e814d2a75429Fd637d01F7ee0E77d615;
    PublicResolver ENSResolver =  PublicResolver(publicResolverAddr);
    constructor(address _owner) public {
        owner = _owner;
       
    }
    
    

function setAddr(bytes32 node, address addr) external{
        ENSResolver.setAddr(node,addr);   
}

    modifier onlyOwner {
        require(msg.sender == owner, "Not the Owner");
        _;
    }

    /**
     * @dev Delegate the calls to Connector And this function is ran by cast().
     * @param _target Target to of Connector.
     * @param _data CallData of function in Connector.
     */
    function _call(address _target, bytes memory _data) internal {
        require(_target != address(0), "target-invalid");
        assembly {
            let succeeded := delegatecall(
                gas(),
                _target,
                add(_data, 0x20),
                mload(_data),
                0,
                0
            )

            switch iszero(succeeded)
                case 1 {
                    // throw if delegatecall failed
                    let size := returndatasize()
                    returndatacopy(0x00, 0x00, size)
                    revert(0x00, size)
                }
        }
    }

    /**
     * @dev This is the main function
     * @param targets Array of Target(s) to of Implementation.
     * @param data Array of Calldata(s) of function.
     */
    function execute(address[] calldata targets, bytes[] calldata data)
        external
        payable
        onlyOwner
    {
        for (uint256 i = 0; i < targets.length; i++) {
            _call(targets[i], data[i]);
        }
    }

    function() external payable {}
    
    
    
    function addFile(uint8 index, bytes calldata hash) external onlyOwner {
        files[index] = hash;
    }
    
}

ParcelStorage.sol

pragma solidity ^0.5.0; 

// import "./uniswapInterface.sol";
// import "./cTokenInterface.sol";
// import "./ERC20.sol";
// import "./comptrollerInterface.sol";
// import "./aaveInterface.sol";
// import "./aTokenInterface.sol";

interface ILendingPoolAddressesProvider {
    function getLendingPool() external view returns (address);
}
 
contract ParcelStorage{
     address public uniswapRouterAddress = 0xf164fC0Ec4E93095b804a4795bBe1e041497b92a;
    //  UniswapInterface uniswap = UniswapInterface(uniswapRouterAddress);
     address WETH_KOVAN = 0xd0A1E359811322d97991E03f863a0C30C2cF029C;
     address DAI_KOVAN = 0x4F96Fe3b7A6Cf9725f59d353F723c1bDb64CA6Aa;
     address cEthAddress = 0xf92FbE0D3C0dcDAE407923b2Ac17eC223b1084E4;
    //  cTokenInterface cEth = cTokenInterface(cEthAddress);
     address cDaiAddress = 0xe7bc397DBd069fC7d0109C0636d06888bb50668c;
    //  cTokenInterface cDai = cTokenInterface(cDaiAddress);
     address comptrollerAddress = 0x1f5D7F3CaAC149fE41b8bd62A3673FE6eC0AB73b;
    //  comptrollerInterface comptroller =  comptrollerInterface(comptrollerAddress);
    //  cTokenInterface dai = cTokenInterface(DAI_KOVAN);
     address public owner;
     
//      // Retrieve LendingPool address
// ILendingPoolAddressesProvider provider = ILendingPoolAddressesProvider(address(0x506B0B2CF20FAA8f38a4E2B524EE43e1f4458Cc5)); // mainnet address, for other addresses: https://docs.aave.com/developers/developing-on-aave/deployed-contract-instances
// LendingPool lendingPool = LendingPool(provider.getLendingPool());

// Input variables
address ethAddress = address(0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE); 
uint16 referral = 0;
}

parcelStorage.sol

pragma solidity ^0.5.0;

contract ParcelStorage {
    address public owner;
    mapping(uint8 => bytes) public files;
}

singleBunch.sol

pragma solidity ^0.5.0;
pragma experimental ABIEncoderV2;

import "./ParcelStorage.sol";
import "./ERC20.sol";
 

contract Bunch is ParcelStorage{
  
    // @dev Delegate the calls to Connector And this function is ran by execute().
    //  * @param _target Target to of Connector.
    //  * @param _data CallData of function in Connector.
    // */
    // function _call(address _target, bytes memory _data) internal {
        
        
    //     require(_target != address(0), "target-invalid");
    //     assembly {
    //         let succeeded := delegatecall(
    //             gas(),
    //             _target,
    //             add(_data, 0x20),
    //             mload(_data),
    //             0,
    //             0
    //         )

    //         switch iszero(succeeded)
    //             case 1 {
    //                 // throw if delegatecall failed
    //                 let size := returndatasize()
    //                 returndatacopy(0x00, 0x00, size)
    //                 revert(0x00, size)
    //             }
    //     }
    // }
   
    function multiToken(address targets,address payable addresses,uint values) internal  {
        
            if(targets == ethAddress){
                address(addresses).transfer(values);
            }else{
             ERC20 erc20 = ERC20(targets);
             erc20.transfer(addresses,values);
            }
        
    }   
    


    function execute(
       address[] calldata targets,
       address payable[] calldata addresses,
       uint[] calldata values
    )
    external
    payable
    {
        
        for (uint i = 0; i < targets.length; i++) {
            multiToken(targets[i], addresses[i],values[i]);
        }
        
    }
}

testParcel.sol

 
pragma solidity ^0.5.0;

import "parcelProxy.sol";

interface ENS {

    // Logged when the owner of a node assigns a new owner to a subnode.
    event NewOwner(bytes32 indexed node, bytes32 indexed label, address owner);

    // Logged when the owner of a node transfers ownership to a new account.
    event Transfer(bytes32 indexed node, address owner);

    // Logged when the resolver for a node changes.
    event NewResolver(bytes32 indexed node, address resolver);

    // Logged when the TTL of a node changes
    event NewTTL(bytes32 indexed node, uint64 ttl);

    // Logged when an operator is added or removed.
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    function setRecord(bytes32 node, address owner, address resolver, uint64 ttl) external;
    function setSubnodeRecord(bytes32 node, bytes32 label, address owner, address resolver, uint64 ttl) external;
    function setSubnodeOwner(bytes32 node, bytes32 label, address owner) external returns(bytes32);
    function setResolver(bytes32 node, address resolver) external;
    function setOwner(bytes32 node, address owner) external;
    function setTTL(bytes32 node, uint64 ttl) external;
    function setApprovalForAll(address operator, bool approved) external;
    function owner(bytes32 node) external view returns (address);
    function resolver(bytes32 node) external view returns (address);
    function ttl(bytes32 node) external view returns (uint64);
    function recordExists(bytes32 node) external view returns (bool);
    // function isApprovedForAll(address owner, address operator) external view returns (bool);
}



interface PublicResolver{
    function setAddr(bytes32 node, address addr) external;
}
contract Test {
    mapping(address => address) public registered;
    ENS ENSRegistry = ENS(0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e);
    address public publicResolverAddr = 0xf6305c19e814d2a75429Fd637d01F7ee0E77d615;
    PublicResolver ENSResolver =  PublicResolver(publicResolverAddr);

    // modifier oneAccount {
    //     require(registered[msg.sender] == address(0), "account exists");
    //     _;
    // }
    function changeENSOwner(bytes32 _node, address _newOwner)external {
        ENSRegistry.setOwner(_node,_newOwner);
    } 


    function createSubDomain(bytes32 _node, bytes32 _label, address _ownerOfSubdomain) external {
        ENSRegistry.setSubnodeOwner(_node,_label,_ownerOfSubdomain);
    }
    
    function createSubnodeOwner(bytes32 _node, bytes32 _label, address _ownerOfSubdomain) external {
        ENSRegistry.setSubnodeRecord(_node,_label,_ownerOfSubdomain,publicResolverAddr,0);
    }


function change(bytes32 _node, bytes32 _label, address _ownerOfSubdomain) external {
    ENSRegistry.setSubnodeOwner(_node,_label,_ownerOfSubdomain);
}

function create(bytes32 _node, bytes32 _label, address _ownerOfSubdomain) external {
     ENSRegistry.setSubnodeRecord(_node,_label,address(this),publicResolverAddr,0);
     
}

function setAdd(bytes32 _ownerNode , address _owner) external {
     ENSResolver.setAddr(_ownerNode,address(this));
}


    function register() external payable  returns (address) {
        ParcelProxy newAccount = new ParcelProxy(msg.sender);
        registered[msg.sender] = address(newAccount);
    }
}

// Public resolver :  0xf6305c19e814d2a75429fd637d01f7ee0e77d615

 
// parcelpay.eth namehash
// 0x80fcc19e84f9861048b415dfeb3aadd7737e20ab244c3fd19e572d92ecc65617