Implement vet.domains (#839) (#867)

* feat: init name lookup prototype using vet.domains

* refactor: improve name resolving

* test: improve test process

* feat: add support for vet.domains names in clauses

* refactor: improve name lookup on transaction clauses

* refactor: simplify resolving process

* feat: add support for vet.domains primary name lookups

* refactor: improve ethers interface compatibility on provider & signer

* refactor: remove duplicate definition

* test: add vet.domains vns seeding to thor solo-node

* test: improve testing process for vet.domains

---------

Co-authored-by: Rodolfo Pietro Calabrò <33911400+rodolfopietro97@users.noreply.github.com>

Author: ifavo

docs/package.json

@@ -27,4 +27,4 @@
     "expect": "^29.7.0",
     "ts-node-test": "^0.4.3"
   }
-}
+}

packages/core/src/utils/transaction/transaction.ts

@@ -25,10 +25,10 @@ function intrinsicGas(clauses: TransactionClause[]): number {
     // Some clauses
     return clauses.reduce((sum, clause: TransactionClause) => {
         if (clause.to !== null) {
-            // Invalid address
+            // Invalid address or no vet.domains name
             assert(
                 'intrinsicGas',
-                addressUtils.isAddress(clause.to),
+                addressUtils.isAddress(clause.to) || clause.to.includes('.'),
                 DATA.INVALID_DATA_TYPE,
                 `Invalid data type in clause. Each 'to' field must be a valid address.`,
                 { clause }

packages/network/solo-seeding/thor-solo-seeding.ts

@@ -16,7 +16,7 @@ import {
     type SubscriptionManager
 } from './types';
 import { Quantity } from '@vechain/sdk-core';
-import { type EventPoll, Poll } from '../../../utils';
+import { type EventPoll, Poll, vnsUtils } from '../../../utils';
 import {
     type CompressedBlockDetail,
     type ThorClient
@@ -283,6 +283,24 @@ class VechainProvider extends EventEmitter implements EIP1193ProviderMessage {
         }
         return await this.wallet?.getSigner(this, address);
     }
+
+    /**
+     * Use vet.domains to resolve name to adress
+     * @param vnsName - The name to resolve
+     * @returns the address for a name or null
+     */
+    async resolveName(vnsName: string): Promise<null | string> {
+        return await vnsUtils.resolveName(this.thorClient, vnsName);
+    }
+
+    /**
+     * Use vet.domains to lookup a verified primary name for an address
+     * @param address - The address to lookup
+     * @returns the primary name for an address or null
+     */
+    async lookupAddress(address: string): Promise<null | string> {
+        return await vnsUtils.lookupAddress(this.thorClient, address);
+    }
 }
 
 export { VechainProvider };

packages/network/src/provider/providers/vechain-provider/vechain-provider.ts

@@ -370,9 +370,9 @@ interface VechainSigner {
     // ) => Promise<string>;
 
     /**
-     *  Resolves an ENS Name to an address.
+     *  Resolves an VNS Name to an address.
      */
-    // resolveName: (name: string) => Promise<null | string>;
+    resolveName: (vnsName: string) => Promise<null | string>;
 }
 
 export {

packages/network/src/signer/signers/types.d.ts

@@ -22,6 +22,7 @@ import {
 import { RPC_METHODS } from '../../../provider';
 import { assert, DATA, JSONRPC, TRANSACTION } from '@vechain/sdk-errors';
 import { assertTransactionCanBeSigned } from '../../../assertions';
+import { vnsUtils } from '../../../utils';
 
 /**
  * Basic vechain signer.
@@ -476,6 +477,19 @@ class VechainBaseSigner implements VechainSigner {
         // Return new signed transaction
         return Hex0x.of(new Transaction(unsignedTx.body, signature).encoded);
     }
+
+    /**
+     * Use vet.domains to resolve name to adress
+     * @param vnsName - The name to resolve
+     * @returns the address for a name or null
+     */
+    async resolveName(vnsName: string): Promise<null | string> {
+        if (this.provider === null) {
+            return null;
+        }
+
+        return await vnsUtils.resolveName(this.provider.thorClient, vnsName);
+    }
 }
 
 export { VechainBaseSigner };

packages/network/src/signer/signers/vechain-base-signer/vechain-base-signer.ts

@@ -16,7 +16,8 @@ import {
     ERROR_SELECTOR,
     PANIC_SELECTOR,
     Poll,
-    thorest
+    thorest,
+    vnsUtils
 } from '../../utils';
 import {
     type GetTransactionInputOptions,
@@ -241,7 +242,7 @@ class TransactionsModule {
         return {
             blockRef,
             chainTag,
-            clauses,
+            clauses: await this.resolveNamesInClauses(clauses),
             dependsOn: options?.dependsOn ?? null,
             expiration: options?.expiration ?? 32,
             gas,
@@ -252,6 +253,57 @@ class TransactionsModule {
         };
     }
 
+    /**
+     * Ensures that names in clauses are resolved to addresses
+     *
+     * @param clauses - The clauses of the transaction.
+     * @returns A promise that resolves to clauses with resolved addresses
+     */
+    public async resolveNamesInClauses(
+        clauses: TransactionClause[]
+    ): Promise<TransactionClause[]> {
+        // find unique names in the clause list
+        const uniqueNames = clauses.reduce((map, clause) => {
+            if (
+                typeof clause.to === 'string' &&
+                !map.has(clause.to) &&
+                clause.to.includes('.')
+            ) {
+                map.set(clause.to, clause.to);
+            }
+            return map;
+        }, new Map<string, string>());
+
+        const nameList = [...uniqueNames.keys()];
+
+        // no names, return the original clauses
+        if (uniqueNames.size === 0) {
+            return clauses;
+        }
+
+        // resolve the names to addresses
+        const addresses = await vnsUtils.resolveNames(this.thor, nameList);
+
+        // map unique names with resolved addresses
+        addresses.forEach((address, index) => {
+            if (address !== null) {
+                uniqueNames.set(nameList[index], address);
+            }
+        });
+
+        // replace names with resolved addresses, or leave unchanged
+        return clauses.map((clause) => {
+            if (typeof clause.to !== 'string') {
+                return clause;
+            }
+
+            return {
+                ...clause,
+                to: uniqueNames.get(clause.to) ?? clause.to
+            };
+        });
+    }
+
     /**
      * Simulates the execution of a transaction.
      * Allows to estimate the gas cost of a transaction without sending it, as well as to retrieve the return value(s) of the transaction.
@@ -292,12 +344,14 @@ class TransactionsModule {
             {
                 query: buildQuery({ revision }),
                 body: {
-                    clauses: clauses.map((clause) => {
-                        return {
-                            ...clause,
-                            value: BigInt(clause.value).toString()
-                        };
-                    }),
+                    clauses: await this.resolveNamesInClauses(
+                        clauses.map((clause) => {
+                            return {
+                                ...clause,
+                                value: BigInt(clause.value).toString()
+                            };
+                        })
+                    ),
                     gas,
                     gasPrice,
                     caller,

packages/network/src/thor-client/transactions/transactions-module.ts

@@ -4,3 +4,4 @@ export * from './http';
 export * from './poll';
 export * from './thorest';
 export * from './subscriptions';
+export * from './vns';

packages/network/src/utils/index.ts

@@ -0,0 +1,27 @@
+import {
+    MAINNET_NETWORK,
+    SOLO_NETWORK,
+    TESTNET_NETWORK
+} from '../../../../core';
+
+const NetworkContracts: Record<
+    string,
+    { registry: string; resolveUtils: string }
+> = {
+    [MAINNET_NETWORK.genesisBlock.id]: {
+        registry: '0xa9231da8BF8D10e2df3f6E03Dd5449caD600129b',
+        resolveUtils: '0xA11413086e163e41901bb81fdc5617c975Fa5a1A'
+    },
+
+    [TESTNET_NETWORK.genesisBlock.id]: {
+        registry: '0xcBFB30c1F267914816668d53AcBA7bA7c9806D13',
+        resolveUtils: '0xc403b8EA53F707d7d4de095f0A20bC491Cf2bc94'
+    },
+
+    [SOLO_NETWORK.genesisBlock.id]: {
+        registry: '0x1c4a602ed21f3d1dddd1142c81f231ef1a08c921',
+        resolveUtils: '0xb2f08bbfa8a42b1fbe63feec604cb147385203d7'
+    }
+};
+
+export { NetworkContracts };

packages/network/src/utils/vns/addresses.ts

@@ -0,0 +1,122 @@
+import { NetworkContracts } from './addresses';
+import { type ThorClient } from '../../thor-client';
+import {
+    addressUtils,
+    ZERO_ADDRESS,
+    type FunctionFragment
+} from '../../../../core';
+
+/**
+ * Returns a single address or null for a name resolved at vet.domains
+ *
+ * @param thorClient - The thor client instance to use.
+ * @param name - The name to resolve
+ * @returns The address or null
+ */
+const resolveName = async (
+    thorClient: ThorClient,
+    name: string
+): Promise<null | string> => {
+    const [address] = await vnsUtils.resolveNames(thorClient, [name]);
+    return address ?? null;
+};
+
+/**
+ * Returns a list of addresses or null for names resolved by vet.domains
+ *
+ * @param thorClient - The thor client instance to use.
+ * @param names - The names to resolve
+ * @returns The list of the same size of names with the resolved address or null
+ */
+const resolveNames = async (
+    thorClient: ThorClient,
+    names: string[]
+): Promise<Array<null | string>> => {
+    // identify current chain
+    const genesisBlock = await thorClient.blocks.getGenesisBlock();
+
+    // verify configuration for chain exists
+    if (
+        genesisBlock === null ||
+        !addressUtils.isAddress(NetworkContracts[genesisBlock.id]?.resolveUtils)
+    ) {
+        return names.map(() => null);
+    }
+
+    const resolveUtilsAddress = NetworkContracts[genesisBlock.id].resolveUtils;
+
+    // use the resolveUtils to lookup names
+    const [addresses] = (await thorClient.contracts.executeCall(
+        resolveUtilsAddress,
+        'function getAddresses(string[] names) returns (address[] addresses)' as unknown as FunctionFragment,
+        [names]
+    )) as string[][];
+
+    return addresses.map((address) => {
+        // zero addresses are missing configuration entries
+        if (address === ZERO_ADDRESS || !addressUtils.isAddress(address)) {
+            return null;
+        }
+
+        return address;
+    });
+};
+
+/**
+ * Returns a single primary name for a given address resolved at vet.domains
+ *
+ * @param thorClient - The thor client instance to use.
+ * @param address - The address to lookup
+ * @returns The name or null
+ */
+const lookupAddress = async (
+    thorClient: ThorClient,
+    address: string
+): Promise<null | string> => {
+    const [name] = await vnsUtils.lookupAddresses(thorClient, [address]);
+    return name ?? null;
+};
+
+/**
+ * Returns a list of names or null for addresses primary names resolved by vet.domains. Reverse lookup of name to address is verified.
+ *
+ * @param thorClient - The thor client instance to use.
+ * @param addresses - The addresses to lookup
+ * @returns The list of the same size of addresses with the resolved primary names or null
+ */
+const lookupAddresses = async (
+    thorClient: ThorClient,
+    addresses: string[]
+): Promise<Array<null | string>> => {
+    // identify current chain
+    const genesisBlock = await thorClient.blocks.getGenesisBlock();
+
+    // verify configuration for chain exists
+    if (
+        genesisBlock === null ||
+        !addressUtils.isAddress(NetworkContracts[genesisBlock.id]?.resolveUtils)
+    ) {
+        return addresses.map(() => null);
+    }
+
+    const resolveUtilsAddress = NetworkContracts[genesisBlock.id].resolveUtils;
+
+    // use the resolveUtils to lookup names
+    const [names] = (await thorClient.contracts.executeCall(
+        resolveUtilsAddress,
+        'function getNames(address[] addresses) returns (string[] names)' as unknown as FunctionFragment,
+        [addresses]
+    )) as string[][];
+
+    return names.map((name) => {
+        // empty strings indicate a missing entry
+        if (name === '') {
+            return null;
+        }
+
+        return name;
+    });
+};
+
+const vnsUtils = { resolveName, resolveNames, lookupAddress, lookupAddresses };
+export { vnsUtils };

packages/network/src/utils/vns/index.ts

@@ -358,4 +358,32 @@ describe('Vechain provider tests - solo', () => {
                 })
         ).rejects.toThrowError(InvalidDataTypeError);
     });
+
+    describe('resolveName(vnsName)', () => {
+        test('Should be able to resolve an address by name', async () => {
+            const name = 'test-sdk.vet';
+            const address = await provider.resolveName(name);
+            expect(address).toBe('0xF02f557c753edf5fcdCbfE4c1c3a448B3cC84D54');
+        });
+
+        test('Should resolve to null for unknown names', async () => {
+            const name = 'unknown.test-sdk.vet';
+            const address = await provider.resolveName(name);
+            expect(address).toBe(null);
+        });
+    });
+
+    describe('lookupAddress(address)', () => {
+        test('Should be able to lookup a name for an address', async () => {
+            const address = '0xF02f557c753edf5fcdCbfE4c1c3a448B3cC84D54';
+            const name = await provider.lookupAddress(address);
+            expect(name).toBe('test-sdk.vet');
+        });
+
+        test('Should resolve to null for unknown names', async () => {
+            const address = '0x0000000000000000000000000000000000000001';
+            const name = await provider.resolveName(address);
+            expect(name).toBe(null);
+        });
+    });
 });