diff --git a/packages/web3-eth-ens/src/ens.ts b/packages/web3-eth-ens/src/ens.ts index 264f1e31331..5359e885f79 100644 --- a/packages/web3-eth-ens/src/ens.ts +++ b/packages/web3-eth-ens/src/ens.ts @@ -293,4 +293,8 @@ export class ENS extends Web3Context { public async supportsInterface(ENSName: string, interfaceId: string) { return this._resolver.supportsInterface(ENSName, interfaceId); } + + public get events() { + return this._registry.events; + } } diff --git a/packages/web3-eth-ens/src/registry.ts b/packages/web3-eth-ens/src/registry.ts index 89a875f7fcb..88b91378862 100644 --- a/packages/web3-eth-ens/src/registry.ts +++ b/packages/web3-eth-ens/src/registry.ts @@ -234,4 +234,7 @@ export class Registry { throw new Error(); // TODO: TransactionRevertError Needs to be added after web3-eth call method is implemented } } + public get events() { + return this.contract.events; + } } diff --git a/packages/web3-eth-ens/test/integration/ens.events.test.ts b/packages/web3-eth-ens/test/integration/ens.events.test.ts new file mode 100644 index 00000000000..5b859600b69 --- /dev/null +++ b/packages/web3-eth-ens/test/integration/ens.events.test.ts @@ -0,0 +1,201 @@ +/* +This file is part of web3.js. + +web3.js is free software: you can redistribute it and/or modify +it under the terms of the GNU Lesser General Public License as published by +the Free Software Foundation, either version 3 of the License, or +(at your option) any later version. + +web3.js is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public License +along with web3.js. If not, see . +*/ + +/* eslint-disable @typescript-eslint/no-unused-vars */ +import { Contract, PayableTxOptions } from 'web3-eth-contract'; +import { sha3, DEFAULT_RETURN_FORMAT } from 'web3-utils'; +import { getBlock } from 'web3-eth'; + +import { Address, Bytes } from 'web3-types'; +import { ENS } from '../../src'; +import { namehash } from '../../src/utils'; + +import { + getSystemTestAccounts, + getSystemTestProvider, + isWs, + isIpc, + closeOpenConnection, + isSocket, + describeIf, +} from '../fixtures/system_tests_utils'; + +import { ENSRegistryAbi } from '../../src/abi/ens/ENSRegistry'; +import { ENSRegistryBytecode } from '../fixtures/ens/bytecode/ENSRegistryBytecode'; +import { NameWrapperAbi } from '../fixtures/ens/abi/NameWrapper'; +import { NameWrapperBytecode } from '../fixtures/ens/bytecode/NameWrapperBytecode'; +import { PublicResolverAbi } from '../../src/abi/ens/PublicResolver'; +import { PublicResolverBytecode } from '../fixtures/ens/bytecode/PublicResolverBytecode'; + +describeIf(isSocket)('ens events', () => { + let registry: Contract; + let resolver: Contract; + let nameWrapper: Contract; + + type ResolverContract = Contract; + + let Resolver: ResolverContract; + let setEnsResolver: ResolverContract; + let getEnsResolver: ResolverContract; + + let sendOptions: PayableTxOptions; + + const domain = 'test'; + const node = namehash('resolver'); + const label = sha3('resolver') as string; + + const web3jsName = 'web3js.test'; + + const ttl = 3600; + + let accounts: string[]; + let ens: ENS; + let defaultAccount: string; + let accountOne: string; + + const ZERO_NODE: Bytes = '0x0000000000000000000000000000000000000000000000000000000000000000'; + const addressOne: Address = '0x0000000000000000000000000000000000000001'; + + beforeAll(async () => { + accounts = await getSystemTestAccounts(); + + [defaultAccount, accountOne] = accounts; + + sendOptions = { from: defaultAccount, gas: '10000000' }; + + const Registry = new Contract(ENSRegistryAbi, undefined, { + provider: getSystemTestProvider(), + }); + + const NameWrapper = new Contract(NameWrapperAbi, undefined, { + provider: getSystemTestProvider(), + }); + + Resolver = new Contract(PublicResolverAbi, undefined, { + provider: getSystemTestProvider(), + }); + + registry = await Registry.deploy({ data: ENSRegistryBytecode }).send(sendOptions); + + nameWrapper = await NameWrapper.deploy({ data: NameWrapperBytecode }).send(sendOptions); + + resolver = await Resolver.deploy({ + data: PublicResolverBytecode, + arguments: [ + registry.options.address as string, + nameWrapper.options.address as string, + accountOne, + defaultAccount, + ], + }).send(sendOptions); + + await registry.methods.setSubnodeOwner(ZERO_NODE, label, defaultAccount).send(sendOptions); + await registry.methods + .setResolver(node, resolver.options.address as string) + .send(sendOptions); + await resolver.methods.setAddr(node, addressOne).send(sendOptions); + + await registry.methods + .setSubnodeOwner(ZERO_NODE, sha3(domain) as string, defaultAccount) + .send(sendOptions); + + const clientUrl = getSystemTestProvider(); + let provider; + if (isIpc) provider = new ENS.providers.IpcProvider(clientUrl); + else if (isWs) provider = new ENS.providers.WebsocketProvider(clientUrl); + else provider = new ENS.providers.HttpProvider(clientUrl); + + ens = new ENS(registry.options.address, provider); + + const block = await getBlock(ens, 'latest', false, DEFAULT_RETURN_FORMAT); + const gas = block.gasLimit.toString(); + + // Increase gas for contract calls + sendOptions = { + ...sendOptions, + gas, + }; + }); + + afterAll(async () => { + await closeOpenConnection(ens); + // @ts-expect-error @typescript-eslint/ban-ts-comment + await closeOpenConnection(ens?._registry?.contract); + await closeOpenConnection(getEnsResolver); + await closeOpenConnection(setEnsResolver); + await closeOpenConnection(registry); + await closeOpenConnection(resolver); + await closeOpenConnection(nameWrapper); + }); + + beforeEach(async () => { + // set up subnode + await registry.methods + .setSubnodeOwner(namehash(domain), sha3('web3js') as string, defaultAccount) + .send(sendOptions); + }); + + // eslint-disable-next-line jest/expect-expect, jest/no-done-callback, jest/consistent-test-it + it('ApprovalForAll event', async () => { + // eslint-disable-next-line @typescript-eslint/no-misused-promises, no-async-promise-executor + await new Promise(async resolve => { + const event = ens.events.ApprovalForAll(); + + // eslint-disable-next-line @typescript-eslint/no-unsafe-call + event.on('data', () => { + resolve(); + }); + + await ens.setApprovalForAll(accountOne, true, sendOptions); + }); + }); + + // eslint-disable-next-line jest/expect-expect, jest/no-done-callback + test('NewTTL event', async () => { + // eslint-disable-next-line @typescript-eslint/no-misused-promises, no-async-promise-executor + await new Promise(async resolve => { + const event = ens.events.NewTTL(); + + event.on('data', () => { + resolve(); + }); + + event.on('error', () => { + resolve(); + }); + + await ens.setTTL(web3jsName, ttl, sendOptions); + }); + }); + + // eslint-disable-next-line jest/expect-expect, jest/no-done-callback, jest/consistent-test-it + it('NewResolver event', async () => { + // eslint-disable-next-line @typescript-eslint/no-misused-promises, no-async-promise-executor + await new Promise(async resolve => { + const mockAddress = '0x0000000000000000000000000000000000000000'; + const ENS_NAME = 'web3js.eth'; + const event = ens.events.NewResolver(); + + // eslint-disable-next-line @typescript-eslint/no-unsafe-call + event.on('data', () => { + resolve(); + }); + + await ens.setResolver(ENS_NAME, mockAddress, sendOptions); + }); + }); +}); diff --git a/packages/web3-eth-ens/test/integration/resolver.test.ts b/packages/web3-eth-ens/test/integration/resolver.test.ts index 096df74ac6c..8b50fd89e2c 100644 --- a/packages/web3-eth-ens/test/integration/resolver.test.ts +++ b/packages/web3-eth-ens/test/integration/resolver.test.ts @@ -31,6 +31,7 @@ import { isIpc, closeOpenConnection, isSocket, + itIf, } from '../fixtures/system_tests_utils'; import { ENSRegistryAbi } from '../../src/abi/ens/ENSRegistry'; @@ -197,6 +198,20 @@ describe('ens', () => { expect(res).toBe(contentHash); }); + // eslint-disable-next-line jest/expect-expect + itIf(isSocket)('ContenthashChanged event', async () => { + // eslint-disable-next-line @typescript-eslint/no-misused-promises, no-async-promise-executor + await new Promise(async resolve => { + const resolver2 = await ens.getResolver('resolver'); + const event = resolver2.events.ContenthashChanged(); + + event.on('data', () => { + resolve(); + }); + await ens.setContenthash(domain, contentHash, sendOptions); + }); + }); + it('fetches contenthash', async () => { await resolver.methods.setContenthash(domainNode, contentHash).call(sendOptions); diff --git a/packages/web3-providers-ws/test/integration/reconnection.test.ts b/packages/web3-providers-ws/test/integration/reconnection.test.ts index 34fd0749039..aaf3acdb533 100644 --- a/packages/web3-providers-ws/test/integration/reconnection.test.ts +++ b/packages/web3-providers-ws/test/integration/reconnection.test.ts @@ -84,7 +84,9 @@ describeIf(isWs && !isBrowser)('WebSocketProvider - reconnection', () => { expect(!!(await disconnectPromise)).toBe(true); }); - it('should connect, disconnect and reconnect', async () => { + + // eslint-disable-next-line jest/no-disabled-tests + it.skip('should connect, disconnect and reconnect', async () => { const server = await createProxy(18546, getSystemTestProvider()); const web3Provider = new WebSocketProvider(server.path, {}, reconnectionOptions);