Blockchain-based domain name registrar and management system

Abstract

A name server receives a request from a client device to access a web page. The name server generates a blockchain query based on the request to query a domain registrar blockchain, which stores domain name registration data in a smart contract. The name server sends the first blockchain query to the domain registrar blockchain. In response to receiving a name server identifier from the domain registrar blockchain, the name server retrieves a DNS record for the web page using the received name server identifier. The name server then provides information from the retrieved DNS record to the client device to enable access to the web page.

Description

[Background technology]

[0001] This application claims the benefit of and incorporates by reference U.S. Provisional Application No. 63 / 408,826, filed September 21, 2022.

[0002] Embodiments of the present invention relate to the field of data storage using blockchain, and more particularly to a blockchain-based domain name registrar.

[0003] The domain name system is a naming system for computing devices and resources (e.g., web pages) on the Internet. The domain name system utilizes Internet Protocol (IP) addresses that are assigned to computing devices and resources, making them identifiable and searchable to enable communication, data exchange, and the like. One important aspect of the domain name system is the storage of domain names and their corresponding IP addresses. This allows users to access desired web pages using web addresses (e.g., URLs) without requiring the users to remember the specific numerical values ​​of the IP addresses that correspond to the desired web pages. When a domain name is registered with a domain name registrar, the registrar can provide domain name resolution services for that domain name. Thus, when a user requests a web page (e.g., by providing a URL to a browser application), a domain name resolution process is performed to identify the corresponding IP address and return the address to the browser application. The domain name resolution process may involve multiple recursive steps of querying name server databases to find DNS records containing IP addresses. Summary of the Invention [Means for solving the problem]

[0004] The technology presented here enables a blockchain-based domain name registrar and management system to convert domain names and their corresponding DNS records into on-chain assets stored and managed directly on the blockchain. The blockchain-based registrar system uses smart contracts on the Ethereum network to support the features and functionality required by the Internet Corporation for Assigned Names and Numbers (ICANN) to become an accredited domain registrar. More specifically, the blockchain-based registrar system supports full functionality equivalent to that of a traditional Web2 registrar, enabling the registration of new domain names and the transfer and renewal of existing domain names.

[0005] A name server of a blockchain-based domain name registrar and management system receives a first request to access a web page from a client device. The name server generates a blockchain query based on the request to query a domain registrar blockchain. The domain registrar blockchain stores domain name registration data in a smart contract. The name server sends the blockchain query to the domain registrar blockchain. The domain registrar blockchain checks the smart contract to determine whether the requested domain name is stored in the domain registrar blockchain and obtains a name server identifier. The name server identifier is used to obtain a DNS record for the web page, and information from the obtained DNS record (e.g., an IP address) is provided to the client device.

[0006] The present invention will be best understood by referring to the following description and accompanying drawings, which are used to illustrate embodiments of the invention. In the drawings: [Brief explanation of the drawings]

[0007] [Figure 1] FIG. 1 illustrates a blockchain-based domain name registrar and management system according to some embodiments described herein.

[0008] [Figure 2] FIG. 2 illustrates an example network system for resolving domain names using a blockchain-based domain registrar according to some embodiments described herein.

[0009] [Figure 3] FIG. 3 illustrates an example network system for sending email messages using a blockchain-based domain registrar according to some embodiments described herein.

[0010] [Figure 4] FIG. 4 illustrates an exemplary network system for performing a new domain name registration process using a blockchain-based domain registrar according to some embodiments described herein.

[0011] [Figure 5] FIG. 5 illustrates an example network system for performing an off-chain renewal process for a domain name using a blockchain-based domain registrar according to some embodiments described herein.

[0012] [Figure 6] FIG. 6 illustrates an example network system for performing an on-chain renewal process for a domain name using a blockchain-based domain registrar according to some embodiments described herein.

[0013] [Figure 7]FIG. 7 illustrates an exemplary network system for performing a domain name transfer process from a blockchain-based domain registrar to a non-blockchain registrar according to some embodiments described herein.

[0014] [Figure 8] FIG. 8 illustrates an exemplary network system for performing a domain name transfer process from a non-blockchain registrar to a blockchain-based domain registrar according to some embodiments described herein.

[0015] [Figure 9] FIG. 9 illustrates an example network system for configuring DNS records for a domain name at a blockchain-based domain registrar according to some embodiments described herein.

[0016] [Figure 10] FIG. 10 is a flow diagram illustrating exemplary operations for a blockchain-based domain name registrar, according to an embodiment.

[0017] [Figure 11] FIG. 11 is a block diagram of an exemplary data processing system that can be used in some embodiments.

[0018] Embodiments of the present disclosure include a blockchain-based domain name registrar and management system. Blockchain serves as a key infrastructure layer for performing distributed computations on a trustless network. Using smart contracts, any set of parties can conduct trustless interactions based on predefined rules. Actions that occur on-chain are fully auditable, immutable, and cryptographically managed. Blockchain is a distributed system that enables high levels of security and direct ownership / control of assets. The blockchain-based domain name registrar and management system can perform operations and processes using blockchain queries and transactions, including domain name registration, renewal, transfer, and DNS record resolution.

[0019] Traditional domain name registrars manage domain name registrations by maintaining domain name registration information in a centralized database. Typical drawbacks of using a centralized database include the introduction of a single point of failure. Furthermore, centralized databases typically have excessive administrative powers, no ability to prove and verify data integrity, and lack an auditable history.

[0020] To address the deficiencies of traditional systems, the disclosed blockchain-based domain name registrar and management system stores domain name registration information and DNS records on a blockchain. Because domain names and their corresponding DNS records are all stored on-chain, the blockchain-based domain name registrar uses a "wrapper" middleware service to translate traditional name server requests into blockchain queries.

[0021] The embodiments described herein address the deficiencies of previous solutions, as well as provide many technical advantages and improvements. A blockchain-based domain name registrar and management system manages and facilitates the administration of domain names using the security and finality guarantees of blockchain transactions, while complying with ICANN requirements and maintaining interoperability with legacy systems. For example, the use of a serverless middleware service to translate traditional name server requests into blockchain queries abstracts the complexity of interfacing with smart contracts and provides an interface structured as a standard name server. This allows the blockchain-based domain name registrar to be queried using requests structured as if they were processed by a traditional database-based domain name registrar.

[0022] Additionally, blockchain-based domain name registrars and management systems can offer the benefits of using blockchain to store DNS records and resolve requests. For example, a decentralized approach to registering and resolving domain names and DNS records using a blockchain-based domain name registrar and management system provides a fully transparent, auditable, and cryptographically secure domain name registration system. Blockchain-based domain name registrars also make current DNS records, historical versions, and administrative actions publicly accessible. Unlike traditional systems, resolving DNS records for on-chain domains does not require access to any centralized service provided by a registrar of record; instead, they can be resolved directly by users themselves. Transactions on top domains do not require a third party and can be performed directly on-chain due to the composable nature of the asset. By issuing domain names on-chain, blockchain-based registrars further improve the composability and interoperability of domain names.

[0023] Furthermore, blockchain-based domain names can have the advantage of real-time transfer and settlement guarantees. For example, because the registration of a domain name on a domain registrar blockchain is tied to on-chain assets (e.g., tokens or NFTs) stored in the domain owner's digital wallet, the domain name can be transferred to another person by transferring on-chain assets from the owner's digital wallet to the new owner's digital wallet. Once the on-chain assets are in the new owner's digital wallet, the new owner alone has control over the domain.

[0024] Figure 1 illustrates a blockchain-based domain name registrar and management system according to some embodiments described herein. The blockchain-based domain name registrar and management system 100 illustrated in Figure 1 includes a name server 102, a blockchain that operates a domain registrar blockchain 106, and a blockchain that operates a DNS resolver blockchain 112. The domain registrar blockchain 106 is a blockchain that operates a domain registrar, and the DNS resolver blockchain 112 is a blockchain that operates a DNS resolver.

[0025] In some embodiments, name server 102 is an authoritative name server configured and authorized to receive requests for domain names and to send IP addresses in response. In the embodiment of Figure 1, name server 102 includes registrar middleware 104 and DNS middleware 110 as separate modules / components. In other embodiments, registrar middleware 104 and DNS middleware 110 are a single module / component of name server 102.

[0026] In one embodiment, registrar middleware 104 is intermediately configured to receive requests from client devices. In an embodiment, registrar middleware 104 is further configured to translate the received requests into blockchain queries for querying domain registrar blockchain 106. Examples of requests received by registrar middleware 104 include accessing / retrieving a web page, sending an email, registering a new domain name, renewing a domain name, transferring a domain name to or from domain registrar blockchain 106, etc. In one embodiment, DNS middleware 110 is intermediately configured to receive DNS requests, translate them into blockchain queries for querying DNS resolver blockchain 112, and return IP addresses from DNS records. In an embodiment, the purpose of registrar middleware 104 and DNS middleware 110 is to maintain a link between domain name information stored off-chain and domain name information in domain registrar blockchain 106.

[0027] In embodiments, registrar middleware 104 and DNS middleware 110 enable blockchain-based domain name registrar and management system 100 to store domain names and DNS records on blockchains (e.g., domain registrar blockchain 106 and DNS resolver blockchain 112) using on-chain assets (e.g., tokens or NFTs). For example, while the domain name registration process involves off-chain operations (e.g., processes with ICANN, registering name servers at a top-level registry, etc.), when a domain name is registered on domain registrar blockchain 106, on-chain assets are minted and added to the digital wallet of the user who registered the domain name.

[0028] On-chain assets serve as the controller / master of domain names in the blockchain-based domain name registrar and management system 100. In embodiments, because on-chain assets are stored in the holder's digital wallet, ownership of the on-chain assets gives the holder of the on-chain assets exclusive administrative rights / permissions over the domain name corresponding to the on-chain asset. For example, changes to a domain name's DNS records stored in the DNS resolver blockchain 112 can only be made by the owner of the on-chain asset associated with the domain name. To update a DNS record in the DNS resolver blockchain 112, a request can include the owner's digital wallet address to indicate that the request is from the owner of the on-chain asset. In contrast, traditional database-based domain registrars manage domain names stored in a centralized database. While users can contact the traditional domain registrar to reset credentials or change DNS records, the traditional domain registrar has ultimate control over whether to execute the requested action. For example, when a request to change a DNS record is sent to a traditional domain registrar, the traditional domain registrar decides whether to execute the request.

[0029] In one embodiment, on-chain assets can be transferred from one user to another (e.g., via an on-chain transaction between digital wallets), and once transferred, the new owner of the on-chain assets becomes the controller / master of the domain name and is the only entity that can modify the DNS records of the domain name associated with the on-chain assets.

[0030] In one embodiment, when a request for a domain name is received, the request is sent to a registry to identify the owner / name server that owns the domain name. If the owner / name server stores the domain name in the domain registrar blockchain 106 and the DNS records in the DNS resolver blockchain 112, the owner / name server is configured to read the appropriate blockchain and return the data stored in the blockchain.

[0031] In one embodiment, the domain registrar blockchain 106, or blockchain-based domain registrar, is a blockchain database or distributed ledger that stores domain name registration data. The domain registrar blockchain 106 can use the name server smart contract 108 to build a registrar for storing domain names. In embodiments, the name server smart contract 108 can include one or more smart contracts. A smart contract is a state-based unit of logic that operates on-chain. A smart contract is a programmable agreement that can be used to build a decentralized protocol on the domain registrar blockchain 106. In some embodiments, the name server smart contract 108 is used to mint and register new domain names on-chain in the domain registrar blockchain 106. For the domain registrar blockchain 106, the name server smart contract 108 stores which domain names are stored on-chain.

[0032] In one embodiment, the DNS resolver blockchain 112 is a blockchain database, or distributed ledger, that stores DNS records. The DNS resolver blockchain 112 can use the blockchain resolver smart contract 114 to build a registrar for storing and managing DNS records for corresponding domain names. In embodiments, the resolver smart contract 114 can include one or more smart contracts. A smart contract is a programmable agreement that can be used to build a decentralized protocol on the DNS resolver blockchain 112. In some embodiments, the blockchain resolver smart contract 114 is used to store and resolve DNS records associated with a particular domain name. In the DNS resolver blockchain 112, the blockchain resolver smart contract 114 stores a different DNS record for each domain name.

[0033] 2 illustrates an exemplary network system for resolving domain names using a blockchain-based domain registrar according to some embodiments described herein. The exemplary network system 200 illustrated in FIG. 2 includes a blockchain-based domain name registrar and management system 100, a client device 202, and a web server 204. The blockchain-based domain name registrar and management system 100 includes a registrar middleware 104, a domain registrar blockchain 106, a DNS middleware 110, and a DNS resolver blockchain 112.

[0034] Examples of client devices 202 include computing devices capable of sending and / or receiving network traffic (e.g., laptops, workstations, smartphones, palmtops, mobile phones, tablets, gaming systems, set-top boxes, wearable devices, electronic devices, etc.). In some embodiments, client devices 202 execute client network applications capable of sending and / or receiving network traffic. For example, the client network application may be a web browser or other application that can access network resources (e.g., web pages).

[0035] In one embodiment, web server 204 is a device that receives requests (e.g., HTTP / S requests) for resources such as web pages. For example, web server 204 may receive a request for a resource (e.g., a web page) that includes the address (e.g., an IP address) of the resource and return the requested resource or an error message.

[0036] In one embodiment, in operation 2.1, a request for a web page is received from a client device 202 at the registrar middleware 104. The request for the web page is generated in response to a user selecting a link or URL for the web page (e.g., in a browser application or client network application). For example, the request may be for the web page "http: / / page.example.com." In an embodiment, a forward lookup process is performed by sending a first request to a local DNS server to identify a name server that owns or manages the requested web page. If the address of the web page's name server is not stored in the local DNS server's cache, the local DNS server performs a recursive query or lookup on other DNS servers to determine the identity (e.g., IP address) of the web page's name server. For example, if the request is for "page.example.com," the local DNS server may first forward the request to a DNS root server, which returns the address of a ".com" top-level DNS server. The local DNS server forwards the request to the ".com" top-level DNS server, which returns the address of the "example.com" name server, which stores the DNS record on-chain. The local DNS server forwards the request to the "example.com" name server where registrar middleware 104 is running.

[0037] In one embodiment, in operation 2.2, the registrar middleware 104 converts the web page request into a blockchain query. For example, the registrar middleware 104 converts the web page request into a blockchain query by decoding the DNS request and performing a recursive query on the associated DNS records. The blockchain query is sent to the domain registrar blockchain 106 to perform a name server lookup request in operation 2.3. A typical DNS request can include a QName (or target zone) and a QType (or requested record type). Each recursive query performs a series of record lookups by asking the smart contract for records of the XQName and XQType. The blockchain query is sent to the domain registrar blockchain 106 to perform a name server lookup request in operation 2.3.

[0038] In one embodiment, in operation 2.4, the name server smart contract 108 is accessed to find name server information. In one embodiment, when a blockchain query generated by the registrar middleware 104 hits the domain registrar blockchain 106, the domain registrar blockchain 106 checks the name server smart contract 108 to determine whether the requested domain name is stored in the domain registrar blockchain 106. In one embodiment, the blockchain query is sent to a public remote procedure code (RPC) node, which executes the RPC request and returns corresponding data. In another embodiment, the RPC node runs locally and is synchronized with the blockchain network. The blockchain query is sent to a local RPC node, which executes the RPC request and returns data. In both cases, the blockchain queries are queries (e.g., non-transactional, interacting with nodes and the network) that only read data from the blockchain. They do not modify state because they are used to look up DNS records.

[0039] In one embodiment, the registrar middleware 104 performs a series of recursive queries to identify the zone associated with a DNS request. Because every zone is treated as its own registration, the registrar middleware 104 performs recursive queries from left to right to identify the parent zone to which the request corresponds. For example, a request for "abexample.com" may have three possible zones (e.g., "abexample.com," "b.example.com," and "example.com"). However, each zone may be owned by a different user / entity. For example, a first user / entity owns "example.com" and mints the subdomain "b.example.com" as an on-chain asset (e.g., a token or NFT) into a second user / entity's digital wallet. The registration link between the domain and the zone is stored in the domain registrar blockchain 106. In this situation, the DNS record for "b.example.com" is configured in the context of the first user's zone in the resolver blockchain, but the second user's zone record takes precedence. Only if the second user's zone is burned will the first user's DNS record, which overlaps with the second user's zone, be referenced. Thus, when a blockchain query for "abexample.com" is received, the second user's zone (e.g., "x.example.com") is referenced instead of the first user's zone (e.g., "example.com").

[0040] Once the registrar middleware 104 identifies the parent zone from the domain registrar blockchain 106, that zone (or node) is used to query the corresponding DNS record.

[0041] If it is determined that the requested domain name is stored in the domain registrar blockchain 106, a name server lookup response is returned to the registrar middleware 104 in operation 2.5. The name server lookup response may include the name servers (e.g., addresses of name servers) for the requested domain name. For example, the name servers for "example.com" may be provided. The name servers for the requested domain name are sent to the DNS middleware 110 in operation 2.6.

[0042] In one embodiment, the DNS middleware 110 generates the DNS record lookup request as a blockchain query using the name servers for the requested domain name in operation 2.7. The DNS middleware 110 resolves the DNS record request by sending the blockchain query to the DNS resolver blockchain in operation 2.8. In an embodiment, the blockchain query is specific to the configuration of the blockchain resolver smart contract 114 and the schema of the data stored in the blockchain resolver smart contract 114. In one embodiment, the blockchain resolver smart contract 114 includes a function called "DNSRecord" that takes in a root zone, a qname (or query name), and a resource (e.g., indicating the requested DNS record type). Using the example "http: / / page.example.com", the root zone is "example.com", the qname is "page.example.com", and the resource is the "A record".

[0043] In one embodiment, the blockchain resolver smart contract 114 is accessed in operation 2.9 to find the DNS record for the requested web page. If the requested domain name is stored in the DNS resolver blockchain 112, a DNS record lookup is performed to determine whether the requested domain name has delegated authority elsewhere. For example, a delegation DNS record type (e.g., a DS record) is used to point control authority to a different IP address or canonical name (CNAME). If the requested domain name has delegated authority, the request is forwarded. If the requested domain name has not delegated authority, the DNS resolver blockchain 112 checks whether a corresponding record exists. If the record exists, data is returned that includes the name servers for finding the DNS record. If the record does not exist, a "no data" response is returned. If the requested domain name is not stored in the DNS resolver blockchain 112, the DNS request is rejected. For example, continuing the example, the root servers for "http: / / page.example.com" are queried to return the servers that control ".com." The ".com" server is queried for "example.com" and the server that controls "example.com" is returned. The "example.com" server is then queried for "page.example.com" and the "page.example.com" record is returned. In some embodiments, if the "example.com" server has delegated authority for the subdomain to another server, the querying process continues until a server that has the record is identified.

[0044] In some embodiments, data from the blockchain resolver smart contract 114 is tracked and stored in an off-chain database. In such embodiments, bots can be used to monitor for new transactions and update the off-chain database with changes to on-chain DNS records. The off-chain database can simply be queried to perform a lookup of where the data is stored in the off-chain database.

[0045] In one embodiment, after locating the DNS record, in operation 2.10, the DNS record or an IP address determined from the DNS record is returned. In one embodiment, after receiving the DNS record, in operation 2.11, the DNS middleware 110 sends a request for the web page to the web server using the IP address indicated by the DNS record. In another embodiment, the DNS middleware 110 returns the IP address indicated by the DNS record directly to the client device 202, and the client device 202 sends a request for the web page to the web server 204 using that IP address.

[0046] In one embodiment, the retrieved web page is sent to the client device 202 in operation 2.12.

[0047] 3 illustrates an exemplary network system for sending email messages using a blockchain-based domain registrar according to some embodiments described herein. The exemplary network system 300 illustrated in FIG. 3 includes a blockchain-based domain name registrar and management system 100, a client device 302, a mail server 308, and a domain owner server 310. The blockchain-based domain name registrar and management system 100 includes a registrar middleware 104, a domain registrar blockchain 106, a DNS middleware 110, and an MX record blockchain 304.

[0048] In one embodiment, the MX record blockchain 304 is a blockchain database or distributed ledger that stores mail exchange (MX) records. An MX record is a record that indicates how an email message should be routed to reach a mail server. The MX record blockchain 304 can use the MX record smart contract 306 to build a registrar that stores and manages the MX records for corresponding domain names. A smart contract is a programmable agreement that can be used to build a decentralized protocol on top of the MX record blockchain 304. In some embodiments, the MX record smart contract 306 is used to store and resolve MX records associated with a particular domain name. For the MX record blockchain 304, the MX record smart contract 306 stores a different MX record for each domain name.

[0049] In one embodiment, mail server 308 is a device configured to receive and send email messages between computing devices. For example, mail server 308 can receive email from a sending computing device (e.g., client device 302) to a receiving computing device (e.g., via domain owner server 310).

[0050] In one embodiment, in operation 3.1, the client device 302 sends an email message addressed to a recipient in a domain that is received by the registrar middleware 104. For example, the email message may be addressed to an email address of "mail@example.com," where "example.com" is the recipient's domain. In an embodiment, the email message may be sent using a client application (e.g., an email application). In an embodiment, a forward lookup process is performed, as described with respect to FIG. 2, to identify a name server that owns or manages the requested email domain.

[0051] In one embodiment, at operation 3.2, the registrar middleware 104 converts the name server lookup request for the domain into a blockchain query. In some embodiments, the registrar middleware 104 converts the request for a web page into a blockchain query, as described with respect to Figure 2. The blockchain query for fulfilling the name server lookup request is sent to the domain registrar blockchain 106 at operation 3.3.

[0052] In one embodiment, in operation 3.4, the name server smart contract 108 is accessed to find the name server information. In one embodiment, when the blockchain query generated by the registrar middleware 104 hits the domain registrar blockchain 106, the domain registrar blockchain 106 checks the name server smart contract 108 to determine if the requested domain name (e.g., "example.com") is stored in the domain registrar blockchain 106.

[0053] If, in operation 3.5, it is determined that the requested domain name is stored in the domain registrar blockchain 106, a name server lookup response is returned to the registrar middleware 104. The name server lookup response may include the name servers (e.g., addresses of name servers) for the requested domain name. For example, the name servers for "example.com" may be provided. The name servers for the requested domain name are then sent to the DNS middleware 110 in operation 3.6.

[0054] In one embodiment, in operation 3.7, DNS middleware 110 then generates an MX record lookup request as a blockchain query using the name servers of the requested domain name. Then, in operation 3.8, DNS middleware 110 resolves the MX record request by sending the blockchain query to MX record blockchain 304.

[0055] In one embodiment, in operation 3.9, the MX record smart contract 306 is accessed to find the MX record for the requested domain. If the requested domain name is stored in the MX record blockchain 304, an MX record lookup is performed to determine if the requested domain name has delegated control elsewhere. If the requested domain name has delegated control, the request is forwarded. If the requested domain name has not delegated control, the MX record blockchain 304 checks whether a corresponding record exists. If the record exists, data is returned that includes the name servers for finding the MX record. If the record does not exist, a "no data" response is returned. If the requested domain name is not stored in the MX record blockchain 304, the MX request is rejected.

[0056] In one embodiment, in operation 3.10, after locating the MX record, the MX record or an IP address determined from the MX record is returned. In one embodiment, in operation 3.11, after receiving the MX record, DNS middleware 110 sends the email message to mail server 308 using the IP address indicated by the MX record. In one embodiment, in operation 3.12, mail server 308 sends the email message to domain owner server 310 for delivery to the recipient client device.

[0057] 4 illustrates an exemplary network system for performing a new domain name registration process using a blockchain-based domain registrar according to some embodiments described herein. The exemplary network system 400 illustrated in FIG. 4 includes a blockchain-based domain name registrar and management system 100 and a client device 402. The blockchain-based domain name registrar and management system 100 includes a registrar middleware 104 and a domain registrar blockchain 106.

[0058] In one embodiment, in operation 4.1, client device 402 submits a registration request to register a new domain for a user. For example, client device 402 may submit a registration request to register "newexample.com." The registration request is received by registrar middleware 104. In an embodiment, a forward lookup process is performed, as described with respect to FIG. 2, to identify the name server that owns or manages the new domain.

[0059] In one embodiment, registrar middleware 104 verifies the availability of a new domain and reserves the domain for the user. In some embodiments, registrar middleware 104 verifies the uniqueness of the new domain name before issuing the domain name on-chain and performs off-chain registration. For example, registrar middleware 104 performs a verification process with the Internet Corporation for Assigned Names and Numbers (ICANN) for the new domain name, which may include, among other things, providing identifying contact information for the registrant.

[0060] In some embodiments, instead of performing off-chain registration, all domains can be stored as top-level domains in the domain registrar blockchain 106. In such embodiments, the registrar middleware 104 does not connect with other off-chain systems to see if new domain names are available, because the registrar middleware 104 only needs to check the domain registrar blockchain 106.

[0061] In one embodiment, in operation 4.3, after the registrar middleware 104 reserves the new domain, the registrar middleware 104 sends a blockchain transaction to the domain registrar blockchain 106 to mint the new domain name. The blockchain transaction may include an approval signature used by the registrar smart contract to approve the mint. Funds may be collected on-chain or off-chain. In operation 4.4, the name server smart contract 108 is accessed and the new domain name is minted as a new on-chain asset in the user's digital wallet. For example, the on-chain asset is assigned to the user's digital wallet address. In some embodiments, this involves storing a mapping in a specific smart contract that maps the new domain name to the user's wallet address. This mapping stores all domain names registered in the domain registrar blockchain 106 and their owners. This allows for lookup of registered domains and, if so, to see who registered them.

[0062] In some embodiments, a notification message confirming the registration of the new domain name can be sent back to the client device 402. In some embodiments, the newly registered domain can be returned to the client device 402 as an NFT.

[0063] Figure 5 illustrates an exemplary network system for performing an off-chain renewal process for a domain name using a blockchain-based domain registrar according to some embodiments described herein. The exemplary network system 500 illustrated in Figure 5 includes a blockchain-based domain name registrar and management system 100 and a client device 502. The blockchain-based domain name registrar and management system 100 includes a registrar middleware 104 and a domain registrar blockchain 106.

[0064] In one embodiment, in operation 5.1, client device 502 submits a domain update request. For example, client device 502 may submit an update request to perform an off-chain domain update for "example.com." The update request is received by registrar middleware 104. In an embodiment, a forward lookup process is performed, as described with respect to FIG. 2, to identify the name server that owns or manages the domain.

[0065] In one embodiment, the registrar middleware 104 updates the ICANN registration for the domain name off-chain. In one embodiment, in operation 5.3, after the registrar middleware 104 updates the ICANN registration for the domain name to reflect the update, the registrar middleware 104 sends a blockchain transaction to the domain registrar blockchain 106 to update the expiration date of the domain. In operation 5.4, the name server smart contract 108 is accessed to update the registration expiration date of the domain name to the user's wallet address. For example, an expiration date metadata variable associated with the existing on-chain asset in the domain registrar blockchain 106 is updated.

[0066] In some embodiments, a notification message may be sent back to the client device 502 confirming the domain name renewal, including the updated expiration date of the user's domain name registration.

[0067] 6 illustrates an exemplary network system for performing an on-chain renewal process for domain names using a blockchain-based domain registrar, according to some embodiments described herein. The exemplary network system 600 illustrated in FIG. 6 includes a blockchain-based domain name registrar and management system 100 and a client device 602. The blockchain-based domain name registrar and management system 100 includes a registrar middleware 104 and a domain registrar blockchain 106.

[0068] In one embodiment, in operation 6.1, client device 602 performs a registration renewal request (e.g., paying a registrar to extend a domain). For example, client device 602 performs a renewal to extend the domain registration of "example.com." In an embodiment, a forward lookup process is performed, as described with respect to FIG. 2, to identify the name server that owns or manages the domain.

[0069] In one embodiment, in operation 6.2, the registrar middleware 104 identifies an update event. In one embodiment, the registrar middleware 104 publishes the update event. Publishing the update event indicates that the update transaction was successfully executed in the domain registrar blockchain 106. This makes the update event a transparent and auditable event. Furthermore, publishing the update event indicates that the update should be replicated off-chain. In one embodiment, in operation 6.3, after the registrar middleware 104 identifies the update event, the registrar middleware 104 sends a blockchain transaction to the domain registrar blockchain 106 to update the expiration date of the domain. In operation 6.4, the name server smart contract 108 is accessed to update the domain name's registration expiration date in the user's digital wallet. For example, the expiration date of an on-chain asset is updated.

[0070] In some embodiments, a notification message may be sent back to the client device 602 confirming the domain name renewal including the updated expiration date of the user's domain name registration.

[0071] 7 illustrates an exemplary network system for performing a domain name transfer process from a blockchain-based domain registrar to a non-blockchain registrar, according to some embodiments described herein. The exemplary network system 700 illustrated in FIG. 7 includes a blockchain-based domain name registrar and management system 100 and a client device 702. The blockchain-based domain name registrar and management system 100 includes a registrar middleware 104 and a domain registrar blockchain 106.

[0072] In one embodiment, in operation 7.1, the client device 702 requests that a domain name on the domain registrar blockchain 106 be transferred to a new non-blockchain-based registrar (e.g., a traditional registrar database). For example, the client device 702 may send a request to burn on-chain tokens in the user's wallet for the on-chain domain name on the domain registrar blockchain 106. The request may further include information about the new non-blockchain-based registrar. The registration request is received by the registrar middleware 104. In an embodiment, a forward lookup process is performed, as described with respect to FIG. 2, to identify the name server that owns or manages the domain.

[0073] In one embodiment, in operation 7.2, the registrar middleware 104 identifies a transfer event. In one embodiment, the registrar middleware 104 publishes the transfer event. The publication of the transfer event indicates that a transfer transaction to transfer the domain name from the domain registrar blockchain to the non-blockchain registrar has been successfully executed. This makes the transfer event a transparent and auditable event. Furthermore, the publication of the transfer event indicates that the transfer should be replicated off-chain. In one embodiment, in operation 7.3, the registrar middleware 104 sends a blockchain transaction to transfer the domain from the domain registrar blockchain 106 to the new non-blockchain based registrar. In operation 7.4, the domain registrar blockchain 106 updates the ICANN registration of the domain name to reflect the transfer of the domain name from the domain registrar blockchain 106 to the new non-blockchain based registrar.

[0074] In some embodiments, a notification message can be sent back to the client device 702 confirming that the domain has been transferred from the domain registrar blockchain 106 to the new non-blockchain based registrar.

[0075] Figure 8 illustrates an exemplary network system for performing a domain name transfer process from a non-blockchain registrar to a blockchain-based domain registrar according to some embodiments described herein. The exemplary network system 800 illustrated in Figure 8 includes a blockchain-based domain name registrar and management system 100, a client device 802, and a registrar database 804. The registrar database 804 may be a database that stores domain names for the domain name registrar. The blockchain-based domain name registrar and management system 100 includes a registrar middleware 104 and a domain registrar blockchain 106.

[0076] In one embodiment, in operation 8.1, the client device 802 requests that a domain name on a non-blockchain-based registrar (e.g., registrar database 804) be transferred to a domain registrar blockchain (e.g., domain registrar blockchain 106). In such an embodiment, the client device 802 may further provide the registrar database 804 with a wallet address for transferring the domain name to the domain registrar blockchain 106.

[0077] In one embodiment, in operation 8.3, the registrar database 804 sends a request to transfer the domain to the domain registrar blockchain 106. In an embodiment, a forward lookup process is performed, as described with respect to FIG. 2, to identify the name server that owns or manages the domain. In operation 8.4, the registration request is received by the registrar middleware 104, and a transfer event is identified. The issuance of the transfer event indicates that the transfer transaction to transfer the domain name from the domain registrar blockchain to the non-blockchain registrar has been successfully executed. This makes the transfer event a transparent and auditable event. Furthermore, the issuance of the transfer event indicates that the transfer should be replicated off-chain. In one embodiment, in operation 8.3, the registrar middleware 104 sends a blockchain transaction to transfer the domain to the domain registrar blockchain 106. In operation 8.6, the domain registrar blockchain 106 mints the domain name to the wallet address received from the client device 802.

[0078] In some embodiments, a notification message can be sent back to the client device 802 confirming that the domain has been transferred to the domain registrar blockchain 106.

[0079] Figure 9 illustrates an example network system for performing a process for configuring DNS records for a domain name at a blockchain-based domain registrar according to some embodiments described herein. The example network system 900 illustrated in Figure 9 includes a blockchain-based domain name registrar and management system 100 and a client device 902. The blockchain-based domain name registrar and management system 100 includes a registrar middleware 104 and a domain registrar blockchain 106.

[0080] In one embodiment, in operation 9.1, the client device 902 sends a request to set up a DNS record associated with a domain name stored in the domain registrar blockchain 106. The request includes information identifying at least the domain name and the address of the DNS record (e.g., the new or updated IP address). In some embodiments, the request may be to change or update the DNS record. In embodiments, a forward lookup process is performed, as described with respect to FIG. 2, to identify the name server that owns or manages the domain. In operation 9.2, the request is received by the registrar middleware 104, which converts the request into a blockchain transaction. In one embodiment, in operation 9.3, the registrar middleware 104 sends a blockchain transaction to set up the DNS record for the domain to the domain registrar blockchain 106. In operation 9.4, the domain registrar blockchain 106 updates the DNS record for the domain name.

[0081] Figure 10 is a flow diagram illustrating exemplary operations for a blockchain-based domain name registrar, according to one embodiment. The operations of Figure 10 are described with reference to exemplary embodiments of other figures. However, it should be understood that the operations of Figure 10 may be performed by embodiments other than those described with reference to other figures, and that embodiments described with reference to other figures may perform operations differently than those described with reference to Figure 10. The operations of Figure 10 are described as being performed by a name server 102 of a blockchain-based domain name registrar and management system 100.

[0082] At operation 1010, a name server receives a first request to access a web page from a client device. In some embodiments, the request for the web page may be generated in response to a user selecting a link or URL for the web page (e.g., in a browser application or client network application). In embodiments, to identify a name server that owns or manages the requested web page, a recursive forward lookup process is performed to identify an authoritative name server for the requested web page.

[0083] At operation 1015, the name server generates a first blockchain query to query the domain registrar blockchain based on the first request. In one embodiment, the name server includes a middleware service (e.g., registrar middleware) configured to convert the request message from the first request type to a second request type. For example, the registrar middleware can convert a name server lookup request structured to identify name server (NS) records from a centralized database into a first blockchain query structured to query data in the blockchain.

[0084] At operation 1020, the name server sends a first blockchain query to a domain registrar blockchain that stores the domain name registration data in a smart contract on the domain registrar blockchain.

[0085] At operation 1025, the name server receives a name server identifier from the domain registrar blockchain. In some embodiments, when the blockchain query generated by the registrar middleware hits the domain registrar blockchain, the domain registrar blockchain checks a name server smart contract to determine whether the requested domain name is stored in the domain registrar blockchain. If it is determined that the requested domain name is stored in the domain registrar blockchain, a name server lookup response is returned to the registrar middleware. The name server lookup response may include a name server identifier (e.g., a name server address) for the requested domain name. For example, the name server for "example.com" is provided. At operation 2.6, the name server for the requested domain name is sent to DNS middleware 110.

[0086] At operation 1030, the name server retrieves the DNS record for the web page using the received name server identifier. After receiving the name server identifier from the domain registrar blockchain, the name server identifier for the requested domain name can be sent to middleware (e.g., DNS middleware). In some embodiments, the registrar middleware and the DNS middleware can be a single component of the name server. In one embodiment, the DNS middleware generates a DNS record lookup request as a second blockchain query using the name server identifier for the requested domain name. In some embodiments, the domain registrar blockchain designates a DNS resolver blockchain that stores the DNS records in a smart contract. For example, a blockchain-based domain name registrar can set the DNS resolver blockchain as a default smart contract controlled by the blockchain-based domain name registrar. In embodiments, when the blockchain-based domain name registrar updates its smart contract for subsequent registrations, users with existing registrations can migrate to the new smart contract or keep their existing registrations. In one embodiment, migrating to the new smart contract includes changing the address of the resolver smart contract corresponding to the zone in the registrar smart contract. In some embodiments, the migration can also include configuring the same DNS record in a new resolver smart contract. The DNS middleware resolves the DNS record request by sending a second blockchain query to the DNS resolver blockchain. In one embodiment, the blockchain resolver smart contract is accessed to find the DNS record for the requested web page. If the record exists, the DNS record is returned to the name server.

[0087] In operation 1035, the name server provides information from the retrieved DNS record to the client device to enable access to the web page. For example, the name server may extract or obtain the IP address of the requested web page from the retrieved DNS record. In some embodiments, the name server may use the IP address to contact the web server hosting the web page and obtain the requested web page on behalf of the client device.

[0088] 11 illustrates a block diagram of an exemplary data processing system 1100 that can be used in some embodiments. One or more such data processing systems 1100 can be utilized to implement the embodiments and operations described with respect to the name server 102, the domain registrar blockchain 106, and the DNS resolver blockchain 112, or other computing devices. The data processing system 1100 is a computing device that stores and transmits (internally and / or with other computing devices over a network) code (comprised of software instructions, sometimes referred to as computer program code or computer programs) and / or data using machine-readable media (also called computer-readable media), such as machine-readable storage media 1110 (e.g., magnetic disks, optical disks, read-only memory (ROM), flash memory devices, phase-change memory) and machine-readable transmission media (also called carriers) (e.g., electrical, optical, radio, acoustic, or other forms of propagated signals, e.g., carrier waves, infrared signals, etc.) coupled to a processing system 1120 (e.g., one or more processors and connected system components, such as multiple connected chips). For example, the illustrated machine-readable storage medium 1110 may store program code 1130 that, when executed by the processing system 1120, causes the data processing system 1100 to perform any of the operations described herein.

[0089] Data processing system 1100 also includes one or more network interfaces 1140 (e.g., wired and / or wireless interfaces) that enable data processing system 1100 to send and receive data from other computing devices, typically over one or more networks (e.g., a local area network (LAN), the Internet, etc.).

[0090] The data processing system 1100 also includes one or more input or output (“I / O”) components 1150 provided to enable a user to provide input to the system, receive output, and send and receive data to the system. These I / O components 1150 can include a mouse, keypad, keyboard, touch panel or multi-touch input panel, camera, frame grabber, optical scanner, audio input / output subsystem (which may include a microphone and / or speaker), other known I / O devices, or combinations thereof. The one or more I / O components 1150 can include a wireless transceiver, such as an IEEE 802.11 transceiver, infrared transceiver, Bluetooth transceiver, wireless cellular transceiver (e.g., 2G, 3G, 4G, 5G), NFC transceiver, or other wireless protocol transceiver for connecting the data processing system 1100 with other devices, external components, or networks to receive stored instructions, data, tokens, etc.

[0091] Additional components not shown in Figure 11 may also be part of data processing system 1100, and in particular embodiments, fewer components may be used in data processing system 1100 than are shown in Figure 11. One or more buses may also be used to interconnect the various components shown in Figure 11.

[0092] The techniques shown in the figures can be implemented using code and data stored and executed on one or more computing devices (e.g., client devices, servers, etc.). Such computing devices store and communicate code and data using machine-readable media, such as machine-readable media (e.g., magnetic disks, optical disks, random access memory, read-only memory, flash memory devices, phase-change memory) and machine-readable communication media (e.g., electrical, optical, acoustic, or other forms of propagated signals, e.g., carrier waves, infrared signals, digital signals, etc.). Furthermore, such computing devices typically include a set of one or more processors connected to one or more other components, such as one or more storage devices, user input / output devices (e.g., keyboards, touchscreens, and / or displays), and network connections. The processor set and other components are typically coupled via one or more buses and bridges (also referred to as bus controllers). The storage devices and signals carrying network traffic represent one or more machine-readable storage media and machine-readable communication media, respectively. Thus, the storage device of a particular computing device typically stores code and / or data for execution by the processor set or processors of that computing device. Of course, one or more portions of an embodiment of the invention may be implemented using different combinations of software, firmware, and / or hardware.

[0093] In the foregoing description, many specific details are set forth. However, it should be understood that embodiments of the invention may be practiced without these specific details. In other instances, well-known circuits, structures, and techniques have not been shown in detail so as not to obscure an understanding of the invention. Given the included description, one skilled in the art will be able to implement the appropriate functionality without undue experimentation.

[0094] References in the specification to "one embodiment," "one embodiment," "one exemplary embodiment," and the like indicate that the described embodiment may include a particular feature, structure, or characteristic, but that not all embodiments necessarily include that particular feature, structure, or characteristic. Moreover, such phrases do not necessarily refer to the same embodiment. Furthermore, if a particular feature, structure, or characteristic is described in connection with one embodiment, it is understood by one of ordinary skill in the art that it also works in connection with other embodiments.

[0095] In the foregoing description and claims, the terms "coupled" and "connected," along with their derivatives, may be used. It should be understood that these terms are not intended as synonyms for each other. "Coupled" is used to indicate that two or more elements cooperate or interact with each other, whether or not there is direct physical or electrical contact. "Connected" is used to indicate that communication is established between two or more elements that are coupled.

[0096] While the flow diagrams in the figures indicate a particular order of operations performed by certain embodiments of the invention, it should be understood that this order is exemplary (e.g., alternative embodiments may perform operations in a different order, combine certain operations, or overlap certain operations).

[0097] While the invention has been described in terms of several embodiments, those skilled in the art will recognize that the invention is not limited to the described embodiments, but can be practiced with modification and alteration within the spirit and scope of the appended claims. The description is therefore to be regarded as illustrative rather than limiting.

Claims

1. receiving, by the name server, a first request from a client device to access a web page; generating a first blockchain query to query a domain registrar blockchain based on the first request; sending the first blockchain query to the domain registrar blockchain, the domain registrar blockchain storing domain name registration data in a smart contract of the domain registrar; receiving a name server identifier from the domain registrar blockchain; Retrieving a DNS record for the web page using the received name server identifier; providing information from the obtained DNS record to the client device to access the web page; method.

2. Retrieving the DNS record for the web page using the received name server identifier includes: generating, by the name server, a second blockchain query that includes the received name server identifier; sending the second blockchain query to a DNS resolver blockchain, the DNS resolver blockchain storing the DNS record in a DNS resolver blockchain smart contract; receiving the DNS record for the web page from the DNS resolver blockchain; The method of claim 1 , comprising:

3. the DNS resolver blockchain for obtaining the DNS record for the web page is designated by the domain registrar blockchain; The method of claim 2.

4. Generating the first blockchain query based on the first request includes: Converting a name server lookup request of a first request type into the first blockchain query of a second request type; The method of claim 1 , comprising:

5. the name server receives the first request in response to a forward lookup process that identifies the name server as an authoritative name server for a domain name; The method of claim 1.

6. receiving, by the name server, a second request from the user to register a new domain name; performing an off-chain operation to register the domain name for the user; sending to the domain registrar blockchain a blockchain transaction that causes the domain registrar blockchain to mint on-chain assets for the new domain name, store the on-chain assets in a digital wallet associated with the user, and store a mapping between the new domain name and the digital wallet in a smart contract; The method of claim 1 further comprising:

7. When executed by a processor, the processor: receiving, by a name server, a first request from a client device to access a web page; generating a first blockchain query to query a domain registrar blockchain based on the first request; sending the first blockchain query to the domain registrar blockchain, the domain registrar blockchain storing domain name registration data in a smart contract of the domain registrar; receiving a name server identifier from the domain registrar blockchain; retrieving a DNS record for the web page using the received name server identifier; providing information from the obtained DNS record to the client device to access the web page; A non-transitory machine-readable storage medium that provides instructions for performing procedures including:

8. Retrieving the DNS record for the web page using the received name server identifier includes: generating, by the name server, a second blockchain query that includes the received name server identifier; sending the second blockchain query to a DNS resolver blockchain, the DNS resolver blockchain storing the DNS record in a DNS resolver blockchain smart contract; receiving the DNS record for the web page from the DNS resolver blockchain; 8. The non-transitory machine-readable storage medium of claim 7, comprising:

9. the DNS resolver blockchain for obtaining the DNS record for the web page is designated by the domain registrar blockchain; The non-transitory machine-readable storage medium of claim 8.

10. Generating the first blockchain query based on the first request includes: Converting a name server lookup request of a first request type into the first blockchain query of a second request type; 8. The non-transitory machine-readable storage medium of claim 7, comprising:

11. the name server receives the first request in response to a forward lookup process that identifies the name server as an authoritative name server for a domain name; The non-transitory machine-readable storage medium of claim 7.

12. receiving, by the name server, a second request from the user to register a new domain name; performing an off-chain operation to register the domain name for the user; sending to the domain registrar blockchain a blockchain transaction that causes the domain registrar blockchain to mint on-chain assets for the new domain name, store the on-chain assets in a digital wallet associated with the user, and store a mapping between the new domain name and the digital wallet in a smart contract; 8. The non-transitory machine-readable storage medium of claim 7, further comprising:

13. a processor; In combination with the processor, when executed by the processor, the processor receiving, by a name server, a first request from a client device to access a web page; generating a first blockchain query to query a domain registrar blockchain based on the first request; sending the first blockchain query to the domain registrar blockchain, the domain registrar blockchain storing domain name registration data in a smart contract of the domain registrar; receiving a name server identifier from the domain registrar blockchain; retrieving a DNS record for the web page using the received name server identifier; providing information from the obtained DNS record to the client device to access the web page; a non-transitory machine-readable storage medium storing instructions for carrying out the steps, including: An apparatus comprising:

14. Retrieving the DNS record for the web page using the received name server identifier further comprises: generating, by the name server, a second blockchain query that includes the received name server identifier; sending the second blockchain query to a DNS resolver blockchain, the DNS resolver blockchain storing the DNS record in a DNS resolver blockchain smart contract; receiving the DNS record for the web page from the DNS resolver blockchain; The apparatus of claim 13 , wherein the apparatus causes the following to be executed:

15. the DNS resolver blockchain for obtaining the DNS record for the web page is designated by the domain registrar blockchain; 15. The apparatus of claim 14.

16. Generating the first blockchain query based on the first request further includes causing the processor to: Converting a name server lookup request of a first request type into the first blockchain query of a second request type; The apparatus of claim 13 , wherein the apparatus causes the following to be executed:

17. 14. The apparatus of claim 13, wherein the name server receives the first request in response to a forward lookup process that identifies the name server as an authoritative name server for a domain name.

18. The instructions further cause the processor to: receiving, by the name server, a second request from the user to register a new domain name; performing an off-chain operation to register the domain name for the user; sending to the domain registrar blockchain a blockchain transaction that causes the domain registrar blockchain to mint on-chain assets for the new domain name, store the on-chain assets in a digital wallet associated with the user, and store a mapping between the new domain name and the digital wallet in a smart contract; The apparatus of claim 13 , wherein the apparatus causes the following to be executed:

Images