feat: add name service infrastructure and ENS (#567)

* feat: add name service infrastructrure and ENS

* feat: resolveName and lookupAddress

* chore: naming & declaration

Co-authored-by: Krasimir Raykov <raykov@weichain.tech>

packages/client/lib/Wallet.ts

@@ -1,23 +1,44 @@
 import { UnsupportedMethodError } from '@chainify/errors';
-import { Address, AddressType, Asset, BigNumber, FeeType, Network, Transaction, TransactionRequest, WalletProvider } from '@chainify/types';
+import {
+    Address,
+    AddressType,
+    Asset,
+    BigNumber,
+    FeeType,
+    NamingProvider,
+    Network,
+    Transaction,
+    TransactionRequest,
+    WalletProvider,
+} from '@chainify/types';
 import Chain from './Chain';
 
 export default abstract class Wallet<T, S> implements WalletProvider {
     protected chainProvider: Chain<T>;
+    protected namingProvider: NamingProvider;
 
-    constructor(chainProvider?: Chain<T>) {
+    constructor(chainProvider?: Chain<T>, namingProvider?: NamingProvider) {
         this.chainProvider = chainProvider;
+        this.namingProvider = namingProvider;
     }
 
-    setChainProvider(chainProvider: Chain<T>): void {
+    public setChainProvider(chainProvider: Chain<T>): void {
         this.chainProvider = chainProvider;
         this.onChainProviderUpdate(chainProvider);
     }
 
-    getChainProvider(): Chain<T> {
+    public getChainProvider(): Chain<T> {
         return this.chainProvider;
     }
 
+    public setNamingProvider(namingProvider: NamingProvider) {
+        this.namingProvider = namingProvider;
+    }
+
+    public getNamingProvider(): NamingProvider {
+        return this.namingProvider;
+    }
+
     public signTypedData(_data: any): Promise<string> {
         throw new UnsupportedMethodError('Method not supported');
     }

packages/evm/lib/index.ts

@@ -4,6 +4,7 @@ export { OptimismChainProvider } from './chain/OptimismChainProvider';
 export { EIP1559FeeApiProvider } from './fee/EIP1559FeeApiProvider';
 export { EIP1559FeeProvider } from './fee/EIP1559FeeProvider';
 export { RpcFeeProvider } from './fee/RpcFeeProvider';
+export { EnsProvider } from './naming/EnsProvider';
 export { EvmNetworks } from './networks';
 export { CovalentNftProvider } from './nft/CovalentNftProvider';
 export { EvmNftProvider } from './nft/EvmNftProvider';

packages/evm/lib/naming/EnsProvider.ts

@@ -0,0 +1,26 @@
+import { AddressType, NamingProvider } from '@chainify/types';
+import { StaticJsonRpcProvider } from '@ethersproject/providers';
+
+export class EnsProvider implements NamingProvider {
+    private _provider: StaticJsonRpcProvider;
+
+    constructor(provider: StaticJsonRpcProvider) {
+        this._provider = provider;
+    }
+
+    /**
+     * @param address - resolve name to address
+     * @returns - address
+     */
+    public async resolveName(name: string): Promise<AddressType> {
+        return this._provider.resolveName(name);
+    }
+
+    /**
+     * @param address - look up address
+     * @returns - ens
+     */
+    public async lookupAddress(address: AddressType): Promise<string> {
+        return this._provider.lookupAddress(address.toString());
+    }
+}

packages/evm/lib/wallet/EvmBaseWalletProvider.ts

@@ -1,6 +1,6 @@
 import { Chain, Wallet } from '@chainify/client';
 import { NodeError, ReplaceFeeInsufficientError } from '@chainify/errors';
-import { AddressType, Asset, BigNumber, FeeType, Network, Transaction } from '@chainify/types';
+import { AddressType, Asset, BigNumber, FeeType, NamingProvider, Network, Transaction } from '@chainify/types';
 import { ensure0x, remove0x } from '@chainify/utils';
 import { Signer } from '@ethersproject/abstract-signer';
 import { BaseProvider, TransactionRequest as EthersTxRequest } from '@ethersproject/providers';
@@ -11,8 +11,8 @@ import { calculateGasMargin, extractFeeData, fromGwei, parseTxRequest, parseTxRe
 export abstract class EvmBaseWalletProvider<Provider extends BaseProvider, S extends Signer = Signer> extends Wallet<Provider, S> {
     protected signer: S;
 
-    constructor(chainProvider?: Chain<Provider>) {
-        super(chainProvider);
+    constructor(chainProvider?: Chain<Provider>, namingProvider?: NamingProvider) {
+        super(chainProvider, namingProvider);
     }
 
     public getSigner() {

packages/evm/lib/wallet/EvmWalletProvider.ts

@@ -1,5 +1,5 @@
 import { Chain } from '@chainify/client';
-import { Address, Network, WalletOptions } from '@chainify/types';
+import { Address, NamingProvider, Network, WalletOptions } from '@chainify/types';
 import { compare, remove0x } from '@chainify/utils';
 import { StaticJsonRpcProvider } from '@ethersproject/providers';
 import { Wallet as EthersWallet } from '@ethersproject/wallet';
@@ -11,8 +11,8 @@ export class EvmWalletProvider extends EvmBaseWalletProvider<StaticJsonRpcProvid
     private _wallet: EthersWallet;
     private _walletOptions: WalletOptions;
 
-    constructor(walletOptions: WalletOptions, chainProvider?: Chain<StaticJsonRpcProvider>) {
-        super(chainProvider);
+    constructor(walletOptions: WalletOptions, chainProvider?: Chain<StaticJsonRpcProvider>, namingProvider?: NamingProvider) {
+        super(chainProvider, namingProvider);
         this._walletOptions = walletOptions;
         this._wallet = EthersWallet.fromMnemonic(walletOptions.mnemonic, walletOptions.derivationPath);
 
@@ -24,10 +24,13 @@ export class EvmWalletProvider extends EvmBaseWalletProvider<StaticJsonRpcProvid
     }
 
     public async getAddress(): Promise<Address> {
+        const name = this.getNamingProvider() ? await this.getNamingProvider().lookupAddress(this._wallet.address) : null;
+
         return new Address({
             address: this._wallet.address,
             derivationPath: this._walletOptions.derivationPath,
             publicKey: this._wallet.publicKey,
+            name,
         });
     }
 

packages/types/lib/Address.ts

@@ -3,8 +3,9 @@ export class Address {
     derivationPath?: string;
     publicKey?: string;
     privateKey?: string;
+    name?: string;
 
-    constructor(fields?: { address: string; derivationPath?: string; publicKey?: string; privateKey?: string }) {
+    constructor(fields?: { address: string; derivationPath?: string; publicKey?: string; privateKey?: string; name?: string }) {
         if (fields) {
             Object.assign(this, fields);
         }

packages/types/lib/Naming.ts

@@ -0,0 +1,15 @@
+import { AddressType } from './Address';
+
+export interface NamingProvider {
+    /**
+     * @param address - resolve name to address
+     * @returns - address
+     */
+    resolveName(name: string): Promise<AddressType>;
+
+    /**
+     * @param address - look up address
+     * @returns - ens
+     */
+    lookupAddress(address: AddressType): Promise<string>;
+}

packages/types/lib/index.ts

@@ -6,6 +6,7 @@ export * from './Asset';
 export * from './Block';
 export * from './Chain';
 export * from './Fees';
+export * from './Naming';
 export * from './Network';
 export * from './Nft';
 export * from './Swap';