@metamask/snaps-rpc-methods 6.0.0 → 7.0.1

package/dist/esm/endowments/index.js

@@ -1,68 +0,0 @@
-import { HandlerType } from '@metamask/snaps-utils';
-import { createMaxRequestTimeMapper, getMaxRequestTimeCaveatMapper, maxRequestTimeCaveatSpecifications } from './caveats';
-import { cronjobCaveatSpecifications, cronjobEndowmentBuilder, getCronjobCaveatMapper } from './cronjob';
-import { ethereumProviderEndowmentBuilder } from './ethereum-provider';
-import { homePageEndowmentBuilder } from './home-page';
-import { getKeyringCaveatMapper, keyringCaveatSpecifications, keyringEndowmentBuilder } from './keyring';
-import { lifecycleHooksEndowmentBuilder } from './lifecycle-hooks';
-import { getNameLookupCaveatMapper, nameLookupCaveatSpecifications, nameLookupEndowmentBuilder } from './name-lookup';
-import { networkAccessEndowmentBuilder } from './network-access';
-import { getRpcCaveatMapper, rpcCaveatSpecifications, rpcEndowmentBuilder } from './rpc';
-import { getSignatureInsightCaveatMapper, signatureInsightCaveatSpecifications, signatureInsightEndowmentBuilder } from './signature-insight';
-import { getTransactionInsightCaveatMapper, transactionInsightCaveatSpecifications, transactionInsightEndowmentBuilder } from './transaction-insight';
-import { webAssemblyEndowmentBuilder } from './web-assembly';
-export const endowmentPermissionBuilders = {
-    [networkAccessEndowmentBuilder.targetName]: networkAccessEndowmentBuilder,
-    [transactionInsightEndowmentBuilder.targetName]: transactionInsightEndowmentBuilder,
-    [cronjobEndowmentBuilder.targetName]: cronjobEndowmentBuilder,
-    [ethereumProviderEndowmentBuilder.targetName]: ethereumProviderEndowmentBuilder,
-    [rpcEndowmentBuilder.targetName]: rpcEndowmentBuilder,
-    [webAssemblyEndowmentBuilder.targetName]: webAssemblyEndowmentBuilder,
-    [nameLookupEndowmentBuilder.targetName]: nameLookupEndowmentBuilder,
-    [lifecycleHooksEndowmentBuilder.targetName]: lifecycleHooksEndowmentBuilder,
-    [keyringEndowmentBuilder.targetName]: keyringEndowmentBuilder,
-    [homePageEndowmentBuilder.targetName]: homePageEndowmentBuilder,
-    [signatureInsightEndowmentBuilder.targetName]: signatureInsightEndowmentBuilder
-};
-export const endowmentCaveatSpecifications = {
-    ...cronjobCaveatSpecifications,
-    ...transactionInsightCaveatSpecifications,
-    ...rpcCaveatSpecifications,
-    ...nameLookupCaveatSpecifications,
-    ...keyringCaveatSpecifications,
-    ...signatureInsightCaveatSpecifications,
-    ...maxRequestTimeCaveatSpecifications
-};
-export const endowmentCaveatMappers = {
-    [cronjobEndowmentBuilder.targetName]: createMaxRequestTimeMapper(getCronjobCaveatMapper),
-    [transactionInsightEndowmentBuilder.targetName]: createMaxRequestTimeMapper(getTransactionInsightCaveatMapper),
-    [rpcEndowmentBuilder.targetName]: createMaxRequestTimeMapper(getRpcCaveatMapper),
-    [nameLookupEndowmentBuilder.targetName]: createMaxRequestTimeMapper(getNameLookupCaveatMapper),
-    [keyringEndowmentBuilder.targetName]: createMaxRequestTimeMapper(getKeyringCaveatMapper),
-    [signatureInsightEndowmentBuilder.targetName]: createMaxRequestTimeMapper(getSignatureInsightCaveatMapper),
-    [lifecycleHooksEndowmentBuilder.targetName]: getMaxRequestTimeCaveatMapper,
-    [homePageEndowmentBuilder.targetName]: getMaxRequestTimeCaveatMapper
-};
-// We allow null because a permitted handler does not have an endowment
-export const handlerEndowments = {
-    [HandlerType.OnRpcRequest]: rpcEndowmentBuilder.targetName,
-    [HandlerType.OnTransaction]: transactionInsightEndowmentBuilder.targetName,
-    [HandlerType.OnCronjob]: cronjobEndowmentBuilder.targetName,
-    [HandlerType.OnNameLookup]: nameLookupEndowmentBuilder.targetName,
-    [HandlerType.OnInstall]: lifecycleHooksEndowmentBuilder.targetName,
-    [HandlerType.OnUpdate]: lifecycleHooksEndowmentBuilder.targetName,
-    [HandlerType.OnKeyringRequest]: keyringEndowmentBuilder.targetName,
-    [HandlerType.OnHomePage]: homePageEndowmentBuilder.targetName,
-    [HandlerType.OnSignature]: signatureInsightEndowmentBuilder.targetName,
-    [HandlerType.OnUserInput]: null
-};
-export * from './enum';
-export { getRpcCaveatOrigins } from './rpc';
-export { getSignatureOriginCaveat } from './signature-insight';
-export { getTransactionOriginCaveat } from './transaction-insight';
-export { getChainIdsCaveat, getLookupMatchersCaveat } from './name-lookup';
-export { getKeyringCaveatOrigins } from './keyring';
-export { getMaxRequestTimeCaveat } from './caveats';
-export { getCronjobCaveatJobs } from './cronjob';
-
-//# sourceMappingURL=index.js.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/endowments/index.ts"],"sourcesContent":["import type { PermissionConstraint } from '@metamask/permission-controller';\nimport { HandlerType } from '@metamask/snaps-utils';\nimport type { Json } from '@metamask/utils';\n\nimport {\n  createMaxRequestTimeMapper,\n  getMaxRequestTimeCaveatMapper,\n  maxRequestTimeCaveatSpecifications,\n} from './caveats';\nimport {\n  cronjobCaveatSpecifications,\n  cronjobEndowmentBuilder,\n  getCronjobCaveatMapper,\n} from './cronjob';\nimport { ethereumProviderEndowmentBuilder } from './ethereum-provider';\nimport { homePageEndowmentBuilder } from './home-page';\nimport {\n  getKeyringCaveatMapper,\n  keyringCaveatSpecifications,\n  keyringEndowmentBuilder,\n} from './keyring';\nimport { lifecycleHooksEndowmentBuilder } from './lifecycle-hooks';\nimport {\n  getNameLookupCaveatMapper,\n  nameLookupCaveatSpecifications,\n  nameLookupEndowmentBuilder,\n} from './name-lookup';\nimport { networkAccessEndowmentBuilder } from './network-access';\nimport {\n  getRpcCaveatMapper,\n  rpcCaveatSpecifications,\n  rpcEndowmentBuilder,\n} from './rpc';\nimport {\n  getSignatureInsightCaveatMapper,\n  signatureInsightCaveatSpecifications,\n  signatureInsightEndowmentBuilder,\n} from './signature-insight';\nimport {\n  getTransactionInsightCaveatMapper,\n  transactionInsightCaveatSpecifications,\n  transactionInsightEndowmentBuilder,\n} from './transaction-insight';\nimport { webAssemblyEndowmentBuilder } from './web-assembly';\n\nexport const endowmentPermissionBuilders = {\n  [networkAccessEndowmentBuilder.targetName]: networkAccessEndowmentBuilder,\n  [transactionInsightEndowmentBuilder.targetName]:\n    transactionInsightEndowmentBuilder,\n  [cronjobEndowmentBuilder.targetName]: cronjobEndowmentBuilder,\n  [ethereumProviderEndowmentBuilder.targetName]:\n    ethereumProviderEndowmentBuilder,\n  [rpcEndowmentBuilder.targetName]: rpcEndowmentBuilder,\n  [webAssemblyEndowmentBuilder.targetName]: webAssemblyEndowmentBuilder,\n  [nameLookupEndowmentBuilder.targetName]: nameLookupEndowmentBuilder,\n  [lifecycleHooksEndowmentBuilder.targetName]: lifecycleHooksEndowmentBuilder,\n  [keyringEndowmentBuilder.targetName]: keyringEndowmentBuilder,\n  [homePageEndowmentBuilder.targetName]: homePageEndowmentBuilder,\n  [signatureInsightEndowmentBuilder.targetName]:\n    signatureInsightEndowmentBuilder,\n} as const;\n\nexport const endowmentCaveatSpecifications = {\n  ...cronjobCaveatSpecifications,\n  ...transactionInsightCaveatSpecifications,\n  ...rpcCaveatSpecifications,\n  ...nameLookupCaveatSpecifications,\n  ...keyringCaveatSpecifications,\n  ...signatureInsightCaveatSpecifications,\n  ...maxRequestTimeCaveatSpecifications,\n};\n\nexport const endowmentCaveatMappers: Record<\n  string,\n  (value: Json) => Pick<PermissionConstraint, 'caveats'>\n> = {\n  [cronjobEndowmentBuilder.targetName]: createMaxRequestTimeMapper(\n    getCronjobCaveatMapper,\n  ),\n  [transactionInsightEndowmentBuilder.targetName]: createMaxRequestTimeMapper(\n    getTransactionInsightCaveatMapper,\n  ),\n  [rpcEndowmentBuilder.targetName]:\n    createMaxRequestTimeMapper(getRpcCaveatMapper),\n  [nameLookupEndowmentBuilder.targetName]: createMaxRequestTimeMapper(\n    getNameLookupCaveatMapper,\n  ),\n  [keyringEndowmentBuilder.targetName]: createMaxRequestTimeMapper(\n    getKeyringCaveatMapper,\n  ),\n  [signatureInsightEndowmentBuilder.targetName]: createMaxRequestTimeMapper(\n    getSignatureInsightCaveatMapper,\n  ),\n  [lifecycleHooksEndowmentBuilder.targetName]: getMaxRequestTimeCaveatMapper,\n  [homePageEndowmentBuilder.targetName]: getMaxRequestTimeCaveatMapper,\n};\n\n// We allow null because a permitted handler does not have an endowment\nexport const handlerEndowments: Record<HandlerType, string | null> = {\n  [HandlerType.OnRpcRequest]: rpcEndowmentBuilder.targetName,\n  [HandlerType.OnTransaction]: transactionInsightEndowmentBuilder.targetName,\n  [HandlerType.OnCronjob]: cronjobEndowmentBuilder.targetName,\n  [HandlerType.OnNameLookup]: nameLookupEndowmentBuilder.targetName,\n  [HandlerType.OnInstall]: lifecycleHooksEndowmentBuilder.targetName,\n  [HandlerType.OnUpdate]: lifecycleHooksEndowmentBuilder.targetName,\n  [HandlerType.OnKeyringRequest]: keyringEndowmentBuilder.targetName,\n  [HandlerType.OnHomePage]: homePageEndowmentBuilder.targetName,\n  [HandlerType.OnSignature]: signatureInsightEndowmentBuilder.targetName,\n  [HandlerType.OnUserInput]: null,\n};\n\nexport * from './enum';\nexport { getRpcCaveatOrigins } from './rpc';\nexport { getSignatureOriginCaveat } from './signature-insight';\nexport { getTransactionOriginCaveat } from './transaction-insight';\nexport { getChainIdsCaveat, getLookupMatchersCaveat } from './name-lookup';\nexport { getKeyringCaveatOrigins } from './keyring';\nexport { getMaxRequestTimeCaveat } from './caveats';\nexport { getCronjobCaveatJobs } from './cronjob';\n"],"names":["HandlerType","createMaxRequestTimeMapper","getMaxRequestTimeCaveatMapper","maxRequestTimeCaveatSpecifications","cronjobCaveatSpecifications","cronjobEndowmentBuilder","getCronjobCaveatMapper","ethereumProviderEndowmentBuilder","homePageEndowmentBuilder","getKeyringCaveatMapper","keyringCaveatSpecifications","keyringEndowmentBuilder","lifecycleHooksEndowmentBuilder","getNameLookupCaveatMapper","nameLookupCaveatSpecifications","nameLookupEndowmentBuilder","networkAccessEndowmentBuilder","getRpcCaveatMapper","rpcCaveatSpecifications","rpcEndowmentBuilder","getSignatureInsightCaveatMapper","signatureInsightCaveatSpecifications","signatureInsightEndowmentBuilder","getTransactionInsightCaveatMapper","transactionInsightCaveatSpecifications","transactionInsightEndowmentBuilder","webAssemblyEndowmentBuilder","endowmentPermissionBuilders","targetName","endowmentCaveatSpecifications","endowmentCaveatMappers","handlerEndowments","OnRpcRequest","OnTransaction","OnCronjob","OnNameLookup","OnInstall","OnUpdate","OnKeyringRequest","OnHomePage","OnSignature","OnUserInput","getRpcCaveatOrigins","getSignatureOriginCaveat","getTransactionOriginCaveat","getChainIdsCaveat","getLookupMatchersCaveat","getKeyringCaveatOrigins","getMaxRequestTimeCaveat","getCronjobCaveatJobs"],"mappings":"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"}

package/dist/esm/endowments/keyring.js

@@ -1,95 +0,0 @@
-import { PermissionType, SubjectType } from '@metamask/permission-controller';
-import { rpcErrors } from '@metamask/rpc-errors';
-import { assertIsKeyringOrigins, SnapCaveatType } from '@metamask/snaps-utils';
-import { assert, hasProperty, isPlainObject } from '@metamask/utils';
-import { createGenericPermissionValidator } from './caveats';
-import { SnapEndowments } from './enum';
-const permissionName = SnapEndowments.Keyring;
-/**
- * `endowment:keyring` returns nothing; it is intended to be used as a flag
- * by the client to detect whether the snap has keyring capabilities.
- *
- * @param _builderOptions - Optional specification builder options.
- * @returns The specification for the keyring endowment.
- */ const specificationBuilder = (_builderOptions)=>{
-    return {
-        permissionType: PermissionType.Endowment,
-        targetName: permissionName,
-        allowedCaveats: [
-            SnapCaveatType.KeyringOrigin,
-            SnapCaveatType.MaxRequestTime
-        ],
-        endowmentGetter: (_getterOptions)=>undefined,
-        validator: createGenericPermissionValidator([
-            {
-                type: SnapCaveatType.KeyringOrigin
-            },
-            {
-                type: SnapCaveatType.MaxRequestTime,
-                optional: true
-            }
-        ]),
-        subjectTypes: [
-            SubjectType.Snap
-        ]
-    };
-};
-export const keyringEndowmentBuilder = Object.freeze({
-    targetName: permissionName,
-    specificationBuilder
-});
-/**
- * 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 validateCaveatOrigins(caveat) {
-    if (!hasProperty(caveat, 'value') || !isPlainObject(caveat.value)) {
-        throw rpcErrors.invalidParams({
-            message: 'Invalid keyring origins: Expected a plain object.'
-        });
-    }
-    const { value } = caveat;
-    assertIsKeyringOrigins(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 getKeyringCaveatMapper(value) {
-    return {
-        caveats: [
-            {
-                type: SnapCaveatType.KeyringOrigin,
-                value
-            }
-        ]
-    };
-}
-/**
- * Getter function to get the {@link KeyringOrigins} caveat value from a
- * permission.
- *
- * @param permission - The permission to get the caveat value from.
- * @returns The caveat value.
- * @throws If the permission does not have a valid {@link KeyringOrigins}
- * caveat.
- */ export function getKeyringCaveatOrigins(permission) {
-    assert(permission?.caveats);
-    assert(permission.caveats.length === 1);
-    assert(permission.caveats[0].type === SnapCaveatType.KeyringOrigin);
-    const caveat = permission.caveats[0];
-    return caveat.value;
-}
-export const keyringCaveatSpecifications = {
-    [SnapCaveatType.KeyringOrigin]: Object.freeze({
-        type: SnapCaveatType.KeyringOrigin,
-        validator: (caveat)=>validateCaveatOrigins(caveat)
-    })
-};
-
-//# sourceMappingURL=keyring.js.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/endowments/keyring.ts"],"sourcesContent":["import type {\n  Caveat,\n  CaveatSpecificationConstraint,\n  EndowmentGetterParams,\n  PermissionConstraint,\n  PermissionSpecificationBuilder,\n  PermissionValidatorConstraint,\n  ValidPermissionSpecification,\n} from '@metamask/permission-controller';\nimport { PermissionType, SubjectType } from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport type { KeyringOrigins } from '@metamask/snaps-utils';\nimport { assertIsKeyringOrigins, SnapCaveatType } from '@metamask/snaps-utils';\nimport type { Json, NonEmptyArray } from '@metamask/utils';\nimport { assert, hasProperty, isPlainObject } from '@metamask/utils';\n\nimport { createGenericPermissionValidator } from './caveats';\nimport { SnapEndowments } from './enum';\n\nconst permissionName = SnapEndowments.Keyring;\n\ntype KeyringEndowmentSpecification = ValidPermissionSpecification<{\n  permissionType: PermissionType.Endowment;\n  targetName: typeof permissionName;\n  endowmentGetter: (_options?: EndowmentGetterParams) => undefined;\n  allowedCaveats: Readonly<NonEmptyArray<string>> | null;\n  validator: PermissionValidatorConstraint;\n  subjectTypes: readonly SubjectType[];\n}>;\n\n/**\n * `endowment:keyring` returns nothing; it is intended to be used as a flag\n * by the client to detect whether the snap has keyring capabilities.\n *\n * @param _builderOptions - Optional specification builder options.\n * @returns The specification for the keyring endowment.\n */\nconst specificationBuilder: PermissionSpecificationBuilder<\n  PermissionType.Endowment,\n  any,\n  KeyringEndowmentSpecification\n> = (_builderOptions?: unknown) => {\n  return {\n    permissionType: PermissionType.Endowment,\n    targetName: permissionName,\n    allowedCaveats: [\n      SnapCaveatType.KeyringOrigin,\n      SnapCaveatType.MaxRequestTime,\n    ],\n    endowmentGetter: (_getterOptions?: EndowmentGetterParams) => undefined,\n    validator: createGenericPermissionValidator([\n      { type: SnapCaveatType.KeyringOrigin },\n      { type: SnapCaveatType.MaxRequestTime, optional: true },\n    ]),\n    subjectTypes: [SubjectType.Snap],\n  };\n};\n\nexport const keyringEndowmentBuilder = Object.freeze({\n  targetName: permissionName,\n  specificationBuilder,\n} as const);\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 validateCaveatOrigins(caveat: Caveat<string, any>) {\n  if (!hasProperty(caveat, 'value') || !isPlainObject(caveat.value)) {\n    throw rpcErrors.invalidParams({\n      message: 'Invalid keyring origins: Expected a plain object.',\n    });\n  }\n\n  const { value } = caveat;\n  assertIsKeyringOrigins(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 getKeyringCaveatMapper(\n  value: Json,\n): Pick<PermissionConstraint, 'caveats'> {\n  return {\n    caveats: [\n      {\n        type: SnapCaveatType.KeyringOrigin,\n        value,\n      },\n    ],\n  };\n}\n\n/**\n * Getter function to get the {@link KeyringOrigins} caveat value from a\n * permission.\n *\n * @param permission - The permission to get the caveat value from.\n * @returns The caveat value.\n * @throws If the permission does not have a valid {@link KeyringOrigins}\n * caveat.\n */\nexport function getKeyringCaveatOrigins(\n  permission?: PermissionConstraint,\n): KeyringOrigins | null {\n  assert(permission?.caveats);\n  assert(permission.caveats.length === 1);\n  assert(permission.caveats[0].type === SnapCaveatType.KeyringOrigin);\n\n  const caveat = permission.caveats[0] as Caveat<string, KeyringOrigins>;\n  return caveat.value;\n}\n\nexport const keyringCaveatSpecifications: Record<\n  SnapCaveatType.KeyringOrigin,\n  CaveatSpecificationConstraint\n> = {\n  [SnapCaveatType.KeyringOrigin]: Object.freeze({\n    type: SnapCaveatType.KeyringOrigin,\n    validator: (caveat: Caveat<string, any>) => validateCaveatOrigins(caveat),\n  }),\n};\n"],"names":["PermissionType","SubjectType","rpcErrors","assertIsKeyringOrigins","SnapCaveatType","assert","hasProperty","isPlainObject","createGenericPermissionValidator","SnapEndowments","permissionName","Keyring","specificationBuilder","_builderOptions","permissionType","Endowment","targetName","allowedCaveats","KeyringOrigin","MaxRequestTime","endowmentGetter","_getterOptions","undefined","validator","type","optional","subjectTypes","Snap","keyringEndowmentBuilder","Object","freeze","validateCaveatOrigins","caveat","value","invalidParams","message","getKeyringCaveatMapper","caveats","getKeyringCaveatOrigins","permission","length","keyringCaveatSpecifications"],"mappings":"AASA,SAASA,cAAc,EAAEC,WAAW,QAAQ,kCAAkC;AAC9E,SAASC,SAAS,QAAQ,uBAAuB;AAEjD,SAASC,sBAAsB,EAAEC,cAAc,QAAQ,wBAAwB;AAE/E,SAASC,MAAM,EAAEC,WAAW,EAAEC,aAAa,QAAQ,kBAAkB;AAErE,SAASC,gCAAgC,QAAQ,YAAY;AAC7D,SAASC,cAAc,QAAQ,SAAS;AAExC,MAAMC,iBAAiBD,eAAeE,OAAO;AAW7C;;;;;;CAMC,GACD,MAAMC,uBAIF,CAACC;IACH,OAAO;QACLC,gBAAgBd,eAAee,SAAS;QACxCC,YAAYN;QACZO,gBAAgB;YACdb,eAAec,aAAa;YAC5Bd,eAAee,cAAc;SAC9B;QACDC,iBAAiB,CAACC,iBAA2CC;QAC7DC,WAAWf,iCAAiC;YAC1C;gBAAEgB,MAAMpB,eAAec,aAAa;YAAC;YACrC;gBAAEM,MAAMpB,eAAee,cAAc;gBAAEM,UAAU;YAAK;SACvD;QACDC,cAAc;YAACzB,YAAY0B,IAAI;SAAC;IAClC;AACF;AAEA,OAAO,MAAMC,0BAA0BC,OAAOC,MAAM,CAAC;IACnDd,YAAYN;IACZE;AACF,GAAY;AAEZ;;;;;;CAMC,GACD,SAASmB,sBAAsBC,MAA2B;IACxD,IAAI,CAAC1B,YAAY0B,QAAQ,YAAY,CAACzB,cAAcyB,OAAOC,KAAK,GAAG;QACjE,MAAM/B,UAAUgC,aAAa,CAAC;YAC5BC,SAAS;QACX;IACF;IAEA,MAAM,EAAEF,KAAK,EAAE,GAAGD;IAClB7B,uBAAuB8B,OAAO/B,UAAUgC,aAAa;AACvD;AAEA;;;;;;;CAOC,GACD,OAAO,SAASE,uBACdH,KAAW;IAEX,OAAO;QACLI,SAAS;YACP;gBACEb,MAAMpB,eAAec,aAAa;gBAClCe;YACF;SACD;IACH;AACF;AAEA;;;;;;;;CAQC,GACD,OAAO,SAASK,wBACdC,UAAiC;IAEjClC,OAAOkC,YAAYF;IACnBhC,OAAOkC,WAAWF,OAAO,CAACG,MAAM,KAAK;IACrCnC,OAAOkC,WAAWF,OAAO,CAAC,EAAE,CAACb,IAAI,KAAKpB,eAAec,aAAa;IAElE,MAAMc,SAASO,WAAWF,OAAO,CAAC,EAAE;IACpC,OAAOL,OAAOC,KAAK;AACrB;AAEA,OAAO,MAAMQ,8BAGT;IACF,CAACrC,eAAec,aAAa,CAAC,EAAEW,OAAOC,MAAM,CAAC;QAC5CN,MAAMpB,eAAec,aAAa;QAClCK,WAAW,CAACS,SAAgCD,sBAAsBC;IACpE;AACF,EAAE"}

package/dist/esm/endowments/lifecycle-hooks.js

@@ -1,27 +0,0 @@
-import { PermissionType, SubjectType } from '@metamask/permission-controller';
-import { SnapEndowments } from './enum';
-const permissionName = SnapEndowments.LifecycleHooks;
-/**
- * `endowment:lifecycle-hooks` 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 lifecycle hooks.
- *
- * @param _builderOptions - Optional specification builder options.
- * @returns The specification for the `lifecycle-hooks` endowment.
- */ const specificationBuilder = (_builderOptions)=>{
-    return {
-        permissionType: PermissionType.Endowment,
-        targetName: permissionName,
-        allowedCaveats: null,
-        endowmentGetter: (_getterOptions)=>undefined,
-        subjectTypes: [
-            SubjectType.Snap
-        ]
-    };
-};
-export const lifecycleHooksEndowmentBuilder = Object.freeze({
-    targetName: permissionName,
-    specificationBuilder
-});
-
-//# sourceMappingURL=lifecycle-hooks.js.map

package/dist/esm/endowments/lifecycle-hooks.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/endowments/lifecycle-hooks.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.LifecycleHooks;\n\ntype LifecycleHooksEndowmentSpecification = 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:lifecycle-hooks` 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 lifecycle hooks.\n *\n * @param _builderOptions - Optional specification builder options.\n * @returns The specification for the `lifecycle-hooks` endowment.\n */\nconst specificationBuilder: PermissionSpecificationBuilder<\n  PermissionType.Endowment,\n  any,\n  LifecycleHooksEndowmentSpecification\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 lifecycleHooksEndowmentBuilder = Object.freeze({\n  targetName: permissionName,\n  specificationBuilder,\n} as const);\n"],"names":["PermissionType","SubjectType","SnapEndowments","permissionName","LifecycleHooks","specificationBuilder","_builderOptions","permissionType","Endowment","targetName","allowedCaveats","endowmentGetter","_getterOptions","undefined","subjectTypes","Snap","lifecycleHooksEndowmentBuilder","Object","freeze"],"mappings":"AAKA,SAASA,cAAc,EAAEC,WAAW,QAAQ,kCAAkC;AAG9E,SAASC,cAAc,QAAQ,SAAS;AAExC,MAAMC,iBAAiBD,eAAeE,cAAc;AASpD;;;;;;;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,iCAAiCC,OAAOC,MAAM,CAAC;IAC1DT,YAAYN;IACZE;AACF,GAAY"}

package/dist/esm/endowments/name-lookup.js

@@ -1,146 +0,0 @@
-import { PermissionType, SubjectType } from '@metamask/permission-controller';
-import { rpcErrors } from '@metamask/rpc-errors';
-import { ChainIdsStruct, LookupMatchersStruct, SnapCaveatType } from '@metamask/snaps-utils';
-import { assert, assertStruct, hasProperty, isObject, isPlainObject } from '@metamask/utils';
-import { createGenericPermissionValidator } from './caveats';
-import { SnapEndowments } from './enum';
-const permissionName = SnapEndowments.NameLookup;
-/**
- * `endowment:name-lookup` returns nothing; it is intended to be used as a flag
- * by the extension to detect whether the snap has the capability to resolve a domain/address.
- *
- * @param _builderOptions - Optional specification builder options.
- * @returns The specification for the name-lookup endowment.
- */ const specificationBuilder = (_builderOptions)=>{
-    return {
-        permissionType: PermissionType.Endowment,
-        targetName: permissionName,
-        allowedCaveats: [
-            SnapCaveatType.ChainIds,
-            SnapCaveatType.LookupMatchers,
-            SnapCaveatType.MaxRequestTime
-        ],
-        endowmentGetter: (_getterOptions)=>undefined,
-        validator: createGenericPermissionValidator([
-            {
-                type: SnapCaveatType.ChainIds,
-                optional: true
-            },
-            {
-                type: SnapCaveatType.LookupMatchers,
-                optional: true
-            },
-            {
-                type: SnapCaveatType.MaxRequestTime,
-                optional: true
-            }
-        ]),
-        subjectTypes: [
-            SubjectType.Snap
-        ]
-    };
-};
-export const nameLookupEndowmentBuilder = Object.freeze({
-    targetName: permissionName,
-    specificationBuilder
-});
-/**
- * Validates the type of the caveat value.
- *
- * @param caveat - The caveat to validate.
- * @throws If the caveat value is invalid.
- */ function validateCaveat(caveat) {
-    if (!hasProperty(caveat, 'value') || !isPlainObject(caveat)) {
-        throw rpcErrors.invalidParams({
-            message: 'Expected a plain object.'
-        });
-    }
-    const { value } = caveat;
-    switch(caveat.type){
-        case SnapCaveatType.ChainIds:
-            assertStruct(value, ChainIdsStruct);
-            break;
-        case SnapCaveatType.LookupMatchers:
-            assertStruct(value, LookupMatchersStruct);
-            break;
-        default:
-            throw rpcErrors.invalidParams({
-                message: 'Invalid caveat type, must be one of the following: "chainIds", "matchers".'
-            });
-    }
-}
-/**
- * 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 getNameLookupCaveatMapper(value) {
-    if (!value || !isObject(value) || Object.keys(value).length === 0) {
-        return {
-            caveats: null
-        };
-    }
-    const caveats = [];
-    if (value.chains) {
-        caveats.push({
-            type: SnapCaveatType.ChainIds,
-            value: value.chains
-        });
-    }
-    if (value.matchers) {
-        caveats.push({
-            type: SnapCaveatType.LookupMatchers,
-            value: value.matchers
-        });
-    }
-    assert(caveats.length > 0);
-    return {
-        caveats: caveats
-    };
-}
-/**
- * Getter function to get the chainIds caveat 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 `chainIds` caveat from.
- * @returns An array of `chainIds` that the snap supports.
- */ export function getChainIdsCaveat(permission) {
-    if (!permission?.caveats) {
-        return null;
-    }
-    const caveat = permission.caveats.find((permCaveat)=>permCaveat.type === SnapCaveatType.ChainIds);
-    return caveat ? caveat.value : null;
-}
-/**
- * Getter function to get the matchers caveat 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 `matchers` caveat from.
- * @returns A `matchers` object that defines the input that the snap supports.
- */ export function getLookupMatchersCaveat(permission) {
-    if (!permission?.caveats) {
-        return null;
-    }
-    const caveat = permission.caveats.find((permCaveat)=>permCaveat.type === SnapCaveatType.LookupMatchers);
-    return caveat ? caveat.value : null;
-}
-export const nameLookupCaveatSpecifications = {
-    [SnapCaveatType.ChainIds]: Object.freeze({
-        type: SnapCaveatType.ChainIds,
-        validator: (caveat)=>validateCaveat(caveat)
-    }),
-    [SnapCaveatType.LookupMatchers]: Object.freeze({
-        type: SnapCaveatType.LookupMatchers,
-        validator: (caveat)=>validateCaveat(caveat)
-    })
-};
-
-//# sourceMappingURL=name-lookup.js.map

package/dist/esm/endowments/name-lookup.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/endowments/name-lookup.ts"],"sourcesContent":["import type {\n  EndowmentGetterParams,\n  PermissionSpecificationBuilder,\n  PermissionValidatorConstraint,\n  ValidPermissionSpecification,\n  Caveat,\n  CaveatSpecificationConstraint,\n  PermissionConstraint,\n  CaveatConstraint,\n} from '@metamask/permission-controller';\nimport { PermissionType, SubjectType } from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport {\n  ChainIdsStruct,\n  LookupMatchersStruct,\n  SnapCaveatType,\n} from '@metamask/snaps-utils';\nimport type { Json, NonEmptyArray } from '@metamask/utils';\nimport {\n  assert,\n  assertStruct,\n  hasProperty,\n  isObject,\n  isPlainObject,\n} from '@metamask/utils';\n\nimport { createGenericPermissionValidator } from './caveats';\nimport { SnapEndowments } from './enum';\n\nconst permissionName = SnapEndowments.NameLookup;\n\ntype NameLookupEndowmentSpecification = ValidPermissionSpecification<{\n  permissionType: PermissionType.Endowment;\n  targetName: typeof permissionName;\n  endowmentGetter: (_options?: EndowmentGetterParams) => undefined;\n  allowedCaveats: Readonly<NonEmptyArray<string>> | null;\n  validator: PermissionValidatorConstraint;\n}>;\n\n/**\n * `endowment:name-lookup` returns nothing; it is intended to be used as a flag\n * by the extension to detect whether the snap has the capability to resolve a domain/address.\n *\n * @param _builderOptions - Optional specification builder options.\n * @returns The specification for the name-lookup endowment.\n */\nconst specificationBuilder: PermissionSpecificationBuilder<\n  PermissionType.Endowment,\n  any,\n  NameLookupEndowmentSpecification\n> = (_builderOptions?: unknown) => {\n  return {\n    permissionType: PermissionType.Endowment,\n    targetName: permissionName,\n    allowedCaveats: [\n      SnapCaveatType.ChainIds,\n      SnapCaveatType.LookupMatchers,\n      SnapCaveatType.MaxRequestTime,\n    ],\n    endowmentGetter: (_getterOptions?: EndowmentGetterParams) => undefined,\n    validator: createGenericPermissionValidator([\n      { type: SnapCaveatType.ChainIds, optional: true },\n      { type: SnapCaveatType.LookupMatchers, optional: true },\n      { type: SnapCaveatType.MaxRequestTime, optional: true },\n    ]),\n    subjectTypes: [SubjectType.Snap],\n  };\n};\n\nexport const nameLookupEndowmentBuilder = Object.freeze({\n  targetName: permissionName,\n  specificationBuilder,\n} as const);\n\n/**\n * Validates the type of the caveat value.\n *\n * @param caveat - The caveat to validate.\n * @throws If the caveat value is invalid.\n */\nfunction validateCaveat(caveat: Caveat<string, any>): void {\n  if (!hasProperty(caveat, 'value') || !isPlainObject(caveat)) {\n    throw rpcErrors.invalidParams({\n      message: 'Expected a plain object.',\n    });\n  }\n\n  const { value } = caveat;\n\n  switch (caveat.type) {\n    case SnapCaveatType.ChainIds:\n      assertStruct(value, ChainIdsStruct);\n      break;\n    case SnapCaveatType.LookupMatchers:\n      assertStruct(value, LookupMatchersStruct);\n      break;\n    default:\n      throw rpcErrors.invalidParams({\n        message:\n          'Invalid caveat type, must be one of the following: \"chainIds\", \"matchers\".',\n      });\n  }\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 getNameLookupCaveatMapper(\n  value: Json,\n): Pick<PermissionConstraint, 'caveats'> {\n  if (!value || !isObject(value) || Object.keys(value).length === 0) {\n    return { caveats: null };\n  }\n\n  const caveats = [];\n\n  if (value.chains) {\n    caveats.push({\n      type: SnapCaveatType.ChainIds,\n      value: value.chains,\n    });\n  }\n\n  if (value.matchers) {\n    caveats.push({\n      type: SnapCaveatType.LookupMatchers,\n      value: value.matchers,\n    });\n  }\n\n  assert(caveats.length > 0);\n\n  return { caveats: caveats as NonEmptyArray<CaveatConstraint> };\n}\n\n/**\n * Getter function to get the chainIds caveat 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 `chainIds` caveat from.\n * @returns An array of `chainIds` that the snap supports.\n */\nexport function getChainIdsCaveat(\n  permission?: PermissionConstraint,\n): string[] | null {\n  if (!permission?.caveats) {\n    return null;\n  }\n\n  const caveat = permission.caveats.find(\n    (permCaveat) => permCaveat.type === SnapCaveatType.ChainIds,\n  ) as Caveat<string, string[]> | undefined;\n\n  return caveat ? caveat.value : null;\n}\n\n/**\n * Getter function to get the matchers caveat 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 `matchers` caveat from.\n * @returns A `matchers` object that defines the input that the snap supports.\n */\nexport function getLookupMatchersCaveat(\n  permission?: PermissionConstraint,\n): Record<string, string[]> | null {\n  if (!permission?.caveats) {\n    return null;\n  }\n\n  const caveat = permission.caveats.find(\n    (permCaveat) => permCaveat.type === SnapCaveatType.LookupMatchers,\n  ) as Caveat<string, Record<string, string[]>> | undefined;\n\n  return caveat ? caveat.value : null;\n}\n\nexport const nameLookupCaveatSpecifications: Record<\n  SnapCaveatType.ChainIds | SnapCaveatType.LookupMatchers,\n  CaveatSpecificationConstraint\n> = {\n  [SnapCaveatType.ChainIds]: Object.freeze({\n    type: SnapCaveatType.ChainIds,\n    validator: (caveat: Caveat<string, any>) => validateCaveat(caveat),\n  }),\n  [SnapCaveatType.LookupMatchers]: Object.freeze({\n    type: SnapCaveatType.LookupMatchers,\n    validator: (caveat: Caveat<string, any>) => validateCaveat(caveat),\n  }),\n};\n"],"names":["PermissionType","SubjectType","rpcErrors","ChainIdsStruct","LookupMatchersStruct","SnapCaveatType","assert","assertStruct","hasProperty","isObject","isPlainObject","createGenericPermissionValidator","SnapEndowments","permissionName","NameLookup","specificationBuilder","_builderOptions","permissionType","Endowment","targetName","allowedCaveats","ChainIds","LookupMatchers","MaxRequestTime","endowmentGetter","_getterOptions","undefined","validator","type","optional","subjectTypes","Snap","nameLookupEndowmentBuilder","Object","freeze","validateCaveat","caveat","invalidParams","message","value","getNameLookupCaveatMapper","keys","length","caveats","chains","push","matchers","getChainIdsCaveat","permission","find","permCaveat","getLookupMatchersCaveat","nameLookupCaveatSpecifications"],"mappings":"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"}

package/dist/esm/endowments/network-access.js

@@ -1,34 +0,0 @@
-import { PermissionType, SubjectType } from '@metamask/permission-controller';
-import { SnapEndowments } from './enum';
-const permissionName = SnapEndowments.NetworkAccess;
-/**
- * `endowment:network-access` returns the name of global browser API(s) that
- * enable network access. This is intended to populate the endowments of the
- * SES Compartment in which a Snap executes.
- *
- * @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 [
-                'fetch',
-                'Request',
-                'Headers',
-                'Response'
-            ];
-        },
-        subjectTypes: [
-            SubjectType.Snap
-        ]
-    };
-};
-export const networkAccessEndowmentBuilder = Object.freeze({
-    targetName: permissionName,
-    specificationBuilder
-});
-
-//# sourceMappingURL=network-access.js.map

package/dist/esm/endowments/network-access.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/endowments/network-access.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.NetworkAccess;\n\ntype NetworkAccessEndowmentSpecification = ValidPermissionSpecification<{\n  permissionType: PermissionType.Endowment;\n  targetName: typeof permissionName;\n  endowmentGetter: (\n    _options?: any,\n  ) => ['fetch', 'Request', 'Headers', 'Response'];\n  allowedCaveats: null;\n}>;\n\n/**\n * `endowment:network-access` returns the name of global browser API(s) that\n * enable network access. This is intended to populate the endowments of the\n * SES Compartment in which a Snap executes.\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  NetworkAccessEndowmentSpecification\n> = (_builderOptions?: any) => {\n  return {\n    permissionType: PermissionType.Endowment,\n    targetName: permissionName,\n    allowedCaveats: null,\n    endowmentGetter: (_getterOptions?: EndowmentGetterParams) => {\n      return ['fetch', 'Request', 'Headers', 'Response'];\n    },\n    subjectTypes: [SubjectType.Snap],\n  };\n};\n\nexport const networkAccessEndowmentBuilder = Object.freeze({\n  targetName: permissionName,\n  specificationBuilder,\n} as const);\n"],"names":["PermissionType","SubjectType","SnapEndowments","permissionName","NetworkAccess","specificationBuilder","_builderOptions","permissionType","Endowment","targetName","allowedCaveats","endowmentGetter","_getterOptions","subjectTypes","Snap","networkAccessEndowmentBuilder","Object","freeze"],"mappings":"AAKA,SAASA,cAAc,EAAEC,WAAW,QAAQ,kCAAkC;AAE9E,SAASC,cAAc,QAAQ,SAAS;AAExC,MAAMC,iBAAiBD,eAAeE,aAAa;AAWnD;;;;;;;CAOC,GACD,MAAMC,uBAIF,CAACC;IACH,OAAO;QACLC,gBAAgBP,eAAeQ,SAAS;QACxCC,YAAYN;QACZO,gBAAgB;QAChBC,iBAAiB,CAACC;YAChB,OAAO;gBAAC;gBAAS;gBAAW;gBAAW;aAAW;QACpD;QACAC,cAAc;YAACZ,YAAYa,IAAI;SAAC;IAClC;AACF;AAEA,OAAO,MAAMC,gCAAgCC,OAAOC,MAAM,CAAC;IACzDR,YAAYN;IACZE;AACF,GAAY"}

package/dist/esm/endowments/rpc.js

@@ -1,92 +0,0 @@
-import { PermissionType, SubjectType } from '@metamask/permission-controller';
-import { rpcErrors } from '@metamask/rpc-errors';
-import { assertIsRpcOrigins, SnapCaveatType } from '@metamask/snaps-utils';
-import { hasProperty, isPlainObject, assert } from '@metamask/utils';
-import { createGenericPermissionValidator } from './caveats';
-import { SnapEndowments } from './enum';
-const targetName = SnapEndowments.Rpc;
-/**
- * The specification builder for the JSON-RPC endowment permission.
- *
- * @param _builderOptions - Optional specification builder options.
- * @returns The specification for the JSON-RPC endowment permission.
- */ const specificationBuilder = (_builderOptions)=>{
-    return {
-        permissionType: PermissionType.Endowment,
-        targetName,
-        allowedCaveats: [
-            SnapCaveatType.RpcOrigin,
-            SnapCaveatType.MaxRequestTime
-        ],
-        endowmentGetter: (_getterOptions)=>undefined,
-        validator: createGenericPermissionValidator([
-            {
-                type: SnapCaveatType.RpcOrigin
-            },
-            {
-                type: SnapCaveatType.MaxRequestTime,
-                optional: true
-            }
-        ]),
-        subjectTypes: [
-            SubjectType.Snap
-        ]
-    };
-};
-export const rpcEndowmentBuilder = Object.freeze({
-    targetName,
-    specificationBuilder
-});
-/**
- * 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 validateCaveatOrigins(caveat) {
-    if (!hasProperty(caveat, 'value') || !isPlainObject(caveat.value)) {
-        throw rpcErrors.invalidParams({
-            message: 'Invalid JSON-RPC origins: Expected a plain object.'
-        });
-    }
-    const { value } = caveat;
-    assertIsRpcOrigins(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 getRpcCaveatMapper(value) {
-    return {
-        caveats: [
-            {
-                type: SnapCaveatType.RpcOrigin,
-                value
-            }
-        ]
-    };
-}
-/**
- * Getter function to get the {@link RpcOrigins} caveat value from a permission.
- *
- * @param permission - The permission to get the caveat value from.
- * @returns The caveat value.
- * @throws If the permission does not have a valid {@link RpcOrigins} caveat.
- */ export function getRpcCaveatOrigins(permission) {
-    const caveats = permission?.caveats?.filter((caveat)=>caveat.type === SnapCaveatType.RpcOrigin);
-    assert(caveats);
-    assert(caveats.length === 1);
-    const caveat = caveats[0];
-    return caveat.value;
-}
-export const rpcCaveatSpecifications = {
-    [SnapCaveatType.RpcOrigin]: Object.freeze({
-        type: SnapCaveatType.RpcOrigin,
-        validator: (caveat)=>validateCaveatOrigins(caveat)
-    })
-};
-
-//# sourceMappingURL=rpc.js.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/endowments/rpc.ts"],"sourcesContent":["import type {\n  Caveat,\n  CaveatSpecificationConstraint,\n  EndowmentGetterParams,\n  PermissionConstraint,\n  PermissionSpecificationBuilder,\n  PermissionValidatorConstraint,\n  ValidPermissionSpecification,\n} from '@metamask/permission-controller';\nimport { PermissionType, SubjectType } from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport type { RpcOrigins } from '@metamask/snaps-utils';\nimport { assertIsRpcOrigins, SnapCaveatType } from '@metamask/snaps-utils';\nimport type { Json, NonEmptyArray } from '@metamask/utils';\nimport { hasProperty, isPlainObject, assert } from '@metamask/utils';\n\nimport { createGenericPermissionValidator } from './caveats';\nimport { SnapEndowments } from './enum';\n\nconst targetName = SnapEndowments.Rpc;\n\ntype RpcSpecification = ValidPermissionSpecification<{\n  permissionType: PermissionType.Endowment;\n  targetName: typeof targetName;\n  endowmentGetter: (_options?: any) => undefined;\n  allowedCaveats: Readonly<NonEmptyArray<string>> | null;\n  validator: PermissionValidatorConstraint;\n  subjectTypes: readonly SubjectType[];\n}>;\n\ntype RpcSpecificationBuilderOptions = {\n  // Empty for now.\n};\n\n/**\n * The specification builder for the JSON-RPC endowment permission.\n *\n * @param _builderOptions - Optional specification builder options.\n * @returns The specification for the JSON-RPC endowment permission.\n */\nconst specificationBuilder: PermissionSpecificationBuilder<\n  PermissionType.Endowment,\n  RpcSpecificationBuilderOptions,\n  RpcSpecification\n> = (_builderOptions?: any): RpcSpecification => {\n  return {\n    permissionType: PermissionType.Endowment,\n    targetName,\n    allowedCaveats: [SnapCaveatType.RpcOrigin, SnapCaveatType.MaxRequestTime],\n    endowmentGetter: (_getterOptions?: EndowmentGetterParams) => undefined,\n    validator: createGenericPermissionValidator([\n      { type: SnapCaveatType.RpcOrigin },\n      { type: SnapCaveatType.MaxRequestTime, optional: true },\n    ]),\n    subjectTypes: [SubjectType.Snap],\n  };\n};\n\nexport const rpcEndowmentBuilder = Object.freeze({\n  targetName,\n  specificationBuilder,\n} as const);\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 validateCaveatOrigins(caveat: Caveat<string, any>) {\n  if (!hasProperty(caveat, 'value') || !isPlainObject(caveat.value)) {\n    throw rpcErrors.invalidParams({\n      message: 'Invalid JSON-RPC origins: Expected a plain object.',\n    });\n  }\n\n  const { value } = caveat;\n  assertIsRpcOrigins(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 getRpcCaveatMapper(\n  value: Json,\n): Pick<PermissionConstraint, 'caveats'> {\n  return {\n    caveats: [\n      {\n        type: SnapCaveatType.RpcOrigin,\n        value,\n      },\n    ],\n  };\n}\n\n/**\n * Getter function to get the {@link RpcOrigins} caveat value from a permission.\n *\n * @param permission - The permission to get the caveat value from.\n * @returns The caveat value.\n * @throws If the permission does not have a valid {@link RpcOrigins} caveat.\n */\nexport function getRpcCaveatOrigins(\n  permission?: PermissionConstraint,\n): RpcOrigins | null {\n  const caveats = permission?.caveats?.filter(\n    (caveat) => caveat.type === SnapCaveatType.RpcOrigin,\n  );\n  assert(caveats);\n  assert(caveats.length === 1);\n\n  const caveat = caveats[0] as Caveat<string, RpcOrigins>;\n  return caveat.value;\n}\n\nexport const rpcCaveatSpecifications: Record<\n  SnapCaveatType.RpcOrigin,\n  CaveatSpecificationConstraint\n> = {\n  [SnapCaveatType.RpcOrigin]: Object.freeze({\n    type: SnapCaveatType.RpcOrigin,\n    validator: (caveat: Caveat<string, any>) => validateCaveatOrigins(caveat),\n  }),\n};\n"],"names":["PermissionType","SubjectType","rpcErrors","assertIsRpcOrigins","SnapCaveatType","hasProperty","isPlainObject","assert","createGenericPermissionValidator","SnapEndowments","targetName","Rpc","specificationBuilder","_builderOptions","permissionType","Endowment","allowedCaveats","RpcOrigin","MaxRequestTime","endowmentGetter","_getterOptions","undefined","validator","type","optional","subjectTypes","Snap","rpcEndowmentBuilder","Object","freeze","validateCaveatOrigins","caveat","value","invalidParams","message","getRpcCaveatMapper","caveats","getRpcCaveatOrigins","permission","filter","length","rpcCaveatSpecifications"],"mappings":"AASA,SAASA,cAAc,EAAEC,WAAW,QAAQ,kCAAkC;AAC9E,SAASC,SAAS,QAAQ,uBAAuB;AAEjD,SAASC,kBAAkB,EAAEC,cAAc,QAAQ,wBAAwB;AAE3E,SAASC,WAAW,EAAEC,aAAa,EAAEC,MAAM,QAAQ,kBAAkB;AAErE,SAASC,gCAAgC,QAAQ,YAAY;AAC7D,SAASC,cAAc,QAAQ,SAAS;AAExC,MAAMC,aAAaD,eAAeE,GAAG;AAerC;;;;;CAKC,GACD,MAAMC,uBAIF,CAACC;IACH,OAAO;QACLC,gBAAgBd,eAAee,SAAS;QACxCL;QACAM,gBAAgB;YAACZ,eAAea,SAAS;YAAEb,eAAec,cAAc;SAAC;QACzEC,iBAAiB,CAACC,iBAA2CC;QAC7DC,WAAWd,iCAAiC;YAC1C;gBAAEe,MAAMnB,eAAea,SAAS;YAAC;YACjC;gBAAEM,MAAMnB,eAAec,cAAc;gBAAEM,UAAU;YAAK;SACvD;QACDC,cAAc;YAACxB,YAAYyB,IAAI;SAAC;IAClC;AACF;AAEA,OAAO,MAAMC,sBAAsBC,OAAOC,MAAM,CAAC;IAC/CnB;IACAE;AACF,GAAY;AAEZ;;;;;;CAMC,GACD,SAASkB,sBAAsBC,MAA2B;IACxD,IAAI,CAAC1B,YAAY0B,QAAQ,YAAY,CAACzB,cAAcyB,OAAOC,KAAK,GAAG;QACjE,MAAM9B,UAAU+B,aAAa,CAAC;YAC5BC,SAAS;QACX;IACF;IAEA,MAAM,EAAEF,KAAK,EAAE,GAAGD;IAClB5B,mBAAmB6B,OAAO9B,UAAU+B,aAAa;AACnD;AAEA;;;;;;;CAOC,GACD,OAAO,SAASE,mBACdH,KAAW;IAEX,OAAO;QACLI,SAAS;YACP;gBACEb,MAAMnB,eAAea,SAAS;gBAC9Be;YACF;SACD;IACH;AACF;AAEA;;;;;;CAMC,GACD,OAAO,SAASK,oBACdC,UAAiC;IAEjC,MAAMF,UAAUE,YAAYF,SAASG,OACnC,CAACR,SAAWA,OAAOR,IAAI,KAAKnB,eAAea,SAAS;IAEtDV,OAAO6B;IACP7B,OAAO6B,QAAQI,MAAM,KAAK;IAE1B,MAAMT,SAASK,OAAO,CAAC,EAAE;IACzB,OAAOL,OAAOC,KAAK;AACrB;AAEA,OAAO,MAAMS,0BAGT;IACF,CAACrC,eAAea,SAAS,CAAC,EAAEW,OAAOC,MAAM,CAAC;QACxCN,MAAMnB,eAAea,SAAS;QAC9BK,WAAW,CAACS,SAAgCD,sBAAsBC;IACpE;AACF,EAAE"}