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 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 string GetNameHashFromMainNet(string addr)
{
//To connect to infura using .net451 and TLS2 you need to set it in advance
ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
var web3 = new Web3(Constants.ETHConnection1);
var fullNameNode = new EnsUtil().GetNameHash(addr);
//Using mainnet to resolve
var ensRegistryService = new ENSRegistryService(web3, Constants.MAINNET_RESOLVER_ADDRESS);
//get the resolver address from ENS
var resolverAddress = ensRegistryService.ResolverQueryAsync(new ResolverFunction()
{
Node = fullNameNode.HexToByteArray()
}).Result;
var resolverService = new PublicResolverService(web3, resolverAddress);
//and get the address from the resolver
var x = fullNameNode.HexToByteArray();
var theAddress = resolverService.AddrQueryAsync(x).Result;
//Owner address
return(theAddress);
}
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 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 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());
}
}
