Merge pull request #5895 from trufflesuite/sne

Reverse ENS resolution support in debugger and decoder

packages/codec/lib/abi-data/decode/index.ts

@@ -287,7 +287,8 @@ export function* decodeAbiReferenceByAddress(
       return {
         type: dataType,
         kind: "value" as const,
-        value: decodedChildren
+        value: decodedChildren,
+        interpretations: {}
       };
 
     case "struct":
@@ -369,7 +370,8 @@ export function* decodeAbiReferenceStatic(
       return {
         type: dataType,
         kind: "value" as const,
-        value: decodedChildren
+        value: decodedChildren,
+        interpretations: {}
       };
 
     case "struct":
@@ -451,7 +453,8 @@ function* decodeAbiStructByPosition(
   return {
     type: dataType,
     kind: "value" as const,
-    value: decodedMembers
+    value: decodedMembers,
+    interpretations: {}
   };
 }
 
@@ -490,6 +493,7 @@ function* decodeAbiTupleByPosition(
   return {
     type: dataType,
     kind: "value" as const,
-    value: decodedMembers
+    value: decodedMembers,
+    interpretations: {}
   };
 }

packages/codec/lib/abify.ts

@@ -151,7 +151,8 @@ export function abifyResult(
             value: {
               asAddress: coercedResult.value.address,
               rawAsHex: coercedResult.value.rawAddress
-            }
+            },
+            interpretations: coercedResult.interpretations
           };
         case "error":
           switch (coercedResult.error.kind) {
@@ -213,7 +214,8 @@ export function abifyResult(
             type: <Format.Types.TupleType>(
               abifyType(result.type, userDefinedTypes)
             ), //note: may throw exception
-            value: abifiedMembers
+            value: abifiedMembers,
+            interpretations: coercedResult.interpretations
           };
         case "error":
           return {
@@ -230,7 +232,8 @@ export function abifyResult(
         case "value":
           return abifyResult(coercedResult.value, userDefinedTypes);
         case "error":
-          return <Format.Errors.BuiltInValueErrorResult>{ //I have no idea what TS is thinking here
+          return <Format.Errors.BuiltInValueErrorResult>{
+            //I have no idea what TS is thinking here
             ...coercedResult,
             type: abifyType(result.type, userDefinedTypes)
           };
@@ -252,7 +255,8 @@ export function abifyResult(
             kind: "value",
             value: {
               asBN: coercedResult.value.numericAsBN.clone()
-            }
+            },
+            interpretations: coercedResult.interpretations
           };
         case "error":
           switch (coercedResult.error.kind) {
@@ -262,7 +266,8 @@ export function abifyResult(
                 kind: "value",
                 value: {
                   asBN: coercedResult.error.rawAsBN.clone()
-                }
+                },
+                interpretations: {}
               };
             case "EnumPaddingError":
               return {
@@ -282,7 +287,8 @@ export function abifyResult(
                   kind: "value",
                   value: {
                     asBN: numericValue
-                  }
+                  },
+                  interpretations: {}
                 };
               } else {
                 return {
@@ -319,7 +325,8 @@ export function abifyResult(
             type: <Format.Types.ArrayType>(
               abifyType(result.type, userDefinedTypes)
             ),
-            value: abifiedMembers
+            value: abifiedMembers,
+            interpretations: coercedResult.interpretations
           };
         case "error":
           return {

packages/codec/lib/ast-constant/decode/index.ts

@@ -47,7 +47,8 @@ export function* decodeConstant(
       kind: "value" as const,
       value: {
         asHex: Conversion.toHexString(bytes, size, true) //padding in case of short string literal
-      }
+      },
+      interpretations: {}
     }; //we'll skip including a raw value, as that would be meaningless
   }
 

packages/codec/lib/basic/decode/index.ts

@@ -6,11 +6,16 @@ import * as Conversion from "@truffle/codec/conversion";
 import * as Format from "@truffle/codec/format";
 import * as Contexts from "@truffle/codec/contexts";
 import type * as Pointer from "@truffle/codec/pointer";
-import type { DecoderRequest, DecoderOptions } from "@truffle/codec/types";
+import type {
+  DecoderRequest,
+  DecoderOptions,
+  EnsPrimaryNameRequest
+} from "@truffle/codec/types";
 import type { PaddingMode, PaddingType } from "@truffle/codec/common";
 import * as Evm from "@truffle/codec/evm";
 import { handleDecodingError, StopDecodingError } from "@truffle/codec/errors";
 import { byteLength } from "@truffle/codec/basic/allocate";
+import { decodeString } from "@truffle/codec/bytes/decode";
 
 export function* decodeBasic(
   dataType: Format.Types.Type,
@@ -70,7 +75,8 @@ export function* decodeBasic(
             //no idea why need coercion here
             type: fullType,
             kind: "value" as const,
-            value: underlyingResult
+            value: underlyingResult,
+            interpretations: {}
           };
         case "error":
           //wrap the error and return an error result!
@@ -115,13 +121,15 @@ export function* decodeBasic(
         return {
           type: dataType,
           kind: "value" as const,
-          value: { asBoolean: false }
+          value: { asBoolean: false },
+          interpretations: {}
         };
       } else if (numeric.eqn(1)) {
         return {
           type: dataType,
           kind: "value" as const,
-          value: { asBoolean: true }
+          value: { asBoolean: true },
+          interpretations: {}
         };
       } else {
         let error = {
@@ -164,7 +172,8 @@ export function* decodeBasic(
         value: {
           asBN: Conversion.toBN(bytes),
           rawAsBN: Conversion.toBN(rawBytes)
-        }
+        },
+        interpretations: {}
       };
     case "int":
       //first, check padding (if needed)
@@ -191,10 +200,11 @@ export function* decodeBasic(
         value: {
           asBN: Conversion.toSignedBN(bytes),
           rawAsBN: Conversion.toSignedBN(rawBytes)
-        }
+        },
+        interpretations: {}
       };
 
-    case "address":
+    case "address": {
       if (!checkPadding(bytes, dataType, paddingMode)) {
         let error = {
           kind: "AddressPaddingError" as const,
@@ -211,16 +221,25 @@ export function* decodeBasic(
         };
       }
       bytes = removePadding(bytes, dataType, paddingMode);
-      return {
+      const address = Evm.Utils.toAddress(bytes);
+      let decoded = {
         type: dataType,
         kind: "value" as const,
         value: {
-          asAddress: Evm.Utils.toAddress(bytes),
+          asAddress: address,
           rawAsHex: Conversion.toHexString(rawBytes)
-        }
+        },
+        interpretations: {}
       };
+      //now: attach interpretations
+      const ensName = yield* reverseEnsResolve(address);
+      if (ensName !== null) {
+        decoded.interpretations = { ensName };
+      }
+      return decoded;
+    }
 
-    case "contract":
+    case "contract": {
       if (!checkPadding(bytes, dataType, paddingMode)) {
         let error = {
           kind: "ContractPaddingError" as const,
@@ -241,11 +260,19 @@ export function* decodeBasic(
         Format.Types.fullType(dataType, info.userDefinedTypes)
       );
       const contractValueInfo = yield* decodeContract(bytes, info);
-      return {
+      let decoded = {
         type: fullType,
         kind: "value" as const,
-        value: contractValueInfo
+        value: contractValueInfo,
+        interpretations: {}
       };
+      //now: attach interpretations
+      const ensName = yield* reverseEnsResolve(contractValueInfo.address);
+      if (ensName !== null) {
+        decoded.interpretations = { ensName };
+      }
+      return decoded;
+    }
 
     case "bytes":
       //NOTE: we assume this is a *static* bytestring,
@@ -277,7 +304,8 @@ export function* decodeBasic(
         value: {
           asHex: Conversion.toHexString(bytes),
           rawAsHex: Conversion.toHexString(rawBytes)
-        }
+        },
+        interpretations: {}
       };
 
     case "function":
@@ -304,11 +332,25 @@ export function* decodeBasic(
             Evm.Utils.ADDRESS_SIZE,
             Evm.Utils.ADDRESS_SIZE + Evm.Utils.SELECTOR_SIZE
           );
-          return {
+          const valueInfo = yield* decodeExternalFunction(
+            address,
+            selector,
+            info
+          );
+          let decoded = {
             type: dataType,
             kind: "value" as const,
-            value: yield* decodeExternalFunction(address, selector, info)
+            value: valueInfo,
+            interpretations: {}
           };
+          //now: attach interpretations
+          const contractEnsName = yield* reverseEnsResolve(
+            valueInfo.contract.address
+          );
+          if (contractEnsName !== null) {
+            decoded.interpretations = { contractEnsName };
+          }
+          return decoded;
         case "internal":
           //note: we used to error if we hit this point with strict === true,
           //since internal function pointers don't go in the ABI, and strict
@@ -403,7 +445,8 @@ export function* decodeBasic(
           value: {
             name,
             numericAsBN: numeric
-          }
+          },
+          interpretations: {}
         };
       } else {
         let error = {
@@ -467,7 +510,8 @@ export function* decodeBasic(
         value: {
           asBig,
           rawAsBig
-        }
+        },
+        interpretations: {}
       };
     }
     case "ufixed": {
@@ -505,7 +549,8 @@ export function* decodeBasic(
         value: {
           asBig,
           rawAsBig
-        }
+        },
+        interpretations: {}
       };
     }
   }
@@ -620,7 +665,8 @@ function decodeInternalFunction(
         context,
         deployedProgramCounter: deployedPc,
         constructorProgramCounter: constructorPc
-      }
+      },
+      interpretations: {}
     };
   }
   //also before we continue: is the PC zero? if so let's just return that
@@ -633,7 +679,8 @@ function decodeInternalFunction(
         context,
         deployedProgramCounter: deployedPc,
         constructorProgramCounter: constructorPc
-      }
+      },
+      interpretations: {}
     };
   }
   //another check: is only the deployed PC zero?
@@ -699,7 +746,8 @@ function decodeInternalFunction(
         context,
         deployedProgramCounter: deployedPc,
         constructorProgramCounter: constructorPc
-      }
+      },
+      interpretations: {}
     };
   }
   const name = functionEntry.name;
@@ -718,7 +766,8 @@ function decodeInternalFunction(
       id,
       definedIn,
       mutability
-    }
+    },
+    interpretations: {}
   };
 }
 
@@ -844,6 +893,17 @@ function checkPaddingSigned(bytes: Uint8Array, length: number): boolean {
   return padding.every(paddingByte => paddingByte === signByte);
 }
 
+function* reverseEnsResolve(
+  address: string
+): Generator<
+  EnsPrimaryNameRequest,
+  Format.Values.StringValueInfo | null,
+  Uint8Array | null
+> {
+  const nameAsBytes = yield { type: "ens-primary-name" as const, address };
+  return nameAsBytes !== null ? decodeString(nameAsBytes) : null;
+}
+
 //the following types are intended for internal use only
 /**
  * @hidden

packages/codec/lib/bytes/decode/index.ts

@@ -41,14 +41,16 @@ export function* decodeBytes(
         kind: "value" as const,
         value: {
           asHex: Conversion.toHexString(bytes)
-        }
+        },
+        interpretations: {}
       };
 
     case "string":
       return {
         type: dataType,
         kind: "value" as const,
-        value: decodeString(bytes)
+        value: decodeString(bytes),
+        interpretations: {}
       };
   }
 }

packages/codec/lib/conversion.ts

@@ -245,7 +245,8 @@ export function cleanBool(
             kind: "value",
             value: {
               asBoolean: true
-            }
+            },
+            interpretations: {}
           };
         default:
           return result;