@metamask/keyring-sdk 2.1.1 → 2.2.0

package/dist/v2/eth/eth-keyring-v1-adapter.d.cts

@@ -0,0 +1,156 @@
+import type { TypedTransaction } from "@ethereumjs/tx";
+import type { EthBaseTransaction, EthBaseUserOperation, EthUserOperation, EthUserOperationPatch, KeyringExecutionContext } from "@metamask/keyring-api";
+import type { Keyring as KeyringV2 } from "@metamask/keyring-api/v2";
+import type { BaseKeyring, EthKeyring } from "@metamask/keyring-utils";
+import type { Hex } from "@metamask/utils";
+import type { Eth4337Keyring } from "../../eth/index.cjs";
+import { KeyringV1Adapter } from "../keyring-v1-adapter.cjs";
+/**
+ * Legacy ETH keyring API surface exposed by {@link EthKeyringV1Adapter}.
+ */
+export type BaseEthKeyring = BaseKeyring & Pick<EthKeyring, 'exportAccount' | 'signMessage' | 'signEip7702Authorization' | 'signPersonalMessage' | 'signTypedData' | 'signTransaction'> & Eth4337Keyring;
+/**
+ * Error thrown when an account cannot be resolved from the requested address.
+ */
+export declare class EthKeyringV1AccountNotFoundError extends Error {
+    readonly address: string;
+    constructor(address: string);
+}
+/**
+ * Error thrown when a resolved account does not support a requested method.
+ */
+export declare class EthKeyringV1MethodNotSupportedError extends Error {
+    readonly address: string;
+    readonly method: string;
+    constructor(method: string, address: string);
+}
+/**
+ * Adapts a `KeyringV2` instance to the subset of the legacy ETH keyring API
+ * used by existing ETH export and signing flows.
+ *
+ * The adapter is account-agnostic: each method resolves the requested address
+ * against the wrapped v2 keyring's accounts, verifies that the resolved account
+ * supports the requested method, then forwards the request through the v2
+ * `submitRequest` or `exportAccount` APIs.
+ */
+export declare class EthKeyringV1Adapter<InnerKeyring extends KeyringV2 = KeyringV2> extends KeyringV1Adapter<InnerKeyring> implements BaseEthKeyring {
+    #private;
+    /**
+     * Gets the private data associated with the given address so
+     * that it may be exported.
+     *
+     * Used by the UI to export an account.
+     *
+     * @param address - Address of the account to export.
+     * @returns A promise that resolves to the exported private key.
+     * @throws {@link EthKeyringV1AccountNotFoundError} if no account matches the
+     * address.
+     */
+    exportAccount(address: Hex): Promise<string>;
+    /**
+     * Sign a transaction.
+     *
+     * @param address - Sender's address.
+     * @param transaction - Transaction.
+     * @returns A promise that resolves to the signed transaction.
+     * @throws {@link EthKeyringV1AccountNotFoundError} if no account matches the
+     * address.
+     * @throws {@link EthKeyringV1MethodNotSupportedError} if the account does
+     * not support transaction signing.
+     */
+    signTransaction(address: Hex, transaction: TypedTransaction): Promise<TypedTransaction>;
+    /**
+     * Sign a message.
+     *
+     * @param address - Signer's address.
+     * @param data - Data to sign.
+     * @returns A promise that resolves to the signature.
+     * @throws {@link EthKeyringV1AccountNotFoundError} if no account matches the
+     * address.
+     * @throws {@link EthKeyringV1MethodNotSupportedError} if the account does
+     * not support message signing.
+     */
+    signMessage(address: Hex, data: string): Promise<string>;
+    /**
+     * Sign an EIP-7702 authorization.
+     *
+     * @param address - Signer's address.
+     * @param authorization - Authorization tuple to sign.
+     * @returns A promise that resolves to the signature.
+     * @throws {@link EthKeyringV1AccountNotFoundError} if no account matches the
+     * address.
+     * @throws {@link EthKeyringV1MethodNotSupportedError} if the account does
+     * not support EIP-7702 authorization signing.
+     */
+    signEip7702Authorization(address: Hex, authorization: [chainId: number, contractAddress: Hex, nonce: number]): Promise<string>;
+    /**
+     * Sign a personal message.
+     *
+     * Note: KeyringController says this should return a Buffer but it actually
+     * expects a string.
+     *
+     * @param address - Signer's address.
+     * @param message - Data to sign.
+     * @returns A promise that resolves to the signature.
+     * @throws {@link EthKeyringV1AccountNotFoundError} if no account matches the
+     * address.
+     * @throws {@link EthKeyringV1MethodNotSupportedError} if the account does
+     * not support personal message signing.
+     */
+    signPersonalMessage(address: Hex, message: Hex): Promise<string>;
+    /**
+     * Sign a typed data message.
+     *
+     * @param address - Signer's address.
+     * @param typedData - Typed data to sign.
+     * @param options - Signing options.
+     * @param options.version - The typed data version to use.
+     * @returns A promise that resolves to the signature.
+     * @throws {@link EthKeyringV1AccountNotFoundError} if no account matches the
+     * address.
+     * @throws {@link EthKeyringV1MethodNotSupportedError} if the account does
+     * not support the requested typed data signing method.
+     */
+    signTypedData(address: Hex, typedData: unknown[] | Record<string, unknown>, options?: Record<string, unknown>): Promise<string>;
+    /**
+     * Convert base transactions to a base UserOperation.
+     *
+     * @param address - Address of the sender.
+     * @param transactions - Base transactions to include in the UserOperation.
+     * @param context - Keyring execution context.
+     * @returns A pseudo-UserOperation that can be used to construct a real one.
+     * @throws {@link EthKeyringV1AccountNotFoundError} if no account matches the
+     * address.
+     * @throws {@link EthKeyringV1MethodNotSupportedError} if the account does
+     * not support UserOperation preparation.
+     */
+    prepareUserOperation(address: string, transactions: EthBaseTransaction[], context: KeyringExecutionContext): Promise<EthBaseUserOperation>;
+    /**
+     * Patches properties of a UserOperation. Currently, only the
+     * `paymasterAndData` can be patched.
+     *
+     * @param address - Address of the sender.
+     * @param userOperation - UserOperation to patch.
+     * @param context - Keyring execution context.
+     * @returns A patch to apply to the UserOperation.
+     * @throws {@link EthKeyringV1AccountNotFoundError} if no account matches the
+     * address.
+     * @throws {@link EthKeyringV1MethodNotSupportedError} if the account does
+     * not support UserOperation patching.
+     */
+    patchUserOperation(address: string, userOperation: EthUserOperation, context: KeyringExecutionContext): Promise<EthUserOperationPatch>;
+    /**
+     * Signs a UserOperation.
+     *
+     * @param address - Address of the sender.
+     * @param userOperation - UserOperation to sign.
+     * @param context - Keyring execution context.
+     * @returns The signature of the UserOperation.
+     * @throws {@link EthKeyringV1AccountNotFoundError} if no account matches the
+     * address.
+     * @throws {@link EthKeyringV1MethodNotSupportedError} if the account does
+     * not support UserOperation signing.
+     */
+    signUserOperation(address: string, userOperation: EthUserOperation, context: KeyringExecutionContext): Promise<string>;
+}
+//# sourceMappingURL=eth-keyring-v1-adapter.d.cts.map

package/dist/v2/eth/eth-keyring-v1-adapter.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eth-keyring-v1-adapter.d.cts","sourceRoot":"","sources":["../../../src/v2/eth/eth-keyring-v1-adapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,uBAAuB;AAWvD,OAAO,KAAK,EACV,kBAAkB,EAClB,oBAAoB,EACpB,gBAAgB,EAChB,qBAAqB,EAErB,uBAAuB,EAExB,8BAA8B;AAC/B,OAAO,KAAK,EAAE,OAAO,IAAI,SAAS,EAAE,iCAAiC;AAKrE,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,gCAAgC;AAGvE,OAAO,KAAK,EAAE,GAAG,EAAQ,wBAAwB;AASjD,OAAO,KAAK,EAAE,cAAc,EAAE,4BAAkB;AAChD,OAAO,EAAE,gBAAgB,EAAE,kCAA8B;AA8CzD;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,WAAW,GAEtC,IAAI,CACF,UAAU,EACR,eAAe,GACf,aAAa,GACb,0BAA0B,GAC1B,qBAAqB,GACrB,eAAe,GACf,iBAAiB,CACpB,GACD,cAAc,CAAC;AAEjB;;GAEG;AACH,qBAAa,gCAAiC,SAAQ,KAAK;IACzD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;gBAEb,OAAO,EAAE,MAAM;CAM5B;AAED;;GAEG;AACH,qBAAa,mCAAoC,SAAQ,KAAK;IAC5D,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAEzB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;gBAEZ,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;CAO5C;AAED;;;;;;;;GAQG;AACH,qBAAa,mBAAmB,CAAC,YAAY,SAAS,SAAS,GAAG,SAAS,CACzE,SAAQ,gBAAgB,CAAC,YAAY,CACrC,YAAW,cAAc;;IAEzB;;;;;;;;;;OAUG;IACG,aAAa,CAAC,OAAO,EAAE,GAAG,GAAG,OAAO,CAAC,MAAM,CAAC;IAelD;;;;;;;;;;OAUG;IACG,eAAe,CACnB,OAAO,EAAE,GAAG,EACZ,WAAW,EAAE,gBAAgB,GAC5B,OAAO,CAAC,gBAAgB,CAAC;IAwC5B;;;;;;;;;;OAUG;IACG,WAAW,CAAC,OAAO,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAiB9D;;;;;;;;;;OAUG;IACG,wBAAwB,CAC5B,OAAO,EAAE,GAAG,EACZ,aAAa,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,eAAe,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,CAAC,GACpE,OAAO,CAAC,MAAM,CAAC;IAmBlB;;;;;;;;;;;;;OAaG;IACG,mBAAmB,CAAC,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,GAAG,GAAG,OAAO,CAAC,MAAM,CAAC;IAiBtE;;;;;;;;;;;;OAYG;IACG,aAAa,CACjB,OAAO,EAAE,GAAG,EACZ,SAAS,EAAE,OAAO,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9C,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAChC,OAAO,CAAC,MAAM,CAAC;IAuBlB;;;;;;;;;;;OAWG;IACG,oBAAoB,CACxB,OAAO,EAAE,MAAM,EACf,YAAY,EAAE,kBAAkB,EAAE,EAClC,OAAO,EAAE,uBAAuB,GAC/B,OAAO,CAAC,oBAAoB,CAAC;IAuBhC;;;;;;;;;;;;OAYG;IACG,kBAAkB,CACtB,OAAO,EAAE,MAAM,EACf,aAAa,EAAE,gBAAgB,EAC/B,OAAO,EAAE,uBAAuB,GAC/B,OAAO,CAAC,qBAAqB,CAAC;IAiBjC;;;;;;;;;;;OAWG;IACG,iBAAiB,CACrB,OAAO,EAAE,MAAM,EACf,aAAa,EAAE,gBAAgB,EAC/B,OAAO,EAAE,uBAAuB,GAC/B,OAAO,CAAC,MAAM,CAAC;CAuFnB"}

package/dist/v2/eth/eth-keyring-v1-adapter.d.mts

@@ -0,0 +1,156 @@
+import type { TypedTransaction } from "@ethereumjs/tx";
+import type { EthBaseTransaction, EthBaseUserOperation, EthUserOperation, EthUserOperationPatch, KeyringExecutionContext } from "@metamask/keyring-api";
+import type { Keyring as KeyringV2 } from "@metamask/keyring-api/v2";
+import type { BaseKeyring, EthKeyring } from "@metamask/keyring-utils";
+import type { Hex } from "@metamask/utils";
+import type { Eth4337Keyring } from "../../eth/index.mjs";
+import { KeyringV1Adapter } from "../keyring-v1-adapter.mjs";
+/**
+ * Legacy ETH keyring API surface exposed by {@link EthKeyringV1Adapter}.
+ */
+export type BaseEthKeyring = BaseKeyring & Pick<EthKeyring, 'exportAccount' | 'signMessage' | 'signEip7702Authorization' | 'signPersonalMessage' | 'signTypedData' | 'signTransaction'> & Eth4337Keyring;
+/**
+ * Error thrown when an account cannot be resolved from the requested address.
+ */
+export declare class EthKeyringV1AccountNotFoundError extends Error {
+    readonly address: string;
+    constructor(address: string);
+}
+/**
+ * Error thrown when a resolved account does not support a requested method.
+ */
+export declare class EthKeyringV1MethodNotSupportedError extends Error {
+    readonly address: string;
+    readonly method: string;
+    constructor(method: string, address: string);
+}
+/**
+ * Adapts a `KeyringV2` instance to the subset of the legacy ETH keyring API
+ * used by existing ETH export and signing flows.
+ *
+ * The adapter is account-agnostic: each method resolves the requested address
+ * against the wrapped v2 keyring's accounts, verifies that the resolved account
+ * supports the requested method, then forwards the request through the v2
+ * `submitRequest` or `exportAccount` APIs.
+ */
+export declare class EthKeyringV1Adapter<InnerKeyring extends KeyringV2 = KeyringV2> extends KeyringV1Adapter<InnerKeyring> implements BaseEthKeyring {
+    #private;
+    /**
+     * Gets the private data associated with the given address so
+     * that it may be exported.
+     *
+     * Used by the UI to export an account.
+     *
+     * @param address - Address of the account to export.
+     * @returns A promise that resolves to the exported private key.
+     * @throws {@link EthKeyringV1AccountNotFoundError} if no account matches the
+     * address.
+     */
+    exportAccount(address: Hex): Promise<string>;
+    /**
+     * Sign a transaction.
+     *
+     * @param address - Sender's address.
+     * @param transaction - Transaction.
+     * @returns A promise that resolves to the signed transaction.
+     * @throws {@link EthKeyringV1AccountNotFoundError} if no account matches the
+     * address.
+     * @throws {@link EthKeyringV1MethodNotSupportedError} if the account does
+     * not support transaction signing.
+     */
+    signTransaction(address: Hex, transaction: TypedTransaction): Promise<TypedTransaction>;
+    /**
+     * Sign a message.
+     *
+     * @param address - Signer's address.
+     * @param data - Data to sign.
+     * @returns A promise that resolves to the signature.
+     * @throws {@link EthKeyringV1AccountNotFoundError} if no account matches the
+     * address.
+     * @throws {@link EthKeyringV1MethodNotSupportedError} if the account does
+     * not support message signing.
+     */
+    signMessage(address: Hex, data: string): Promise<string>;
+    /**
+     * Sign an EIP-7702 authorization.
+     *
+     * @param address - Signer's address.
+     * @param authorization - Authorization tuple to sign.
+     * @returns A promise that resolves to the signature.
+     * @throws {@link EthKeyringV1AccountNotFoundError} if no account matches the
+     * address.
+     * @throws {@link EthKeyringV1MethodNotSupportedError} if the account does
+     * not support EIP-7702 authorization signing.
+     */
+    signEip7702Authorization(address: Hex, authorization: [chainId: number, contractAddress: Hex, nonce: number]): Promise<string>;
+    /**
+     * Sign a personal message.
+     *
+     * Note: KeyringController says this should return a Buffer but it actually
+     * expects a string.
+     *
+     * @param address - Signer's address.
+     * @param message - Data to sign.
+     * @returns A promise that resolves to the signature.
+     * @throws {@link EthKeyringV1AccountNotFoundError} if no account matches the
+     * address.
+     * @throws {@link EthKeyringV1MethodNotSupportedError} if the account does
+     * not support personal message signing.
+     */
+    signPersonalMessage(address: Hex, message: Hex): Promise<string>;
+    /**
+     * Sign a typed data message.
+     *
+     * @param address - Signer's address.
+     * @param typedData - Typed data to sign.
+     * @param options - Signing options.
+     * @param options.version - The typed data version to use.
+     * @returns A promise that resolves to the signature.
+     * @throws {@link EthKeyringV1AccountNotFoundError} if no account matches the
+     * address.
+     * @throws {@link EthKeyringV1MethodNotSupportedError} if the account does
+     * not support the requested typed data signing method.
+     */
+    signTypedData(address: Hex, typedData: unknown[] | Record<string, unknown>, options?: Record<string, unknown>): Promise<string>;
+    /**
+     * Convert base transactions to a base UserOperation.
+     *
+     * @param address - Address of the sender.
+     * @param transactions - Base transactions to include in the UserOperation.
+     * @param context - Keyring execution context.
+     * @returns A pseudo-UserOperation that can be used to construct a real one.
+     * @throws {@link EthKeyringV1AccountNotFoundError} if no account matches the
+     * address.
+     * @throws {@link EthKeyringV1MethodNotSupportedError} if the account does
+     * not support UserOperation preparation.
+     */
+    prepareUserOperation(address: string, transactions: EthBaseTransaction[], context: KeyringExecutionContext): Promise<EthBaseUserOperation>;
+    /**
+     * Patches properties of a UserOperation. Currently, only the
+     * `paymasterAndData` can be patched.
+     *
+     * @param address - Address of the sender.
+     * @param userOperation - UserOperation to patch.
+     * @param context - Keyring execution context.
+     * @returns A patch to apply to the UserOperation.
+     * @throws {@link EthKeyringV1AccountNotFoundError} if no account matches the
+     * address.
+     * @throws {@link EthKeyringV1MethodNotSupportedError} if the account does
+     * not support UserOperation patching.
+     */
+    patchUserOperation(address: string, userOperation: EthUserOperation, context: KeyringExecutionContext): Promise<EthUserOperationPatch>;
+    /**
+     * Signs a UserOperation.
+     *
+     * @param address - Address of the sender.
+     * @param userOperation - UserOperation to sign.
+     * @param context - Keyring execution context.
+     * @returns The signature of the UserOperation.
+     * @throws {@link EthKeyringV1AccountNotFoundError} if no account matches the
+     * address.
+     * @throws {@link EthKeyringV1MethodNotSupportedError} if the account does
+     * not support UserOperation signing.
+     */
+    signUserOperation(address: string, userOperation: EthUserOperation, context: KeyringExecutionContext): Promise<string>;
+}
+//# sourceMappingURL=eth-keyring-v1-adapter.d.mts.map

package/dist/v2/eth/eth-keyring-v1-adapter.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eth-keyring-v1-adapter.d.mts","sourceRoot":"","sources":["../../../src/v2/eth/eth-keyring-v1-adapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,uBAAuB;AAWvD,OAAO,KAAK,EACV,kBAAkB,EAClB,oBAAoB,EACpB,gBAAgB,EAChB,qBAAqB,EAErB,uBAAuB,EAExB,8BAA8B;AAC/B,OAAO,KAAK,EAAE,OAAO,IAAI,SAAS,EAAE,iCAAiC;AAKrE,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,gCAAgC;AAGvE,OAAO,KAAK,EAAE,GAAG,EAAQ,wBAAwB;AASjD,OAAO,KAAK,EAAE,cAAc,EAAE,4BAAkB;AAChD,OAAO,EAAE,gBAAgB,EAAE,kCAA8B;AA8CzD;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,WAAW,GAEtC,IAAI,CACF,UAAU,EACR,eAAe,GACf,aAAa,GACb,0BAA0B,GAC1B,qBAAqB,GACrB,eAAe,GACf,iBAAiB,CACpB,GACD,cAAc,CAAC;AAEjB;;GAEG;AACH,qBAAa,gCAAiC,SAAQ,KAAK;IACzD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;gBAEb,OAAO,EAAE,MAAM;CAM5B;AAED;;GAEG;AACH,qBAAa,mCAAoC,SAAQ,KAAK;IAC5D,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAEzB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;gBAEZ,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;CAO5C;AAED;;;;;;;;GAQG;AACH,qBAAa,mBAAmB,CAAC,YAAY,SAAS,SAAS,GAAG,SAAS,CACzE,SAAQ,gBAAgB,CAAC,YAAY,CACrC,YAAW,cAAc;;IAEzB;;;;;;;;;;OAUG;IACG,aAAa,CAAC,OAAO,EAAE,GAAG,GAAG,OAAO,CAAC,MAAM,CAAC;IAelD;;;;;;;;;;OAUG;IACG,eAAe,CACnB,OAAO,EAAE,GAAG,EACZ,WAAW,EAAE,gBAAgB,GAC5B,OAAO,CAAC,gBAAgB,CAAC;IAwC5B;;;;;;;;;;OAUG;IACG,WAAW,CAAC,OAAO,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAiB9D;;;;;;;;;;OAUG;IACG,wBAAwB,CAC5B,OAAO,EAAE,GAAG,EACZ,aAAa,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,eAAe,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,CAAC,GACpE,OAAO,CAAC,MAAM,CAAC;IAmBlB;;;;;;;;;;;;;OAaG;IACG,mBAAmB,CAAC,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,GAAG,GAAG,OAAO,CAAC,MAAM,CAAC;IAiBtE;;;;;;;;;;;;OAYG;IACG,aAAa,CACjB,OAAO,EAAE,GAAG,EACZ,SAAS,EAAE,OAAO,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9C,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAChC,OAAO,CAAC,MAAM,CAAC;IAuBlB;;;;;;;;;;;OAWG;IACG,oBAAoB,CACxB,OAAO,EAAE,MAAM,EACf,YAAY,EAAE,kBAAkB,EAAE,EAClC,OAAO,EAAE,uBAAuB,GAC/B,OAAO,CAAC,oBAAoB,CAAC;IAuBhC;;;;;;;;;;;;OAYG;IACG,kBAAkB,CACtB,OAAO,EAAE,MAAM,EACf,aAAa,EAAE,gBAAgB,EAC/B,OAAO,EAAE,uBAAuB,GAC/B,OAAO,CAAC,qBAAqB,CAAC;IAiBjC;;;;;;;;;;;OAWG;IACG,iBAAiB,CACrB,OAAO,EAAE,MAAM,EACf,aAAa,EAAE,gBAAgB,EAC/B,OAAO,EAAE,uBAAuB,GAC/B,OAAO,CAAC,MAAM,CAAC;CAuFnB"}

package/dist/v2/eth/eth-keyring-v1-adapter.mjs

@@ -0,0 +1,314 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _EthKeyringV1Adapter_instances, _EthKeyringV1Adapter_getAccount, _EthKeyringV1Adapter_getAccountForMethod, _EthKeyringV1Adapter_getSignTypedDataMethod, _EthKeyringV1Adapter_submitRequest;
+import { TransactionFactory } from "@ethereumjs/tx";
+import { normalize as ethNormalize } from "@metamask/eth-sig-util";
+import { EthBaseUserOperationStruct, EthBytesStrictStruct, EthBytesStruct, EthMethod, EthUserOperationPatchStruct } from "@metamask/keyring-api";
+import { AccountExportType, PrivateKeyEncoding } from "@metamask/keyring-api/v2";
+import { strictMask } from "@metamask/keyring-utils";
+import { mask, object } from "@metamask/superstruct";
+import { bigIntToHex, KnownCaipNamespace, remove0x, toCaipChainId } from "@metamask/utils";
+import { v4 as uuid } from "uuid";
+import { KeyringV1Adapter } from "../keyring-v1-adapter.mjs";
+import { EthKeyringMethod } from "./eth-keyring-wrapper.mjs";
+const METAMASK_ORIGIN = 'metamask';
+/**
+ * Convert a value to a valid JSON object.
+ *
+ * The function chains JSON.stringify and JSON.parse to ensure that the result
+ * is a valid JSON object.
+ *
+ * We assume that the input value is JSON-serializable.
+ *
+ * However, some transformations can occur like: in objects, undefined values
+ * are removed, and in arrays, they are replaced with null.
+ *
+ * @param value - Value to convert to JSON - Assumed to be JSON-serializable.
+ * @returns JSON representation of the value.
+ */
+function toJson(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+/**
+ * Convert a chain ID (number or hex) to an EIP-155 CAIP chain ID string for keyring request scoping.
+ *
+ * @param chainId - The chain ID to convert.
+ * @returns The EIP-155 CAIP chain ID string.
+ */
+function toEip155Scope(chainId) {
+    return toCaipChainId(KnownCaipNamespace.Eip155, BigInt(chainId).toString());
+}
+/**
+ * Error thrown when an account cannot be resolved from the requested address.
+ */
+export class EthKeyringV1AccountNotFoundError extends Error {
+    constructor(address) {
+        super(`Account not found for address: ${address}`);
+        this.name = 'EthKeyringV1AccountNotFoundError';
+        this.address = address;
+        Object.setPrototypeOf(this, EthKeyringV1AccountNotFoundError.prototype);
+    }
+}
+/**
+ * Error thrown when a resolved account does not support a requested method.
+ */
+export class EthKeyringV1MethodNotSupportedError extends Error {
+    constructor(method, address) {
+        super(`Account ${address} does not support method: ${method}`);
+        this.name = 'EthKeyringV1MethodNotSupportedError';
+        this.address = address;
+        this.method = method;
+        Object.setPrototypeOf(this, EthKeyringV1MethodNotSupportedError.prototype);
+    }
+}
+/**
+ * Adapts a `KeyringV2` instance to the subset of the legacy ETH keyring API
+ * used by existing ETH export and signing flows.
+ *
+ * The adapter is account-agnostic: each method resolves the requested address
+ * against the wrapped v2 keyring's accounts, verifies that the resolved account
+ * supports the requested method, then forwards the request through the v2
+ * `submitRequest` or `exportAccount` APIs.
+ */
+export class EthKeyringV1Adapter extends KeyringV1Adapter {
+    constructor() {
+        super(...arguments);
+        _EthKeyringV1Adapter_instances.add(this);
+    }
+    /**
+     * Gets the private data associated with the given address so
+     * that it may be exported.
+     *
+     * Used by the UI to export an account.
+     *
+     * @param address - Address of the account to export.
+     * @returns A promise that resolves to the exported private key.
+     * @throws {@link EthKeyringV1AccountNotFoundError} if no account matches the
+     * address.
+     */
+    async exportAccount(address) {
+        const { account } = await __classPrivateFieldGet(this, _EthKeyringV1Adapter_instances, "m", _EthKeyringV1Adapter_getAccount).call(this, address);
+        if (!this.inner.exportAccount) {
+            throw new Error('Keyring does not support exportAccount');
+        }
+        const exportedAccount = await this.inner.exportAccount(account.id, {
+            type: AccountExportType.PrivateKey,
+            encoding: PrivateKeyEncoding.Hexadecimal,
+        });
+        return remove0x(exportedAccount.privateKey);
+    }
+    /**
+     * Sign a transaction.
+     *
+     * @param address - Sender's address.
+     * @param transaction - Transaction.
+     * @returns A promise that resolves to the signed transaction.
+     * @throws {@link EthKeyringV1AccountNotFoundError} if no account matches the
+     * address.
+     * @throws {@link EthKeyringV1MethodNotSupportedError} if the account does
+     * not support transaction signing.
+     */
+    async signTransaction(address, transaction) {
+        const { account, normalizedAddress } = await __classPrivateFieldGet(this, _EthKeyringV1Adapter_instances, "m", _EthKeyringV1Adapter_getAccountForMethod).call(this, address, EthMethod.SignTransaction);
+        const chainId = transaction.common.chainId();
+        const tx = toJson({
+            ...transaction.toJSON(),
+            from: normalizedAddress,
+            type: `0x${transaction.type.toString(16)}`,
+            chainId: bigIntToHex(chainId),
+        });
+        const signedTx = await __classPrivateFieldGet(this, _EthKeyringV1Adapter_instances, "m", _EthKeyringV1Adapter_submitRequest).call(this, account, EthMethod.SignTransaction, toJson([tx]), toEip155Scope(chainId));
+        // Only take the signature fields from the keyring response. This prevents
+        // the keyring from overwriting the transaction payload we submitted.
+        const signature = mask(signedTx, object({
+            r: EthBytesStrictStruct,
+            s: EthBytesStrictStruct,
+            v: EthBytesStrictStruct,
+        }));
+        return TransactionFactory.fromTxData({
+            ...tx,
+            r: signature.r,
+            s: signature.s,
+            v: signature.v,
+        });
+    }
+    /**
+     * Sign a message.
+     *
+     * @param address - Signer's address.
+     * @param data - Data to sign.
+     * @returns A promise that resolves to the signature.
+     * @throws {@link EthKeyringV1AccountNotFoundError} if no account matches the
+     * address.
+     * @throws {@link EthKeyringV1MethodNotSupportedError} if the account does
+     * not support message signing.
+     */
+    async signMessage(address, data) {
+        const { account, normalizedAddress } = await __classPrivateFieldGet(this, _EthKeyringV1Adapter_instances, "m", _EthKeyringV1Adapter_getAccountForMethod).call(this, address, EthMethod.Sign);
+        return strictMask(await __classPrivateFieldGet(this, _EthKeyringV1Adapter_instances, "m", _EthKeyringV1Adapter_submitRequest).call(this, account, EthMethod.Sign, toJson([normalizedAddress, data]), ''), EthBytesStruct);
+    }
+    /**
+     * Sign an EIP-7702 authorization.
+     *
+     * @param address - Signer's address.
+     * @param authorization - Authorization tuple to sign.
+     * @returns A promise that resolves to the signature.
+     * @throws {@link EthKeyringV1AccountNotFoundError} if no account matches the
+     * address.
+     * @throws {@link EthKeyringV1MethodNotSupportedError} if the account does
+     * not support EIP-7702 authorization signing.
+     */
+    async signEip7702Authorization(address, authorization) {
+        const { account } = await __classPrivateFieldGet(this, _EthKeyringV1Adapter_instances, "m", _EthKeyringV1Adapter_getAccountForMethod).call(this, address, EthKeyringMethod.SignEip7702Authorization);
+        const [chainId] = authorization;
+        return strictMask(await __classPrivateFieldGet(this, _EthKeyringV1Adapter_instances, "m", _EthKeyringV1Adapter_submitRequest).call(this, account, EthKeyringMethod.SignEip7702Authorization, [authorization], toEip155Scope(chainId)), EthBytesStruct);
+    }
+    /**
+     * Sign a personal message.
+     *
+     * Note: KeyringController says this should return a Buffer but it actually
+     * expects a string.
+     *
+     * @param address - Signer's address.
+     * @param message - Data to sign.
+     * @returns A promise that resolves to the signature.
+     * @throws {@link EthKeyringV1AccountNotFoundError} if no account matches the
+     * address.
+     * @throws {@link EthKeyringV1MethodNotSupportedError} if the account does
+     * not support personal message signing.
+     */
+    async signPersonalMessage(address, message) {
+        const { account, normalizedAddress } = await __classPrivateFieldGet(this, _EthKeyringV1Adapter_instances, "m", _EthKeyringV1Adapter_getAccountForMethod).call(this, address, EthMethod.PersonalSign);
+        return strictMask(await __classPrivateFieldGet(this, _EthKeyringV1Adapter_instances, "m", _EthKeyringV1Adapter_submitRequest).call(this, account, EthMethod.PersonalSign, toJson([message, normalizedAddress]), ''), EthBytesStruct);
+    }
+    /**
+     * Sign a typed data message.
+     *
+     * @param address - Signer's address.
+     * @param typedData - Typed data to sign.
+     * @param options - Signing options.
+     * @param options.version - The typed data version to use.
+     * @returns A promise that resolves to the signature.
+     * @throws {@link EthKeyringV1AccountNotFoundError} if no account matches the
+     * address.
+     * @throws {@link EthKeyringV1MethodNotSupportedError} if the account does
+     * not support the requested typed data signing method.
+     */
+    async signTypedData(address, typedData, options) {
+        const version = options?.version;
+        const method = __classPrivateFieldGet(this, _EthKeyringV1Adapter_instances, "m", _EthKeyringV1Adapter_getSignTypedDataMethod).call(this, version);
+        const { account, normalizedAddress } = await __classPrivateFieldGet(this, _EthKeyringV1Adapter_instances, "m", _EthKeyringV1Adapter_getAccountForMethod).call(this, address, method);
+        // Extract chain ID as if it was a typed message (as defined by EIP-712), if
+        // input is not a typed message, then chain ID will be undefined!
+        const chainId = typedData.domain?.chainId;
+        return strictMask(await __classPrivateFieldGet(this, _EthKeyringV1Adapter_instances, "m", _EthKeyringV1Adapter_submitRequest).call(this, account, method, toJson([normalizedAddress, typedData]), chainId === undefined ? '' : toEip155Scope(chainId)), EthBytesStruct);
+    }
+    /**
+     * Convert base transactions to a base UserOperation.
+     *
+     * @param address - Address of the sender.
+     * @param transactions - Base transactions to include in the UserOperation.
+     * @param context - Keyring execution context.
+     * @returns A pseudo-UserOperation that can be used to construct a real one.
+     * @throws {@link EthKeyringV1AccountNotFoundError} if no account matches the
+     * address.
+     * @throws {@link EthKeyringV1MethodNotSupportedError} if the account does
+     * not support UserOperation preparation.
+     */
+    async prepareUserOperation(address, transactions, context) {
+        const { account } = await __classPrivateFieldGet(this, _EthKeyringV1Adapter_instances, "m", _EthKeyringV1Adapter_getAccountForMethod).call(this, address, EthMethod.PrepareUserOperation);
+        return strictMask(await __classPrivateFieldGet(this, _EthKeyringV1Adapter_instances, "m", _EthKeyringV1Adapter_submitRequest).call(this, account, EthMethod.PrepareUserOperation, 
+        // NOTE: This is inconsistent with the other methods. We are not wrapping `transactions` in an array.
+        // Which means the receiver of the `submitRequest` call would see individual transactions spread as
+        // separate params rather than a single transactions array as the first param, which doesn't match
+        // the method signature of `prepareUserOperation(address, transactions, context)`.
+        // This was already implemented like this in the legacy Snap keyring, so we keep the same logic here
+        // too!
+        toJson(transactions), toEip155Scope(context.chainId)), EthBaseUserOperationStruct);
+    }
+    /**
+     * Patches properties of a UserOperation. Currently, only the
+     * `paymasterAndData` can be patched.
+     *
+     * @param address - Address of the sender.
+     * @param userOperation - UserOperation to patch.
+     * @param context - Keyring execution context.
+     * @returns A patch to apply to the UserOperation.
+     * @throws {@link EthKeyringV1AccountNotFoundError} if no account matches the
+     * address.
+     * @throws {@link EthKeyringV1MethodNotSupportedError} if the account does
+     * not support UserOperation patching.
+     */
+    async patchUserOperation(address, userOperation, context) {
+        const { account } = await __classPrivateFieldGet(this, _EthKeyringV1Adapter_instances, "m", _EthKeyringV1Adapter_getAccountForMethod).call(this, address, EthMethod.PatchUserOperation);
+        return strictMask(await __classPrivateFieldGet(this, _EthKeyringV1Adapter_instances, "m", _EthKeyringV1Adapter_submitRequest).call(this, account, EthMethod.PatchUserOperation, toJson([userOperation]), toEip155Scope(context.chainId)), EthUserOperationPatchStruct);
+    }
+    /**
+     * Signs a UserOperation.
+     *
+     * @param address - Address of the sender.
+     * @param userOperation - UserOperation to sign.
+     * @param context - Keyring execution context.
+     * @returns The signature of the UserOperation.
+     * @throws {@link EthKeyringV1AccountNotFoundError} if no account matches the
+     * address.
+     * @throws {@link EthKeyringV1MethodNotSupportedError} if the account does
+     * not support UserOperation signing.
+     */
+    async signUserOperation(address, userOperation, context) {
+        const { account } = await __classPrivateFieldGet(this, _EthKeyringV1Adapter_instances, "m", _EthKeyringV1Adapter_getAccountForMethod).call(this, address, EthMethod.SignUserOperation);
+        return strictMask(await __classPrivateFieldGet(this, _EthKeyringV1Adapter_instances, "m", _EthKeyringV1Adapter_submitRequest).call(this, account, EthMethod.SignUserOperation, toJson([userOperation]), toEip155Scope(context.chainId)), EthBytesStruct);
+    }
+}
+_EthKeyringV1Adapter_instances = new WeakSet(), _EthKeyringV1Adapter_getAccount = async function _EthKeyringV1Adapter_getAccount(address) {
+    const normalizedAddress = ethNormalize(address);
+    const normalizedAddressLowerCase = normalizedAddress?.toLowerCase();
+    if (!normalizedAddress || !normalizedAddressLowerCase) {
+        throw new EthKeyringV1AccountNotFoundError(address);
+    }
+    const accounts = await this.inner.getAccounts();
+    const account = accounts.find((keyringAccount) => {
+        const accountAddress = ethNormalize(keyringAccount.address);
+        return accountAddress?.toLowerCase() === normalizedAddressLowerCase;
+    });
+    if (!account) {
+        throw new EthKeyringV1AccountNotFoundError(address);
+    }
+    return {
+        account,
+        normalizedAddress: normalizedAddress,
+    };
+}, _EthKeyringV1Adapter_getAccountForMethod = async function _EthKeyringV1Adapter_getAccountForMethod(address, method) {
+    const resolvedAccount = await __classPrivateFieldGet(this, _EthKeyringV1Adapter_instances, "m", _EthKeyringV1Adapter_getAccount).call(this, address);
+    if (!resolvedAccount.account.methods.includes(method)) {
+        throw new EthKeyringV1MethodNotSupportedError(method, address);
+    }
+    return resolvedAccount;
+}, _EthKeyringV1Adapter_getSignTypedDataMethod = function _EthKeyringV1Adapter_getSignTypedDataMethod(version) {
+    switch (version) {
+        case 'V3':
+            return EthMethod.SignTypedDataV3;
+        case 'V4':
+            return EthMethod.SignTypedDataV4;
+        case 'V1':
+        default:
+            // Use 'V1' by default to match other keyring implementations. V1 will be
+            // used if the version is not specified or not supported.
+            return EthMethod.SignTypedDataV1;
+    }
+}, _EthKeyringV1Adapter_submitRequest = async function _EthKeyringV1Adapter_submitRequest(account, method, params, scope) {
+    return (await this.inner.submitRequest({
+        id: uuid(),
+        origin: METAMASK_ORIGIN,
+        scope,
+        account: account.id,
+        request: {
+            method,
+            params,
+        },
+    }));
+};
+//# sourceMappingURL=eth-keyring-v1-adapter.mjs.map