public async void ShouldResolveNameFromMainnet() { var web3 = new Web3.Web3("https://mainnet.infura.io"); var fullNameNode = new EnsUtil().GetNameHash("nickjohnson.eth"); var ensRegistryService = new ENSRegistryService(web3, "0x314159265dd8dbb310642f98f50c066173c1259b"); //get the resolver address from ENS var resolverAddress = await ensRegistryService.ResolverQueryAsync( new ResolverFunction() { Node = fullNameNode.HexToByteArray() }); Assert.Equal("0x1da022710df5002339274aadee8d58218e9d6ab5", resolverAddress); //using the resolver address we can create our service (should be an abstract / interface based on abi as we can have many) var resolverService = new PublicResolverService(web3, resolverAddress); //and get the address from the resolver var theAddress = await resolverService.AddrQueryAsync(new AddrFunction() { Node = fullNameNode.HexToByteArray() }); //Owner address var expectedAddress = "0xfdb33f8ac7ce72d7d4795dd8610e323b4c122fbb"; Assert.Equal(expectedAddress.ToLower(), theAddress.ToLower()); }
public async Task <string> GetAddress(string accountDomain) { if (!IsValidDomain(accountDomain)) { throw new ArgumentException("Invalid name.", nameof(accountDomain)); } try { var ensRegistryService = new ENSRegistryService(Web3Client, RnsRegistry); var fullNameNode = new EnsUtil().GetNameHash(accountDomain); var resolverAddress = await ensRegistryService.ResolverQueryAsync( new ResolverFunction() { Node = fullNameNode.HexToByteArray() }).ConfigureAwait(false); var resolverService = new PublicResolverService(Web3Client, resolverAddress); var theAddress = await resolverService .AddrQueryAsync(fullNameNode.HexToByteArray()) .ConfigureAwait(false); return(theAddress); } catch (Exception e) { return(null); } }
public async Task <string> GetEnsAddress(string ensName) { var ensUtil = new EnsUtil(); var contract = "0x314159265dD8dbb310642f98f50C066173C1259b"; //ENS contract address var web3 = new Web3("https://mainnet.infura.io/v3/146c5ff4a83a4a62b8eb4bbc93e07974"); var fullNameNode = ensUtil.GetNameHash(ensName); var ensRegistryService = new ENSRegistryService(web3, contract); var resolverAddress = await ensRegistryService.ResolverQueryAsync( new ResolverFunction() { Node = fullNameNode.HexToByteArray() }); var newRes = "0x4976fb03C32e5B8cfe2b6cCB31c09Ba78EBaBa41"; var resolverService = new PublicResolverService(web3, resolverAddress); var migratedResolverService = new PublicResolverService(web3, newRes); var address = await resolverService.AddrQueryAsync(fullNameNode.HexToByteArray()); var migratedAddress = await migratedResolverService.AddrQueryAsync(fullNameNode.HexToByteArray()); if (migratedAddress == "0x0000000000000000000000000000000000000000") { return(address); } else { return(migratedAddress); } }
public ENS(Uri Uri, string RegistryAddress) { Web3 = new Web3(Uri.ToString()); EnsUtil = new EnsUtil(); ENSRegistryService = new ENSRegistryService(Web3, RegistryAddress); BinarySerializer = new BinarySerializer(); }
public void Initialize() { Web3 = new Web3($"http://localhost:7545"); EnsUtil = new EnsUtil(); ENSRegistryService = new ENSRegistryService(Web3, ENSRegistryAddress); FIFSRegistrarService = new FIFSRegistrarService(Web3, FIFSRegistrarAddress); PublicResolverService = new PublicResolverService(Web3, PublicResolverAddress); }
public void ShouldEncodeCorrectly() { var ensUtil = new EnsUtil(); Assert.Equal("0x0000000000000000000000000000000000000000000000000000000000000000", ensUtil.GetEnsNameHash("")); Assert.Equal("0x93cdeb708b7545dc668eb9280176169d1c33cfd8ed6f04690a0bcc88a93fc4ae", ensUtil.GetEnsNameHash("eth")); Assert.Equal("0xde9b09fd7c5f901e23a3f19fecc54828e9c848539801e86591bd9801b019f84f", ensUtil.GetEnsNameHash("foo.eth")); }
public ENS(IOptionsMonitor <ENSOptions> ENSOptions, ILog Log) { Web3 = new Web3(ENSOptions.CurrentValue.Web3.ToString(), Log); EnsUtil = new EnsUtil(); ENSService = new ENSService(Web3); ENSRegistryService = new ENSRegistryService(Web3, ENSService.EnsRegistryAddress); BaseRegistrarService = new BaseRegistrarService(Web3, "0x57f1887a8BF19b14fC0dF6Fd9B2acc9Af147eA85"); }
public static async Task <IActionResult> Run( [HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "v0.1/publickeys/lookup")] HttpRequest req, [Table("%PublicKey:Storage:PublicKeyTable%", Connection = "PublicKey:Storage:Connection")] CloudTable table, ILogger log, ExecutionContext context) { IConfigurationRoot config = new ConfigurationBuilder() .SetBasePath(context.FunctionAppDirectory) .AddJsonFile("local.settings.json", optional: true, reloadOnChange: true) .AddEnvironmentVariables() .Build(); var queryParam = (string)req.Query["q"]; var model = new PublicKeyLookupModel(); if (!string.IsNullOrEmpty(queryParam) && !AddressUtil.Current.IsValidEthereumAddressHexFormat(queryParam)) { var web3 = new Web3(config.GetValue <string>("Blockchain:Endpoint")); var nameHash = new EnsUtil().GetNameHash(queryParam); var ensRegistryService = new ENSRegistryService(web3, config.GetValue <string>("Blockchain:ENSRegistryService")); var resolverAddress = await ensRegistryService.ResolverQueryAsync( new ResolverFunction() { Node = nameHash.HexToByteArray() }); var resolverService = new PublicResolverService(web3, resolverAddress); var address = await resolverService.AddrQueryAsync(nameHash.HexToByteArray()); model.Ens = new EnsModel { Name = queryParam, Hash = nameHash, Resolver = resolverAddress }; model.Address = address; queryParam = address; } if (AddressUtil.Current.IsValidEthereumAddressHexFormat(queryParam)) { var entity = await FindPublicKey(table, queryParam); if (entity != null) { model.Address = entity.PartitionKey; model.PublicKey = entity.RowKey; } } return(string.IsNullOrEmpty(model.Address) && model.Ens == null ? new NotFoundObjectResult("Public key not found") : (IActionResult) new OkObjectResult(model)); }
public void ShouldEncodeCorrectly() { var ensUtil = new EnsUtil(); //empty Assert.Equal("0x0000000000000000000000000000000000000000000000000000000000000000", ensUtil.GetNameHash("")); //tld Assert.Equal("0x93cdeb708b7545dc668eb9280176169d1c33cfd8ed6f04690a0bcc88a93fc4ae", ensUtil.GetNameHash("eth")); //foo.eth Assert.Equal("0xde9b09fd7c5f901e23a3f19fecc54828e9c848539801e86591bd9801b019f84f", ensUtil.GetNameHash("foo.eth")); //normalise ascii domain Assert.Equal("foo.eth", ensUtil.Normalise("foo.eth")); //normalise international domain //with crylic 'o' Assert.Equal("xn--f-1tba.eth", ensUtil.Normalise("fоо.eth")); }
public static async Task <string> GetENSAddress(string ensName) { try { var ensUtil = new EnsUtil(); var contract = "0x314159265dD8dbb310642f98f50C066173C1259b"; //ENS contract address var web3 = new Web3(ChainWatcher.GETH_WEB3_ENDPOINT); var fullNameNode = ensUtil.GetNameHash(ensName); var ensRegistryService = new ENSRegistryService(web3, contract); var oldResolver = "0x226159d592E2b063810a10Ebf6dcbADA94Ed68b8"; var resolverAddress = await ensRegistryService.ResolverQueryAsync( new ResolverFunction() { Node = fullNameNode.HexToByteArray() }); var newRes = "0x4976fb03C32e5B8cfe2b6cCB31c09Ba78EBaBa41"; var resolverService = new PublicResolverService(web3, resolverAddress); var migratedResolverService = new PublicResolverService(web3, newRes); var address = await resolverService.AddrQueryAsync(fullNameNode.HexToByteArray()); var migratedAddress = await migratedResolverService.AddrQueryAsync(fullNameNode.HexToByteArray()); if (migratedAddress == "0x0000000000000000000000000000000000000000") { return(address); } else { return(migratedAddress); } } catch (Exception e) { Console.WriteLine(e.Message); } return(null); }
public async void ShouldCreateEnsRegistarResolverAndRegiterandResolveANewAddress() { //Ignoring parity due to https://github.com/paritytech/parity-ethereum/issues/8675 if (_ethereumClientIntegrationFixture.Geth) { //The address we want to resolve when using "test.eth" var addressToResolve = "0x12890D2cce102216644c59daE5baed380d84830c"; var addressFrom = "0x12890D2cce102216644c59daE5baed380d84830c"; var web3 = _ethereumClientIntegrationFixture.GetWeb3(); //deploy ENS contract var ensDeploymentReceipt = await ENSRegistryService.DeployContractAndWaitForReceiptAsync(web3, new ENSRegistryDeployment()); var ensUtil = new EnsUtil(); var ethNode = ensUtil.GetNameHash("eth"); //create a new First in First service registrar for "eth" var fifsDeploymentReceipt = await FIFSRegistrarService.DeployContractAndWaitForReceiptAsync(web3, new FIFSRegistrarDeployment() { EnsAddr = ensDeploymentReceipt.ContractAddress, Node = ethNode.HexToByteArray() }); var publicResolverDeploymentReceipt = await PublicResolverService.DeployContractAndWaitForReceiptAsync( web3, new PublicResolverDeployment() { Ens = ensDeploymentReceipt.ContractAddress } ); var ensRegistryService = new ENSRegistryService(web3, ensDeploymentReceipt.ContractAddress); //set ownership of "eth" to the fifs service //we are owners of "", so a subnode label "eth" will now be owned by the FIFS registar, which will allow to also to set ownership in Ens of further subnodes of Eth. var ethLabel = ensUtil.GetLabelHash("eth"); var receipt = await ensRegistryService.SetSubnodeOwnerRequestAndWaitForReceiptAsync( ensUtil.GetNameHash("").HexToByteArray(), ethLabel.HexToByteArray(), fifsDeploymentReceipt.ContractAddress ); //Now the owner of Eth is the FIFS var ownerOfEth = await ensRegistryService.OwnerQueryAsync(ethNode.HexToByteArray()); Assert.Equal(fifsDeploymentReceipt.ContractAddress.ToLower(), ownerOfEth.ToLower()); /**** setup done **/ //registration of "myname" //create a service for the registrar var fifsService = new FIFSRegistrarService(web3, fifsDeploymentReceipt.ContractAddress); //create a label var testLabel = ensUtil.GetLabelHash("myname"); //submit the registration using the label bytes, and set ourselves as the owner await fifsService.RegisterRequestAndWaitForReceiptAsync(new RegisterFunction() { Owner = addressFrom, Subnode = testLabel.HexToByteArray() }); //now using the the full name var fullNameNode = ensUtil.GetNameHash("myname.eth"); var ownerOfMyName = await ensRegistryService.OwnerQueryAsync(fullNameNode.HexToByteArray()); //set the resolver (the public one) await ensRegistryService.SetResolverRequestAndWaitForReceiptAsync( new SetResolverFunction() { Resolver = publicResolverDeploymentReceipt.ContractAddress, Node = fullNameNode.HexToByteArray() }); var publicResolverService = new PublicResolverService(web3, publicResolverDeploymentReceipt.ContractAddress); // set the address in the resolver which we want to resolve, ownership is validated using ENS in the background //Fails here await publicResolverService.SetAddrRequestAndWaitForReceiptAsync(fullNameNode.HexToByteArray(), addressToResolve ); //Now as "end user" we can start resolving... //get the resolver address from ENS var resolverAddress = await ensRegistryService.ResolverQueryAsync( fullNameNode.HexToByteArray()); //using the resolver address we can create our service (should be an abstract / interface based on abi as we can have many) var resolverService = new PublicResolverService(web3, resolverAddress); //and get the address from the resolver var theAddress = await resolverService.AddrQueryAsync(fullNameNode.HexToByteArray()); Assert.Equal(addressToResolve.ToLower(), theAddress.ToLower()); } }
public async void ShouldCreateEnsRegistarResolverAndRegiterandResolveANewAddress() { //The address we want to resolve when using "test.eth" var addressToResolve = "0x12890d2cce102216644c59dae5baed380d84830c"; var defaultGas = new HexBigInteger(900000); var addressFrom = "0x12890d2cce102216644c59dae5baed380d84830c"; var pass = "******"; var web3 = _ethereumClientIntegrationFixture.GetWeb3(); var txService = new TransactionReceiptPollingService(web3.TransactionManager); // var addressFrom = (await web3.Eth.Accounts.SendRequestAsync()).First(); //uncomment to use geth instead of test-rpc //deploy ENS contract var ensAddress = await txService.DeployContractAndGetAddressAsync(() => EnsService.DeployContractAsync(web3, addressFrom, defaultGas)); var ensUtil = new EnsUtil(); var ethNode = ensUtil.GetEnsNameHash("eth"); //create a new First in First service registrar for "eth" var fifsAddress = await txService.DeployContractAndGetAddressAsync(() => FIFSRegistrarService.DeployContractAsync(web3, addressFrom, ensAddress, ethNode.HexToByteArray(), defaultGas)); //create a public registry, which will allow us to find the registered address var publicResolverAddress = await txService.DeployContractAndGetAddressAsync( () => PublicResolverService.DeployContractAsync(web3, addressFrom, ensAddress, defaultGas)); var ensService = new EnsService(web3, ensAddress); //set ownership of "eth" to the fifs service //we are owners of "", so a subnode label "eth" will now be owned by the FIFS registar, which will allow to also to set ownership in Ens of further subnodes of Eth. var ethLabel = ensUtil.GetEnsLabelHash("eth"); await txService.SendRequestAndWaitForReceiptAsync(() => ensService.SetSubnodeOwnerAsync(addressFrom, ensUtil.GetEnsNameHash("").HexToByteArray(), ethLabel.HexToByteArray(), fifsAddress, defaultGas)); //Now the owner of Eth is the FIFS var ownerOfEth = await ensService.OwnerAsyncCall(ethNode.HexToByteArray()); Assert.Equal(fifsAddress, ownerOfEth); /**** setup done **/ //registration of "myname" //create a service for the registrar var fifsService = new FIFSRegistrarService(web3, fifsAddress); //create a label var testLabel = ensUtil.GetEnsLabelHash("myname"); //submit the registration using the label bytes, and set ourselves as the owner await txService.SendRequestAndWaitForReceiptAsync(() => fifsService.RegisterAsync(addressFrom, testLabel.HexToByteArray(), addressFrom, defaultGas)); //now using the the full name var fullNameNode = ensUtil.GetEnsNameHash("myname.eth"); //set the resolver (the public one) await txService.SendRequestAndWaitForReceiptAsync(() => ensService.SetResolverAsync(addressFrom, fullNameNode.HexToByteArray(), publicResolverAddress, defaultGas)); var publicResolverService = new PublicResolverService(web3, publicResolverAddress); // set the address in the resolver which we want to resolve, ownership is validated using ENS in the background await txService.SendRequestAndWaitForReceiptAsync(() => publicResolverService.SetAddrAsync(addressFrom, fullNameNode.HexToByteArray(), addressToResolve, defaultGas)); //Now as "end user" we can start resolving... //get the resolver address from ENS var resolverAddress = await ensService.ResolverAsyncCall(fullNameNode.HexToByteArray()); //using the resolver address we can create our service (should be an abstract / interface based on abi as we can have many) var resolverService = new PublicResolverService(web3, resolverAddress); //and get the address from the resolver var theAddress = await resolverService.AddrAsyncCall(fullNameNode.HexToByteArray()); Assert.Equal(addressToResolve, theAddress); }