/**
 *Submitted for verification at Etherscan.io on 2025-04-15
*/

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.18 <0.8.20;

// ungravel.eth, GroupWalletFactory, GroupWalletMaster, GroupWallet, ProxyWallet, TokenMaster, ProxyToken, PrePaidContract, AuctionMaster, BiddingProxy, intDeedMaster, extDeedMaster, IntDeedProxy, Invitations by pepihasenfuss.eth 2017-2025, Copyright (c) 2025

// GroupWallet and Ungravel is entirely based on Ethereum Name Service, "ENS", the domain name registry.

//   ENS, ENSRegistryWithFallback, PublicResolver, Resolver, FIFS-Registrar, Registrar, AuctionRegistrar, BaseRegistrar, ReverseRegistrar, DefaultReverseResolver, ETHRegistrarController,
//   PriceOracle, SimplePriceOracle, StablePriceOracle, ENSMigrationSubdomainRegistrar, CustomRegistrar, Root, RegistrarMigration are contracts of "ENS", by Nick Johnson and team.
//
//   Copyright (c) 2018, True Names Limited / ENS Labs Limited
//
//   Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
//   The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
//   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

interface ENS_F {
  event NewOwner(bytes32 indexed node, bytes32 indexed label, address owner);
  event Transfer(bytes32 indexed node, address owner);
  event NewResolver(bytes32 indexed node, address resolver);
  event NewTTL(bytes32 indexed node, uint64 ttl);
  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 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 ensowner, address operator) external view returns (bool);
}

abstract contract AbstractGWF_ENS {
  event NewOwner(bytes32 indexed node, bytes32 indexed label, address owner);
  event Transfer(bytes32 indexed node, address owner);
  event NewTTL(bytes32 indexed node, uint64 ttl);
  event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

  function setRecord(bytes32 node, address owner, address resolver, uint64 ttl) external virtual;
  function setSubnodeRecord(bytes32 node, bytes32 label, address owner, address resolver, uint64 ttl) external virtual;
  function setSubnodeOwner(bytes32 node, bytes32 label, address owner) external virtual returns(bytes32);
  function setResolver(bytes32 node, address resolver) external virtual;
  function setOwner(bytes32 node, address owner) external virtual;
  
  function owner(bytes32 node) public view virtual returns (address);
  function recordExists(bytes32 node) external virtual view returns (bool);
  function isApprovedForAll(address ensowner, address operator) external virtual view returns (bool);
}

abstract contract AbstractGWF_ReverseRegistrar {
  function claim(address owner) external virtual returns (bytes32);
  function claimWithResolver(address owner, address resolver) external virtual returns (bytes32);
  function setName(string memory name) external virtual returns (bytes32);
  function node(address addr) external virtual pure returns (bytes32);
}

abstract contract AbstractBaseRegistrar {
  event NameMigrated(uint256 indexed id, address indexed owner, uint expires);
  event NameRegistered(uint256 indexed id, address indexed owner, uint expires);
  event NameRenewed(uint256 indexed id, uint expires);

  bytes32 public baseNode;   // The namehash of the TLD this registrar owns eg, (.)eth
  ENS_F public ens;
}

abstract contract AbsIntentionsGWF {
  function saveLetterOfIntent(address target, uint nbOfShares) public virtual payable;
  function hashOfGWP(AbstractGWF_GWP _gwp) internal virtual view returns (bytes32);
  function getIntendedLOIShares(address target, address investor) public virtual view returns (uint);
  function chain_name(uint chainId) public virtual pure returns (string memory);
}

abstract contract AbstractGWF_GWP {
  function getGWF() external view virtual returns (address);
  function getIsOwner(address _owner) external virtual view returns (bool);
  function getOwners()                external virtual view returns (address[] memory);
  function newProxyGroupWallet_j5O(address[] calldata _owners) external virtual payable;
  function reverseENS(string calldata _domain, address _reverse) external virtual;
  function getTransactionsCount() external view virtual returns (uint);
  function getTransactionRecord(uint _tNb) external view virtual returns (uint256);
  function getIntention() public virtual view returns (AbsIntentionsGWF);
}

interface Abstract_TokenProxy {
  function newToken(uint256[] calldata _data) external payable;
}

abstract contract AbstractETHRegController {
  mapping(bytes32=>uint) public commitments;

  uint public minCommitmentAge;
  uint public maxCommitmentAge;

  address public nameWrapper;

  event NameRegistered(string name, bytes32 indexed label, address indexed owner, uint cost, uint expires);
  event NameRenewed(string name, bytes32 indexed label, uint cost, uint expires);
  event NewPriceOracle(address indexed oracle);

  function rentPrice(string memory name, uint duration) view external virtual returns(uint);
  function makeCommitmentWithConfig(string memory name, address owner, bytes32 secret, address resolver, address addr) pure external virtual returns(bytes32);
  function commit(bytes32 commitment) external virtual;
  function register(string calldata name, address owner, uint duration, bytes32 secret) external virtual payable;
  function registerWithConfig(string memory name, address owner, uint duration, bytes32 secret, address resolver, address addr) external virtual payable;
  function available(string memory name) external virtual view returns(bool);
  function register(string calldata name,address owner,uint256 duration,bytes32 secret,address resolver,bytes[] calldata data,bool reverseRecord,uint16 ownerControlledFuses) external virtual payable;
}

abstract contract AbstractGWF_Resolver {
  mapping(bytes32=>bytes) hashes;

  event AddrChanged(bytes32 indexed node, address a);
  event AddressChanged(bytes32 indexed node, uint coinType, bytes newAddress);
  event NameChanged(bytes32 indexed node, string name);
  event ABIChanged(bytes32 indexed node, uint256 indexed contentType);
  event PubkeyChanged(bytes32 indexed node, bytes32 x, bytes32 y);
  event TextChanged(bytes32 indexed node, string indexed indexedKey, string key);
  event ContenthashChanged(bytes32 indexed node, bytes hash);
  
  function ABI(bytes32 node, uint256 contentTypes) external virtual view returns (uint256, bytes memory);
  function addr(bytes32 node) external virtual view returns (address);
  function addr(bytes32 node, uint coinType) external virtual view returns(bytes memory);
  function name(bytes32 node) external virtual view returns (string memory);
  function text(bytes32 node, string calldata key) external virtual view returns (string memory);
  function supportsInterface(bytes4 interfaceId) external virtual view returns (bool);
  function setApprovalForAll(address operator, bool approved) virtual external;

  function setABI(bytes32 node, uint256 contentType, bytes calldata data) external virtual;
  function setAddr(bytes32 node, address r_addr) external virtual;
  function setAddr(bytes32 node, uint coinType, bytes calldata a) external virtual;
  function setName(bytes32 node, string calldata _name) external virtual;
  function setText(bytes32 node, string calldata key, string calldata value) external virtual;
}

abstract contract Abstract_GWF {
  AbstractGWF_Resolver            public  resolverContract;
  AbstractETHRegController        public  controllerContract;
  AbstractBaseRegistrar           public  base;
  AbstractGWF_ENS                 public  ens;
  AbstractGWF_ReverseRegistrar    public  reverseContract;
  address                         public  GWFowner;
  
  mapping(uint64=>uint256)        private installations;                        // installTime +  proxyTokenAddr
  mapping(bytes32=>uint256)       private commitments;                          // commitment  +  ownerAddr
  
  function version() public pure virtual returns(uint256 v);
  function getOwner(bytes32 _domainHash) external virtual view returns (address);
  function importGWP(bytes32 _dHash, uint256 commitment, uint256 installation) external virtual payable;
  function getGWProxy(bytes32 _dHash) public virtual view returns (address);
  function getProxyToken(bytes32 _domainHash) public virtual view returns (address p);
}

interface Abstract_GWPC {
  function getMasterCopy() external view returns (address);
}

abstract contract Abs_AuctionRegistrar {
  function startAuction_ge0(bytes32 _hash, uint revealP) public virtual payable;
  function intentionsFromGWP(bytes32 _hash) public virtual returns (AbsIntentionsGWF);
}

abstract contract NWrapper {
  function setSubnodeRecord(bytes32 parentNode,string memory label,address owner,address resolver,uint64 ttl,uint32 fuses,uint64 expiry) external virtual returns (bytes32 node);
  function setSubnodeOwner(bytes32 node,string calldata label,address newOwner,uint32 fuses,uint64 expiry) external virtual returns (bytes32);
  function setApprovalForAll(address operator,bool approved) external virtual;
  function setRecord(bytes32 node, address owner, address resolver, uint64 ttl) public virtual;
}

interface I_NWrapper {
  function setSubnodeRecord(bytes32 parentNode,string memory label,address owner,address resolver,uint64 ttl,uint32 fuses,uint64 expiry) external returns (bytes32 node);
  function setSubnodeOwner(bytes32 node,string calldata label,address newOwner,uint32 fuses,uint64 expiry) external returns (bytes32);
  function setApprovalForAll(address operator,bool approved) external;
  function setRecord(bytes32 node, address owner, address resolver, uint64 ttl) external;
}

/// @title Proxy - Generic proxy contract allows to execute all transactions applying the code of a master contract.
/// @author Stefan George - <stefan@gnosis.pm> /// ProxyGroupWallet adapted and applied for GroupWallet by pepihasenfuss.eth

contract ProxyGroupWallet {
    address internal masterCopy;

    mapping(uint256 => uint256) private tArr;
    address[]                   private owners;
    
    address internal GWF;                                                       // GWF - GroupWalletFactory contract
    mapping(uint256 => bytes)   private structures;
  
    // *************************************************************************
    event Deposit(address dep_from, uint256 dep_value);
    
    constructor(address _masterCopy, string memory _domainName, AbstractGWF_ReverseRegistrar _reverse) payable
    { 
      masterCopy = _masterCopy;
      _reverse.setName(_domainName);
    }
    
    fallback () external payable
    {   
        // solium-disable-next-line security/no-inline-assembly
        assembly {
            let master := and(sload(0), 0xffffffffffffffffffffffffffffffffffffffff)
            if eq(calldataload(0), 0xa619486e00000000000000000000000000000000000000000000000000000000) {
                mstore(0, master)
                return(0, 0x20)
            }

            let ptr := mload(0x40)
            calldatacopy(ptr, 0, calldatasize())
            let success := delegatecall(gas(), master, ptr, calldatasize(), 0, 0)
            returndatacopy(0, 0, returndatasize())
            if eq(success, 0) { 
              if eq(returndatasize(),0) { revert(0, 0x504) }
              revert(0, returndatasize())
            }
            return(0, returndatasize())
        }
    }
    
    function upgrade(address master) external payable {
      bytes32 hash = bytes32(tArr[uint256(uint160(GWF))]);
      address gwp  = Abstract_GWF(GWF).getProxyToken(hash);
      require(msg.sender==Abstract_GWPC(gwp).getMasterCopy(),"gw");
      masterCopy = master;
    }
    
    receive() external payable { emit Deposit(msg.sender, msg.value); }         // *** GWP can sell common shares to TokenProxy, thus receiving payments ***
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_masterCopy","type":"address"},{"internalType":"string","name":"_domainName","type":"string"},{"internalType":"contract AbstractGWF_ReverseRegistrar","name":"_reverse","type":"address"}],"stateMutability":"payable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"dep_from","type":"address"},{"indexed":false,"internalType":"uint256","name":"dep_value","type":"uint256"}],"name":"Deposit","type":"event"},{"stateMutability":"payable","type":"fallback"},{"inputs":[{"internalType":"address","name":"master","type":"address"}],"name":"upgrade","outputs":[],"stateMutability":"payable","type":"function"},{"stateMutability":"payable","type":"receive"}]

0x60806040526040516104e63803806104e683398101604081905261002291610115565b600080546001600160a01b0319166001600160a01b038581169190911790915560405163c47f002760e01b81529082169063c47f0027906100679085906004016101e7565b6020604051808303816000875af1158015610086573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906100aa919061021a565b50505050610233565b6001600160a01b03811681146100c857600080fd5b50565b634e487b7160e01b600052604160045260246000fd5b60005b838110156100fc5781810151838201526020016100e4565b50506000910152565b8051610110816100b3565b919050565b60008060006060848603121561012a57600080fd5b8351610135816100b3565b60208501519093506001600160401b038082111561015257600080fd5b818601915086601f83011261016657600080fd5b815181811115610178576101786100cb565b604051601f8201601f19908116603f011681019083821181831017156101a0576101a06100cb565b816040528281528960208487010111156101b957600080fd5b6101ca8360208301602088016100e1565b80965050505050506101de60408501610105565b90509250925092565b60208152600082518060208401526102068160408501602087016100e1565b601f01601f19169190910160400192915050565b60006020828403121561022c57600080fd5b5051919050565b6102a4806102426000396000f3fe6080604052600436106100225760003560e01c80630900f010146100b357610061565b3661006157604080513381523460208201527fe1fffcc4923d04b559f4d29a8bfc6cda04eb5b0d3c460751c2402c5c5cc9109c910160405180910390a1005b600080546001600160a01b0316632cf35bc960e11b82350161008557808252602082f35b6040513683823782833683855af49150503d82833e806100ae573d6100aa5761050482fd5b3d82fd5b503d81f35b6100c66100c136600461022d565b6100c8565b005b6003546001600160a01b0316600081815260016020526040808220549051631b5576df60e11b8152600481018290529092906336aaedbe90602401602060405180830381865afa158015610120573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906101449190610251565b9050806001600160a01b03166304e80e906040518163ffffffff1660e01b8152600401602060405180830381865afa158015610184573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906101a89190610251565b6001600160a01b0316336001600160a01b0316146101f15760405162461bcd60e51b8152602060048201526002602482015261677760f01b604482015260640160405180910390fd5b5050600080546001600160a01b0319166001600160a01b0392909216919091179055565b6001600160a01b038116811461022a57600080fd5b50565b60006020828403121561023f57600080fd5b813561024a81610215565b9392505050565b60006020828403121561026357600080fd5b815161024a8161021556fea264697066735822122098b5c081892307733e4b6bc45e91ba9be9033b2bc863136e7bf43cc2f61a1c7b64736f6c63430008130033000000000000000000000000c75aa6f24783083d4d668b0e7d389bbe3f56ea2e0000000000000000000000000000000000000000000000000000000000000060000000000000000000000000a58e81fe9b61b5c3fe2afd33cf304c454abfc7cb00000000000000000000000000000000000000000000000000000000000000206261636b2d6d61696c2e65746800000000000000000000000000000000000000

0x6080604052600436106100225760003560e01c80630900f010146100b357610061565b3661006157604080513381523460208201527fe1fffcc4923d04b559f4d29a8bfc6cda04eb5b0d3c460751c2402c5c5cc9109c910160405180910390a1005b600080546001600160a01b0316632cf35bc960e11b82350161008557808252602082f35b6040513683823782833683855af49150503d82833e806100ae573d6100aa5761050482fd5b3d82fd5b503d81f35b6100c66100c136600461022d565b6100c8565b005b6003546001600160a01b0316600081815260016020526040808220549051631b5576df60e11b8152600481018290529092906336aaedbe90602401602060405180830381865afa158015610120573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906101449190610251565b9050806001600160a01b03166304e80e906040518163ffffffff1660e01b8152600401602060405180830381865afa158015610184573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906101a89190610251565b6001600160a01b0316336001600160a01b0316146101f15760405162461bcd60e51b8152602060048201526002602482015261677760f01b604482015260640160405180910390fd5b5050600080546001600160a01b0319166001600160a01b0392909216919091179055565b6001600160a01b038116811461022a57600080fd5b50565b60006020828403121561023f57600080fd5b813561024a81610215565b9392505050565b60006020828403121561026357600080fd5b815161024a8161021556fea264697066735822122098b5c081892307733e4b6bc45e91ba9be9033b2bc863136e7bf43cc2f61a1c7b64736f6c63430008130033

11622:1983:0:-:0;;;;;;;;;;;;;;;;;;;;;;;13484:30;;;13492:10;188:51:1;;13504:9:0;270:2:1;255:18;;248:34;13484:30:0;;161:18:1;13484:30:0;;;;;;;11622:1983;;12478:1;12472:8;;-1:-1:-1;;;;;12468:57:0;-1:-1:-1;;;12545:15:0;;12542:87;12539:175;;12659:6;12478:1;12649:17;12694:4;12478:1;12684:15;12539:175;12747:4;12741:11;12787:14;12478:1;12779:3;12766:36;12478:1;;12787:14;12859:3;12851:6;12844:5;12831:54;12816:69;;;12920:16;12478:1;;12899:38;12957:7;12951:140;;12993:16;12987:46;;13025:5;12478:1;13015:16;12987:46;13059:16;12478:1;13049:27;12951:140;;13115:16;12478:1;13105:27;13162:276;;;;;;:::i;:::-;;:::i;:::-;;;13265:3;;-1:-1:-1;;;;;13265:3:0;13221:12;13244:27;;;:4;:27;;;;;;;13296:37;;-1:-1:-1;;;13296:37:0;;;;;827:25:1;;;13244:27:0;;13265:3;13296:31;;800:18:1;;13296:37:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;13281:52;;13376:3;-1:-1:-1;;;;;13362:32:0;;:34;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;13350:46:0;:10;-1:-1:-1;;;;;13350:46:0;;13342:60;;;;-1:-1:-1;;;13342:60:0;;1321:2:1;13342:60:0;;;1303:21:1;1360:1;1340:18;;;1333:29;-1:-1:-1;;;1378:18:1;;;1371:32;1420:18;;13342:60:0;;;;;;;;-1:-1:-1;;13411:10:0;:19;;-1:-1:-1;;;;;;13411:19:0;-1:-1:-1;;;;;13411:19:0;;;;;;;;;;13162:276::o;293:131:1:-;-1:-1:-1;;;;;368:31:1;;358:42;;348:70;;414:1;411;404:12;348:70;293:131;:::o;429:247::-;488:6;541:2;529:9;520:7;516:23;512:32;509:52;;;557:1;554;547:12;509:52;596:9;583:23;615:31;640:5;615:31;:::i;:::-;665:5;429:247;-1:-1:-1;;;429:247:1:o;863:251::-;933:6;986:2;974:9;965:7;961:23;957:32;954:52;;;1002:1;999;992:12;954:52;1034:9;1028:16;1053:31;1078:5;1053:31;:::i

ipfs://98b5c081892307733e4b6bc45e91ba9be9033b2bc863136e7bf43cc2f61a1c7b