Add onNameLookup export

packages/examples/packages/bip32/snap.manifest.json

@@ -7,7 +7,7 @@
     "url": "https://github.com/MetaMask/snaps.git"
   },
   "source": {
-    "shasum": "KH8aF/EMcR04f03R1UGKdifPNw7fpyZE6FkWx3CCXok=",
+    "shasum": "FzEv7I4+3tYNzM6dcEEaoq3J3aH6l8WCo0bFp56hI3k=",
     "location": {
       "npm": {
         "filePath": "dist/bundle.js",

packages/examples/packages/bip44/snap.manifest.json

@@ -7,7 +7,7 @@
     "url": "https://github.com/MetaMask/snaps.git"
   },
   "source": {
-    "shasum": "vHWASh9ACAU5KJrBTL9W5h+E4gBz1qicoLPaUPgyn1M=",
+    "shasum": "jX8PaE9Oi1FWnJsW2Dm71crLo2uBEksCNeYPphmoy0Y=",
     "location": {
       "npm": {
         "filePath": "dist/bundle.js",

packages/examples/packages/dialogs/snap.manifest.json

@@ -7,7 +7,7 @@
     "url": "https://github.com/MetaMask/snaps.git"
   },
   "source": {
-    "shasum": "oUlB7WJmzj4xkUy5zipc3a3XRuWX0y4Sb2RFe+W9Wl0=",
+    "shasum": "7ryoRHayMjd7Ws8C+806kGR3OMNQFryMvIXPp6cDRw8=",
     "location": {
       "npm": {
         "filePath": "dist/bundle.js",

packages/examples/packages/get-entropy/snap.manifest.json

@@ -7,7 +7,7 @@
     "url": "https://github.com/MetaMask/snaps.git"
   },
   "source": {
-    "shasum": "35pPRJItVu1++OdXtdFJSpQnikDwiGceqhLQstCcjDg=",
+    "shasum": "txKgxLDTD0dBYL6WQgZxUqwHTcQcUUNNPU9/oWVK4Kg=",
     "location": {
       "npm": {
         "filePath": "dist/bundle.js",

packages/examples/packages/get-locale/snap.manifest.json

@@ -7,7 +7,7 @@
     "url": "https://github.com/MetaMask/snaps.git"
   },
   "source": {
-    "shasum": "Hr7FyKdx/cCL589IHA9ktIb2x3ZuJnur0Ou3uHdz/BU=",
+    "shasum": "0T4dTLDl+8OxbagVuXQ+hgE81KlmdxpZYWSShfw6+Hc=",
     "location": {
       "npm": {
         "filePath": "dist/bundle.js",

packages/examples/packages/invoke-snap/packages/core-signer/snap.manifest.json

@@ -7,7 +7,7 @@
     "url": "https://github.com/MetaMask/snaps.git"
   },
   "source": {
-    "shasum": "8j4f5pa80kudzKuhSZv4vjwACbnvSNMkL7E3JHht2Rc=",
+    "shasum": "AVvItsFeFROPIhuZLuxiNc6egWLhbhJQR9//daxg8qQ=",
     "location": {
       "npm": {
         "filePath": "dist/bundle.js",

packages/examples/packages/manage-state/snap.manifest.json

@@ -7,7 +7,7 @@
     "url": "https://github.com/MetaMask/snaps.git"
   },
   "source": {
-    "shasum": "d8UDQBUPEjjFcO6L2RmRSoMS5pFyvWn1XPhhlJws074=",
+    "shasum": "Gw+1DNkjLVuQfJbrVA2sG+lIgek5oEuk0jRdsd44Ky8=",
     "location": {
       "npm": {
         "filePath": "dist/bundle.js",

packages/examples/packages/notifications/snap.manifest.json

@@ -7,7 +7,7 @@
     "url": "https://github.com/MetaMask/snaps.git"
   },
   "source": {
-    "shasum": "M6vtG8D2FjhY/E7fNT7qHeRT5I7tg1Rs6KKT3z1+8cM=",
+    "shasum": "cZdsqMkePYvSOaFyIkpn3WchgN4Dk/tDvVEHRyjdHeQ=",
     "location": {
       "npm": {
         "filePath": "dist/bundle.js",

packages/snaps-controllers/coverage.json

@@ -1,6 +1,6 @@
 {
-  "branches": 88.7,
-  "functions": 95,
-  "lines": 96.7,
-  "statements": 96.35
+  "branches": 89,
+  "functions": 95.13,
+  "lines": 96.77,
+  "statements": 96.44
 }

packages/snaps-controllers/src/snaps/SnapController.test.ts

@@ -2529,7 +2529,7 @@ describe('SnapController', () => {
           [MOCK_SNAP_ID]: {},
         }),
       ).rejects.toThrow(
-        'A snap must request at least one of the following permissions: endowment:rpc, endowment:transaction-insight, endowment:cronjob, endowment:lifecycle-hooks.',
+        'A snap must request at least one of the following permissions: endowment:rpc, endowment:transaction-insight, endowment:cronjob, endowment:name-lookup, endowment:lifecycle-hooks.',
       );
 
       controller.destroy();

packages/snaps-controllers/src/snaps/endowments/enum.ts

@@ -6,5 +6,6 @@ export enum SnapEndowments {
   EthereumProvider = 'endowment:ethereum-provider',
   Rpc = 'endowment:rpc',
   WebAssemblyAccess = 'endowment:webassembly',
+  NameLookup = 'endowment:name-lookup',
   LifecycleHooks = 'endowment:lifecycle-hooks',
 }

packages/snaps-controllers/src/snaps/endowments/index.ts

@@ -10,6 +10,11 @@ import {
 import { ethereumProviderEndowmentBuilder } from './ethereum-provider';
 import { lifecycleHooksEndowmentBuilder } from './lifecycle-hooks';
 import { longRunningEndowmentBuilder } from './long-running';
+import {
+  getNameLookupCaveatMapper,
+  nameLookupCaveatSpecifications,
+  nameLookupEndowmentBuilder,
+} from './name-lookup';
 import { networkAccessEndowmentBuilder } from './network-access';
 import {
   getRpcCaveatMapper,
@@ -33,13 +38,15 @@ export const endowmentPermissionBuilders = {
     ethereumProviderEndowmentBuilder,
   [rpcEndowmentBuilder.targetName]: rpcEndowmentBuilder,
   [webAssemblyEndowmentBuilder.targetName]: webAssemblyEndowmentBuilder,
+  [nameLookupEndowmentBuilder.targetName]: nameLookupEndowmentBuilder,
   [lifecycleHooksEndowmentBuilder.targetName]: lifecycleHooksEndowmentBuilder,
 } as const;
 
 export const endowmentCaveatSpecifications = {
   ...cronjobCaveatSpecifications,
   ...transactionInsightCaveatSpecifications,
   ...rpcCaveatSpecifications,
+  ...nameLookupCaveatSpecifications,
 };
 
 export const endowmentCaveatMappers: Record<
@@ -50,16 +57,19 @@ export const endowmentCaveatMappers: Record<
   [transactionInsightEndowmentBuilder.targetName]:
     getTransactionInsightCaveatMapper,
   [rpcEndowmentBuilder.targetName]: getRpcCaveatMapper,
+  [nameLookupEndowmentBuilder.targetName]: getNameLookupCaveatMapper,
 };
 
 export const handlerEndowments: Record<HandlerType, string> = {
   [HandlerType.OnRpcRequest]: rpcEndowmentBuilder.targetName,
   [HandlerType.OnTransaction]: transactionInsightEndowmentBuilder.targetName,
   [HandlerType.OnCronjob]: cronjobEndowmentBuilder.targetName,
+  [HandlerType.OnNameLookup]: nameLookupEndowmentBuilder.targetName,
   [HandlerType.OnInstall]: lifecycleHooksEndowmentBuilder.targetName,
   [HandlerType.OnUpdate]: lifecycleHooksEndowmentBuilder.targetName,
 };
 
 export * from './enum';
 export { getRpcCaveatOrigins } from './rpc';
 export { getTransactionOriginCaveat } from './transaction-insight';
+export { getChainIdsCaveat } from './name-lookup';

packages/snaps-controllers/src/snaps/endowments/name-lookup.test.ts

@@ -0,0 +1,187 @@
+import type { PermissionConstraint } from '@metamask/permission-controller';
+import { PermissionType, SubjectType } from '@metamask/permission-controller';
+import { SnapCaveatType } from '@metamask/snaps-utils';
+
+import { SnapEndowments } from '.';
+import {
+  nameLookupEndowmentBuilder,
+  getChainIdsCaveat,
+  getNameLookupCaveatMapper,
+  nameLookupCaveatSpecifications,
+} from './name-lookup';
+
+describe('endowment:name-lookup', () => {
+  const specification = nameLookupEndowmentBuilder.specificationBuilder({});
+  it('builds the expected permission specification', () => {
+    expect(specification).toStrictEqual({
+      permissionType: PermissionType.Endowment,
+      targetName: SnapEndowments.NameLookup,
+      endowmentGetter: expect.any(Function),
+      allowedCaveats: [SnapCaveatType.ChainIds],
+      subjectTypes: [SubjectType.Snap],
+      validator: expect.any(Function),
+    });
+
+    expect(specification.endowmentGetter()).toBeUndefined();
+  });
+
+  describe('validator', () => {
+    it('disallows no caveats', () => {
+      expect(() =>
+        // @ts-expect-error Missing required permission types.
+        specification.validator({}),
+      ).toThrow('Expected a single "chainIds" caveat.');
+    });
+
+    it('throws if the caveat is not a single "chainIds"', () => {
+      expect(() =>
+        // @ts-expect-error Missing other required permission types.
+        specification.validator({
+          caveats: [{ type: 'foo', value: 'bar' }],
+        }),
+      ).toThrow('Expected a single "chainIds" caveat.');
+
+      expect(() =>
+        // @ts-expect-error Missing other required permission types.
+        specification.validator({
+          caveats: [
+            { type: 'chainIds', value: ['foo'] },
+            { type: 'chainIds', value: ['bar'] },
+          ],
+        }),
+      ).toThrow('Expected a single "chainIds" caveat.');
+    });
+  });
+});
+
+describe('getChainIdsCaveat', () => {
+  it('returns the value from a name-lookup permission', () => {
+    const permission: PermissionConstraint = {
+      date: 0,
+      parentCapability: 'foo',
+      invoker: 'bar',
+      id: 'baz',
+      caveats: [
+        {
+          type: SnapCaveatType.ChainIds,
+          value: ['eip155:1'],
+        },
+      ],
+    };
+    expect(getChainIdsCaveat(permission)).toStrictEqual(['eip155:1']);
+  });
+
+  it('returns null if the input is undefined', () => {
+    expect(getChainIdsCaveat(undefined)).toBeNull();
+  });
+
+  it('returns null if the permission does not have caveats', () => {
+    const permission: PermissionConstraint = {
+      date: 0,
+      parentCapability: 'foo',
+      invoker: 'bar',
+      id: 'baz',
+      caveats: null,
+    };
+
+    expect(getChainIdsCaveat(permission)).toBeNull();
+  });
+
+  it('throws if the permission does not have exactly one caveat', () => {
+    const permission: PermissionConstraint = {
+      date: 0,
+      parentCapability: 'foo',
+      invoker: 'bar',
+      id: 'baz',
+      caveats: [
+        {
+          type: SnapCaveatType.ChainIds,
+          value: ['eip155:1'],
+        },
+        {
+          type: SnapCaveatType.ChainIds,
+          value: ['eip155:2'],
+        },
+      ],
+    };
+
+    expect(() => getChainIdsCaveat(permission)).toThrow('Assertion failed');
+  });
+
+  it('throws if the first caveat is not a "chainIds" caveat', () => {
+    const permission: PermissionConstraint = {
+      date: 0,
+      parentCapability: 'foo',
+      invoker: 'bar',
+      id: 'baz',
+      caveats: [
+        {
+          type: SnapCaveatType.PermittedCoinTypes,
+          value: 'foo',
+        },
+      ],
+    };
+
+    expect(() => getChainIdsCaveat(permission)).toThrow('Assertion failed');
+  });
+});
+
+describe('getNameLookupCaveatMapper', () => {
+  it('maps input to a caveat', () => {
+    expect(getNameLookupCaveatMapper(['eip155:1'])).toStrictEqual({
+      caveats: [
+        {
+          type: 'chainIds',
+          value: ['eip155:1'],
+        },
+      ],
+    });
+  });
+
+  it('does not include caveat if input is empty array', () => {
+    expect(getNameLookupCaveatMapper([])).toStrictEqual({
+      caveats: null,
+    });
+  });
+});
+
+describe('nameLookupCaveatSpecifications', () => {
+  describe('validator', () => {
+    it('throws if the caveat is missing a value key or is not an object', () => {
+      expect(() =>
+        nameLookupCaveatSpecifications[SnapCaveatType.ChainIds].validator?.(
+          // @ts-expect-error Missing value type.
+          {
+            type: SnapCaveatType.ChainIds,
+          },
+        ),
+      ).toThrow('Expected a plain object.');
+    });
+
+    it.each([
+      {
+        type: SnapCaveatType.ChainIds,
+        value: ['eip155'],
+      },
+      {
+        type: SnapCaveatType.ChainIds,
+        value: undefined,
+      },
+    ])('throws if the caveat values are invalid types', (val) => {
+      expect(() =>
+        nameLookupCaveatSpecifications[SnapCaveatType.ChainIds].validator?.(
+          val,
+        ),
+      ).toThrow('Expected caveat value to have type "string array"');
+    });
+
+    it('will not throw with a valid caveat value', () => {
+      expect(() =>
+        nameLookupCaveatSpecifications[SnapCaveatType.ChainIds].validator?.({
+          type: SnapCaveatType.ChainIds,
+          value: ['eip155:1'],
+        }),
+      ).not.toThrow();
+    });
+  });
+});