Bancor

1/**
2 * @dev This contract maintains contract addresses by name.
3 *
4 * The owner can update contract addresses so that a contract name always points to the latest version
5 * of the given contract.
6 *
7 * Other contracts can query the registry to get updated addresses instead of depending on specific
8 * addresses.
9 *
10 * Note that contract names are limited to 32 bytes UTF8 encoded ASCII strings to optimize gas costs
11 */
12contract ContractRegistry is IContractRegistry, Owned, Utils {
13    struct RegistryItem {
14        address contractAddress; // contract address
15        uint256 nameIndex; // index of the item in the list of contract names
16    }
17​
18    mapping(bytes32 => RegistryItem) private items; // name -> RegistryItem mapping
19    string[] public contractNames; // list of all registered contract names
20​
21    /**
22     * @dev triggered when an address pointed to by a contract name is modified
23     *
24     * @param _contractName    contract name
25     * @param _contractAddress new contract address
26     */
27    event AddressUpdate(bytes32 indexed _contractName, address _contractAddress);
28​
29    /**
30     * @dev returns the number of items in the registry
31     *
32     * @return number of items
33     */
34    function itemCount() public view returns (uint256) {
35        return contractNames.length;
36    }
37​
38    /**
39     * @dev returns the address associated with the given contract name
40     *
41     * @param _contractName    contract name
42     *
43     * @return contract address
44     */
45    function addressOf(bytes32 _contractName) public view override returns (address) {
46        return items[_contractName].contractAddress;
47    }
48​
49    /**
50     * @dev registers a new address for the contract name in the registry
51     *
52     * @param _contractName     contract name
53     * @param _contractAddress  contract address
54     */
55    function registerAddress(bytes32 _contractName, address _contractAddress)
56        public
57        ownerOnly
58        validAddress(_contractAddress)
59    {
60        // validate input
61        require(_contractName.length > 0, "ERR_INVALID_NAME");
62​
63        // check if any change is needed
64        address currentAddress = items[_contractName].contractAddress;
65        if (_contractAddress == currentAddress) {
66            return;
67        }
68​
69        if (currentAddress == address(0)) {
70            // update the item's index in the list
71            items[_contractName].nameIndex = contractNames.length;
72​
73            // add the contract name to the name list
74            contractNames.push(bytes32ToString(_contractName));
75        }
76​
77        // update the address in the registry
78        items[_contractName].contractAddress = _contractAddress;
79​
80        // dispatch the address update event
81        emit AddressUpdate(_contractName, _contractAddress);
82    }
83​
84    /**
85     * @dev removes an existing contract address from the registry
86     *
87     * @param _contractName contract name
88     */
89    function unregisterAddress(bytes32 _contractName) public ownerOnly {
90        // validate input
91        require(_contractName.length > 0, "ERR_INVALID_NAME");
92        require(items[_contractName].contractAddress != address(0), "ERR_INVALID_NAME");
93​
94        // remove the address from the registry
95        items[_contractName].contractAddress = address(0);
96​
97        / if there are multiple items in the registry, move the last element to the deleted element's position
98        / and modify last element's registryItem.nameIndex in the items collection to point to the right position in contractNames
99        if (contractNames.length > 1) {
100            string memory lastContractNameString = contractNames[contractNames.length - 1];
101            uint256 unregisterIndex = items[_contractName].nameIndex;
102​
103            contractNames[unregisterIndex] = lastContractNameString;
104            bytes32 lastContractName = stringToBytes32(lastContractNameString);
105            RegistryItem storage registryItem = items[lastContractName];
106            registryItem.nameIndex = unregisterIndex;
107        }
108​
109        // remove the last element from the name list
110        contractNames.pop();
111        // zero the deleted element's index
112        items[_contractName].nameIndex = 0;
113​
114        // dispatch the address update event
115        emit AddressUpdate(_contractName, address(0));
116    }
117​
118    /**
119     * @dev utility, converts bytes32 to a string
120     * note that the bytes32 argument is assumed to be UTF8 encoded ASCII string
121     *
122     * @return string representation of the given bytes32 argument
123     */
124    function bytes32ToString(bytes32 _bytes) private pure returns (string memory) {
125        bytes memory byteArray = new bytes(32);
126        for (uint256 i = 0; i < 32; i++) {
127            byteArray[i] = _bytes[i];
128        }
129​
130        return string(byteArray);
131    }
132​
133    /**
134     * @dev utility, converts string to bytes32
135     * note that the bytes32 argument is assumed to be UTF8 encoded ASCII string
136     *
137     * @return string representation of the given bytes32 argument
138     */
139    function stringToBytes32(string memory _string) private pure returns (bytes32) {
140        bytes32 result;
141        assembly {
142            result := mload(add(_string, 32))
143        }
144        return result;
145    }

Solidity Contracts

JavaScript Tests