certusone
/
xdapp-book
mirror of https://github.com/certusone/xdapp-book.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

added registrars and basic registry

This commit is contained in:
spacemandev 2022-10-17 21:20:20 -05:00
parent 1a2cf7ebc1
commit 5ab4e81c7d
3 changed files with 193 additions and 158 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
projects/xid/chains/evm/src/ForeignRegistrar.sol
View File

@ -1,6 +1,27 @@
// SPDX-License-Identifier: Apache 2 // SPDX-License-Identifier: Apache 2
pragma solidity ^0.8.0; pragma solidity ^0.8.0;
contract ForeignRegistrar { import "./XID.sol";
contract HomeRegistrar {
XID xid;
bytes32 rootNode;
modifier only_owner(bytes32 label) {
address currentOwner = xid.owner(keccak256(abi.encodePacked(rootNode, label)));
require(currentOwner == address(0x0) || currentOwner == msg.sender);
_;
}
constructor(XID xidAddr, bytes32 node){
xid = xidAddr;
rootNode = node;
}
/**
Registers label to the first account that claims it.
*/
function register(bytes32 label, address owner) public only_owner(label) {
xid.setSubnodeOwner(rootNode, label, owner);
}
} }

310
projects/xid/chains/evm/src/Registry.sol
View File

@ -1,176 +1,176 @@
pragma solidity ^0.8.0; // pragma solidity ^0.8.0;
/** // /**
* The ENS registry contract. // * The ENS registry contract
*/ // */
contract ENSRegistry { // contract ENSRegistry {
struct Record { // struct Record {
address owner; // address owner;
address resolver; // address resolver;
uint64 ttl; // uint64 ttl;
} // }
mapping (bytes32 => Record) records; // mapping (bytes32 => Record) records;
mapping (address => mapping(address => bool)) operators; // mapping (address => mapping(address => bool)) operators;
// Permits modifications only by the owner of the specified node. // // Permits modifications only by the owner of the specified node.
modifier authorised(bytes32 node) { // modifier authorised(bytes32 node) {
address owner = records[node].owner; // address owner = records[node].owner;
require(owner == msg.sender || operators[owner][msg.sender]); // require(owner == msg.sender || operators[owner][msg.sender]);
_; // _;
} // }
/** // /**
* @dev Constructs a new ENS registrar. // * @dev Constructs a new ENS registrar.
*/ // */
constructor() public { // constructor() public {
records[0x0].owner = msg.sender; // records[0x0].owner = msg.sender;
} // }
/** // /**
* @dev Sets the record for a node. // * @dev Sets the record for a node.
* @param node The node to update. // * @param node The node to update.
* @param owner The address of the new owner. // * @param owner The address of the new owner.
* @param resolver The address of the resolver. // * @param resolver The address of the resolver.
* @param ttl The TTL in seconds. // * @param ttl The TTL in seconds.
*/ // */
function setRecord(bytes32 node, address owner, address resolver, uint64 ttl) external virtual override { // function setRecord(bytes32 node, address owner, address resolver, uint64 ttl) external virtual override {
setOwner(node, owner); // setOwner(node, owner);
_setResolverAndTTL(node, resolver, ttl); // _setResolverAndTTL(node, resolver, ttl);
} // }
/** // /**
* @dev Sets the record for a subnode. // * @dev Sets the record for a subnode.
* @param node The parent node. // * @param node The parent node.
* @param label The hash of the label specifying the subnode. // * @param label The hash of the label specifying the subnode.
* @param owner The address of the new owner. // * @param owner The address of the new owner.
* @param resolver The address of the resolver. // * @param resolver The address of the resolver.
* @param ttl The TTL in seconds. // * @param ttl The TTL in seconds.
*/ // */
function setSubnodeRecord(bytes32 node, bytes32 label, address owner, address resolver, uint64 ttl) external virtual override { // function setSubnodeRecord(bytes32 node, bytes32 label, address owner, address resolver, uint64 ttl) external virtual override {
bytes32 subnode = setSubnodeOwner(node, label, owner); // bytes32 subnode = setSubnodeOwner(node, label, owner);
_setResolverAndTTL(subnode, resolver, ttl); // _setResolverAndTTL(subnode, resolver, ttl);
} // }
/** // /**
* @dev Transfers ownership of a node to a new address. May only be called by the current owner of the node. // * @dev Transfers ownership of a node to a new address. May only be called by the current owner of the node.
* @param node The node to transfer ownership of. // * @param node The node to transfer ownership of.
* @param owner The address of the new owner. // * @param owner The address of the new owner.
*/ // */
function setOwner(bytes32 node, address owner) public virtual override authorised(node) { // function setOwner(bytes32 node, address owner) public virtual override authorised(node) {
_setOwner(node, owner); // _setOwner(node, owner);
emit Transfer(node, owner); // emit Transfer(node, owner);
} // }
/** // /**
* @dev Transfers ownership of a subnode keccak256(node, label) to a new address. May only be called by the owner of the parent node. // * @dev Transfers ownership of a subnode keccak256(node, label) to a new address. May only be called by the owner of the parent node.
* @param node The parent node. // * @param node The parent node.
* @param label The hash of the label specifying the subnode. // * @param label The hash of the label specifying the subnode.
* @param owner The address of the new owner. // * @param owner The address of the new owner.
*/ // */
function setSubnodeOwner(bytes32 node, bytes32 label, address owner) public virtual override authorised(node) returns(bytes32) { // function setSubnodeOwner(bytes32 node, bytes32 label, address owner) public virtual override authorised(node) returns(bytes32) {
bytes32 subnode = keccak256(abi.encodePacked(node, label)); // bytes32 subnode = keccak256(abi.encodePacked(node, label));
_setOwner(subnode, owner); // _setOwner(subnode, owner);
emit NewOwner(node, label, owner); // emit NewOwner(node, label, owner);
return subnode; // return subnode;
} // }
/** // /**
* @dev Sets the resolver address for the specified node. // * @dev Sets the resolver address for the specified node.
* @param node The node to update. // * @param node The node to update.
* @param resolver The address of the resolver. // * @param resolver The address of the resolver.
*/ // */
function setResolver(bytes32 node, address resolver) public virtual override authorised(node) { // function setResolver(bytes32 node, address resolver) public virtual override authorised(node) {
emit NewResolver(node, resolver); // emit NewResolver(node, resolver);
records[node].resolver = resolver; // records[node].resolver = resolver;
} // }
/** // /**
* @dev Sets the TTL for the specified node. // * @dev Sets the TTL for the specified node.
* @param node The node to update. // * @param node The node to update.
* @param ttl The TTL in seconds. // * @param ttl The TTL in seconds.
*/ // */
function setTTL(bytes32 node, uint64 ttl) public virtual override authorised(node) { // function setTTL(bytes32 node, uint64 ttl) public virtual override authorised(node) {
emit NewTTL(node, ttl); // emit NewTTL(node, ttl);
records[node].ttl = ttl; // records[node].ttl = ttl;
} // }
/** // /**
* @dev Enable or disable approval for a third party ("operator") to manage // * @dev Enable or disable approval for a third party ("operator") to manage
* all of `msg.sender`'s ENS records. Emits the ApprovalForAll event. // * all of `msg.sender`'s ENS records. Emits the ApprovalForAll event.
* @param operator Address to add to the set of authorized operators. // * @param operator Address to add to the set of authorized operators.
* @param approved True if the operator is approved, false to revoke approval. // * @param approved True if the operator is approved, false to revoke approval.
*/ // */
function setApprovalForAll(address operator, bool approved) external virtual override { // function setApprovalForAll(address operator, bool approved) external virtual override {
operators[msg.sender][operator] = approved; // operators[msg.sender][operator] = approved;
emit ApprovalForAll(msg.sender, operator, approved); // emit ApprovalForAll(msg.sender, operator, approved);
} // }
/** // /**
* @dev Returns the address that owns the specified node. // * @dev Returns the address that owns the specified node.
* @param node The specified node. // * @param node The specified node.
* @return address of the owner. // * @return address of the owner.
*/ // */
function owner(bytes32 node) public virtual override view returns (address) { // function owner(bytes32 node) public virtual override view returns (address) {
address addr = records[node].owner; // address addr = records[node].owner;
if (addr == address(this)) { // if (addr == address(this)) {
return address(0x0); // return address(0x0);
} // }
return addr; // return addr;
} // }
/** // /**
* @dev Returns the address of the resolver for the specified node. // * @dev Returns the address of the resolver for the specified node.
* @param node The specified node. // * @param node The specified node.
* @return address of the resolver. // * @return address of the resolver.
*/ // */
function resolver(bytes32 node) public virtual override view returns (address) { // function resolver(bytes32 node) public virtual override view returns (address) {
return records[node].resolver; // return records[node].resolver;
} // }
/** // /**
* @dev Returns the TTL of a node, and any records associated with it. // * @dev Returns the TTL of a node, and any records associated with it.
* @param node The specified node. // * @param node The specified node.
* @return ttl of the node. // * @return ttl of the node.
*/ // */
function ttl(bytes32 node) public virtual override view returns (uint64) { // function ttl(bytes32 node) public virtual override view returns (uint64) {
return records[node].ttl; // return records[node].ttl;
} // }
/** // /**
* @dev Returns whether a record has been imported to the registry. // * @dev Returns whether a record has been imported to the registry.
* @param node The specified node. // * @param node The specified node.
* @return Bool if record exists // * @return Bool if record exists
*/ // */
function recordExists(bytes32 node) public virtual override view returns (bool) { // function recordExists(bytes32 node) public virtual override view returns (bool) {
return records[node].owner != address(0x0); // return records[node].owner != address(0x0);
} // }
/** // /**
* @dev Query if an address is an authorized operator for another address. // * @dev Query if an address is an authorized operator for another address.
* @param owner The address that owns the records. // * @param owner The address that owns the records.
* @param operator The address that acts on behalf of the owner. // * @param operator The address that acts on behalf of the owner.
* @return True if `operator` is an approved operator for `owner`, false otherwise. // * @return True if `operator` is an approved operator for `owner`, false otherwise.
*/ // */
function isApprovedForAll(address owner, address operator) external virtual override view returns (bool) { // function isApprovedForAll(address owner, address operator) external virtual override view returns (bool) {
return operators[owner][operator]; // return operators[owner][operator];
} // }
function _setOwner(bytes32 node, address owner) internal virtual { // function _setOwner(bytes32 node, address owner) internal virtual {
records[node].owner = owner; // records[node].owner = owner;
} // }
function _setResolverAndTTL(bytes32 node, address resolver, uint64 ttl) internal { // function _setResolverAndTTL(bytes32 node, address resolver, uint64 ttl) internal {
if(resolver != records[node].resolver) { // if(resolver != records[node].resolver) {
records[node].resolver = resolver; // records[node].resolver = resolver;
emit NewResolver(node, resolver); // emit NewResolver(node, resolver);
} // }
if(ttl != records[node].ttl) { // if(ttl != records[node].ttl) {
records[node].ttl = ttl; // records[node].ttl = ttl;
emit NewTTL(node, ttl); // emit NewTTL(node, ttl);
} // }
} // }
} // }

14
projects/xid/chains/evm/src/XIDRegistry.sol
View File

@ -35,6 +35,20 @@ contract XIDRegistry is XID {
records[0x0].owner = msg.sender; records[0x0].owner = msg.sender;
} }
/**
* @dev Returns the address that owns the specified node.
* @param node The specified node.
* @return address of the owner.
*/
function owner(bytes32 node) public virtual override view returns (address) {
address addr = records[node].owner;
if (addr == address(this)) {
return address(0x0);
}
return addr;
}
/** /**
* @dev Transfers ownership of a node to a new address. May only be called by the current owner of the node. * @dev Transfers ownership of a node to a new address. May only be called by the current owner of the node.
* @param node The node to transfer ownership of. * @param node The node to transfer ownership of.