chore: Allow scope type to be specified either as ScopeType enum, or string literal (#133)

Author: MoMannn

packages/smart-accounts-kit/CHANGELOG.md

@@ -7,6 +7,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Fixed
+
+- Allow scope type to be specified either as `ScopeType` enum, or string literal ([#133](https://github.com/MetaMask/smart-accounts-kit/pull/133))
+
 ## [0.4.0-beta.1]
 
 ### Added

packages/smart-accounts-kit/src/caveatBuilder/scope/erc20PeriodicScope.ts

@@ -1,13 +1,11 @@
+import type { ScopeType } from '../../constants';
 import type { SmartAccountsEnvironment } from '../../types';
 import { createCaveatBuilder } from '../coreCaveatBuilder';
 import type { CoreCaveatBuilder } from '../coreCaveatBuilder';
-import type {
-  erc20PeriodTransfer,
-  Erc20PeriodTransferBuilderConfig,
-} from '../erc20PeriodTransferBuilder';
+import type { Erc20PeriodTransferBuilderConfig } from '../erc20PeriodTransferBuilder';
 
 export type Erc20PeriodicScopeConfig = {
-  type: typeof erc20PeriodTransfer;
+  type: ScopeType.Erc20PeriodTransfer;
 } & Erc20PeriodTransferBuilderConfig;
 
 /**

packages/smart-accounts-kit/src/caveatBuilder/scope/erc20StreamingScope.ts

@@ -1,13 +1,11 @@
+import type { ScopeType } from '../../constants';
 import type { SmartAccountsEnvironment } from '../../types';
 import { createCaveatBuilder } from '../coreCaveatBuilder';
 import type { CoreCaveatBuilder } from '../coreCaveatBuilder';
-import type {
-  erc20Streaming,
-  Erc20StreamingBuilderConfig,
-} from '../erc20StreamingBuilder';
+import type { Erc20StreamingBuilderConfig } from '../erc20StreamingBuilder';
 
 export type Erc20StreamingScopeConfig = {
-  type: typeof erc20Streaming;
+  type: ScopeType.Erc20Streaming;
 } & Erc20StreamingBuilderConfig;
 
 /**

packages/smart-accounts-kit/src/caveatBuilder/scope/erc20TransferScope.ts

@@ -1,13 +1,11 @@
+import type { ScopeType } from '../../constants';
 import type { SmartAccountsEnvironment } from '../../types';
 import { createCaveatBuilder } from '../coreCaveatBuilder';
 import type { CoreCaveatBuilder } from '../coreCaveatBuilder';
-import type {
-  erc20TransferAmount,
-  Erc20TransferAmountBuilderConfig,
-} from '../erc20TransferAmountBuilder';
+import type { Erc20TransferAmountBuilderConfig } from '../erc20TransferAmountBuilder';
 
 export type Erc20TransferScopeConfig = {
-  type: typeof erc20TransferAmount;
+  type: ScopeType.Erc20TransferAmount;
 } & Erc20TransferAmountBuilderConfig;
 
 /**

packages/smart-accounts-kit/src/caveatBuilder/scope/erc721Scope.ts

@@ -1,14 +1,12 @@
+import type { ScopeType } from '../../constants';
 import type { SmartAccountsEnvironment } from '../../types';
 import { hasProperties } from '../../utils';
 import { createCaveatBuilder } from '../coreCaveatBuilder';
 import type { CoreCaveatBuilder } from '../coreCaveatBuilder';
-import type {
-  erc721Transfer,
-  Erc721TransferBuilderConfig,
-} from '../erc721TransferBuilder';
+import type { Erc721TransferBuilderConfig } from '../erc721TransferBuilder';
 
 export type Erc721ScopeBaseConfig = {
-  type: typeof erc721Transfer;
+  type: ScopeType.Erc721Transfer;
 };
 
 export type Erc721ScopeConfig = Erc721ScopeBaseConfig &

packages/smart-accounts-kit/src/caveatBuilder/scope/functionCallScope.ts

@@ -1,3 +1,4 @@
+import type { ScopeType } from '../../constants';
 import type { SmartAccountsEnvironment } from '../../types';
 import { hasProperties } from '../../utils';
 import type { AllowedCalldataBuilderConfig } from '../allowedCalldataBuilder';
@@ -9,7 +10,7 @@ import type { ExactCalldataBuilderConfig } from '../exactCalldataBuilder';
 import type { ValueLteBuilderConfig } from '../valueLteBuilder';
 
 type FunctionCallScopeBaseConfig = {
-  type: 'functionCall';
+  type: ScopeType.FunctionCall;
   allowedCalldata?: AllowedCalldataBuilderConfig[];
   exactCalldata?: ExactCalldataBuilderConfig;
   valueLte?: ValueLteBuilderConfig;

packages/smart-accounts-kit/src/caveatBuilder/scope/index.ts

@@ -34,18 +34,20 @@ import {
   createOwnershipCaveatBuilder,
   type OwnershipScopeConfig,
 } from './ownershipScope';
+import { ScopeType } from '../../constants';
 import type { SmartAccountsEnvironment } from '../../types';
-// Import caveat builder name constants
-import { erc20PeriodTransfer } from '../erc20PeriodTransferBuilder';
-import { erc20Streaming } from '../erc20StreamingBuilder';
-import { erc20TransferAmount } from '../erc20TransferAmountBuilder';
-import { erc721Transfer } from '../erc721TransferBuilder';
-import { nativeTokenPeriodTransfer } from '../nativeTokenPeriodTransferBuilder';
-import { nativeTokenStreaming } from '../nativeTokenStreamingBuilder';
-import { nativeTokenTransferAmount } from '../nativeTokenTransferAmountBuilder';
-import { ownershipTransfer } from '../ownershipTransferBuilder';
+import type { CoreCaveatBuilder } from '../coreCaveatBuilder';
 
-export type ScopeConfig =
+// We want to allow the scope `type` to be passed as either an enum reference,
+// or the enum's string value this generic accepts a union of scope configs, and
+// converts them to an identical union except the `type` parameter is converted
+// to a union of `ScopeType.XXXX | `${ScopeType.XXXX}`.
+export type ConvertScopeConfigsToInputs<T extends { type: ScopeType }> =
+  T extends { type: ScopeType }
+    ? Omit<T, 'type'> & { type: T['type'] | `${T['type']}` }
+    : never;
+
+type ScopeConfigBase =
   | Erc20TransferScopeConfig
   | Erc20StreamingScopeConfig
   | Erc20PeriodicScopeConfig
@@ -56,32 +58,64 @@ export type ScopeConfig =
   | OwnershipScopeConfig
   | FunctionCallScopeConfig;
 
+export type ScopeConfig = ConvertScopeConfigsToInputs<ScopeConfigBase>;
+
+const normalizeScopeConfig = (config: ScopeConfig): ScopeConfigBase => {
+  return {
+    ...config,
+    type: config.type as ScopeType,
+  } as ScopeConfigBase;
+};
+
 export const createCaveatBuilderFromScope = (
   environment: SmartAccountsEnvironment,
   scopeConfig: ScopeConfig,
-) => {
-  switch (scopeConfig.type) {
-    case erc20TransferAmount:
-      return createErc20TransferCaveatBuilder(environment, scopeConfig);
-    case erc20Streaming:
-      return createErc20StreamingCaveatBuilder(environment, scopeConfig);
-    case erc20PeriodTransfer:
-      return createErc20PeriodicCaveatBuilder(environment, scopeConfig);
-    case nativeTokenTransferAmount:
-      return createNativeTokenTransferCaveatBuilder(environment, scopeConfig);
-    case nativeTokenStreaming:
-      return createNativeTokenStreamingCaveatBuilder(environment, scopeConfig);
-    case nativeTokenPeriodTransfer:
-      return createNativeTokenPeriodicCaveatBuilder(environment, scopeConfig);
-    case erc721Transfer:
-      return createErc721CaveatBuilder(environment, scopeConfig);
-    case ownershipTransfer:
-      return createOwnershipCaveatBuilder(environment, scopeConfig);
-    case 'functionCall':
-      return createFunctionCallCaveatBuilder(environment, scopeConfig);
+): CoreCaveatBuilder => {
+  const normalizedScopeConfig = normalizeScopeConfig(scopeConfig);
+
+  switch (normalizedScopeConfig.type) {
+    case ScopeType.Erc20TransferAmount:
+      return createErc20TransferCaveatBuilder(
+        environment,
+        normalizedScopeConfig,
+      );
+    case ScopeType.Erc20Streaming:
+      return createErc20StreamingCaveatBuilder(
+        environment,
+        normalizedScopeConfig,
+      );
+    case ScopeType.Erc20PeriodTransfer:
+      return createErc20PeriodicCaveatBuilder(
+        environment,
+        normalizedScopeConfig,
+      );
+    case ScopeType.NativeTokenTransferAmount:
+      return createNativeTokenTransferCaveatBuilder(
+        environment,
+        normalizedScopeConfig,
+      );
+    case ScopeType.NativeTokenStreaming:
+      return createNativeTokenStreamingCaveatBuilder(
+        environment,
+        normalizedScopeConfig,
+      );
+    case ScopeType.NativeTokenPeriodTransfer:
+      return createNativeTokenPeriodicCaveatBuilder(
+        environment,
+        normalizedScopeConfig,
+      );
+    case ScopeType.Erc721Transfer:
+      return createErc721CaveatBuilder(environment, normalizedScopeConfig);
+    case ScopeType.OwnershipTransfer:
+      return createOwnershipCaveatBuilder(environment, normalizedScopeConfig);
+    case ScopeType.FunctionCall:
+      return createFunctionCallCaveatBuilder(
+        environment,
+        normalizedScopeConfig,
+      );
     default:
       // eslint-disable-next-line no-case-declarations
-      const exhaustivenessCheck: never = scopeConfig;
+      const exhaustivenessCheck: never = normalizedScopeConfig;
       throw new Error(
         `Invalid scope type: ${(exhaustivenessCheck as { type: string }).type}`,
       );

packages/smart-accounts-kit/src/caveatBuilder/scope/nativeTokenPeriodicScope.ts

@@ -1,15 +1,13 @@
+import type { ScopeType } from '../../constants';
 import type { SmartAccountsEnvironment } from '../../types';
 import type { AllowedCalldataBuilderConfig } from '../allowedCalldataBuilder';
 import { createCaveatBuilder } from '../coreCaveatBuilder';
 import type { CoreCaveatBuilder } from '../coreCaveatBuilder';
 import type { ExactCalldataBuilderConfig } from '../exactCalldataBuilder';
-import type {
-  nativeTokenPeriodTransfer,
-  NativeTokenPeriodTransferBuilderConfig,
-} from '../nativeTokenPeriodTransferBuilder';
+import type { NativeTokenPeriodTransferBuilderConfig } from '../nativeTokenPeriodTransferBuilder';
 
 export type NativeTokenPeriodicScopeConfig = {
-  type: typeof nativeTokenPeriodTransfer;
+  type: ScopeType.NativeTokenPeriodTransfer;
   allowedCalldata?: AllowedCalldataBuilderConfig[];
   exactCalldata?: ExactCalldataBuilderConfig;
 } & NativeTokenPeriodTransferBuilderConfig;

packages/smart-accounts-kit/src/caveatBuilder/scope/nativeTokenStreamingScope.ts

@@ -1,15 +1,13 @@
+import type { ScopeType } from '../../constants';
 import type { SmartAccountsEnvironment } from '../../types';
 import type { AllowedCalldataBuilderConfig } from '../allowedCalldataBuilder';
 import { createCaveatBuilder } from '../coreCaveatBuilder';
 import type { CoreCaveatBuilder } from '../coreCaveatBuilder';
 import type { ExactCalldataBuilderConfig } from '../exactCalldataBuilder';
-import type {
-  nativeTokenStreaming,
-  NativeTokenStreamingBuilderConfig,
-} from '../nativeTokenStreamingBuilder';
+import type { NativeTokenStreamingBuilderConfig } from '../nativeTokenStreamingBuilder';
 
 export type NativeTokenStreamingScopeConfig = {
-  type: typeof nativeTokenStreaming;
+  type: ScopeType.NativeTokenStreaming;
   allowedCalldata?: AllowedCalldataBuilderConfig[];
   exactCalldata?: ExactCalldataBuilderConfig;
 } & NativeTokenStreamingBuilderConfig;

packages/smart-accounts-kit/src/caveatBuilder/scope/nativeTokenTransferScope.ts

@@ -1,15 +1,13 @@
+import type { ScopeType } from '../../constants';
 import type { SmartAccountsEnvironment } from '../../types';
 import type { AllowedCalldataBuilderConfig } from '../allowedCalldataBuilder';
 import { createCaveatBuilder } from '../coreCaveatBuilder';
 import type { CoreCaveatBuilder } from '../coreCaveatBuilder';
 import type { ExactCalldataBuilderConfig } from '../exactCalldataBuilder';
-import type {
-  nativeTokenTransferAmount,
-  NativeTokenTransferAmountBuilderConfig,
-} from '../nativeTokenTransferAmountBuilder';
+import type { NativeTokenTransferAmountBuilderConfig } from '../nativeTokenTransferAmountBuilder';
 
 export type NativeTokenTransferScopeConfig = {
-  type: typeof nativeTokenTransferAmount;
+  type: ScopeType.NativeTokenTransferAmount;
   allowedCalldata?: AllowedCalldataBuilderConfig[];
   exactCalldata?: ExactCalldataBuilderConfig;
 } & NativeTokenTransferAmountBuilderConfig;