fix: insufficient label checks for validity + compare tweaks

.gitignore

@@ -73,4 +73,5 @@ typings/
 # intellij
 .idea
 
-/tests/.bin
+/tests/.bin
+/tests/.latest.json

src/@types/assembly/package.json

@@ -0,0 +1,3 @@
+{
+  "types": "index.d.ts"
+}

src/@types/es5/package.json

@@ -0,0 +1,3 @@
+{
+  "types": "index.d.ts"
+}

src/ensRegistry.ts

@@ -2,6 +2,7 @@
 import { BigInt, crypto, ens } from "@graphprotocol/graph-ts";
 
 import {
+  checkValidLabel,
   concat,
   createEventID,
   EMPTY_ADDRESS,
@@ -47,7 +48,7 @@ function getDomain(
   timestamp: BigInt = BIG_INT_ZERO
 ): Domain | null {
   let domain = Domain.load(node);
-  if (domain === null && node == ROOT_NODE) {
+  if (domain == null && node == ROOT_NODE) {
     return createDomain(node, timestamp);
   } else {
     return domain;
@@ -94,25 +95,23 @@ function _handleNewOwner(event: NewOwnerEvent, isMigrated: boolean): void {
   let domain = getDomain(subnode, event.block.timestamp);
   let parent = getDomain(event.params.node.toHexString());
 
-  if (domain === null) {
+  if (domain == null) {
     domain = new Domain(subnode);
     domain.createdAt = event.block.timestamp;
     domain.subdomainCount = 0;
   }
 
-  if (domain.parent === null && parent !== null) {
+  if (domain.parent == null && parent != null) {
     parent.subdomainCount = parent.subdomainCount + 1;
     parent.save();
   }
 
   if (domain.name == null) {
     // Get label and node names
     let label = ens.nameByHash(event.params.label.toHexString());
-    if (label != null) {
+    if (checkValidLabel(label)) {
       domain.labelName = label;
-    }
-
-    if (label === null) {
+    } else {
       label = "[" + event.params.label.toHexString().slice(2) + "]";
     }
     if (

src/ethRegistrar.ts

@@ -55,7 +55,7 @@ export function handleNameRegistered(event: NameRegisteredEvent): void {
   domain.expiryDate = event.params.expires.plus(GRACE_PERIOD_SECONDS);
 
   let labelName = ens.nameByHash(label.toHexString());
-  if (labelName != null) {
+  if (checkValidLabel(labelName)) {
     domain.labelName = labelName;
     domain.name = labelName! + ".eth";
     registration.labelName = labelName;
@@ -100,7 +100,7 @@ function setNamePreimage(name: string, label: Bytes, cost: BigInt): void {
   }
 
   let domain = Domain.load(crypto.keccak256(concat(rootNode, label)).toHex())!;
-  if (domain.labelName !== name) {
+  if (domain.labelName != name) {
     domain.labelName = name;
     domain.name = name + ".eth";
     domain.save();

src/nameWrapper.ts

@@ -34,7 +34,7 @@ function decodeName(buf: Bytes): Array<string> | null {
   let len = buf[offset++];
   let hex = buf.toHexString();
   let firstLabel = "";
-  if (len === 0) {
+  if (len == 0) {
     return [firstLabel, "."];
   }
 
@@ -68,7 +68,7 @@ export function handleNameWrapped(event: NameWrappedEvent): void {
   let decoded = decodeName(event.params.name);
   let label: string | null = null;
   let name: string | null = null;
-  if (decoded !== null) {
+  if (decoded != null) {
     label = decoded[0];
     name = decoded[1];
   }
@@ -120,7 +120,7 @@ export function handleNameUnwrapped(event: NameUnwrappedEvent): void {
 
   let domain = createOrLoadDomain(node.toHex());
   domain.wrappedOwner = null;
-  if (domain.expiryDate && domain.parent !== ETH_NODE) {
+  if (domain.expiryDate && domain.parent != ETH_NODE) {
     domain.expiryDate = null;
   }
   domain.save();

src/resolver.ts

@@ -57,7 +57,7 @@ export function handleAddrChanged(event: AddrChangedEvent): void {
 }
 
 export function handleMulticoinAddrChanged(event: AddressChangedEvent): void {
-  let resolver = getOrCreateResolver(event.params.node, event.address);
+  let resolver = getOrCreateResolver(event.params.node, event.address, false);
 
   let coinType = event.params.coinType;
   if (resolver.coinTypes == null) {
@@ -84,26 +84,32 @@ export function handleMulticoinAddrChanged(event: AddressChangedEvent): void {
 export function handleNameChanged(event: NameChangedEvent): void {
   if (event.params.name.indexOf("\u0000") != -1) return;
 
+  const resolver = getOrCreateResolver(event.params.node, event.address, true);
+
   let resolverEvent = new NameChanged(createEventID(event));
-  resolverEvent.resolver = createResolverID(event.params.node, event.address);
+  resolverEvent.resolver = resolver.id;
   resolverEvent.blockNumber = event.block.number.toI32();
   resolverEvent.transactionID = event.transaction.hash;
   resolverEvent.name = event.params.name;
   resolverEvent.save();
 }
 
 export function handleABIChanged(event: ABIChangedEvent): void {
+  const resolver = getOrCreateResolver(event.params.node, event.address, true);
+
   let resolverEvent = new AbiChanged(createEventID(event));
-  resolverEvent.resolver = createResolverID(event.params.node, event.address);
+  resolverEvent.resolver = resolver.id;
   resolverEvent.blockNumber = event.block.number.toI32();
   resolverEvent.transactionID = event.transaction.hash;
   resolverEvent.contentType = event.params.contentType;
   resolverEvent.save();
 }
 
 export function handlePubkeyChanged(event: PubkeyChangedEvent): void {
+  const resolver = getOrCreateResolver(event.params.node, event.address, true);
+
   let resolverEvent = new PubkeyChanged(createEventID(event));
-  resolverEvent.resolver = createResolverID(event.params.node, event.address);
+  resolverEvent.resolver = resolver.id;
   resolverEvent.blockNumber = event.block.number.toI32();
   resolverEvent.transactionID = event.transaction.hash;
   resolverEvent.x = event.params.x;
@@ -112,7 +118,7 @@ export function handlePubkeyChanged(event: PubkeyChangedEvent): void {
 }
 
 export function handleTextChanged(event: TextChangedEvent): void {
-  let resolver = getOrCreateResolver(event.params.node, event.address);
+  let resolver = getOrCreateResolver(event.params.node, event.address, false);
 
   let key = event.params.key;
   if (resolver.texts == null) {
@@ -128,7 +134,7 @@ export function handleTextChanged(event: TextChangedEvent): void {
   }
 
   let resolverEvent = new TextChanged(createEventID(event));
-  resolverEvent.resolver = createResolverID(event.params.node, event.address);
+  resolverEvent.resolver = resolver.id;
   resolverEvent.blockNumber = event.block.number.toI32();
   resolverEvent.transactionID = event.transaction.hash;
   resolverEvent.key = event.params.key;
@@ -138,7 +144,7 @@ export function handleTextChanged(event: TextChangedEvent): void {
 export function handleTextChangedWithValue(
   event: TextChangedWithValueEvent
 ): void {
-  let resolver = getOrCreateResolver(event.params.node, event.address);
+  let resolver = getOrCreateResolver(event.params.node, event.address, false);
 
   let key = event.params.key;
   if (resolver.texts == null) {
@@ -154,7 +160,7 @@ export function handleTextChangedWithValue(
   }
 
   let resolverEvent = new TextChanged(createEventID(event));
-  resolverEvent.resolver = createResolverID(event.params.node, event.address);
+  resolverEvent.resolver = resolver.id;
   resolverEvent.blockNumber = event.block.number.toI32();
   resolverEvent.transactionID = event.transaction.hash;
   resolverEvent.key = event.params.key;
@@ -163,21 +169,23 @@ export function handleTextChangedWithValue(
 }
 
 export function handleContentHashChanged(event: ContenthashChangedEvent): void {
-  let resolver = getOrCreateResolver(event.params.node, event.address);
+  let resolver = getOrCreateResolver(event.params.node, event.address, false);
   resolver.contentHash = event.params.hash;
   resolver.save();
 
   let resolverEvent = new ContenthashChanged(createEventID(event));
-  resolverEvent.resolver = createResolverID(event.params.node, event.address);
+  resolverEvent.resolver = resolver.id;
   resolverEvent.blockNumber = event.block.number.toI32();
   resolverEvent.transactionID = event.transaction.hash;
   resolverEvent.hash = event.params.hash;
   resolverEvent.save();
 }
 
 export function handleInterfaceChanged(event: InterfaceChangedEvent): void {
+  const resolver = getOrCreateResolver(event.params.node, event.address, true);
+
   let resolverEvent = new InterfaceChanged(createEventID(event));
-  resolverEvent.resolver = createResolverID(event.params.node, event.address);
+  resolverEvent.resolver = resolver.id;
   resolverEvent.blockNumber = event.block.number.toI32();
   resolverEvent.transactionID = event.transaction.hash;
   resolverEvent.interfaceID = event.params.interfaceID;
@@ -188,10 +196,12 @@ export function handleInterfaceChanged(event: InterfaceChangedEvent): void {
 export function handleAuthorisationChanged(
   event: AuthorisationChangedEvent
 ): void {
+  const resolver = getOrCreateResolver(event.params.node, event.address, true);
+
   let resolverEvent = new AuthorisationChanged(createEventID(event));
   resolverEvent.blockNumber = event.block.number.toI32();
   resolverEvent.transactionID = event.transaction.hash;
-  resolverEvent.resolver = createResolverID(event.params.node, event.address);
+  resolverEvent.resolver = resolver.id;
   resolverEvent.owner = event.params.owner;
   resolverEvent.target = event.params.target;
   resolverEvent.isAuthorized = event.params.isAuthorised;
@@ -207,26 +217,33 @@ export function handleVersionChanged(event: VersionChangedEvent): void {
   resolverEvent.save();
 
   let domain = Domain.load(event.params.node.toHexString());
-  if (domain && domain.resolver === resolverEvent.resolver) {
+  if (domain && domain.resolver == resolverEvent.resolver) {
     domain.resolvedAddress = null;
     domain.save();
   }
 
-  let resolver = getOrCreateResolver(event.params.node, event.address);
+  let resolver = getOrCreateResolver(event.params.node, event.address, false);
   resolver.addr = null;
   resolver.contentHash = null;
   resolver.texts = null;
   resolver.coinTypes = null;
   resolver.save();
 }
 
-function getOrCreateResolver(node: Bytes, address: Address): Resolver {
+function getOrCreateResolver(
+  node: Bytes,
+  address: Address,
+  saveOnNew: boolean
+): Resolver {
   let id = createResolverID(node, address);
   let resolver = Resolver.load(id);
-  if (resolver === null) {
+  if (resolver == null) {
     resolver = new Resolver(id);
     resolver.domain = node.toHexString();
     resolver.address = address;
+    if (saveOnNew) {
+      resolver.save();
+    }
   }
   return resolver as Resolver;
 }
@@ -238,7 +255,7 @@ function createEventID(event: ethereum.Event): string {
     .concat(event.logIndex.toString());
 }
 
-function createResolverID(node: Bytes, resolver: Address): string {
+export function createResolverID(node: Bytes, resolver: Address): string {
   return resolver
     .toHexString()
     .concat("-")

src/utils.ts

@@ -68,18 +68,33 @@ export function createOrLoadDomain(node: string): Domain {
   return domain;
 }
 
-export function checkValidLabel(name: string): boolean {
+export function checkValidLabel(name: string | null): boolean {
+  if (name == null) {
+    return false;
+  }
+  // for compiler
+  name = name!;
   for (let i = 0; i < name.length; i++) {
     let c = name.charCodeAt(i);
     if (c === 0) {
+      // 0 = null byte
       log.warning("Invalid label '{}' contained null byte. Skipping.", [name]);
       return false;
     } else if (c === 46) {
+      // 46 = .
       log.warning(
         "Invalid label '{}' contained separator char '.'. Skipping.",
         [name]
       );
       return false;
+    } else if (c === 91) {
+      // 91 = [
+      log.warning("Invalid label '{}' contained char '['. Skipping.", [name]);
+      return false;
+    } else if (c === 93) {
+      // 93 = ]
+      log.warning("Invalid label '{}' contained char ']'. Skipping.", [name]);
+      return false;
     }
   }
 

tests/.latest.json

@@ -1,4 +1,4 @@
 {
-  "version": "0.5.4",
-  "timestamp": 1689736116460
+  "version": "0.6.0",
+  "timestamp": 1704668302285
 }

tests/ensRegistrar.test.ts

@@ -215,3 +215,75 @@ test("does not assign label name to label with '.' separator", () => {
 
   checkNullLabelName(labelhash, labelhashAsInt, label);
 });
+
+test("does not assign label name to label with '[' char", () => {
+  const labelhash =
+    "0x6d2df8d29c51e5e79bce0067df6a093fd7e535f1fe0a509ead1eb5a2171640c9";
+  const labelhashAsInt =
+    "49383325924636276199200854251362239534766035480602437112552046254651845525705";
+  const label =
+    "[41ff1915eef2bf5841388d748bfcd23bd49ff5521ca4200c20bc0978b136c3cb";
+
+  checkNullLabelName(labelhash, labelhashAsInt, label);
+});
+
+test("does not assign label name to label with ']' char", () => {
+  const labelhash =
+    "0xb9cf267ed9b0cb8caf44655901be5b66f2e6bbedd8dc1436fba973f7a824db58";
+  const labelhashAsInt =
+    "84043880016553362091807057514212448616446700818045523307434280128309910362968";
+  const label =
+    "41ff1915eef2bf5841388d748bfcd23bd49ff5521ca4200c20bc0978b136c3cb]";
+
+  checkNullLabelName(labelhash, labelhashAsInt, label);
+});
+
+test("does not assign label name to label that uses unnormalised label notation", () => {
+  const labelhash =
+    "0x162894963b59f9b7e47a34709830c0211a6ba5f7de3973839f3ee7002e0c8434";
+  const labelhashAsInt =
+    "10022582060124759960163130513734713560279061696053801337665848910969813369908";
+  const label =
+    "[41ff1915eef2bf5841388d748bfcd23bd49ff5521ca4200c20bc0978b136c3cb]";
+
+  checkNullLabelName(labelhash, labelhashAsInt, label);
+});
+
+test("does assign normal label", () => {
+  const labelhash =
+    "0x9c22ff5f21f0b81b113e63f7db6da94fedef11b2119b4088b89664fb9a3cb658";
+  const labelhashAsInt =
+    "70622639689279718371527342103894932928233838121221666359043189029713682937432";
+  const label = "test";
+
+  const newNewOwnerEvent = createNewOwnerEvent(
+    ETH_NAMEHASH,
+    labelhash,
+    DEFAULT_OWNER
+  );
+  handleNewOwner(newNewOwnerEvent);
+
+  let newRegistrationEvent = createNameRegisteredEvent(
+    labelhashAsInt,
+    DEFAULT_OWNER,
+    "1610000000"
+  );
+  handleNameRegistered(newRegistrationEvent);
+
+  let fetchedRegistration = Registration.load(labelhash)!;
+
+  fetchedRegistration.labelName = "eth";
+  fetchedRegistration.save();
+
+  const nameRegisteredByControllerEvent = createNameRegisteredByControllerEvent(
+    label,
+    labelhash,
+    DEFAULT_OWNER,
+    "1610000000"
+  );
+  handleNameRegisteredByController(nameRegisteredByControllerEvent);
+
+  fetchedRegistration = Registration.load(labelhash)!;
+
+  assert.assertTrue(fetchedRegistration.labelName == label);
+});