@metamask/snaps-rpc-methods 6.0.0 → 7.0.1

package/dist/cjs/restricted/manageState.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/restricted/manageState.ts"],"sourcesContent":["import type {\n  PermissionSpecificationBuilder,\n  RestrictedMethodOptions,\n  ValidPermissionSpecification,\n} from '@metamask/permission-controller';\nimport { PermissionType, SubjectType } from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport type { ManageStateParams, ManageStateResult } from '@metamask/snaps-sdk';\nimport { ManageStateOperation } from '@metamask/snaps-sdk';\nimport { STATE_ENCRYPTION_MAGIC_VALUE, parseJson } from '@metamask/snaps-utils';\nimport type { Json, NonEmptyArray, Hex } from '@metamask/utils';\nimport { isObject, getJsonSize, assert, isValidJson } from '@metamask/utils';\n\nimport type { MethodHooksObject } from '../utils';\nimport { deriveEntropy } from '../utils';\n\n// The salt used for SIP-6-based entropy derivation.\nexport const STATE_ENCRYPTION_SALT = 'snap_manageState encryption';\n\nconst methodName = 'snap_manageState';\n\nexport type ManageStateMethodHooks = {\n  /**\n   * @returns The mnemonic of the user's primary keyring.\n   */\n  getMnemonic: () => Promise<Uint8Array>;\n\n  /**\n   * Waits for the extension to be unlocked.\n   *\n   * @returns A promise that resolves once the extension is unlocked.\n   */\n  getUnlockPromise: (shouldShowUnlockRequest: boolean) => Promise<void>;\n\n  /**\n   * A function that clears the state of the requesting Snap.\n   */\n  clearSnapState: (snapId: string, encrypted: boolean) => void;\n\n  /**\n   * A function that gets the encrypted state of the requesting Snap.\n   *\n   * @returns The current state of the Snap.\n   */\n  getSnapState: (snapId: string, encrypted: boolean) => string;\n\n  /**\n   * A function that updates the state of the requesting Snap.\n   *\n   * @param newState - The new state of the Snap.\n   */\n  updateSnapState: (\n    snapId: string,\n    newState: string,\n    encrypted: boolean,\n  ) => void;\n\n  /**\n   * Encrypts data with a key. This is assumed to perform symmetric encryption.\n   *\n   * @param key - The key to use for encryption, in hexadecimal format.\n   * @param data - The JSON data to encrypt.\n   * @returns The ciphertext as a string. The format for this string is\n   * dependent on the implementation, but MUST be a string.\n   */\n  encrypt: (key: string, data: Json) => Promise<string>;\n\n  /**\n   * Decrypts data with a key. This is assumed to perform symmetric decryption.\n   *\n   * @param key - The key to use for decryption, in hexadecimal format.\n   * @param cipherText - The ciphertext to decrypt. The format for this string\n   * is dependent on the implementation, but MUST be a string.\n   * @returns The decrypted data as a JSON object.\n   */\n  decrypt: (key: Hex, cipherText: string) => Promise<unknown>;\n};\n\ntype ManageStateSpecificationBuilderOptions = {\n  allowedCaveats?: Readonly<NonEmptyArray<string>> | null;\n  methodHooks: ManageStateMethodHooks;\n};\n\ntype ManageStateSpecification = ValidPermissionSpecification<{\n  permissionType: PermissionType.RestrictedMethod;\n  targetName: typeof methodName;\n  methodImplementation: ReturnType<typeof getManageStateImplementation>;\n  allowedCaveats: Readonly<NonEmptyArray<string>> | null;\n}>;\n\n/**\n * The specification builder for the `snap_manageState` permission.\n * `snap_manageState` lets the Snap store and manage some of its state on\n * your device.\n *\n * @param options - The specification builder options.\n * @param options.allowedCaveats - The optional allowed caveats for the permission.\n * @param options.methodHooks - The RPC method hooks needed by the method implementation.\n * @returns The specification for the `snap_manageState` permission.\n */\nexport const specificationBuilder: PermissionSpecificationBuilder<\n  PermissionType.RestrictedMethod,\n  ManageStateSpecificationBuilderOptions,\n  ManageStateSpecification\n> = ({\n  allowedCaveats = null,\n  methodHooks,\n}: ManageStateSpecificationBuilderOptions) => {\n  return {\n    permissionType: PermissionType.RestrictedMethod,\n    targetName: methodName,\n    allowedCaveats,\n    methodImplementation: getManageStateImplementation(methodHooks),\n    subjectTypes: [SubjectType.Snap],\n  };\n};\n\nconst methodHooks: MethodHooksObject<ManageStateMethodHooks> = {\n  getMnemonic: true,\n  getUnlockPromise: true,\n  clearSnapState: true,\n  getSnapState: true,\n  updateSnapState: true,\n  encrypt: true,\n  decrypt: true,\n};\n\nexport const manageStateBuilder = Object.freeze({\n  targetName: methodName,\n  specificationBuilder,\n  methodHooks,\n} as const);\n\nexport const STORAGE_SIZE_LIMIT = 104857600; // In bytes (100MB)\n\ntype GetEncryptionKeyArgs = {\n  snapId: string;\n  mnemonicPhrase: Uint8Array;\n};\n\n/**\n * Get a deterministic encryption key to use for encrypting and decrypting the\n * state.\n *\n * This key should only be used for state encryption using `snap_manageState`.\n * To get other encryption keys, a different salt can be used.\n *\n * @param args - The encryption key args.\n * @param args.snapId - The ID of the snap to get the encryption key for.\n * @param args.mnemonicPhrase - The mnemonic phrase to derive the encryption key\n * from.\n * @returns The state encryption key.\n */\nexport async function getEncryptionKey({\n  mnemonicPhrase,\n  snapId,\n}: GetEncryptionKeyArgs) {\n  return await deriveEntropy({\n    mnemonicPhrase,\n    input: snapId,\n    salt: STATE_ENCRYPTION_SALT,\n    magic: STATE_ENCRYPTION_MAGIC_VALUE,\n  });\n}\n\ntype EncryptStateArgs = GetEncryptionKeyArgs & {\n  state: Json;\n  encryptFunction: ManageStateMethodHooks['encrypt'];\n};\n\n/**\n * Encrypt the state using a deterministic encryption algorithm, based on the\n * snap ID and mnemonic phrase.\n *\n * @param args - The encryption args.\n * @param args.state - The state to encrypt.\n * @param args.encryptFunction - The function to use for encrypting the state.\n * @param args.snapId - The ID of the snap to get the encryption key for.\n * @param args.mnemonicPhrase - The mnemonic phrase to derive the encryption key\n * from.\n * @returns The encrypted state.\n */\nasync function encryptState({\n  state,\n  encryptFunction,\n  ...keyArgs\n}: EncryptStateArgs) {\n  const encryptionKey = await getEncryptionKey(keyArgs);\n  return await encryptFunction(encryptionKey, state);\n}\n\ntype DecryptStateArgs = GetEncryptionKeyArgs & {\n  state: string;\n  decryptFunction: ManageStateMethodHooks['decrypt'];\n};\n\n/**\n * Decrypt the state using a deterministic decryption algorithm, based on the\n * snap ID and mnemonic phrase.\n *\n * @param args - The encryption args.\n * @param args.state - The state to decrypt.\n * @param args.decryptFunction - The function to use for decrypting the state.\n * @param args.snapId - The ID of the snap to get the encryption key for.\n * @param args.mnemonicPhrase - The mnemonic phrase to derive the encryption key\n * from.\n * @returns The encrypted state.\n */\nasync function decryptState({\n  state,\n  decryptFunction,\n  ...keyArgs\n}: DecryptStateArgs) {\n  try {\n    const encryptionKey = await getEncryptionKey(keyArgs);\n    const decryptedState = await decryptFunction(encryptionKey, state);\n\n    assert(isValidJson(decryptedState));\n\n    return decryptedState as Record<string, Json>;\n  } catch {\n    throw rpcErrors.internal({\n      message: 'Failed to decrypt snap state, the state must be corrupted.',\n    });\n  }\n}\n\n/**\n * Builds the method implementation for `snap_manageState`.\n *\n * @param hooks - The RPC method hooks.\n * @param hooks.clearSnapState - A function that clears the state stored for a\n * snap.\n * @param hooks.getSnapState - A function that fetches the persisted decrypted\n * state for a snap.\n * @param hooks.updateSnapState - A function that updates the state stored for a\n * snap.\n * @param hooks.getMnemonic - A function to retrieve the Secret Recovery Phrase\n * of the user.\n * @param hooks.getUnlockPromise - A function that resolves once the MetaMask\n * extension is unlocked and prompts the user to unlock their MetaMask if it is\n * locked.\n * @param hooks.encrypt - A function that encrypts the given state.\n * @param hooks.decrypt - A function that decrypts the given state.\n * @returns The method implementation which either returns `null` for a\n * successful state update/deletion or returns the decrypted state.\n * @throws If the params are invalid.\n */\nexport function getManageStateImplementation({\n  getMnemonic,\n  getUnlockPromise,\n  clearSnapState,\n  getSnapState,\n  updateSnapState,\n  encrypt,\n  decrypt,\n}: ManageStateMethodHooks) {\n  return async function manageState(\n    options: RestrictedMethodOptions<ManageStateParams>,\n  ): Promise<ManageStateResult> {\n    const {\n      params = {},\n      method,\n      context: { origin },\n    } = options;\n    const validatedParams = getValidatedParams(params, method);\n\n    // If the encrypted param is undefined or null we default to true.\n    const shouldEncrypt = validatedParams.encrypted ?? true;\n\n    // We only need to prompt the user when the mnemonic is needed\n    // which it isn't for the clear operation or unencrypted storage.\n    if (\n      shouldEncrypt &&\n      validatedParams.operation !== ManageStateOperation.ClearState\n    ) {\n      await getUnlockPromise(true);\n    }\n\n    switch (validatedParams.operation) {\n      case ManageStateOperation.ClearState:\n        clearSnapState(origin, shouldEncrypt);\n        return null;\n\n      case ManageStateOperation.GetState: {\n        const state = getSnapState(origin, shouldEncrypt);\n        if (state === null) {\n          return state;\n        }\n        return shouldEncrypt\n          ? await decryptState({\n              state,\n              decryptFunction: decrypt,\n              mnemonicPhrase: await getMnemonic(),\n              snapId: origin,\n            })\n          : parseJson<Record<string, Json>>(state);\n      }\n\n      case ManageStateOperation.UpdateState: {\n        const finalizedState = shouldEncrypt\n          ? await encryptState({\n              state: validatedParams.newState,\n              encryptFunction: encrypt,\n              mnemonicPhrase: await getMnemonic(),\n              snapId: origin,\n            })\n          : JSON.stringify(validatedParams.newState);\n\n        updateSnapState(origin, finalizedState, shouldEncrypt);\n        return null;\n      }\n\n      default:\n        throw rpcErrors.invalidParams(\n          `Invalid ${method} operation: \"${\n            validatedParams.operation as string\n          }\"`,\n        );\n    }\n  };\n}\n\n/**\n * Validates the manageState method `params` and returns them cast to the correct\n * type. Throws if validation fails.\n *\n * @param params - The unvalidated params object from the method request.\n * @param method - RPC method name used for debugging errors.\n * @param storageSizeLimit - Maximum allowed size (in bytes) of a new state object.\n * @returns The validated method parameter object.\n */\nexport function getValidatedParams(\n  params: unknown,\n  method: string,\n  storageSizeLimit = STORAGE_SIZE_LIMIT,\n): ManageStateParams {\n  if (!isObject(params)) {\n    throw rpcErrors.invalidParams({\n      message: 'Expected params to be a single object.',\n    });\n  }\n\n  const { operation, newState, encrypted } = params;\n\n  if (\n    !operation ||\n    typeof operation !== 'string' ||\n    !Object.values(ManageStateOperation).includes(\n      operation as ManageStateOperation,\n    )\n  ) {\n    throw rpcErrors.invalidParams({\n      message: 'Must specify a valid manage state \"operation\".',\n    });\n  }\n\n  if (encrypted !== undefined && typeof encrypted !== 'boolean') {\n    throw rpcErrors.invalidParams({\n      message: '\"encrypted\" parameter must be a boolean if specified.',\n    });\n  }\n\n  if (operation === ManageStateOperation.UpdateState) {\n    if (!isObject(newState)) {\n      throw rpcErrors.invalidParams({\n        message: `Invalid ${method} \"updateState\" parameter: The new state must be a plain object.`,\n        data: {\n          receivedNewState:\n            typeof newState === 'undefined' ? 'undefined' : newState,\n        },\n      });\n    }\n\n    let size;\n    try {\n      // `getJsonSize` will throw if the state is not JSON serializable.\n      size = getJsonSize(newState);\n    } catch {\n      throw rpcErrors.invalidParams({\n        message: `Invalid ${method} \"updateState\" parameter: The new state must be JSON serializable.`,\n        data: {\n          receivedNewState:\n            typeof newState === 'undefined' ? 'undefined' : newState,\n        },\n      });\n    }\n\n    if (size > storageSizeLimit) {\n      throw rpcErrors.invalidParams({\n        message: `Invalid ${method} \"updateState\" parameter: The new state must not exceed ${storageSizeLimit} bytes in size.`,\n        data: {\n          receivedNewState:\n            typeof newState === 'undefined' ? 'undefined' : newState,\n        },\n      });\n    }\n  }\n\n  return params as ManageStateParams;\n}\n"],"names":["STATE_ENCRYPTION_SALT","specificationBuilder","manageStateBuilder","STORAGE_SIZE_LIMIT","getEncryptionKey","getManageStateImplementation","getValidatedParams","methodName","allowedCaveats","methodHooks","permissionType","PermissionType","RestrictedMethod","targetName","methodImplementation","subjectTypes","SubjectType","Snap","getMnemonic","getUnlockPromise","clearSnapState","getSnapState","updateSnapState","encrypt","decrypt","Object","freeze","mnemonicPhrase","snapId","deriveEntropy","input","salt","magic","STATE_ENCRYPTION_MAGIC_VALUE","encryptState","state","encryptFunction","keyArgs","encryptionKey","decryptState","decryptFunction","decryptedState","assert","isValidJson","rpcErrors","internal","message","manageState","options","params","method","context","origin","validatedParams","shouldEncrypt","encrypted","operation","ManageStateOperation","ClearState","GetState","parseJson","UpdateState","finalizedState","newState","JSON","stringify","invalidParams","storageSizeLimit","isObject","values","includes","undefined","data","receivedNewState","size","getJsonSize"],"mappings":"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"}

package/dist/cjs/restricted/notify.js

@@ -1,92 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    specificationBuilder: function() {
-        return specificationBuilder;
-    },
-    notifyBuilder: function() {
-        return notifyBuilder;
-    },
-    getImplementation: function() {
-        return getImplementation;
-    },
-    getValidatedParams: function() {
-        return getValidatedParams;
-    }
-});
-const _permissioncontroller = require("@metamask/permission-controller");
-const _rpcerrors = require("@metamask/rpc-errors");
-const _snapssdk = require("@metamask/snaps-sdk");
-const _snapsutils = require("@metamask/snaps-utils");
-const _utils = require("@metamask/utils");
-const methodName = 'snap_notify';
-const specificationBuilder = ({ allowedCaveats = null, methodHooks })=>{
-    return {
-        permissionType: _permissioncontroller.PermissionType.RestrictedMethod,
-        targetName: methodName,
-        allowedCaveats,
-        methodImplementation: getImplementation(methodHooks),
-        subjectTypes: [
-            _permissioncontroller.SubjectType.Snap
-        ]
-    };
-};
-const methodHooks = {
-    showNativeNotification: true,
-    showInAppNotification: true,
-    isOnPhishingList: true,
-    maybeUpdatePhishingList: true
-};
-const notifyBuilder = Object.freeze({
-    targetName: methodName,
-    specificationBuilder,
-    methodHooks
-});
-function getImplementation({ showNativeNotification, showInAppNotification, isOnPhishingList, maybeUpdatePhishingList }) {
-    return async function implementation(args) {
-        const { params, context: { origin } } = args;
-        const validatedParams = getValidatedParams(params);
-        await maybeUpdatePhishingList();
-        (0, _snapsutils.validateTextLinks)(validatedParams.message, isOnPhishingList);
-        switch(validatedParams.type){
-            case _snapssdk.NotificationType.Native:
-                return await showNativeNotification(origin, validatedParams);
-            case _snapssdk.NotificationType.InApp:
-                return await showInAppNotification(origin, validatedParams);
-            default:
-                throw _rpcerrors.rpcErrors.invalidParams({
-                    message: 'Must specify a valid notification "type".'
-                });
-        }
-    };
-}
-function getValidatedParams(params) {
-    if (!(0, _utils.isObject)(params)) {
-        throw _rpcerrors.rpcErrors.invalidParams({
-            message: 'Expected params to be a single object.'
-        });
-    }
-    const { type, message } = params;
-    if (!type || typeof type !== 'string' || !Object.values(_snapssdk.NotificationType).includes(type)) {
-        throw _rpcerrors.rpcErrors.invalidParams({
-            message: 'Must specify a valid notification "type".'
-        });
-    }
-    // Set to the max message length on a Mac notification for now.
-    if (!message || typeof message !== 'string' || message.length >= 50) {
-        throw _rpcerrors.rpcErrors.invalidParams({
-            message: 'Must specify a non-empty string "message" less than 50 characters long.'
-        });
-    }
-    return params;
-}
-
-//# sourceMappingURL=notify.js.map

package/dist/cjs/restricted/notify.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/restricted/notify.ts"],"sourcesContent":["import type {\n  PermissionSpecificationBuilder,\n  RestrictedMethodOptions,\n  ValidPermissionSpecification,\n} from '@metamask/permission-controller';\nimport { PermissionType, SubjectType } from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport { NotificationType } from '@metamask/snaps-sdk';\nimport type {\n  NotifyParams,\n  NotifyResult,\n  EnumToUnion,\n} from '@metamask/snaps-sdk';\nimport { validateTextLinks } from '@metamask/snaps-utils';\nimport type { NonEmptyArray } from '@metamask/utils';\nimport { isObject } from '@metamask/utils';\n\nimport { type MethodHooksObject } from '../utils';\n\nconst methodName = 'snap_notify';\n\nexport type NotificationArgs = {\n  /**\n   * Enum type to determine notification type.\n   */\n  type: EnumToUnion<NotificationType>;\n\n  /**\n   * A message to show on the notification.\n   */\n  message: string;\n};\n\nexport type NotifyMethodHooks = {\n  /**\n   * @param snapId - The ID of the Snap that created the notification.\n   * @param args - The notification arguments.\n   */\n  showNativeNotification: (\n    snapId: string,\n    args: NotificationArgs,\n  ) => Promise<null>;\n\n  /**\n   * @param snapId - The ID of the Snap that created the notification.\n   * @param args - The notification arguments.\n   */\n  showInAppNotification: (\n    snapId: string,\n    args: NotificationArgs,\n  ) => Promise<null>;\n\n  isOnPhishingList: (url: string) => boolean;\n\n  maybeUpdatePhishingList: () => Promise<void>;\n};\n\ntype SpecificationBuilderOptions = {\n  allowedCaveats?: Readonly<NonEmptyArray<string>> | null;\n  methodHooks: NotifyMethodHooks;\n};\n\ntype Specification = ValidPermissionSpecification<{\n  permissionType: PermissionType.RestrictedMethod;\n  targetName: typeof methodName;\n  methodImplementation: ReturnType<typeof getImplementation>;\n  allowedCaveats: Readonly<NonEmptyArray<string>> | null;\n}>;\n\n/**\n * The specification builder for the `snap_notify` permission.\n * `snap_notify` allows snaps to send multiple types of notifications to its users.\n *\n * @param options - The specification builder options.\n * @param options.allowedCaveats - The optional allowed caveats for the permission.\n * @param options.methodHooks - The RPC method hooks needed by the method implementation.\n * @returns The specification for the `snap_notify` permission.\n */\nexport const specificationBuilder: PermissionSpecificationBuilder<\n  PermissionType.RestrictedMethod,\n  SpecificationBuilderOptions,\n  Specification\n> = ({ allowedCaveats = null, methodHooks }: SpecificationBuilderOptions) => {\n  return {\n    permissionType: PermissionType.RestrictedMethod,\n    targetName: methodName,\n    allowedCaveats,\n    methodImplementation: getImplementation(methodHooks),\n    subjectTypes: [SubjectType.Snap],\n  };\n};\n\nconst methodHooks: MethodHooksObject<NotifyMethodHooks> = {\n  showNativeNotification: true,\n  showInAppNotification: true,\n  isOnPhishingList: true,\n  maybeUpdatePhishingList: true,\n};\n\nexport const notifyBuilder = Object.freeze({\n  targetName: methodName,\n  specificationBuilder,\n  methodHooks,\n} as const);\n\n/**\n * Builds the method implementation for `snap_notify`.\n *\n * @param hooks - The RPC method hooks.\n * @param hooks.showNativeNotification - A function that shows a native browser notification.\n * @param hooks.showInAppNotification - A function that shows a notification in the MetaMask UI.\n * @param hooks.isOnPhishingList - A function that checks for links against the phishing list.\n * @param hooks.maybeUpdatePhishingList - A function that updates the phishing list if needed.\n * @returns The method implementation which returns `null` on success.\n * @throws If the params are invalid.\n */\nexport function getImplementation({\n  showNativeNotification,\n  showInAppNotification,\n  isOnPhishingList,\n  maybeUpdatePhishingList,\n}: NotifyMethodHooks) {\n  return async function implementation(\n    args: RestrictedMethodOptions<NotifyParams>,\n  ): Promise<NotifyResult> {\n    const {\n      params,\n      context: { origin },\n    } = args;\n\n    const validatedParams = getValidatedParams(params);\n\n    await maybeUpdatePhishingList();\n\n    validateTextLinks(validatedParams.message, isOnPhishingList);\n\n    switch (validatedParams.type) {\n      case NotificationType.Native:\n        return await showNativeNotification(origin, validatedParams);\n      case NotificationType.InApp:\n        return await showInAppNotification(origin, validatedParams);\n      default:\n        throw rpcErrors.invalidParams({\n          message: 'Must specify a valid notification \"type\".',\n        });\n    }\n  };\n}\n\n/**\n * Validates the notify method `params` and returns them cast to the correct\n * type. Throws if validation fails.\n *\n * @param params - The unvalidated params object from the method request.\n * @returns The validated method parameter object.\n */\nexport function getValidatedParams(params: unknown): NotifyParams {\n  if (!isObject(params)) {\n    throw rpcErrors.invalidParams({\n      message: 'Expected params to be a single object.',\n    });\n  }\n\n  const { type, message } = params;\n\n  if (\n    !type ||\n    typeof type !== 'string' ||\n    !Object.values(NotificationType).includes(type as NotificationType)\n  ) {\n    throw rpcErrors.invalidParams({\n      message: 'Must specify a valid notification \"type\".',\n    });\n  }\n\n  // Set to the max message length on a Mac notification for now.\n  if (!message || typeof message !== 'string' || message.length >= 50) {\n    throw rpcErrors.invalidParams({\n      message:\n        'Must specify a non-empty string \"message\" less than 50 characters long.',\n    });\n  }\n\n  return params as NotificationArgs;\n}\n"],"names":["specificationBuilder","notifyBuilder","getImplementation","getValidatedParams","methodName","allowedCaveats","methodHooks","permissionType","PermissionType","RestrictedMethod","targetName","methodImplementation","subjectTypes","SubjectType","Snap","showNativeNotification","showInAppNotification","isOnPhishingList","maybeUpdatePhishingList","Object","freeze","implementation","args","params","context","origin","validatedParams","validateTextLinks","message","type","NotificationType","Native","InApp","rpcErrors","invalidParams","isObject","values","includes","length"],"mappings":";;;;;;;;;;;IA8EaA,oBAAoB;eAApBA;;IAqBAC,aAAa;eAAbA;;IAiBGC,iBAAiB;eAAjBA;;IAwCAC,kBAAkB;eAAlBA;;;sCAvJ4B;2BAClB;0BACO;4BAMC;uBAET;AAIzB,MAAMC,aAAa;AA2DZ,MAAMJ,uBAIT,CAAC,EAAEK,iBAAiB,IAAI,EAAEC,WAAW,EAA+B;IACtE,OAAO;QACLC,gBAAgBC,oCAAc,CAACC,gBAAgB;QAC/CC,YAAYN;QACZC;QACAM,sBAAsBT,kBAAkBI;QACxCM,cAAc;YAACC,iCAAW,CAACC,IAAI;SAAC;IAClC;AACF;AAEA,MAAMR,cAAoD;IACxDS,wBAAwB;IACxBC,uBAAuB;IACvBC,kBAAkB;IAClBC,yBAAyB;AAC3B;AAEO,MAAMjB,gBAAgBkB,OAAOC,MAAM,CAAC;IACzCV,YAAYN;IACZJ;IACAM;AACF;AAaO,SAASJ,kBAAkB,EAChCa,sBAAsB,EACtBC,qBAAqB,EACrBC,gBAAgB,EAChBC,uBAAuB,EACL;IAClB,OAAO,eAAeG,eACpBC,IAA2C;QAE3C,MAAM,EACJC,MAAM,EACNC,SAAS,EAAEC,MAAM,EAAE,EACpB,GAAGH;QAEJ,MAAMI,kBAAkBvB,mBAAmBoB;QAE3C,MAAML;QAENS,IAAAA,6BAAiB,EAACD,gBAAgBE,OAAO,EAAEX;QAE3C,OAAQS,gBAAgBG,IAAI;YAC1B,KAAKC,0BAAgB,CAACC,MAAM;gBAC1B,OAAO,MAAMhB,uBAAuBU,QAAQC;YAC9C,KAAKI,0BAAgB,CAACE,KAAK;gBACzB,OAAO,MAAMhB,sBAAsBS,QAAQC;YAC7C;gBACE,MAAMO,oBAAS,CAACC,aAAa,CAAC;oBAC5BN,SAAS;gBACX;QACJ;IACF;AACF;AASO,SAASzB,mBAAmBoB,MAAe;IAChD,IAAI,CAACY,IAAAA,eAAQ,EAACZ,SAAS;QACrB,MAAMU,oBAAS,CAACC,aAAa,CAAC;YAC5BN,SAAS;QACX;IACF;IAEA,MAAM,EAAEC,IAAI,EAAED,OAAO,EAAE,GAAGL;IAE1B,IACE,CAACM,QACD,OAAOA,SAAS,YAChB,CAACV,OAAOiB,MAAM,CAACN,0BAAgB,EAAEO,QAAQ,CAACR,OAC1C;QACA,MAAMI,oBAAS,CAACC,aAAa,CAAC;YAC5BN,SAAS;QACX;IACF;IAEA,+DAA+D;IAC/D,IAAI,CAACA,WAAW,OAAOA,YAAY,YAAYA,QAAQU,MAAM,IAAI,IAAI;QACnE,MAAML,oBAAS,CAACC,aAAa,CAAC;YAC5BN,SACE;QACJ;IACF;IAEA,OAAOL;AACT"}

package/dist/cjs/utils.js

@@ -1,98 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    selectHooks: function() {
-        return selectHooks;
-    },
-    deriveEntropy: function() {
-        return deriveEntropy;
-    },
-    getPathPrefix: function() {
-        return getPathPrefix;
-    },
-    getNode: function() {
-        return getNode;
-    }
-});
-const _keytree = require("@metamask/key-tree");
-const _utils = require("@metamask/utils");
-const _sha3 = require("@noble/hashes/sha3");
-const HARDENED_VALUE = 0x80000000;
-function selectHooks(hooks, hookNames) {
-    if (hookNames) {
-        return Object.keys(hookNames).reduce((hookSubset, _hookName)=>{
-            const hookName = _hookName;
-            hookSubset[hookName] = hooks[hookName];
-            return hookSubset;
-        }, {});
-    }
-    return undefined;
-}
-/**
- * Get a BIP-32 derivation path array from a hash, which is compatible with
- * `@metamask/key-tree`. The hash is assumed to be 32 bytes long.
- *
- * @param hash - The hash to derive indices from.
- * @returns The derived indices as a {@link HardenedBIP32Node} array.
- */ function getDerivationPathArray(hash) {
-    const array = [];
-    const view = (0, _utils.createDataView)(hash);
-    for(let index = 0; index < 8; index++){
-        const uint32 = view.getUint32(index * 4);
-        // This is essentially `index | 0x80000000`. Because JavaScript numbers are
-        // signed, we use the bitwise unsigned right shift operator to ensure that
-        // the result is a positive number.
-        // eslint-disable-next-line no-bitwise
-        const pathIndex = (uint32 | HARDENED_VALUE) >>> 0;
-        array.push(`bip32:${pathIndex - HARDENED_VALUE}'`);
-    }
-    return array;
-}
-async function deriveEntropy({ input, salt = '', mnemonicPhrase, magic }) {
-    const inputBytes = (0, _utils.stringToBytes)(input);
-    const saltBytes = (0, _utils.stringToBytes)(salt);
-    // Get the derivation path from the snap ID.
-    const hash = (0, _sha3.keccak_256)((0, _utils.concatBytes)([
-        inputBytes,
-        (0, _sha3.keccak_256)(saltBytes)
-    ]));
-    const computedDerivationPath = getDerivationPathArray(hash);
-    // Derive the private key using BIP-32.
-    const { privateKey } = await _keytree.SLIP10Node.fromDerivationPath({
-        derivationPath: [
-            mnemonicPhrase,
-            `bip32:${magic}`,
-            ...computedDerivationPath
-        ],
-        curve: 'secp256k1'
-    });
-    // This should never happen, but this keeps TypeScript happy.
-    (0, _utils.assert)(privateKey, 'Failed to derive the entropy.');
-    return (0, _utils.add0x)(privateKey);
-}
-function getPathPrefix(curve) {
-    if (curve === 'secp256k1') {
-        return 'bip32';
-    }
-    return 'slip10';
-}
-async function getNode({ curve, secretRecoveryPhrase, path }) {
-    const prefix = getPathPrefix(curve);
-    return await _keytree.SLIP10Node.fromDerivationPath({
-        curve,
-        derivationPath: [
-            secretRecoveryPhrase,
-            ...path.slice(1).map((index)=>`${prefix}:${index}`)
-        ]
-    });
-}
-
-//# sourceMappingURL=utils.js.map

package/dist/esm/endowments/caveats/generic.js

@@ -1,40 +0,0 @@
-import { rpcErrors } from '@metamask/rpc-errors';
-/**
- * Create a generic permission validator that validates the presence of certain caveats.
- *
- * This validator only validates the types of the caveats, not the values.
- *
- * @param caveatsToValidate - A list of objects that represent caveats.
- * @param caveatsToValidate.type - The string defining the caveat type.
- * @param caveatsToValidate.optional - An optional boolean flag that defines
- * whether the caveat is optional or not.
- * @returns A function that validates a permission.
- */ export function createGenericPermissionValidator(caveatsToValidate) {
-    const validCaveatTypes = new Set(caveatsToValidate.map((caveat)=>caveat.type));
-    const requiredCaveats = caveatsToValidate.filter((caveat)=>!caveat.optional);
-    return function({ caveats }) {
-        const actualCaveats = caveats ?? [];
-        const passedCaveatTypes = actualCaveats.map((caveat)=>caveat.type);
-        const passedCaveatsSet = new Set(passedCaveatTypes);
-        // Disallow duplicates
-        if (passedCaveatsSet.size !== passedCaveatTypes.length) {
-            throw rpcErrors.invalidParams({
-                message: 'Duplicate caveats are not allowed.'
-            });
-        }
-        // Disallow caveats that don't match expected types
-        if (!actualCaveats.every((caveat)=>validCaveatTypes.has(caveat.type))) {
-            throw rpcErrors.invalidParams({
-                message: `Expected the following caveats: ${caveatsToValidate.map((caveat)=>`"${caveat.type}"`).join(', ')}, received ${actualCaveats.map((caveat)=>`"${caveat.type}"`).join(', ')}.`
-            });
-        }
-        // Fail if not all required caveats are specified
-        if (!requiredCaveats.every((caveat)=>passedCaveatsSet.has(caveat.type))) {
-            throw rpcErrors.invalidParams({
-                message: `Expected the following caveats: ${requiredCaveats.map((caveat)=>`"${caveat.type}"`).join(', ')}.`
-            });
-        }
-    };
-}
-
-//# sourceMappingURL=generic.js.map

package/dist/esm/endowments/caveats/generic.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/endowments/caveats/generic.ts"],"sourcesContent":["import type {\n  PermissionConstraint,\n  PermissionValidatorConstraint,\n} from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport type { Json } from '@metamask/utils';\n\nexport type CaveatMapperReturnValue = Pick<PermissionConstraint, 'caveats'>;\n\nexport type CaveatMapperFunction = (value: Json) => CaveatMapperReturnValue;\n\n/**\n * Create a generic permission validator that validates the presence of certain caveats.\n *\n * This validator only validates the types of the caveats, not the values.\n *\n * @param caveatsToValidate - A list of objects that represent caveats.\n * @param caveatsToValidate.type - The string defining the caveat type.\n * @param caveatsToValidate.optional - An optional boolean flag that defines\n * whether the caveat is optional or not.\n * @returns A function that validates a permission.\n */\nexport function createGenericPermissionValidator(\n  caveatsToValidate: {\n    type: string;\n    optional?: boolean;\n  }[],\n): PermissionValidatorConstraint {\n  const validCaveatTypes = new Set(\n    caveatsToValidate.map((caveat) => caveat.type),\n  );\n  const requiredCaveats = caveatsToValidate.filter(\n    (caveat) => !caveat.optional,\n  );\n\n  return function ({ caveats }) {\n    const actualCaveats = caveats ?? [];\n    const passedCaveatTypes = actualCaveats.map((caveat) => caveat.type);\n    const passedCaveatsSet = new Set(passedCaveatTypes);\n\n    // Disallow duplicates\n    if (passedCaveatsSet.size !== passedCaveatTypes.length) {\n      throw rpcErrors.invalidParams({\n        message: 'Duplicate caveats are not allowed.',\n      });\n    }\n\n    // Disallow caveats that don't match expected types\n    if (!actualCaveats.every((caveat) => validCaveatTypes.has(caveat.type))) {\n      throw rpcErrors.invalidParams({\n        message: `Expected the following caveats: ${caveatsToValidate\n          .map((caveat) => `\"${caveat.type}\"`)\n          .join(', ')}, received ${actualCaveats\n          .map((caveat) => `\"${caveat.type}\"`)\n          .join(', ')}.`,\n      });\n    }\n\n    // Fail if not all required caveats are specified\n    if (!requiredCaveats.every((caveat) => passedCaveatsSet.has(caveat.type))) {\n      throw rpcErrors.invalidParams({\n        message: `Expected the following caveats: ${requiredCaveats\n          .map((caveat) => `\"${caveat.type}\"`)\n          .join(', ')}.`,\n      });\n    }\n  };\n}\n"],"names":["rpcErrors","createGenericPermissionValidator","caveatsToValidate","validCaveatTypes","Set","map","caveat","type","requiredCaveats","filter","optional","caveats","actualCaveats","passedCaveatTypes","passedCaveatsSet","size","length","invalidParams","message","every","has","join"],"mappings":"AAIA,SAASA,SAAS,QAAQ,uBAAuB;AAOjD;;;;;;;;;;CAUC,GACD,OAAO,SAASC,iCACdC,iBAGG;IAEH,MAAMC,mBAAmB,IAAIC,IAC3BF,kBAAkBG,GAAG,CAAC,CAACC,SAAWA,OAAOC,IAAI;IAE/C,MAAMC,kBAAkBN,kBAAkBO,MAAM,CAC9C,CAACH,SAAW,CAACA,OAAOI,QAAQ;IAG9B,OAAO,SAAU,EAAEC,OAAO,EAAE;QAC1B,MAAMC,gBAAgBD,WAAW,EAAE;QACnC,MAAME,oBAAoBD,cAAcP,GAAG,CAAC,CAACC,SAAWA,OAAOC,IAAI;QACnE,MAAMO,mBAAmB,IAAIV,IAAIS;QAEjC,sBAAsB;QACtB,IAAIC,iBAAiBC,IAAI,KAAKF,kBAAkBG,MAAM,EAAE;YACtD,MAAMhB,UAAUiB,aAAa,CAAC;gBAC5BC,SAAS;YACX;QACF;QAEA,mDAAmD;QACnD,IAAI,CAACN,cAAcO,KAAK,CAAC,CAACb,SAAWH,iBAAiBiB,GAAG,CAACd,OAAOC,IAAI,IAAI;YACvE,MAAMP,UAAUiB,aAAa,CAAC;gBAC5BC,SAAS,CAAC,gCAAgC,EAAEhB,kBACzCG,GAAG,CAAC,CAACC,SAAW,CAAC,CAAC,EAAEA,OAAOC,IAAI,CAAC,CAAC,CAAC,EAClCc,IAAI,CAAC,MAAM,WAAW,EAAET,cACxBP,GAAG,CAAC,CAACC,SAAW,CAAC,CAAC,EAAEA,OAAOC,IAAI,CAAC,CAAC,CAAC,EAClCc,IAAI,CAAC,MAAM,CAAC,CAAC;YAClB;QACF;QAEA,iDAAiD;QACjD,IAAI,CAACb,gBAAgBW,KAAK,CAAC,CAACb,SAAWQ,iBAAiBM,GAAG,CAACd,OAAOC,IAAI,IAAI;YACzE,MAAMP,UAAUiB,aAAa,CAAC;gBAC5BC,SAAS,CAAC,gCAAgC,EAAEV,gBACzCH,GAAG,CAAC,CAACC,SAAW,CAAC,CAAC,EAAEA,OAAOC,IAAI,CAAC,CAAC,CAAC,EAClCc,IAAI,CAAC,MAAM,CAAC,CAAC;YAClB;QACF;IACF;AACF"}

package/dist/esm/endowments/caveats/index.js

@@ -1,4 +0,0 @@
-export * from './generic';
-export * from './requestTime';
-
-//# sourceMappingURL=index.js.map

package/dist/esm/endowments/caveats/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/endowments/caveats/index.ts"],"sourcesContent":["export * from './generic';\nexport * from './requestTime';\n"],"names":[],"mappings":"AAAA,cAAc,YAAY;AAC1B,cAAc,gBAAgB"}

package/dist/esm/endowments/caveats/requestTime.js

@@ -1,93 +0,0 @@
-import { rpcErrors } from '@metamask/rpc-errors';
-import { MaxRequestTimeStruct, SnapCaveatType } from '@metamask/snaps-utils';
-import { assertStruct, hasProperty, isObject } from '@metamask/utils';
-/**
- * Asserts that the given value is a valid `maxRequestTime` value.
- *
- * @param value - The value to assert.
- * @param ErrorWrapper - An optional error wrapper to use. Defaults to
- * {@link AssertionError}.
- * @throws If the value is not a valid `maxRequestTime` value.
- */ function assertIsMaxRequestTime(value, ErrorWrapper) {
-    assertStruct(value, MaxRequestTimeStruct, 'Invalid maxRequestTime', ErrorWrapper);
-}
-/**
- * Validate the value of a caveat. This does not validate the type of the
- * caveat itself, only the value of the caveat.
- *
- * @param caveat - The caveat to validate.
- * @throws If the caveat value is invalid.
- */ function validateMaxRequestTimeCaveat(caveat) {
-    if (!hasProperty(caveat, 'value')) {
-        throw rpcErrors.invalidParams({
-            message: 'Invalid maxRequestTime caveat.'
-        });
-    }
-    const { value } = caveat;
-    assertIsMaxRequestTime(value, rpcErrors.invalidParams);
-}
-/**
- * Map a raw value from the `initialPermissions` to a caveat specification.
- * Note that this function does not do any validation, that's handled by the
- * PermissionsController when the permission is requested.
- *
- * @param value - The raw value from the `initialPermissions`.
- * @returns The caveat specification.
- */ export function getMaxRequestTimeCaveatMapper(value) {
-    if (!value || !isObject(value) || isObject(value) && !hasProperty(value, 'maxRequestTime')) {
-        return {
-            caveats: null
-        };
-    }
-    return {
-        caveats: [
-            {
-                type: SnapCaveatType.MaxRequestTime,
-                value: value.maxRequestTime
-            }
-        ]
-    };
-}
-/**
- * Creates a wrapping caveat mapper that creates the `maxRequestTime` caveat
- * and merges it with any other caveats created by the mapper function.
- *
- * @param mapper - Another caveat mapper function.
- * @returns The caveat specification.
- */ export function createMaxRequestTimeMapper(mapper) {
-    return function(value) {
-        // We assume this to be used only with caveats of this type
-        const { maxRequestTime, ...rest } = value;
-        const mapperResult = mapper(rest);
-        if (!maxRequestTime) {
-            return mapperResult;
-        }
-        return {
-            ...mapperResult,
-            caveats: [
-                ...mapperResult.caveats ?? [],
-                {
-                    type: SnapCaveatType.MaxRequestTime,
-                    value: maxRequestTime
-                }
-            ]
-        };
-    };
-}
-/**
- * Getter function to get the {@link MaxRequestTime} caveat value from a permission if specified.
- *
- * @param permission - The permission to get the caveat value from.
- * @returns The caveat value if present, otherwise null.
- */ export function getMaxRequestTimeCaveat(permission) {
-    const foundCaveat = permission?.caveats?.find((caveat)=>caveat.type === SnapCaveatType.MaxRequestTime);
-    return (foundCaveat?.value) ?? null;
-}
-export const maxRequestTimeCaveatSpecifications = {
-    [SnapCaveatType.MaxRequestTime]: Object.freeze({
-        type: SnapCaveatType.MaxRequestTime,
-        validator: (caveat)=>validateMaxRequestTimeCaveat(caveat)
-    })
-};
-
-//# sourceMappingURL=requestTime.js.map

package/dist/esm/endowments/caveats/requestTime.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/endowments/caveats/requestTime.ts"],"sourcesContent":["import type {\n  Caveat,\n  CaveatSpecificationConstraint,\n  PermissionConstraint,\n} from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport { MaxRequestTimeStruct, SnapCaveatType } from '@metamask/snaps-utils';\nimport type { AssertionErrorConstructor, Json } from '@metamask/utils';\nimport { assertStruct, hasProperty, isObject } from '@metamask/utils';\n\nimport type { CaveatMapperFunction, CaveatMapperReturnValue } from './generic';\n\n/**\n * Asserts that the given value is a valid `maxRequestTime` value.\n *\n * @param value - The value to assert.\n * @param ErrorWrapper - An optional error wrapper to use. Defaults to\n * {@link AssertionError}.\n * @throws If the value is not a valid `maxRequestTime` value.\n */\nfunction assertIsMaxRequestTime(\n  value: unknown, // eslint-disable-next-line @typescript-eslint/naming-convention\n  ErrorWrapper?: AssertionErrorConstructor,\n): asserts value is number {\n  assertStruct(\n    value,\n    MaxRequestTimeStruct,\n    'Invalid maxRequestTime',\n    ErrorWrapper,\n  );\n}\n\n/**\n * Validate the value of a caveat. This does not validate the type of the\n * caveat itself, only the value of the caveat.\n *\n * @param caveat - The caveat to validate.\n * @throws If the caveat value is invalid.\n */\nfunction validateMaxRequestTimeCaveat(caveat: Caveat<string, any>) {\n  if (!hasProperty(caveat, 'value')) {\n    throw rpcErrors.invalidParams({\n      message: 'Invalid maxRequestTime caveat.',\n    });\n  }\n\n  const { value } = caveat;\n  assertIsMaxRequestTime(value, rpcErrors.invalidParams);\n}\n\n/**\n * Map a raw value from the `initialPermissions` to a caveat specification.\n * Note that this function does not do any validation, that's handled by the\n * PermissionsController when the permission is requested.\n *\n * @param value - The raw value from the `initialPermissions`.\n * @returns The caveat specification.\n */\nexport function getMaxRequestTimeCaveatMapper(\n  value: Json,\n): CaveatMapperReturnValue {\n  if (\n    !value ||\n    !isObject(value) ||\n    (isObject(value) && !hasProperty(value, 'maxRequestTime'))\n  ) {\n    return { caveats: null };\n  }\n  return {\n    caveats: [\n      {\n        type: SnapCaveatType.MaxRequestTime,\n        value: value.maxRequestTime,\n      },\n    ],\n  };\n}\n\n/**\n * Creates a wrapping caveat mapper that creates the `maxRequestTime` caveat\n * and merges it with any other caveats created by the mapper function.\n *\n * @param mapper - Another caveat mapper function.\n * @returns The caveat specification.\n */\nexport function createMaxRequestTimeMapper(\n  mapper: CaveatMapperFunction,\n): CaveatMapperFunction {\n  return function (value: Json) {\n    // We assume this to be used only with caveats of this type\n    const { maxRequestTime, ...rest } = value as Record<string, Json>;\n\n    const mapperResult = mapper(rest);\n\n    if (!maxRequestTime) {\n      return mapperResult;\n    }\n\n    return {\n      ...mapperResult,\n      caveats: [\n        ...(mapperResult.caveats ?? []),\n        {\n          type: SnapCaveatType.MaxRequestTime,\n          value: maxRequestTime,\n        },\n      ],\n    };\n  };\n}\n\n/**\n * Getter function to get the {@link MaxRequestTime} caveat value from a permission if specified.\n *\n * @param permission - The permission to get the caveat value from.\n * @returns The caveat value if present, otherwise null.\n */\nexport function getMaxRequestTimeCaveat(\n  permission?: PermissionConstraint,\n): number | null {\n  const foundCaveat = permission?.caveats?.find(\n    (caveat) => caveat.type === SnapCaveatType.MaxRequestTime,\n  );\n  return (foundCaveat?.value as number) ?? null;\n}\n\nexport const maxRequestTimeCaveatSpecifications: Record<\n  SnapCaveatType.MaxRequestTime,\n  CaveatSpecificationConstraint\n> = {\n  [SnapCaveatType.MaxRequestTime]: Object.freeze({\n    type: SnapCaveatType.MaxRequestTime,\n    validator: (caveat: Caveat<string, any>) =>\n      validateMaxRequestTimeCaveat(caveat),\n  }),\n};\n"],"names":["rpcErrors","MaxRequestTimeStruct","SnapCaveatType","assertStruct","hasProperty","isObject","assertIsMaxRequestTime","value","ErrorWrapper","validateMaxRequestTimeCaveat","caveat","invalidParams","message","getMaxRequestTimeCaveatMapper","caveats","type","MaxRequestTime","maxRequestTime","createMaxRequestTimeMapper","mapper","rest","mapperResult","getMaxRequestTimeCaveat","permission","foundCaveat","find","maxRequestTimeCaveatSpecifications","Object","freeze","validator"],"mappings":"AAKA,SAASA,SAAS,QAAQ,uBAAuB;AACjD,SAASC,oBAAoB,EAAEC,cAAc,QAAQ,wBAAwB;AAE7E,SAASC,YAAY,EAAEC,WAAW,EAAEC,QAAQ,QAAQ,kBAAkB;AAItE;;;;;;;CAOC,GACD,SAASC,uBACPC,KAAc,EACdC,YAAwC;IAExCL,aACEI,OACAN,sBACA,0BACAO;AAEJ;AAEA;;;;;;CAMC,GACD,SAASC,6BAA6BC,MAA2B;IAC/D,IAAI,CAACN,YAAYM,QAAQ,UAAU;QACjC,MAAMV,UAAUW,aAAa,CAAC;YAC5BC,SAAS;QACX;IACF;IAEA,MAAM,EAAEL,KAAK,EAAE,GAAGG;IAClBJ,uBAAuBC,OAAOP,UAAUW,aAAa;AACvD;AAEA;;;;;;;CAOC,GACD,OAAO,SAASE,8BACdN,KAAW;IAEX,IACE,CAACA,SACD,CAACF,SAASE,UACTF,SAASE,UAAU,CAACH,YAAYG,OAAO,mBACxC;QACA,OAAO;YAAEO,SAAS;QAAK;IACzB;IACA,OAAO;QACLA,SAAS;YACP;gBACEC,MAAMb,eAAec,cAAc;gBACnCT,OAAOA,MAAMU,cAAc;YAC7B;SACD;IACH;AACF;AAEA;;;;;;CAMC,GACD,OAAO,SAASC,2BACdC,MAA4B;IAE5B,OAAO,SAAUZ,KAAW;QAC1B,2DAA2D;QAC3D,MAAM,EAAEU,cAAc,EAAE,GAAGG,MAAM,GAAGb;QAEpC,MAAMc,eAAeF,OAAOC;QAE5B,IAAI,CAACH,gBAAgB;YACnB,OAAOI;QACT;QAEA,OAAO;YACL,GAAGA,YAAY;YACfP,SAAS;mBACHO,aAAaP,OAAO,IAAI,EAAE;gBAC9B;oBACEC,MAAMb,eAAec,cAAc;oBACnCT,OAAOU;gBACT;aACD;QACH;IACF;AACF;AAEA;;;;;CAKC,GACD,OAAO,SAASK,wBACdC,UAAiC;IAEjC,MAAMC,cAAcD,YAAYT,SAASW,KACvC,CAACf,SAAWA,OAAOK,IAAI,KAAKb,eAAec,cAAc;IAE3D,OAAO,CAACQ,aAAajB,KAAe,KAAK;AAC3C;AAEA,OAAO,MAAMmB,qCAGT;IACF,CAACxB,eAAec,cAAc,CAAC,EAAEW,OAAOC,MAAM,CAAC;QAC7Cb,MAAMb,eAAec,cAAc;QACnCa,WAAW,CAACnB,SACVD,6BAA6BC;IACjC;AACF,EAAE"}

package/dist/esm/endowments/cronjob.js

@@ -1,99 +0,0 @@
-import { PermissionType, SubjectType } from '@metamask/permission-controller';
-import { rpcErrors } from '@metamask/rpc-errors';
-import { SnapCaveatType, isCronjobSpecificationArray } from '@metamask/snaps-utils';
-import { assert, hasProperty, isPlainObject } from '@metamask/utils';
-import { SnapEndowments } from './enum';
-const permissionName = SnapEndowments.Cronjob;
-/**
- * `endowment:cronjob` returns nothing; it is intended to be used as a flag to determine whether the snap wants to run cronjobs.
- *
- * @param _builderOptions - Optional specification builder options.
- * @returns The specification for the cronjob endowment.
- */ const specificationBuilder = (_builderOptions)=>{
-    return {
-        permissionType: PermissionType.Endowment,
-        targetName: permissionName,
-        allowedCaveats: [
-            SnapCaveatType.SnapCronjob
-        ],
-        endowmentGetter: (_getterOptions)=>undefined,
-        subjectTypes: [
-            SubjectType.Snap
-        ]
-    };
-};
-export const cronjobEndowmentBuilder = Object.freeze({
-    targetName: permissionName,
-    specificationBuilder
-});
-/**
- * Map a raw value from the `initialPermissions` to a caveat specification.
- * Note that this function does not do any validation, that's handled by the
- * PermissionsController when the permission is requested.
- *
- * @param value - The raw value from the `initialPermissions`.
- * @returns The caveat specification.
- */ export function getCronjobCaveatMapper(value) {
-    return {
-        caveats: [
-            {
-                type: SnapCaveatType.SnapCronjob,
-                value
-            }
-        ]
-    };
-}
-/**
- * Getter function to get the cronjobs from a permission.
- *
- * This does basic validation of the caveat, but does not validate the type or
- * value of the namespaces object itself, as this is handled by the
- * `PermissionsController` when the permission is requested.
- *
- * @param permission - The permission to get the keyring namespaces from.
- * @returns The cronjobs, or `null` if the permission does not have a
- * cronjob caveat.
- */ export function getCronjobCaveatJobs(permission) {
-    if (!permission?.caveats) {
-        return null;
-    }
-    assert(permission.caveats.length === 1);
-    assert(permission.caveats[0].type === SnapCaveatType.SnapCronjob);
-    const caveat = permission.caveats[0];
-    return (caveat.value?.jobs) ?? null;
-}
-/**
- * Validate the cronjob specification values associated with a caveat.
- * This validates that the value is a non-empty array with valid
- * cronjob expression and request object.
- *
- * @param caveat - The caveat to validate.
- * @throws If the value is invalid.
- */ export function validateCronjobCaveat(caveat) {
-    if (!hasProperty(caveat, 'value') || !isPlainObject(caveat.value)) {
-        throw rpcErrors.invalidParams({
-            message: 'Expected a plain object.'
-        });
-    }
-    const { value } = caveat;
-    if (!hasProperty(value, 'jobs') || !isPlainObject(value)) {
-        throw rpcErrors.invalidParams({
-            message: 'Expected a plain object.'
-        });
-    }
-    if (!isCronjobSpecificationArray(value.jobs)) {
-        throw rpcErrors.invalidParams({
-            message: 'Expected a valid cronjob specification array.'
-        });
-    }
-}
-/**
- * Caveat specification for the Cronjob.
- */ export const cronjobCaveatSpecifications = {
-    [SnapCaveatType.SnapCronjob]: Object.freeze({
-        type: SnapCaveatType.SnapCronjob,
-        validator: (caveat)=>validateCronjobCaveat(caveat)
-    })
-};
-
-//# sourceMappingURL=cronjob.js.map

package/dist/esm/endowments/cronjob.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/endowments/cronjob.ts"],"sourcesContent":["import type {\n  PermissionSpecificationBuilder,\n  EndowmentGetterParams,\n  ValidPermissionSpecification,\n  PermissionConstraint,\n  Caveat,\n  CaveatSpecificationConstraint,\n} from '@metamask/permission-controller';\nimport { PermissionType, SubjectType } from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport type { CronjobSpecification } from '@metamask/snaps-utils';\nimport {\n  SnapCaveatType,\n  isCronjobSpecificationArray,\n} from '@metamask/snaps-utils';\nimport type { Json, NonEmptyArray } from '@metamask/utils';\nimport { assert, hasProperty, isPlainObject } from '@metamask/utils';\n\nimport { SnapEndowments } from './enum';\n\nconst permissionName = SnapEndowments.Cronjob;\n\ntype CronjobEndowmentSpecification = ValidPermissionSpecification<{\n  permissionType: PermissionType.Endowment;\n  targetName: typeof permissionName;\n  endowmentGetter: (_options?: any) => undefined;\n  allowedCaveats: Readonly<NonEmptyArray<string>> | null;\n}>;\n\n/**\n * `endowment:cronjob` returns nothing; it is intended to be used as a flag to determine whether the snap wants to run cronjobs.\n *\n * @param _builderOptions - Optional specification builder options.\n * @returns The specification for the cronjob endowment.\n */\nconst specificationBuilder: PermissionSpecificationBuilder<\n  PermissionType.Endowment,\n  any,\n  CronjobEndowmentSpecification\n> = (_builderOptions?: any) => {\n  return {\n    permissionType: PermissionType.Endowment,\n    targetName: permissionName,\n    allowedCaveats: [SnapCaveatType.SnapCronjob],\n    endowmentGetter: (_getterOptions?: EndowmentGetterParams) => undefined,\n    subjectTypes: [SubjectType.Snap],\n  };\n};\n\nexport const cronjobEndowmentBuilder = Object.freeze({\n  targetName: permissionName,\n  specificationBuilder,\n} as const);\n\n/**\n * Map a raw value from the `initialPermissions` to a caveat specification.\n * Note that this function does not do any validation, that's handled by the\n * PermissionsController when the permission is requested.\n *\n * @param value - The raw value from the `initialPermissions`.\n * @returns The caveat specification.\n */\nexport function getCronjobCaveatMapper(\n  value: Json,\n): Pick<PermissionConstraint, 'caveats'> {\n  return {\n    caveats: [\n      {\n        type: SnapCaveatType.SnapCronjob,\n        value,\n      },\n    ],\n  };\n}\n\n/**\n * Getter function to get the cronjobs from a permission.\n *\n * This does basic validation of the caveat, but does not validate the type or\n * value of the namespaces object itself, as this is handled by the\n * `PermissionsController` when the permission is requested.\n *\n * @param permission - The permission to get the keyring namespaces from.\n * @returns The cronjobs, or `null` if the permission does not have a\n * cronjob caveat.\n */\nexport function getCronjobCaveatJobs(\n  permission?: PermissionConstraint,\n): CronjobSpecification[] | null {\n  if (!permission?.caveats) {\n    return null;\n  }\n\n  assert(permission.caveats.length === 1);\n  assert(permission.caveats[0].type === SnapCaveatType.SnapCronjob);\n\n  const caveat = permission.caveats[0] as Caveat<string, { jobs: Json[] }>;\n\n  return (caveat.value?.jobs as CronjobSpecification[]) ?? null;\n}\n\n/**\n * Validate the cronjob specification values associated with a caveat.\n * This validates that the value is a non-empty array with valid\n * cronjob expression and request object.\n *\n * @param caveat - The caveat to validate.\n * @throws If the value is invalid.\n */\nexport function validateCronjobCaveat(caveat: Caveat<string, any>) {\n  if (!hasProperty(caveat, 'value') || !isPlainObject(caveat.value)) {\n    throw rpcErrors.invalidParams({\n      message: 'Expected a plain object.',\n    });\n  }\n\n  const { value } = caveat;\n\n  if (!hasProperty(value, 'jobs') || !isPlainObject(value)) {\n    throw rpcErrors.invalidParams({\n      message: 'Expected a plain object.',\n    });\n  }\n\n  if (!isCronjobSpecificationArray(value.jobs)) {\n    throw rpcErrors.invalidParams({\n      message: 'Expected a valid cronjob specification array.',\n    });\n  }\n}\n\n/**\n * Caveat specification for the Cronjob.\n */\nexport const cronjobCaveatSpecifications: Record<\n  SnapCaveatType.SnapCronjob,\n  CaveatSpecificationConstraint\n> = {\n  [SnapCaveatType.SnapCronjob]: Object.freeze({\n    type: SnapCaveatType.SnapCronjob,\n    validator: (caveat) => validateCronjobCaveat(caveat),\n  }),\n};\n"],"names":["PermissionType","SubjectType","rpcErrors","SnapCaveatType","isCronjobSpecificationArray","assert","hasProperty","isPlainObject","SnapEndowments","permissionName","Cronjob","specificationBuilder","_builderOptions","permissionType","Endowment","targetName","allowedCaveats","SnapCronjob","endowmentGetter","_getterOptions","undefined","subjectTypes","Snap","cronjobEndowmentBuilder","Object","freeze","getCronjobCaveatMapper","value","caveats","type","getCronjobCaveatJobs","permission","length","caveat","jobs","validateCronjobCaveat","invalidParams","message","cronjobCaveatSpecifications","validator"],"mappings":"AAQA,SAASA,cAAc,EAAEC,WAAW,QAAQ,kCAAkC;AAC9E,SAASC,SAAS,QAAQ,uBAAuB;AAEjD,SACEC,cAAc,EACdC,2BAA2B,QACtB,wBAAwB;AAE/B,SAASC,MAAM,EAAEC,WAAW,EAAEC,aAAa,QAAQ,kBAAkB;AAErE,SAASC,cAAc,QAAQ,SAAS;AAExC,MAAMC,iBAAiBD,eAAeE,OAAO;AAS7C;;;;;CAKC,GACD,MAAMC,uBAIF,CAACC;IACH,OAAO;QACLC,gBAAgBb,eAAec,SAAS;QACxCC,YAAYN;QACZO,gBAAgB;YAACb,eAAec,WAAW;SAAC;QAC5CC,iBAAiB,CAACC,iBAA2CC;QAC7DC,cAAc;YAACpB,YAAYqB,IAAI;SAAC;IAClC;AACF;AAEA,OAAO,MAAMC,0BAA0BC,OAAOC,MAAM,CAAC;IACnDV,YAAYN;IACZE;AACF,GAAY;AAEZ;;;;;;;CAOC,GACD,OAAO,SAASe,uBACdC,KAAW;IAEX,OAAO;QACLC,SAAS;YACP;gBACEC,MAAM1B,eAAec,WAAW;gBAChCU;YACF;SACD;IACH;AACF;AAEA;;;;;;;;;;CAUC,GACD,OAAO,SAASG,qBACdC,UAAiC;IAEjC,IAAI,CAACA,YAAYH,SAAS;QACxB,OAAO;IACT;IAEAvB,OAAO0B,WAAWH,OAAO,CAACI,MAAM,KAAK;IACrC3B,OAAO0B,WAAWH,OAAO,CAAC,EAAE,CAACC,IAAI,KAAK1B,eAAec,WAAW;IAEhE,MAAMgB,SAASF,WAAWH,OAAO,CAAC,EAAE;IAEpC,OAAO,CAACK,OAAON,KAAK,EAAEO,IAA8B,KAAK;AAC3D;AAEA;;;;;;;CAOC,GACD,OAAO,SAASC,sBAAsBF,MAA2B;IAC/D,IAAI,CAAC3B,YAAY2B,QAAQ,YAAY,CAAC1B,cAAc0B,OAAON,KAAK,GAAG;QACjE,MAAMzB,UAAUkC,aAAa,CAAC;YAC5BC,SAAS;QACX;IACF;IAEA,MAAM,EAAEV,KAAK,EAAE,GAAGM;IAElB,IAAI,CAAC3B,YAAYqB,OAAO,WAAW,CAACpB,cAAcoB,QAAQ;QACxD,MAAMzB,UAAUkC,aAAa,CAAC;YAC5BC,SAAS;QACX;IACF;IAEA,IAAI,CAACjC,4BAA4BuB,MAAMO,IAAI,GAAG;QAC5C,MAAMhC,UAAUkC,aAAa,CAAC;YAC5BC,SAAS;QACX;IACF;AACF;AAEA;;CAEC,GACD,OAAO,MAAMC,8BAGT;IACF,CAACnC,eAAec,WAAW,CAAC,EAAEO,OAAOC,MAAM,CAAC;QAC1CI,MAAM1B,eAAec,WAAW;QAChCsB,WAAW,CAACN,SAAWE,sBAAsBF;IAC/C;AACF,EAAE"}

package/dist/esm/endowments/enum.js

@@ -1,16 +0,0 @@
-export var SnapEndowments;
-(function(SnapEndowments) {
-    SnapEndowments["NetworkAccess"] = 'endowment:network-access';
-    SnapEndowments["SignatureInsight"] = 'endowment:signature-insight';
-    SnapEndowments["TransactionInsight"] = 'endowment:transaction-insight';
-    SnapEndowments["Cronjob"] = 'endowment:cronjob';
-    SnapEndowments["EthereumProvider"] = 'endowment:ethereum-provider';
-    SnapEndowments["Rpc"] = 'endowment:rpc';
-    SnapEndowments["WebAssemblyAccess"] = 'endowment:webassembly';
-    SnapEndowments["NameLookup"] = 'endowment:name-lookup';
-    SnapEndowments["LifecycleHooks"] = 'endowment:lifecycle-hooks';
-    SnapEndowments["Keyring"] = 'endowment:keyring';
-    SnapEndowments["HomePage"] = 'endowment:page-home';
-})(SnapEndowments || (SnapEndowments = {}));
-
-//# sourceMappingURL=enum.js.map

package/dist/esm/endowments/enum.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/endowments/enum.ts"],"sourcesContent":["export enum SnapEndowments {\n  NetworkAccess = 'endowment:network-access',\n  SignatureInsight = 'endowment:signature-insight',\n  TransactionInsight = 'endowment:transaction-insight',\n  Cronjob = 'endowment:cronjob',\n  EthereumProvider = 'endowment:ethereum-provider',\n  Rpc = 'endowment:rpc',\n  WebAssemblyAccess = 'endowment:webassembly',\n  NameLookup = 'endowment:name-lookup',\n  LifecycleHooks = 'endowment:lifecycle-hooks',\n  Keyring = 'endowment:keyring',\n  HomePage = 'endowment:page-home',\n}\n"],"names":["SnapEndowments","NetworkAccess","SignatureInsight","TransactionInsight","Cronjob","EthereumProvider","Rpc","WebAssemblyAccess","NameLookup","LifecycleHooks","Keyring","HomePage"],"mappings":"WAAO;UAAKA,cAAc;IAAdA,eACVC,mBAAgB;IADND,eAEVE,sBAAmB;IAFTF,eAGVG,wBAAqB;IAHXH,eAIVI,aAAU;IAJAJ,eAKVK,sBAAmB;IALTL,eAMVM,SAAM;IANIN,eAOVO,uBAAoB;IAPVP,eAQVQ,gBAAa;IARHR,eASVS,oBAAiB;IATPT,eAUVU,aAAU;IAVAV,eAWVW,cAAW;GAXDX,mBAAAA"}

package/dist/esm/endowments/ethereum-provider.js

@@ -1,33 +0,0 @@
-import { PermissionType, SubjectType } from '@metamask/permission-controller';
-import { SnapEndowments } from './enum';
-const permissionName = SnapEndowments.EthereumProvider;
-/**
- * `endowment:ethereum-provider` returns the name of the ethereum global browser API.
- * This is intended to populate the endowments of the
- * SES Compartment in which a Snap executes.
- *
- * This populates the global scope with an EIP-1193 provider, which DOES NOT implement all legacy functionality exposed to dapps.
- *
- * @param _builderOptions - Optional specification builder options.
- * @returns The specification for the network endowment.
- */ const specificationBuilder = (_builderOptions)=>{
-    return {
-        permissionType: PermissionType.Endowment,
-        targetName: permissionName,
-        allowedCaveats: null,
-        endowmentGetter: (_getterOptions)=>{
-            return [
-                'ethereum'
-            ];
-        },
-        subjectTypes: [
-            SubjectType.Snap
-        ]
-    };
-};
-export const ethereumProviderEndowmentBuilder = Object.freeze({
-    targetName: permissionName,
-    specificationBuilder
-});
-
-//# sourceMappingURL=ethereum-provider.js.map

package/dist/esm/endowments/ethereum-provider.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/endowments/ethereum-provider.ts"],"sourcesContent":["import type {\n  EndowmentGetterParams,\n  PermissionSpecificationBuilder,\n  ValidPermissionSpecification,\n} from '@metamask/permission-controller';\nimport { PermissionType, SubjectType } from '@metamask/permission-controller';\n\nimport { SnapEndowments } from './enum';\n\nconst permissionName = SnapEndowments.EthereumProvider;\n\ntype EthereumProviderEndowmentSpecification = ValidPermissionSpecification<{\n  permissionType: PermissionType.Endowment;\n  targetName: typeof permissionName;\n  endowmentGetter: (_options?: any) => ['ethereum'];\n  allowedCaveats: null;\n}>;\n\n/**\n * `endowment:ethereum-provider` returns the name of the ethereum global browser API.\n * This is intended to populate the endowments of the\n * SES Compartment in which a Snap executes.\n *\n * This populates the global scope with an EIP-1193 provider, which DOES NOT implement all legacy functionality exposed to dapps.\n *\n * @param _builderOptions - Optional specification builder options.\n * @returns The specification for the network endowment.\n */\nconst specificationBuilder: PermissionSpecificationBuilder<\n  PermissionType.Endowment,\n  any,\n  EthereumProviderEndowmentSpecification\n> = (_builderOptions?: any) => {\n  return {\n    permissionType: PermissionType.Endowment,\n    targetName: permissionName,\n    allowedCaveats: null,\n    endowmentGetter: (_getterOptions?: EndowmentGetterParams) => {\n      return ['ethereum'];\n    },\n    subjectTypes: [SubjectType.Snap],\n  };\n};\n\nexport const ethereumProviderEndowmentBuilder = Object.freeze({\n  targetName: permissionName,\n  specificationBuilder,\n} as const);\n"],"names":["PermissionType","SubjectType","SnapEndowments","permissionName","EthereumProvider","specificationBuilder","_builderOptions","permissionType","Endowment","targetName","allowedCaveats","endowmentGetter","_getterOptions","subjectTypes","Snap","ethereumProviderEndowmentBuilder","Object","freeze"],"mappings":"AAKA,SAASA,cAAc,EAAEC,WAAW,QAAQ,kCAAkC;AAE9E,SAASC,cAAc,QAAQ,SAAS;AAExC,MAAMC,iBAAiBD,eAAeE,gBAAgB;AAStD;;;;;;;;;CASC,GACD,MAAMC,uBAIF,CAACC;IACH,OAAO;QACLC,gBAAgBP,eAAeQ,SAAS;QACxCC,YAAYN;QACZO,gBAAgB;QAChBC,iBAAiB,CAACC;YAChB,OAAO;gBAAC;aAAW;QACrB;QACAC,cAAc;YAACZ,YAAYa,IAAI;SAAC;IAClC;AACF;AAEA,OAAO,MAAMC,mCAAmCC,OAAOC,MAAM,CAAC;IAC5DR,YAAYN;IACZE;AACF,GAAY"}

package/dist/esm/endowments/home-page.js

@@ -1,27 +0,0 @@
-import { PermissionType, SubjectType } from '@metamask/permission-controller';
-import { SnapEndowments } from './enum';
-const permissionName = SnapEndowments.HomePage;
-/**
- * `endowment:page-home` returns nothing; it is intended to be used as a
- * flag by the snap controller to detect whether the snap has the capability to
- * use the snap home page feature.
- *
- * @param _builderOptions - Optional specification builder options.
- * @returns The specification for the `snap-pages` endowment.
- */ const specificationBuilder = (_builderOptions)=>{
-    return {
-        permissionType: PermissionType.Endowment,
-        targetName: permissionName,
-        allowedCaveats: null,
-        endowmentGetter: (_getterOptions)=>undefined,
-        subjectTypes: [
-            SubjectType.Snap
-        ]
-    };
-};
-export const homePageEndowmentBuilder = Object.freeze({
-    targetName: permissionName,
-    specificationBuilder
-});
-
-//# sourceMappingURL=home-page.js.map

package/dist/esm/endowments/home-page.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/endowments/home-page.ts"],"sourcesContent":["import type {\n  PermissionSpecificationBuilder,\n  EndowmentGetterParams,\n  ValidPermissionSpecification,\n} from '@metamask/permission-controller';\nimport { PermissionType, SubjectType } from '@metamask/permission-controller';\nimport type { NonEmptyArray } from '@metamask/utils';\n\nimport { SnapEndowments } from './enum';\n\nconst permissionName = SnapEndowments.HomePage;\n\ntype HomePageEndowmentSpecification = ValidPermissionSpecification<{\n  permissionType: PermissionType.Endowment;\n  targetName: typeof permissionName;\n  endowmentGetter: (_options?: EndowmentGetterParams) => undefined;\n  allowedCaveats: Readonly<NonEmptyArray<string>> | null;\n}>;\n\n/**\n * `endowment:page-home` returns nothing; it is intended to be used as a\n * flag by the snap controller to detect whether the snap has the capability to\n * use the snap home page feature.\n *\n * @param _builderOptions - Optional specification builder options.\n * @returns The specification for the `snap-pages` endowment.\n */\nconst specificationBuilder: PermissionSpecificationBuilder<\n  PermissionType.Endowment,\n  any,\n  HomePageEndowmentSpecification\n> = (_builderOptions?: unknown) => {\n  return {\n    permissionType: PermissionType.Endowment,\n    targetName: permissionName,\n    allowedCaveats: null,\n    endowmentGetter: (_getterOptions?: EndowmentGetterParams) => undefined,\n    subjectTypes: [SubjectType.Snap],\n  };\n};\n\nexport const homePageEndowmentBuilder = Object.freeze({\n  targetName: permissionName,\n  specificationBuilder,\n} as const);\n"],"names":["PermissionType","SubjectType","SnapEndowments","permissionName","HomePage","specificationBuilder","_builderOptions","permissionType","Endowment","targetName","allowedCaveats","endowmentGetter","_getterOptions","undefined","subjectTypes","Snap","homePageEndowmentBuilder","Object","freeze"],"mappings":"AAKA,SAASA,cAAc,EAAEC,WAAW,QAAQ,kCAAkC;AAG9E,SAASC,cAAc,QAAQ,SAAS;AAExC,MAAMC,iBAAiBD,eAAeE,QAAQ;AAS9C;;;;;;;CAOC,GACD,MAAMC,uBAIF,CAACC;IACH,OAAO;QACLC,gBAAgBP,eAAeQ,SAAS;QACxCC,YAAYN;QACZO,gBAAgB;QAChBC,iBAAiB,CAACC,iBAA2CC;QAC7DC,cAAc;YAACb,YAAYc,IAAI;SAAC;IAClC;AACF;AAEA,OAAO,MAAMC,2BAA2BC,OAAOC,MAAM,CAAC;IACpDT,YAAYN;IACZE;AACF,GAAY"}