@metamask-previews/eth-json-rpc-middleware 21.0.0-preview-468843ab

package/dist/inflight-cache.d.cts

@@ -0,0 +1,4 @@
+import type { JsonRpcParams, Json } from "@metamask/utils";
+import type { JsonRpcCacheMiddleware } from "./types.cjs";
+export declare function createInflightCacheMiddleware(): JsonRpcCacheMiddleware<JsonRpcParams, Json>;
+//# sourceMappingURL=inflight-cache.d.cts.map

package/dist/inflight-cache.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inflight-cache.d.cts","sourceRoot":"","sources":["../src/inflight-cache.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,aAAa,EACb,IAAI,EAEL,wBAAwB;AAIzB,OAAO,KAAK,EAAyB,sBAAsB,EAAE,oBAAgB;AAU7E,wBAAgB,6BAA6B,IAAI,sBAAsB,CACrE,aAAa,EACb,IAAI,CACL,CAiFA"}

package/dist/inflight-cache.d.mts

@@ -0,0 +1,4 @@
+import type { JsonRpcParams, Json } from "@metamask/utils";
+import type { JsonRpcCacheMiddleware } from "./types.mjs";
+export declare function createInflightCacheMiddleware(): JsonRpcCacheMiddleware<JsonRpcParams, Json>;
+//# sourceMappingURL=inflight-cache.d.mts.map

package/dist/inflight-cache.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inflight-cache.d.mts","sourceRoot":"","sources":["../src/inflight-cache.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,aAAa,EACb,IAAI,EAEL,wBAAwB;AAIzB,OAAO,KAAK,EAAyB,sBAAsB,EAAE,oBAAgB;AAU7E,wBAAgB,6BAA6B,IAAI,sBAAsB,CACrE,aAAa,EACb,IAAI,CACL,CAiFA"}

package/dist/inflight-cache.mjs

@@ -0,0 +1,76 @@
+import { createAsyncMiddleware } from "@metamask/json-rpc-engine";
+import { klona } from "klona/full";
+import { projectLogger, createModuleLogger } from "./logging-utils.mjs";
+import { cacheIdentifierForRequest } from "./utils/cache.mjs";
+const log = createModuleLogger(projectLogger, 'inflight-cache');
+export function createInflightCacheMiddleware() {
+    const inflightRequests = {};
+    return createAsyncMiddleware(async (req, res, next) => {
+        // allow cach to be skipped if so specified
+        if (req.skipCache) {
+            return next();
+        }
+        // get cacheId, if cacheable
+        const cacheId = cacheIdentifierForRequest(req);
+        // if not cacheable, skip
+        if (!cacheId) {
+            log('Request is not cacheable, proceeding. req = %o', req);
+            return next();
+        }
+        // check for matching requests
+        let activeRequestHandlers = inflightRequests[cacheId];
+        // if found, wait for the active request to be handled
+        if (activeRequestHandlers) {
+            // setup the response listener and wait for it to be called
+            // it will handle copying the result and request fields
+            log('Running %i handler(s) for request %o', activeRequestHandlers.length, req);
+            await createActiveRequestHandler(res, activeRequestHandlers);
+            return undefined;
+        }
+        // setup response handler array for subsequent requests
+        activeRequestHandlers = [];
+        inflightRequests[cacheId] = activeRequestHandlers;
+        // allow request to be handled normally
+        log('Carrying original request forward %o', req);
+        await next();
+        // clear inflight requests
+        delete inflightRequests[cacheId];
+        // schedule activeRequestHandlers to be handled
+        log('Running %i collected handler(s) for request %o', activeRequestHandlers.length, req);
+        handleActiveRequest(res, activeRequestHandlers);
+        // complete
+        return undefined;
+    });
+    async function createActiveRequestHandler(res, activeRequestHandlers) {
+        const { resolve, promise } = deferredPromise();
+        activeRequestHandlers.push((handledRes) => {
+            // append a copy of the result and error to the response
+            res.result = klona(handledRes.result);
+            res.error = klona(handledRes.error);
+            resolve();
+        });
+        return promise;
+    }
+    function handleActiveRequest(res, activeRequestHandlers) {
+        // use setTimeout so we can resolve our original request first
+        setTimeout(() => {
+            activeRequestHandlers.forEach((handler) => {
+                try {
+                    handler(res);
+                }
+                catch (err) {
+                    // catch error so all requests are handled correctly
+                    console.error(err);
+                }
+            });
+        });
+    }
+}
+function deferredPromise() {
+    let resolve;
+    const promise = new Promise((_resolve) => {
+        resolve = _resolve;
+    });
+    return { resolve, promise };
+}
+//# sourceMappingURL=inflight-cache.mjs.map

package/dist/inflight-cache.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"inflight-cache.mjs","sourceRoot":"","sources":["../src/inflight-cache.ts"],"names":[],"mappings":"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","sourcesContent":["import { createAsyncMiddleware } from '@metamask/json-rpc-engine';\nimport type {\n  JsonRpcParams,\n  Json,\n  PendingJsonRpcResponse,\n} from '@metamask/utils';\nimport { klona } from 'klona/full';\n\nimport { projectLogger, createModuleLogger } from './logging-utils';\nimport type { JsonRpcRequestToCache, JsonRpcCacheMiddleware } from './types';\nimport { cacheIdentifierForRequest } from './utils/cache';\n\ntype RequestHandlers = (handledRes: PendingJsonRpcResponse) => void;\ninterface InflightRequest {\n  [cacheId: string]: RequestHandlers[];\n}\n\nconst log = createModuleLogger(projectLogger, 'inflight-cache');\n\nexport function createInflightCacheMiddleware(): JsonRpcCacheMiddleware<\n  JsonRpcParams,\n  Json\n> {\n  const inflightRequests: InflightRequest = {};\n\n  return createAsyncMiddleware(\n    async (req: JsonRpcRequestToCache<JsonRpcParams>, res, next) => {\n      // allow cach to be skipped if so specified\n      if (req.skipCache) {\n        return next();\n      }\n      // get cacheId, if cacheable\n      const cacheId: string | null = cacheIdentifierForRequest(req);\n      // if not cacheable, skip\n      if (!cacheId) {\n        log('Request is not cacheable, proceeding. req = %o', req);\n        return next();\n      }\n      // check for matching requests\n      let activeRequestHandlers: RequestHandlers[] = inflightRequests[cacheId];\n      // if found, wait for the active request to be handled\n      if (activeRequestHandlers) {\n        // setup the response listener and wait for it to be called\n        // it will handle copying the result and request fields\n        log(\n          'Running %i handler(s) for request %o',\n          activeRequestHandlers.length,\n          req,\n        );\n        await createActiveRequestHandler(res, activeRequestHandlers);\n        return undefined;\n      }\n      // setup response handler array for subsequent requests\n      activeRequestHandlers = [];\n      inflightRequests[cacheId] = activeRequestHandlers;\n      // allow request to be handled normally\n      log('Carrying original request forward %o', req);\n      await next();\n\n      // clear inflight requests\n      delete inflightRequests[cacheId];\n      // schedule activeRequestHandlers to be handled\n      log(\n        'Running %i collected handler(s) for request %o',\n        activeRequestHandlers.length,\n        req,\n      );\n      handleActiveRequest(res, activeRequestHandlers);\n      // complete\n      return undefined;\n    },\n  );\n\n  async function createActiveRequestHandler(\n    res: PendingJsonRpcResponse,\n    activeRequestHandlers: RequestHandlers[],\n  ): Promise<void> {\n    const { resolve, promise } = deferredPromise();\n    activeRequestHandlers.push((handledRes: PendingJsonRpcResponse) => {\n      // append a copy of the result and error to the response\n      res.result = klona(handledRes.result);\n      res.error = klona(handledRes.error);\n      resolve();\n    });\n    return promise;\n  }\n\n  function handleActiveRequest(\n    res: PendingJsonRpcResponse,\n    activeRequestHandlers: RequestHandlers[],\n  ): void {\n    // use setTimeout so we can resolve our original request first\n    setTimeout(() => {\n      activeRequestHandlers.forEach((handler) => {\n        try {\n          handler(res);\n        } catch (err) {\n          // catch error so all requests are handled correctly\n          console.error(err);\n        }\n      });\n    });\n  }\n}\n\nfunction deferredPromise() {\n  let resolve: any;\n  const promise: Promise<void> = new Promise((_resolve) => {\n    resolve = _resolve;\n  });\n  return { resolve, promise };\n}\n"]}

package/dist/logging-utils.cjs

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createModuleLogger = exports.projectLogger = void 0;
+const utils_1 = require("@metamask/utils");
+Object.defineProperty(exports, "createModuleLogger", { enumerable: true, get: function () { return utils_1.createModuleLogger; } });
+exports.projectLogger = (0, utils_1.createProjectLogger)('eth-json-rpc-middleware');
+//# sourceMappingURL=logging-utils.cjs.map

package/dist/logging-utils.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"logging-utils.cjs","sourceRoot":"","sources":["../src/logging-utils.ts"],"names":[],"mappings":";;;AAAA,2CAA0E;AAIjE,mGAJqB,0BAAkB,OAIrB;AAFd,QAAA,aAAa,GAAG,IAAA,2BAAmB,EAAC,yBAAyB,CAAC,CAAC","sourcesContent":["import { createProjectLogger, createModuleLogger } from '@metamask/utils';\n\nexport const projectLogger = createProjectLogger('eth-json-rpc-middleware');\n\nexport { createModuleLogger };\n"]}

package/dist/logging-utils.d.cts

@@ -0,0 +1,5 @@
+/// <reference types="debug" />
+import { createModuleLogger } from "@metamask/utils";
+export declare const projectLogger: import("debug").Debugger;
+export { createModuleLogger };
+//# sourceMappingURL=logging-utils.d.cts.map

package/dist/logging-utils.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logging-utils.d.cts","sourceRoot":"","sources":["../src/logging-utils.ts"],"names":[],"mappings":";AAAA,OAAO,EAAuB,kBAAkB,EAAE,wBAAwB;AAE1E,eAAO,MAAM,aAAa,0BAAiD,CAAC;AAE5E,OAAO,EAAE,kBAAkB,EAAE,CAAC"}

package/dist/logging-utils.d.mts

@@ -0,0 +1,5 @@
+/// <reference types="debug" />
+import { createModuleLogger } from "@metamask/utils";
+export declare const projectLogger: import("debug").Debugger;
+export { createModuleLogger };
+//# sourceMappingURL=logging-utils.d.mts.map

package/dist/logging-utils.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logging-utils.d.mts","sourceRoot":"","sources":["../src/logging-utils.ts"],"names":[],"mappings":";AAAA,OAAO,EAAuB,kBAAkB,EAAE,wBAAwB;AAE1E,eAAO,MAAM,aAAa,0BAAiD,CAAC;AAE5E,OAAO,EAAE,kBAAkB,EAAE,CAAC"}

package/dist/logging-utils.mjs

@@ -0,0 +1,4 @@
+import { createProjectLogger, createModuleLogger } from "@metamask/utils";
+export const projectLogger = createProjectLogger('eth-json-rpc-middleware');
+export { createModuleLogger };
+//# sourceMappingURL=logging-utils.mjs.map

package/dist/logging-utils.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"logging-utils.mjs","sourceRoot":"","sources":["../src/logging-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,wBAAwB;AAE1E,MAAM,CAAC,MAAM,aAAa,GAAG,mBAAmB,CAAC,yBAAyB,CAAC,CAAC;AAE5E,OAAO,EAAE,kBAAkB,EAAE,CAAC","sourcesContent":["import { createProjectLogger, createModuleLogger } from '@metamask/utils';\n\nexport const projectLogger = createProjectLogger('eth-json-rpc-middleware');\n\nexport { createModuleLogger };\n"]}

package/dist/methods/wallet-request-execution-permissions.cjs

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.walletRequestExecutionPermissions = exports.RequestExecutionPermissionsStruct = void 0;
+const rpc_errors_1 = require("@metamask/rpc-errors");
+const superstruct_1 = require("@metamask/superstruct");
+const utils_1 = require("@metamask/utils");
+const validation_1 = require("../utils/validation.cjs");
+const PermissionStruct = (0, superstruct_1.object)({
+    type: (0, superstruct_1.string)(),
+    isAdjustmentAllowed: (0, superstruct_1.boolean)(),
+    data: (0, superstruct_1.record)((0, superstruct_1.string)(), (0, superstruct_1.unknown)()),
+});
+const RuleStruct = (0, superstruct_1.object)({
+    type: (0, superstruct_1.string)(),
+    isAdjustmentAllowed: (0, superstruct_1.boolean)(),
+    data: (0, superstruct_1.record)((0, superstruct_1.string)(), (0, superstruct_1.unknown)()),
+});
+const AccountSignerStruct = (0, superstruct_1.object)({
+    type: (0, superstruct_1.literal)('account'),
+    data: (0, superstruct_1.object)({
+        address: utils_1.HexChecksumAddressStruct,
+    }),
+});
+const PermissionRequestStruct = (0, superstruct_1.object)({
+    chainId: utils_1.StrictHexStruct,
+    address: (0, superstruct_1.optional)(utils_1.HexChecksumAddressStruct),
+    signer: AccountSignerStruct,
+    permission: PermissionStruct,
+    rules: (0, superstruct_1.optional)((0, superstruct_1.union)([(0, superstruct_1.array)(RuleStruct), (0, superstruct_1.literal)(null)])),
+});
+exports.RequestExecutionPermissionsStruct = (0, superstruct_1.array)(PermissionRequestStruct);
+async function walletRequestExecutionPermissions(req, res, { processRequestExecutionPermissions, }) {
+    if (!processRequestExecutionPermissions) {
+        throw rpc_errors_1.rpcErrors.methodNotSupported('wallet_requestExecutionPermissions - no middleware configured');
+    }
+    const { params } = req;
+    (0, validation_1.validateParams)(params, exports.RequestExecutionPermissionsStruct);
+    res.result = await processRequestExecutionPermissions(params, req);
+}
+exports.walletRequestExecutionPermissions = walletRequestExecutionPermissions;
+//# sourceMappingURL=wallet-request-execution-permissions.cjs.map

package/dist/methods/wallet-request-execution-permissions.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"wallet-request-execution-permissions.cjs","sourceRoot":"","sources":["../../src/methods/wallet-request-execution-permissions.ts"],"names":[],"mappings":";;;AAAA,qDAAiD;AAEjD,uDAU+B;AAC/B,2CAOyB;AAEzB,wDAAqD;AAErD,MAAM,gBAAgB,GAAG,IAAA,oBAAM,EAAC;IAC9B,IAAI,EAAE,IAAA,oBAAM,GAAE;IACd,mBAAmB,EAAE,IAAA,qBAAO,GAAE;IAC9B,IAAI,EAAE,IAAA,oBAAM,EAAC,IAAA,oBAAM,GAAE,EAAE,IAAA,qBAAO,GAAE,CAAC;CAClC,CAAC,CAAC;AAEH,MAAM,UAAU,GAAG,IAAA,oBAAM,EAAC;IACxB,IAAI,EAAE,IAAA,oBAAM,GAAE;IACd,mBAAmB,EAAE,IAAA,qBAAO,GAAE;IAC9B,IAAI,EAAE,IAAA,oBAAM,EAAC,IAAA,oBAAM,GAAE,EAAE,IAAA,qBAAO,GAAE,CAAC;CAClC,CAAC,CAAC;AAEH,MAAM,mBAAmB,GAAG,IAAA,oBAAM,EAAC;IACjC,IAAI,EAAE,IAAA,qBAAO,EAAC,SAAS,CAAC;IACxB,IAAI,EAAE,IAAA,oBAAM,EAAC;QACX,OAAO,EAAE,gCAAwB;KAClC,CAAC;CACH,CAAC,CAAC;AAEH,MAAM,uBAAuB,GAAG,IAAA,oBAAM,EAAC;IACrC,OAAO,EAAE,uBAAe;IACxB,OAAO,EAAE,IAAA,sBAAQ,EAAC,gCAAwB,CAAC;IAC3C,MAAM,EAAE,mBAAmB;IAC3B,UAAU,EAAE,gBAAgB;IAC5B,KAAK,EAAE,IAAA,sBAAQ,EAAC,IAAA,mBAAK,EAAC,CAAC,IAAA,mBAAK,EAAC,UAAU,CAAC,EAAE,IAAA,qBAAO,EAAC,IAAI,CAAC,CAAC,CAAC,CAAC;CAC3D,CAAC,CAAC;AAEU,QAAA,iCAAiC,GAAG,IAAA,mBAAK,EAAC,uBAAuB,CAAC,CAAC;AAiBzE,KAAK,UAAU,iCAAiC,CACrD,GAAmB,EACnB,GAA2B,EAC3B,EACE,kCAAkC,GAGnC;IAED,IAAI,CAAC,kCAAkC,EAAE;QACvC,MAAM,sBAAS,CAAC,kBAAkB,CAChC,+DAA+D,CAChE,CAAC;KACH;IAED,MAAM,EAAE,MAAM,EAAE,GAAG,GAAG,CAAC;IAEvB,IAAA,2BAAc,EAAC,MAAM,EAAE,yCAAiC,CAAC,CAAC;IAE1D,GAAG,CAAC,MAAM,GAAG,MAAM,kCAAkC,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;AACrE,CAAC;AApBD,8EAoBC","sourcesContent":["import { rpcErrors } from '@metamask/rpc-errors';\nimport type { Infer } from '@metamask/superstruct';\nimport {\n  array,\n  boolean,\n  literal,\n  object,\n  optional,\n  record,\n  string,\n  union,\n  unknown,\n} from '@metamask/superstruct';\nimport {\n  HexChecksumAddressStruct,\n  type Hex,\n  type Json,\n  type JsonRpcRequest,\n  type PendingJsonRpcResponse,\n  StrictHexStruct,\n} from '@metamask/utils';\n\nimport { validateParams } from '../utils/validation';\n\nconst PermissionStruct = object({\n  type: string(),\n  isAdjustmentAllowed: boolean(),\n  data: record(string(), unknown()),\n});\n\nconst RuleStruct = object({\n  type: string(),\n  isAdjustmentAllowed: boolean(),\n  data: record(string(), unknown()),\n});\n\nconst AccountSignerStruct = object({\n  type: literal('account'),\n  data: object({\n    address: HexChecksumAddressStruct,\n  }),\n});\n\nconst PermissionRequestStruct = object({\n  chainId: StrictHexStruct,\n  address: optional(HexChecksumAddressStruct),\n  signer: AccountSignerStruct,\n  permission: PermissionStruct,\n  rules: optional(union([array(RuleStruct), literal(null)])),\n});\n\nexport const RequestExecutionPermissionsStruct = array(PermissionRequestStruct);\n\n// RequestExecutionPermissions API types\nexport type RequestExecutionPermissionsRequestParams = Infer<\n  typeof RequestExecutionPermissionsStruct\n>;\n\nexport type RequestExecutionPermissionsResult = Json &\n  (Infer<typeof PermissionRequestStruct> & {\n    context: Hex;\n  })[];\n\nexport type ProcessRequestExecutionPermissionsHook = (\n  request: RequestExecutionPermissionsRequestParams,\n  req: JsonRpcRequest,\n) => Promise<RequestExecutionPermissionsResult>;\n\nexport async function walletRequestExecutionPermissions(\n  req: JsonRpcRequest,\n  res: PendingJsonRpcResponse,\n  {\n    processRequestExecutionPermissions,\n  }: {\n    processRequestExecutionPermissions?: ProcessRequestExecutionPermissionsHook;\n  },\n): Promise<void> {\n  if (!processRequestExecutionPermissions) {\n    throw rpcErrors.methodNotSupported(\n      'wallet_requestExecutionPermissions - no middleware configured',\n    );\n  }\n\n  const { params } = req;\n\n  validateParams(params, RequestExecutionPermissionsStruct);\n\n  res.result = await processRequestExecutionPermissions(params, req);\n}\n"]}

package/dist/methods/wallet-request-execution-permissions.d.cts

@@ -0,0 +1,131 @@
+import type { Infer } from "@metamask/superstruct";
+import { type Hex, type Json, type JsonRpcRequest, type PendingJsonRpcResponse } from "@metamask/utils";
+declare const PermissionRequestStruct: import("@metamask/superstruct").Struct<{
+    chainId: `0x${string}`;
+    signer: {
+        type: "account";
+        data: {
+            address: `0x${string}`;
+        };
+    };
+    permission: {
+        type: string;
+        data: Record<string, unknown>;
+        isAdjustmentAllowed: boolean;
+    };
+    address?: `0x${string}` | undefined;
+    rules?: {
+        type: string;
+        data: Record<string, unknown>;
+        isAdjustmentAllowed: boolean;
+    }[] | null | undefined;
+}, {
+    chainId: import("@metamask/superstruct").Struct<`0x${string}`, null>;
+    address: import("@metamask/superstruct").Struct<`0x${string}` | undefined, null>;
+    signer: import("@metamask/superstruct").Struct<{
+        type: "account";
+        data: {
+            address: `0x${string}`;
+        };
+    }, {
+        type: import("@metamask/superstruct").Struct<"account", "account">;
+        data: import("@metamask/superstruct").Struct<{
+            address: `0x${string}`;
+        }, {
+            address: import("@metamask/superstruct").Struct<`0x${string}`, null>;
+        }>;
+    }>;
+    permission: import("@metamask/superstruct").Struct<{
+        type: string;
+        data: Record<string, unknown>;
+        isAdjustmentAllowed: boolean;
+    }, {
+        type: import("@metamask/superstruct").Struct<string, null>;
+        isAdjustmentAllowed: import("@metamask/superstruct").Struct<boolean, null>;
+        data: import("@metamask/superstruct").Struct<Record<string, unknown>, null>;
+    }>;
+    rules: import("@metamask/superstruct").Struct<{
+        type: string;
+        data: Record<string, unknown>;
+        isAdjustmentAllowed: boolean;
+    }[] | null | undefined, null>;
+}>;
+export declare const RequestExecutionPermissionsStruct: import("@metamask/superstruct").Struct<{
+    chainId: `0x${string}`;
+    signer: {
+        type: "account";
+        data: {
+            address: `0x${string}`;
+        };
+    };
+    permission: {
+        type: string;
+        data: Record<string, unknown>;
+        isAdjustmentAllowed: boolean;
+    };
+    address?: `0x${string}` | undefined;
+    rules?: {
+        type: string;
+        data: Record<string, unknown>;
+        isAdjustmentAllowed: boolean;
+    }[] | null | undefined;
+}[], import("@metamask/superstruct").Struct<{
+    chainId: `0x${string}`;
+    signer: {
+        type: "account";
+        data: {
+            address: `0x${string}`;
+        };
+    };
+    permission: {
+        type: string;
+        data: Record<string, unknown>;
+        isAdjustmentAllowed: boolean;
+    };
+    address?: `0x${string}` | undefined;
+    rules?: {
+        type: string;
+        data: Record<string, unknown>;
+        isAdjustmentAllowed: boolean;
+    }[] | null | undefined;
+}, {
+    chainId: import("@metamask/superstruct").Struct<`0x${string}`, null>;
+    address: import("@metamask/superstruct").Struct<`0x${string}` | undefined, null>;
+    signer: import("@metamask/superstruct").Struct<{
+        type: "account";
+        data: {
+            address: `0x${string}`;
+        };
+    }, {
+        type: import("@metamask/superstruct").Struct<"account", "account">;
+        data: import("@metamask/superstruct").Struct<{
+            address: `0x${string}`;
+        }, {
+            address: import("@metamask/superstruct").Struct<`0x${string}`, null>;
+        }>;
+    }>;
+    permission: import("@metamask/superstruct").Struct<{
+        type: string;
+        data: Record<string, unknown>;
+        isAdjustmentAllowed: boolean;
+    }, {
+        type: import("@metamask/superstruct").Struct<string, null>;
+        isAdjustmentAllowed: import("@metamask/superstruct").Struct<boolean, null>;
+        data: import("@metamask/superstruct").Struct<Record<string, unknown>, null>;
+    }>;
+    rules: import("@metamask/superstruct").Struct<{
+        type: string;
+        data: Record<string, unknown>;
+        isAdjustmentAllowed: boolean;
+    }[] | null | undefined, null>;
+}>>;
+export type RequestExecutionPermissionsRequestParams = Infer<typeof RequestExecutionPermissionsStruct>;
+export type RequestExecutionPermissionsResult = Json & (Infer<typeof PermissionRequestStruct> & {
+    context: Hex;
+})[];
+export type ProcessRequestExecutionPermissionsHook = (request: RequestExecutionPermissionsRequestParams, req: JsonRpcRequest) => Promise<RequestExecutionPermissionsResult>;
+export declare function walletRequestExecutionPermissions(req: JsonRpcRequest, res: PendingJsonRpcResponse, { processRequestExecutionPermissions, }: {
+    processRequestExecutionPermissions?: ProcessRequestExecutionPermissionsHook;
+}): Promise<void>;
+export {};
+//# sourceMappingURL=wallet-request-execution-permissions.d.cts.map

package/dist/methods/wallet-request-execution-permissions.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wallet-request-execution-permissions.d.cts","sourceRoot":"","sources":["../../src/methods/wallet-request-execution-permissions.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,8BAA8B;AAYnD,OAAO,EAEL,KAAK,GAAG,EACR,KAAK,IAAI,EACT,KAAK,cAAc,EACnB,KAAK,sBAAsB,EAE5B,wBAAwB;AAuBzB,QAAA,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAM3B,CAAC;AAEH,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAiC,CAAC;AAGhF,MAAM,MAAM,wCAAwC,GAAG,KAAK,CAC1D,OAAO,iCAAiC,CACzC,CAAC;AAEF,MAAM,MAAM,iCAAiC,GAAG,IAAI,GAClD,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,GAAG;IACvC,OAAO,EAAE,GAAG,CAAC;CACd,CAAC,EAAE,CAAC;AAEP,MAAM,MAAM,sCAAsC,GAAG,CACnD,OAAO,EAAE,wCAAwC,EACjD,GAAG,EAAE,cAAc,KAChB,OAAO,CAAC,iCAAiC,CAAC,CAAC;AAEhD,wBAAsB,iCAAiC,CACrD,GAAG,EAAE,cAAc,EACnB,GAAG,EAAE,sBAAsB,EAC3B,EACE,kCAAkC,GACnC,EAAE;IACD,kCAAkC,CAAC,EAAE,sCAAsC,CAAC;CAC7E,GACA,OAAO,CAAC,IAAI,CAAC,CAYf"}

package/dist/methods/wallet-request-execution-permissions.d.mts

@@ -0,0 +1,131 @@
+import type { Infer } from "@metamask/superstruct";
+import { type Hex, type Json, type JsonRpcRequest, type PendingJsonRpcResponse } from "@metamask/utils";
+declare const PermissionRequestStruct: import("@metamask/superstruct").Struct<{
+    chainId: `0x${string}`;
+    signer: {
+        type: "account";
+        data: {
+            address: `0x${string}`;
+        };
+    };
+    permission: {
+        type: string;
+        data: Record<string, unknown>;
+        isAdjustmentAllowed: boolean;
+    };
+    address?: `0x${string}` | undefined;
+    rules?: {
+        type: string;
+        data: Record<string, unknown>;
+        isAdjustmentAllowed: boolean;
+    }[] | null | undefined;
+}, {
+    chainId: import("@metamask/superstruct").Struct<`0x${string}`, null>;
+    address: import("@metamask/superstruct").Struct<`0x${string}` | undefined, null>;
+    signer: import("@metamask/superstruct").Struct<{
+        type: "account";
+        data: {
+            address: `0x${string}`;
+        };
+    }, {
+        type: import("@metamask/superstruct").Struct<"account", "account">;
+        data: import("@metamask/superstruct").Struct<{
+            address: `0x${string}`;
+        }, {
+            address: import("@metamask/superstruct").Struct<`0x${string}`, null>;
+        }>;
+    }>;
+    permission: import("@metamask/superstruct").Struct<{
+        type: string;
+        data: Record<string, unknown>;
+        isAdjustmentAllowed: boolean;
+    }, {
+        type: import("@metamask/superstruct").Struct<string, null>;
+        isAdjustmentAllowed: import("@metamask/superstruct").Struct<boolean, null>;
+        data: import("@metamask/superstruct").Struct<Record<string, unknown>, null>;
+    }>;
+    rules: import("@metamask/superstruct").Struct<{
+        type: string;
+        data: Record<string, unknown>;
+        isAdjustmentAllowed: boolean;
+    }[] | null | undefined, null>;
+}>;
+export declare const RequestExecutionPermissionsStruct: import("@metamask/superstruct").Struct<{
+    chainId: `0x${string}`;
+    signer: {
+        type: "account";
+        data: {
+            address: `0x${string}`;
+        };
+    };
+    permission: {
+        type: string;
+        data: Record<string, unknown>;
+        isAdjustmentAllowed: boolean;
+    };
+    address?: `0x${string}` | undefined;
+    rules?: {
+        type: string;
+        data: Record<string, unknown>;
+        isAdjustmentAllowed: boolean;
+    }[] | null | undefined;
+}[], import("@metamask/superstruct").Struct<{
+    chainId: `0x${string}`;
+    signer: {
+        type: "account";
+        data: {
+            address: `0x${string}`;
+        };
+    };
+    permission: {
+        type: string;
+        data: Record<string, unknown>;
+        isAdjustmentAllowed: boolean;
+    };
+    address?: `0x${string}` | undefined;
+    rules?: {
+        type: string;
+        data: Record<string, unknown>;
+        isAdjustmentAllowed: boolean;
+    }[] | null | undefined;
+}, {
+    chainId: import("@metamask/superstruct").Struct<`0x${string}`, null>;
+    address: import("@metamask/superstruct").Struct<`0x${string}` | undefined, null>;
+    signer: import("@metamask/superstruct").Struct<{
+        type: "account";
+        data: {
+            address: `0x${string}`;
+        };
+    }, {
+        type: import("@metamask/superstruct").Struct<"account", "account">;
+        data: import("@metamask/superstruct").Struct<{
+            address: `0x${string}`;
+        }, {
+            address: import("@metamask/superstruct").Struct<`0x${string}`, null>;
+        }>;
+    }>;
+    permission: import("@metamask/superstruct").Struct<{
+        type: string;
+        data: Record<string, unknown>;
+        isAdjustmentAllowed: boolean;
+    }, {
+        type: import("@metamask/superstruct").Struct<string, null>;
+        isAdjustmentAllowed: import("@metamask/superstruct").Struct<boolean, null>;
+        data: import("@metamask/superstruct").Struct<Record<string, unknown>, null>;
+    }>;
+    rules: import("@metamask/superstruct").Struct<{
+        type: string;
+        data: Record<string, unknown>;
+        isAdjustmentAllowed: boolean;
+    }[] | null | undefined, null>;
+}>>;
+export type RequestExecutionPermissionsRequestParams = Infer<typeof RequestExecutionPermissionsStruct>;
+export type RequestExecutionPermissionsResult = Json & (Infer<typeof PermissionRequestStruct> & {
+    context: Hex;
+})[];
+export type ProcessRequestExecutionPermissionsHook = (request: RequestExecutionPermissionsRequestParams, req: JsonRpcRequest) => Promise<RequestExecutionPermissionsResult>;
+export declare function walletRequestExecutionPermissions(req: JsonRpcRequest, res: PendingJsonRpcResponse, { processRequestExecutionPermissions, }: {
+    processRequestExecutionPermissions?: ProcessRequestExecutionPermissionsHook;
+}): Promise<void>;
+export {};
+//# sourceMappingURL=wallet-request-execution-permissions.d.mts.map

package/dist/methods/wallet-request-execution-permissions.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wallet-request-execution-permissions.d.mts","sourceRoot":"","sources":["../../src/methods/wallet-request-execution-permissions.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,8BAA8B;AAYnD,OAAO,EAEL,KAAK,GAAG,EACR,KAAK,IAAI,EACT,KAAK,cAAc,EACnB,KAAK,sBAAsB,EAE5B,wBAAwB;AAuBzB,QAAA,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAM3B,CAAC;AAEH,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAiC,CAAC;AAGhF,MAAM,MAAM,wCAAwC,GAAG,KAAK,CAC1D,OAAO,iCAAiC,CACzC,CAAC;AAEF,MAAM,MAAM,iCAAiC,GAAG,IAAI,GAClD,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,GAAG;IACvC,OAAO,EAAE,GAAG,CAAC;CACd,CAAC,EAAE,CAAC;AAEP,MAAM,MAAM,sCAAsC,GAAG,CACnD,OAAO,EAAE,wCAAwC,EACjD,GAAG,EAAE,cAAc,KAChB,OAAO,CAAC,iCAAiC,CAAC,CAAC;AAEhD,wBAAsB,iCAAiC,CACrD,GAAG,EAAE,cAAc,EACnB,GAAG,EAAE,sBAAsB,EAC3B,EACE,kCAAkC,GACnC,EAAE;IACD,kCAAkC,CAAC,EAAE,sCAAsC,CAAC;CAC7E,GACA,OAAO,CAAC,IAAI,CAAC,CAYf"}

package/dist/methods/wallet-request-execution-permissions.mjs

@@ -0,0 +1,37 @@
+import { rpcErrors } from "@metamask/rpc-errors";
+import { array, boolean, literal, object, optional, record, string, union, unknown } from "@metamask/superstruct";
+import { HexChecksumAddressStruct, StrictHexStruct } from "@metamask/utils";
+import { validateParams } from "../utils/validation.mjs";
+const PermissionStruct = object({
+    type: string(),
+    isAdjustmentAllowed: boolean(),
+    data: record(string(), unknown()),
+});
+const RuleStruct = object({
+    type: string(),
+    isAdjustmentAllowed: boolean(),
+    data: record(string(), unknown()),
+});
+const AccountSignerStruct = object({
+    type: literal('account'),
+    data: object({
+        address: HexChecksumAddressStruct,
+    }),
+});
+const PermissionRequestStruct = object({
+    chainId: StrictHexStruct,
+    address: optional(HexChecksumAddressStruct),
+    signer: AccountSignerStruct,
+    permission: PermissionStruct,
+    rules: optional(union([array(RuleStruct), literal(null)])),
+});
+export const RequestExecutionPermissionsStruct = array(PermissionRequestStruct);
+export async function walletRequestExecutionPermissions(req, res, { processRequestExecutionPermissions, }) {
+    if (!processRequestExecutionPermissions) {
+        throw rpcErrors.methodNotSupported('wallet_requestExecutionPermissions - no middleware configured');
+    }
+    const { params } = req;
+    validateParams(params, RequestExecutionPermissionsStruct);
+    res.result = await processRequestExecutionPermissions(params, req);
+}
+//# sourceMappingURL=wallet-request-execution-permissions.mjs.map

package/dist/methods/wallet-request-execution-permissions.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"wallet-request-execution-permissions.mjs","sourceRoot":"","sources":["../../src/methods/wallet-request-execution-permissions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,6BAA6B;AAEjD,OAAO,EACL,KAAK,EACL,OAAO,EACP,OAAO,EACP,MAAM,EACN,QAAQ,EACR,MAAM,EACN,MAAM,EACN,KAAK,EACL,OAAO,EACR,8BAA8B;AAC/B,OAAO,EACL,wBAAwB,EAKxB,eAAe,EAChB,wBAAwB;AAEzB,OAAO,EAAE,cAAc,EAAE,gCAA4B;AAErD,MAAM,gBAAgB,GAAG,MAAM,CAAC;IAC9B,IAAI,EAAE,MAAM,EAAE;IACd,mBAAmB,EAAE,OAAO,EAAE;IAC9B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,EAAE,OAAO,EAAE,CAAC;CAClC,CAAC,CAAC;AAEH,MAAM,UAAU,GAAG,MAAM,CAAC;IACxB,IAAI,EAAE,MAAM,EAAE;IACd,mBAAmB,EAAE,OAAO,EAAE;IAC9B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,EAAE,OAAO,EAAE,CAAC;CAClC,CAAC,CAAC;AAEH,MAAM,mBAAmB,GAAG,MAAM,CAAC;IACjC,IAAI,EAAE,OAAO,CAAC,SAAS,CAAC;IACxB,IAAI,EAAE,MAAM,CAAC;QACX,OAAO,EAAE,wBAAwB;KAClC,CAAC;CACH,CAAC,CAAC;AAEH,MAAM,uBAAuB,GAAG,MAAM,CAAC;IACrC,OAAO,EAAE,eAAe;IACxB,OAAO,EAAE,QAAQ,CAAC,wBAAwB,CAAC;IAC3C,MAAM,EAAE,mBAAmB;IAC3B,UAAU,EAAE,gBAAgB;IAC5B,KAAK,EAAE,QAAQ,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;CAC3D,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,iCAAiC,GAAG,KAAK,CAAC,uBAAuB,CAAC,CAAC;AAiBhF,MAAM,CAAC,KAAK,UAAU,iCAAiC,CACrD,GAAmB,EACnB,GAA2B,EAC3B,EACE,kCAAkC,GAGnC;IAED,IAAI,CAAC,kCAAkC,EAAE;QACvC,MAAM,SAAS,CAAC,kBAAkB,CAChC,+DAA+D,CAChE,CAAC;KACH;IAED,MAAM,EAAE,MAAM,EAAE,GAAG,GAAG,CAAC;IAEvB,cAAc,CAAC,MAAM,EAAE,iCAAiC,CAAC,CAAC;IAE1D,GAAG,CAAC,MAAM,GAAG,MAAM,kCAAkC,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;AACrE,CAAC","sourcesContent":["import { rpcErrors } from '@metamask/rpc-errors';\nimport type { Infer } from '@metamask/superstruct';\nimport {\n  array,\n  boolean,\n  literal,\n  object,\n  optional,\n  record,\n  string,\n  union,\n  unknown,\n} from '@metamask/superstruct';\nimport {\n  HexChecksumAddressStruct,\n  type Hex,\n  type Json,\n  type JsonRpcRequest,\n  type PendingJsonRpcResponse,\n  StrictHexStruct,\n} from '@metamask/utils';\n\nimport { validateParams } from '../utils/validation';\n\nconst PermissionStruct = object({\n  type: string(),\n  isAdjustmentAllowed: boolean(),\n  data: record(string(), unknown()),\n});\n\nconst RuleStruct = object({\n  type: string(),\n  isAdjustmentAllowed: boolean(),\n  data: record(string(), unknown()),\n});\n\nconst AccountSignerStruct = object({\n  type: literal('account'),\n  data: object({\n    address: HexChecksumAddressStruct,\n  }),\n});\n\nconst PermissionRequestStruct = object({\n  chainId: StrictHexStruct,\n  address: optional(HexChecksumAddressStruct),\n  signer: AccountSignerStruct,\n  permission: PermissionStruct,\n  rules: optional(union([array(RuleStruct), literal(null)])),\n});\n\nexport const RequestExecutionPermissionsStruct = array(PermissionRequestStruct);\n\n// RequestExecutionPermissions API types\nexport type RequestExecutionPermissionsRequestParams = Infer<\n  typeof RequestExecutionPermissionsStruct\n>;\n\nexport type RequestExecutionPermissionsResult = Json &\n  (Infer<typeof PermissionRequestStruct> & {\n    context: Hex;\n  })[];\n\nexport type ProcessRequestExecutionPermissionsHook = (\n  request: RequestExecutionPermissionsRequestParams,\n  req: JsonRpcRequest,\n) => Promise<RequestExecutionPermissionsResult>;\n\nexport async function walletRequestExecutionPermissions(\n  req: JsonRpcRequest,\n  res: PendingJsonRpcResponse,\n  {\n    processRequestExecutionPermissions,\n  }: {\n    processRequestExecutionPermissions?: ProcessRequestExecutionPermissionsHook;\n  },\n): Promise<void> {\n  if (!processRequestExecutionPermissions) {\n    throw rpcErrors.methodNotSupported(\n      'wallet_requestExecutionPermissions - no middleware configured',\n    );\n  }\n\n  const { params } = req;\n\n  validateParams(params, RequestExecutionPermissionsStruct);\n\n  res.result = await processRequestExecutionPermissions(params, req);\n}\n"]}

package/dist/methods/wallet-revoke-execution-permission.cjs

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.walletRevokeExecutionPermission = exports.RevokeExecutionPermissionRequestParamsStruct = exports.RevokeExecutionPermissionResultStruct = void 0;
+const rpc_errors_1 = require("@metamask/rpc-errors");
+const utils_1 = require("@metamask/utils");
+const validation_1 = require("../utils/validation.cjs");
+exports.RevokeExecutionPermissionResultStruct = (0, utils_1.object)({});
+exports.RevokeExecutionPermissionRequestParamsStruct = (0, utils_1.object)({
+    permissionContext: utils_1.StrictHexStruct,
+});
+async function walletRevokeExecutionPermission(req, res, { processRevokeExecutionPermission, }) {
+    if (!processRevokeExecutionPermission) {
+        throw rpc_errors_1.rpcErrors.methodNotSupported('wallet_revokeExecutionPermission - no middleware configured');
+    }
+    const { params } = req;
+    (0, validation_1.validateParams)(params, exports.RevokeExecutionPermissionRequestParamsStruct);
+    res.result = await processRevokeExecutionPermission(params, req);
+}
+exports.walletRevokeExecutionPermission = walletRevokeExecutionPermission;
+//# sourceMappingURL=wallet-revoke-execution-permission.cjs.map

package/dist/methods/wallet-revoke-execution-permission.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"wallet-revoke-execution-permission.cjs","sourceRoot":"","sources":["../../src/methods/wallet-revoke-execution-permission.ts"],"names":[],"mappings":";;;AAAA,qDAAiD;AAEjD,2CAKyB;AAEzB,wDAAqD;AAExC,QAAA,qCAAqC,GAAG,IAAA,cAAM,EAAC,EAAE,CAAC,CAAC;AAMnD,QAAA,4CAA4C,GAAG,IAAA,cAAM,EAAC;IACjE,iBAAiB,EAAE,uBAAe;CACnC,CAAC,CAAC;AAWI,KAAK,UAAU,+BAA+B,CACnD,GAAmB,EACnB,GAA2B,EAC3B,EACE,gCAAgC,GAGjC;IAED,IAAI,CAAC,gCAAgC,EAAE;QACrC,MAAM,sBAAS,CAAC,kBAAkB,CAChC,6DAA6D,CAC9D,CAAC;KACH;IAED,MAAM,EAAE,MAAM,EAAE,GAAG,GAAG,CAAC;IAEvB,IAAA,2BAAc,EAAC,MAAM,EAAE,oDAA4C,CAAC,CAAC;IAErE,GAAG,CAAC,MAAM,GAAG,MAAM,gCAAgC,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;AACnE,CAAC;AApBD,0EAoBC","sourcesContent":["import { rpcErrors } from '@metamask/rpc-errors';\nimport type { Infer } from '@metamask/superstruct';\nimport {\n  type JsonRpcRequest,\n  object,\n  type PendingJsonRpcResponse,\n  StrictHexStruct,\n} from '@metamask/utils';\n\nimport { validateParams } from '../utils/validation';\n\nexport const RevokeExecutionPermissionResultStruct = object({});\n\nexport type RevokeExecutionPermissionResult = Infer<\n  typeof RevokeExecutionPermissionResultStruct\n>;\n\nexport const RevokeExecutionPermissionRequestParamsStruct = object({\n  permissionContext: StrictHexStruct,\n});\n\nexport type RevokeExecutionPermissionRequestParams = Infer<\n  typeof RevokeExecutionPermissionRequestParamsStruct\n>;\n\nexport type ProcessRevokeExecutionPermissionHook = (\n  request: RevokeExecutionPermissionRequestParams,\n  req: JsonRpcRequest,\n) => Promise<RevokeExecutionPermissionResult>;\n\nexport async function walletRevokeExecutionPermission(\n  req: JsonRpcRequest,\n  res: PendingJsonRpcResponse,\n  {\n    processRevokeExecutionPermission,\n  }: {\n    processRevokeExecutionPermission?: ProcessRevokeExecutionPermissionHook;\n  },\n): Promise<void> {\n  if (!processRevokeExecutionPermission) {\n    throw rpcErrors.methodNotSupported(\n      'wallet_revokeExecutionPermission - no middleware configured',\n    );\n  }\n\n  const { params } = req;\n\n  validateParams(params, RevokeExecutionPermissionRequestParamsStruct);\n\n  res.result = await processRevokeExecutionPermission(params, req);\n}\n"]}

package/dist/methods/wallet-revoke-execution-permission.d.cts

@@ -0,0 +1,13 @@
+import type { Infer } from "@metamask/superstruct";
+import { type JsonRpcRequest, type PendingJsonRpcResponse } from "@metamask/utils";
+export declare const RevokeExecutionPermissionResultStruct: import("@metamask/superstruct").Struct<{}, unknown>;
+export type RevokeExecutionPermissionResult = Infer<typeof RevokeExecutionPermissionResultStruct>;
+export declare const RevokeExecutionPermissionRequestParamsStruct: import("@metamask/superstruct").Struct<{
+    permissionContext: `0x${string}`;
+}, unknown>;
+export type RevokeExecutionPermissionRequestParams = Infer<typeof RevokeExecutionPermissionRequestParamsStruct>;
+export type ProcessRevokeExecutionPermissionHook = (request: RevokeExecutionPermissionRequestParams, req: JsonRpcRequest) => Promise<RevokeExecutionPermissionResult>;
+export declare function walletRevokeExecutionPermission(req: JsonRpcRequest, res: PendingJsonRpcResponse, { processRevokeExecutionPermission, }: {
+    processRevokeExecutionPermission?: ProcessRevokeExecutionPermissionHook;
+}): Promise<void>;
+//# sourceMappingURL=wallet-revoke-execution-permission.d.cts.map

package/dist/methods/wallet-revoke-execution-permission.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wallet-revoke-execution-permission.d.cts","sourceRoot":"","sources":["../../src/methods/wallet-revoke-execution-permission.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,8BAA8B;AACnD,OAAO,EACL,KAAK,cAAc,EAEnB,KAAK,sBAAsB,EAE5B,wBAAwB;AAIzB,eAAO,MAAM,qCAAqC,qDAAa,CAAC;AAEhE,MAAM,MAAM,+BAA+B,GAAG,KAAK,CACjD,OAAO,qCAAqC,CAC7C,CAAC;AAEF,eAAO,MAAM,4CAA4C;;WAEvD,CAAC;AAEH,MAAM,MAAM,sCAAsC,GAAG,KAAK,CACxD,OAAO,4CAA4C,CACpD,CAAC;AAEF,MAAM,MAAM,oCAAoC,GAAG,CACjD,OAAO,EAAE,sCAAsC,EAC/C,GAAG,EAAE,cAAc,KAChB,OAAO,CAAC,+BAA+B,CAAC,CAAC;AAE9C,wBAAsB,+BAA+B,CACnD,GAAG,EAAE,cAAc,EACnB,GAAG,EAAE,sBAAsB,EAC3B,EACE,gCAAgC,GACjC,EAAE;IACD,gCAAgC,CAAC,EAAE,oCAAoC,CAAC;CACzE,GACA,OAAO,CAAC,IAAI,CAAC,CAYf"}

package/dist/methods/wallet-revoke-execution-permission.d.mts

@@ -0,0 +1,13 @@
+import type { Infer } from "@metamask/superstruct";
+import { type JsonRpcRequest, type PendingJsonRpcResponse } from "@metamask/utils";
+export declare const RevokeExecutionPermissionResultStruct: import("@metamask/superstruct").Struct<{}, unknown>;
+export type RevokeExecutionPermissionResult = Infer<typeof RevokeExecutionPermissionResultStruct>;
+export declare const RevokeExecutionPermissionRequestParamsStruct: import("@metamask/superstruct").Struct<{
+    permissionContext: `0x${string}`;
+}, unknown>;
+export type RevokeExecutionPermissionRequestParams = Infer<typeof RevokeExecutionPermissionRequestParamsStruct>;
+export type ProcessRevokeExecutionPermissionHook = (request: RevokeExecutionPermissionRequestParams, req: JsonRpcRequest) => Promise<RevokeExecutionPermissionResult>;
+export declare function walletRevokeExecutionPermission(req: JsonRpcRequest, res: PendingJsonRpcResponse, { processRevokeExecutionPermission, }: {
+    processRevokeExecutionPermission?: ProcessRevokeExecutionPermissionHook;
+}): Promise<void>;
+//# sourceMappingURL=wallet-revoke-execution-permission.d.mts.map

package/dist/methods/wallet-revoke-execution-permission.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wallet-revoke-execution-permission.d.mts","sourceRoot":"","sources":["../../src/methods/wallet-revoke-execution-permission.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,8BAA8B;AACnD,OAAO,EACL,KAAK,cAAc,EAEnB,KAAK,sBAAsB,EAE5B,wBAAwB;AAIzB,eAAO,MAAM,qCAAqC,qDAAa,CAAC;AAEhE,MAAM,MAAM,+BAA+B,GAAG,KAAK,CACjD,OAAO,qCAAqC,CAC7C,CAAC;AAEF,eAAO,MAAM,4CAA4C;;WAEvD,CAAC;AAEH,MAAM,MAAM,sCAAsC,GAAG,KAAK,CACxD,OAAO,4CAA4C,CACpD,CAAC;AAEF,MAAM,MAAM,oCAAoC,GAAG,CACjD,OAAO,EAAE,sCAAsC,EAC/C,GAAG,EAAE,cAAc,KAChB,OAAO,CAAC,+BAA+B,CAAC,CAAC;AAE9C,wBAAsB,+BAA+B,CACnD,GAAG,EAAE,cAAc,EACnB,GAAG,EAAE,sBAAsB,EAC3B,EACE,gCAAgC,GACjC,EAAE;IACD,gCAAgC,CAAC,EAAE,oCAAoC,CAAC;CACzE,GACA,OAAO,CAAC,IAAI,CAAC,CAYf"}

package/dist/methods/wallet-revoke-execution-permission.mjs

@@ -0,0 +1,16 @@
+import { rpcErrors } from "@metamask/rpc-errors";
+import { object, StrictHexStruct } from "@metamask/utils";
+import { validateParams } from "../utils/validation.mjs";
+export const RevokeExecutionPermissionResultStruct = object({});
+export const RevokeExecutionPermissionRequestParamsStruct = object({
+    permissionContext: StrictHexStruct,
+});
+export async function walletRevokeExecutionPermission(req, res, { processRevokeExecutionPermission, }) {
+    if (!processRevokeExecutionPermission) {
+        throw rpcErrors.methodNotSupported('wallet_revokeExecutionPermission - no middleware configured');
+    }
+    const { params } = req;
+    validateParams(params, RevokeExecutionPermissionRequestParamsStruct);
+    res.result = await processRevokeExecutionPermission(params, req);
+}
+//# sourceMappingURL=wallet-revoke-execution-permission.mjs.map

package/dist/methods/wallet-revoke-execution-permission.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"wallet-revoke-execution-permission.mjs","sourceRoot":"","sources":["../../src/methods/wallet-revoke-execution-permission.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,6BAA6B;AAEjD,OAAO,EAEL,MAAM,EAEN,eAAe,EAChB,wBAAwB;AAEzB,OAAO,EAAE,cAAc,EAAE,gCAA4B;AAErD,MAAM,CAAC,MAAM,qCAAqC,GAAG,MAAM,CAAC,EAAE,CAAC,CAAC;AAMhE,MAAM,CAAC,MAAM,4CAA4C,GAAG,MAAM,CAAC;IACjE,iBAAiB,EAAE,eAAe;CACnC,CAAC,CAAC;AAWH,MAAM,CAAC,KAAK,UAAU,+BAA+B,CACnD,GAAmB,EACnB,GAA2B,EAC3B,EACE,gCAAgC,GAGjC;IAED,IAAI,CAAC,gCAAgC,EAAE;QACrC,MAAM,SAAS,CAAC,kBAAkB,CAChC,6DAA6D,CAC9D,CAAC;KACH;IAED,MAAM,EAAE,MAAM,EAAE,GAAG,GAAG,CAAC;IAEvB,cAAc,CAAC,MAAM,EAAE,4CAA4C,CAAC,CAAC;IAErE,GAAG,CAAC,MAAM,GAAG,MAAM,gCAAgC,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;AACnE,CAAC","sourcesContent":["import { rpcErrors } from '@metamask/rpc-errors';\nimport type { Infer } from '@metamask/superstruct';\nimport {\n  type JsonRpcRequest,\n  object,\n  type PendingJsonRpcResponse,\n  StrictHexStruct,\n} from '@metamask/utils';\n\nimport { validateParams } from '../utils/validation';\n\nexport const RevokeExecutionPermissionResultStruct = object({});\n\nexport type RevokeExecutionPermissionResult = Infer<\n  typeof RevokeExecutionPermissionResultStruct\n>;\n\nexport const RevokeExecutionPermissionRequestParamsStruct = object({\n  permissionContext: StrictHexStruct,\n});\n\nexport type RevokeExecutionPermissionRequestParams = Infer<\n  typeof RevokeExecutionPermissionRequestParamsStruct\n>;\n\nexport type ProcessRevokeExecutionPermissionHook = (\n  request: RevokeExecutionPermissionRequestParams,\n  req: JsonRpcRequest,\n) => Promise<RevokeExecutionPermissionResult>;\n\nexport async function walletRevokeExecutionPermission(\n  req: JsonRpcRequest,\n  res: PendingJsonRpcResponse,\n  {\n    processRevokeExecutionPermission,\n  }: {\n    processRevokeExecutionPermission?: ProcessRevokeExecutionPermissionHook;\n  },\n): Promise<void> {\n  if (!processRevokeExecutionPermission) {\n    throw rpcErrors.methodNotSupported(\n      'wallet_revokeExecutionPermission - no middleware configured',\n    );\n  }\n\n  const { params } = req;\n\n  validateParams(params, RevokeExecutionPermissionRequestParamsStruct);\n\n  res.result = await processRevokeExecutionPermission(params, req);\n}\n"]}

package/dist/providerAsMiddleware.cjs

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.providerAsMiddleware = void 0;
+const json_rpc_engine_1 = require("@metamask/json-rpc-engine");
+function providerAsMiddleware(provider) {
+    return (0, json_rpc_engine_1.createAsyncMiddleware)(async (req, res) => {
+        res.result = await provider.request(req);
+    });
+}
+exports.providerAsMiddleware = providerAsMiddleware;
+//# sourceMappingURL=providerAsMiddleware.cjs.map