{"version":3,"file":"KeyringController-method-action-types.cjs","sourceRoot":"","sources":["../src/KeyringController-method-action-types.ts"],"names":[],"mappings":";AAAA;;;GAGG","sourcesContent":["/**\n * This file is auto generated.\n * Do not edit manually.\n */\n\nimport type { KeyringController } from './KeyringController';\n\n/**\n * Adds a new account to the default (first) HD seed phrase keyring.\n *\n * @param accountCount - Number of accounts before adding a new one, used to\n * make the method idempotent.\n * @returns Promise resolving to the added account address.\n */\nexport type KeyringControllerAddNewAccountAction = {\n  type: `KeyringController:addNewAccount`;\n  handler: KeyringController['addNewAccount'];\n};\n\n/**\n * Effectively the same as creating a new keychain then populating it\n * using the given seed phrase.\n *\n * @param password - Password to unlock keychain.\n * @param seed - A BIP39-compliant seed phrase as Uint8Array,\n * either as a string or an array of UTF-8 bytes that represent the string.\n * @returns Promise resolving when the operation ends successfully.\n */\nexport type KeyringControllerCreateNewVaultAndRestoreAction = {\n  type: `KeyringController:createNewVaultAndRestore`;\n  handler: KeyringController['createNewVaultAndRestore'];\n};\n\n/**\n * Create a new vault and primary keyring.\n *\n * This only works if keyrings are empty. If there is a pre-existing unlocked vault, calling this will have no effect.\n * If there is a pre-existing locked vault, it will be replaced.\n *\n * @param password - Password to unlock the new vault.\n * @returns Promise resolving when the operation ends successfully.\n */\nexport type KeyringControllerCreateNewVaultAndKeychainAction = {\n  type: `KeyringController:createNewVaultAndKeychain`;\n  handler: KeyringController['createNewVaultAndKeychain'];\n};\n\n/**\n * Adds a new keyring of the given `type`.\n *\n * @param type - Keyring type name.\n * @param opts - Keyring options.\n * @throws If a builder for the given `type` does not exist.\n * @returns Promise resolving to the new keyring metadata.\n */\nexport type KeyringControllerAddNewKeyringAction = {\n  type: `KeyringController:addNewKeyring`;\n  handler: KeyringController['addNewKeyring'];\n};\n\n/**\n * Method to verify a given password validity. Throws an\n * error if the password is invalid.\n *\n * @param password - Password of the keyring.\n */\nexport type KeyringControllerVerifyPasswordAction = {\n  type: `KeyringController:verifyPassword`;\n  handler: KeyringController['verifyPassword'];\n};\n\n/**\n * Returns the status of the vault.\n *\n * @returns Boolean returning true if the vault is unlocked.\n */\nexport type KeyringControllerIsUnlockedAction = {\n  type: `KeyringController:isUnlocked`;\n  handler: KeyringController['isUnlocked'];\n};\n\n/**\n * Gets the seed phrase of the HD keyring.\n *\n * @param credentials - Object holding either the `password` or the vault\n * `encryptionKey`.\n * @param keyringId - The id of the keyring.\n * @returns Promise resolving to the seed phrase.\n */\nexport type KeyringControllerExportSeedPhraseAction = {\n  type: `KeyringController:exportSeedPhrase`;\n  handler: KeyringController['exportSeedPhrase'];\n};\n\n/**\n * Gets the private key from the keyring controlling an address.\n *\n * @param credentials - Object holding either the `password` or the vault\n * `encryptionKey`.\n * @param address - Address to export.\n * @returns Promise resolving to the private key for an address.\n */\nexport type KeyringControllerExportAccountAction = {\n  type: `KeyringController:exportAccount`;\n  handler: KeyringController['exportAccount'];\n};\n\n/**\n * Returns the public addresses of all accounts from every keyring.\n *\n * @returns A promise resolving to an array of addresses.\n */\nexport type KeyringControllerGetAccountsAction = {\n  type: `KeyringController:getAccounts`;\n  handler: KeyringController['getAccounts'];\n};\n\n/**\n * Get encryption public key.\n *\n * @param account - An account address.\n * @param opts - Additional encryption options.\n * @throws If the `account` does not exist or does not support the `getEncryptionPublicKey` method\n * @returns Promise resolving to encyption public key of the `account` if one exists.\n */\nexport type KeyringControllerGetEncryptionPublicKeyAction = {\n  type: `KeyringController:getEncryptionPublicKey`;\n  handler: KeyringController['getEncryptionPublicKey'];\n};\n\n/**\n * Attempts to decrypt the provided message parameters.\n *\n * @param messageParams - The decryption message parameters.\n * @param messageParams.from - The address of the account you want to use to decrypt the message.\n * @param messageParams.data - The encrypted data that you want to decrypt.\n * @returns The raw decryption result.\n */\nexport type KeyringControllerDecryptMessageAction = {\n  type: `KeyringController:decryptMessage`;\n  handler: KeyringController['decryptMessage'];\n};\n\n/**\n * Returns the currently initialized keyring that manages\n * the specified `address` if one exists.\n *\n * @deprecated Use of this method is discouraged as actions executed directly on\n * keyrings are not being reflected in the KeyringController state and not\n * persisted in the vault. Use `withKeyring` instead.\n * @param account - An account address.\n * @returns Promise resolving to keyring of the `account` if one exists.\n */\nexport type KeyringControllerGetKeyringForAccountAction = {\n  type: `KeyringController:getKeyringForAccount`;\n  handler: KeyringController['getKeyringForAccount'];\n};\n\n/**\n * Returns all keyrings of the given type.\n *\n * @deprecated Use of this method is discouraged as actions executed directly on\n * keyrings are not being reflected in the KeyringController state and not\n * persisted in the vault. Use `withKeyring` instead.\n * @param type - Keyring type name.\n * @returns An array of keyrings of the given type.\n */\nexport type KeyringControllerGetKeyringsByTypeAction = {\n  type: `KeyringController:getKeyringsByType`;\n  handler: KeyringController['getKeyringsByType'];\n};\n\n/**\n * Persist all serialized keyrings in the vault.\n *\n * @deprecated This method is being phased out in favor of `withKeyring`.\n * @returns Promise resolving with `true` value when the\n * operation completes.\n */\nexport type KeyringControllerPersistAllKeyringsAction = {\n  type: `KeyringController:persistAllKeyrings`;\n  handler: KeyringController['persistAllKeyrings'];\n};\n\n/**\n * Imports an account with the specified import strategy.\n *\n * @param strategy - Import strategy name.\n * @param args - Array of arguments to pass to the underlying stategy.\n * @throws Will throw when passed an unrecognized strategy.\n * @returns Promise resolving to the imported account address.\n */\nexport type KeyringControllerImportAccountWithStrategyAction = {\n  type: `KeyringController:importAccountWithStrategy`;\n  handler: KeyringController['importAccountWithStrategy'];\n};\n\n/**\n * Removes an account from keyring state.\n *\n * @param address - Address of the account to remove.\n * @fires KeyringController:accountRemoved\n * @returns Promise resolving when the account is removed.\n */\nexport type KeyringControllerRemoveAccountAction = {\n  type: `KeyringController:removeAccount`;\n  handler: KeyringController['removeAccount'];\n};\n\n/**\n * Deallocates all secrets and locks the wallet.\n *\n * @returns Promise resolving when the operation completes.\n */\nexport type KeyringControllerSetLockedAction = {\n  type: `KeyringController:setLocked`;\n  handler: KeyringController['setLocked'];\n};\n\n/**\n * Signs message by calling down into a specific keyring.\n *\n * @param messageParams - PersonalMessageParams object to sign.\n * @returns Promise resolving to a signed message string.\n */\nexport type KeyringControllerSignMessageAction = {\n  type: `KeyringController:signMessage`;\n  handler: KeyringController['signMessage'];\n};\n\n/**\n * Signs EIP-7702 Authorization message by calling down into a specific keyring.\n *\n * @param params - EIP7702AuthorizationParams object to sign.\n * @returns Promise resolving to an EIP-7702 Authorization signature.\n * @throws Will throw UnsupportedSignEIP7702Authorization if the keyring does not support signing EIP-7702 Authorization messages.\n */\nexport type KeyringControllerSignEip7702AuthorizationAction = {\n  type: `KeyringController:signEip7702Authorization`;\n  handler: KeyringController['signEip7702Authorization'];\n};\n\n/**\n * Signs personal message by calling down into a specific keyring.\n *\n * @param messageParams - PersonalMessageParams object to sign.\n * @returns Promise resolving to a signed message string.\n */\nexport type KeyringControllerSignPersonalMessageAction = {\n  type: `KeyringController:signPersonalMessage`;\n  handler: KeyringController['signPersonalMessage'];\n};\n\n/**\n * Signs typed message by calling down into a specific keyring.\n *\n * @param messageParams - TypedMessageParams object to sign.\n * @param version - Compatibility version EIP712.\n * @throws Will throw when passed an unrecognized version.\n * @returns Promise resolving to a signed message string or an error if any.\n */\nexport type KeyringControllerSignTypedMessageAction = {\n  type: `KeyringController:signTypedMessage`;\n  handler: KeyringController['signTypedMessage'];\n};\n\n/**\n * Signs a transaction by calling down into a specific keyring.\n *\n * @param transaction - Transaction object to sign. Must be a `ethereumjs-tx` transaction instance.\n * @param from - Address to sign from, should be in keychain.\n * @param opts - An optional options object.\n * @returns Promise resolving to a signed transaction string.\n */\nexport type KeyringControllerSignTransactionAction = {\n  type: `KeyringController:signTransaction`;\n  handler: KeyringController['signTransaction'];\n};\n\n/**\n * Convert a base transaction to a base UserOperation.\n *\n * @param from - Address of the sender.\n * @param transactions - Base transactions to include in the UserOperation.\n * @param executionContext - The execution context to use for the UserOperation.\n * @returns A pseudo-UserOperation that can be used to construct a real.\n */\nexport type KeyringControllerPrepareUserOperationAction = {\n  type: `KeyringController:prepareUserOperation`;\n  handler: KeyringController['prepareUserOperation'];\n};\n\n/**\n * Patches properties of a UserOperation. Currently, only the\n * `paymasterAndData` can be patched.\n *\n * @param from - Address of the sender.\n * @param userOp - UserOperation to patch.\n * @param executionContext - The execution context to use for the UserOperation.\n * @returns A patch to apply to the UserOperation.\n */\nexport type KeyringControllerPatchUserOperationAction = {\n  type: `KeyringController:patchUserOperation`;\n  handler: KeyringController['patchUserOperation'];\n};\n\n/**\n * Signs an UserOperation.\n *\n * @param from - Address of the sender.\n * @param userOp - UserOperation to sign.\n * @param executionContext - The execution context to use for the UserOperation.\n * @returns The signature of the UserOperation.\n */\nexport type KeyringControllerSignUserOperationAction = {\n  type: `KeyringController:signUserOperation`;\n  handler: KeyringController['signUserOperation'];\n};\n\n/**\n * Changes the password used to encrypt the vault.\n *\n * @param password - The new password.\n * @returns Promise resolving when the operation completes.\n */\nexport type KeyringControllerChangePasswordAction = {\n  type: `KeyringController:changePassword`;\n  handler: KeyringController['changePassword'];\n};\n\n/**\n * Attempts to decrypt the current vault and load its keyrings, using the\n * given encryption key and salt. The optional salt can be used to check for\n * consistency with the vault salt.\n *\n * @param encryptionKey - Key to unlock the keychain.\n * @param encryptionSalt - Optional salt to unlock the keychain.\n * @returns Promise resolving when the operation completes.\n */\nexport type KeyringControllerSubmitEncryptionKeyAction = {\n  type: `KeyringController:submitEncryptionKey`;\n  handler: KeyringController['submitEncryptionKey'];\n};\n\n/**\n * Exports the vault encryption key.\n *\n * @returns The vault encryption key.\n */\nexport type KeyringControllerExportEncryptionKeyAction = {\n  type: `KeyringController:exportEncryptionKey`;\n  handler: KeyringController['exportEncryptionKey'];\n};\n\n/**\n * Attempts to decrypt the current vault and load its keyrings,\n * using the given password.\n *\n * @param password - Password to unlock the keychain.\n * @returns Promise resolving when the operation completes.\n */\nexport type KeyringControllerSubmitPasswordAction = {\n  type: `KeyringController:submitPassword`;\n  handler: KeyringController['submitPassword'];\n};\n\n/**\n * Select a keyring and execute the given operation with\n * the selected keyring, as a mutually exclusive atomic\n * operation.\n *\n * The method automatically persists changes at the end of the\n * function execution, or rolls back the changes if an error\n * is thrown.\n *\n * @param selector - Keyring selector object.\n * @param operation - Function to execute with the selected keyring.\n * @param options - Additional options.\n * @param options.createIfMissing - Whether to create a new keyring if the selected one is missing.\n * @param options.createWithData - Optional data to use when creating a new keyring.\n * @returns Promise resolving to the result of the function execution.\n * @template SelectedKeyring - The type of the selected keyring.\n * @template CallbackResult - The type of the value resolved by the callback function.\n * @deprecated This method overload is deprecated. Use `withKeyring` without options instead.\n */\nexport type KeyringControllerWithKeyringAction = {\n  type: `KeyringController:withKeyring`;\n  handler: KeyringController['withKeyring'];\n};\n\n/**\n * Select a keyring and execute the given operation with the selected\n * keyring, **without** acquiring the controller's mutual exclusion lock.\n *\n * ## When to use this method\n *\n * This method is an escape hatch for read-only access to keyring data that\n * is immutable once the keyring is initialized. A typical safe use case is\n * reading the `mnemonic` from an `HdKeyring`: the mnemonic is set during\n * `deserialize()` and never mutated afterwards, so it can safely be read\n * without holding the lock.\n *\n * ## Why it is \"unsafe\"\n *\n * The \"unsafe\" designation mirrors the semantics of `unsafe { }` blocks in\n * Rust: the method itself does not enforce thread-safety guarantees. By\n * calling this method the **caller** explicitly takes responsibility for\n * ensuring that:\n *\n * - The operation is **read-only** — no state is mutated.\n * - The data being read is **immutable** after the keyring is initialized,\n * so concurrent locked operations cannot alter it while this callback\n * runs.\n *\n * Do **not** use this method to:\n * - Mutate keyring state (add accounts, sign, etc.) — use `withKeyring`.\n * - Read mutable fields that could change during concurrent operations.\n *\n * @param selector - Keyring selector object.\n * @param operation - Read-only function to execute with the selected keyring.\n * @returns Promise resolving to the result of the function execution.\n * @template SelectedKeyring - The type of the selected keyring.\n * @template CallbackResult - The type of the value resolved by the callback function.\n */\nexport type KeyringControllerWithKeyringUnsafeAction = {\n  type: `KeyringController:withKeyringUnsafe`;\n  handler: KeyringController['withKeyringUnsafe'];\n};\n\n/**\n * Select a keyring using its `KeyringV2` adapter, and execute\n * the given operation with the wrapped keyring as a mutually\n * exclusive atomic operation.\n *\n * The cached `KeyringV2` adapter is retrieved from the keyring\n * entry.\n *\n * A `KeyringV2Builder` for the selected keyring's type must exist\n * (either as a default or registered via the `keyringV2Builders`\n * constructor option); otherwise an error is thrown.\n *\n * The method automatically persists changes at the end of the\n * function execution, or rolls back the changes if an error\n * is thrown.\n *\n * @param selector - Keyring selector object.\n * @param operation - Function to execute with the wrapped V2 keyring.\n * @returns Promise resolving to the result of the function execution.\n * @template CallbackResult - The type of the value resolved by the callback function.\n */\nexport type KeyringControllerWithKeyringV2Action = {\n  type: `KeyringController:withKeyringV2`;\n  handler: KeyringController['withKeyringV2'];\n};\n\n/**\n * Select a keyring, wrap it in a `KeyringV2` adapter, and execute\n * the given read-only operation **without** acquiring the controller's\n * mutual exclusion lock.\n *\n * ## When to use this method\n *\n * This method is an escape hatch for read-only access to keyring data that\n * is immutable once the keyring is initialized. A typical safe use case is\n * reading immutable fields from a `KeyringV2` adapter: data that is set\n * during initialization and never mutated afterwards.\n *\n * ## Why it is \"unsafe\"\n *\n * The \"unsafe\" designation mirrors the semantics of `unsafe { }` blocks in\n * Rust: the method itself does not enforce thread-safety guarantees. By\n * calling this method the **caller** explicitly takes responsibility for\n * ensuring that:\n *\n * - The operation is **read-only** — no state is mutated.\n * - The data being read is **immutable** after the keyring is initialized,\n * so concurrent locked operations cannot alter it while this callback\n * runs.\n *\n * Do **not** use this method to:\n * - Mutate keyring state (add accounts, sign, etc.) — use `withKeyringV2`.\n * - Read mutable fields that could change during concurrent operations.\n *\n * @param selector - Keyring selector object.\n * @param operation - Read-only function to execute with the wrapped V2 keyring.\n * @returns Promise resolving to the result of the function execution.\n * @template SelectedKeyring - The type of the selected V2 keyring.\n * @template CallbackResult - The type of the value resolved by the callback function.\n */\nexport type KeyringControllerWithKeyringV2UnsafeAction = {\n  type: `KeyringController:withKeyringV2Unsafe`;\n  handler: KeyringController['withKeyringV2Unsafe'];\n};\n\n/**\n * Execute an operation against all keyrings as a mutually exclusive atomic\n * operation. The operation receives a {@link RestrictedController} instance\n * that exposes a read-only live view of all keyrings as well as\n * `addNewKeyring` and `removeKeyring` methods to stage mutations.\n *\n * The method automatically persists changes at the end of the function\n * execution, or rolls back the changes if an error is thrown.\n *\n * @param operation - Function to execute with the restricted controller.\n * @returns Promise resolving to the result of the function execution.\n * @template CallbackResult - The type of the value resolved by the callback function.\n */\nexport type KeyringControllerWithControllerAction = {\n  type: `KeyringController:withController`;\n  handler: KeyringController['withController'];\n};\n\n/**\n * Gets the type of the keyring that manages the specified account.\n *\n * @param account - The account address to look up.\n * @returns A promise that resolves to the type of the keyring managing the account.\n */\nexport type KeyringControllerGetAccountKeyringTypeAction = {\n  type: `KeyringController:getAccountKeyringType`;\n  handler: KeyringController['getAccountKeyringType'];\n};\n\n/**\n * Union of all KeyringController action types.\n */\nexport type KeyringControllerMethodActions =\n  | KeyringControllerAddNewAccountAction\n  | KeyringControllerCreateNewVaultAndRestoreAction\n  | KeyringControllerCreateNewVaultAndKeychainAction\n  | KeyringControllerAddNewKeyringAction\n  | KeyringControllerVerifyPasswordAction\n  | KeyringControllerIsUnlockedAction\n  | KeyringControllerExportSeedPhraseAction\n  | KeyringControllerExportAccountAction\n  | KeyringControllerGetAccountsAction\n  | KeyringControllerGetEncryptionPublicKeyAction\n  | KeyringControllerDecryptMessageAction\n  | KeyringControllerGetKeyringForAccountAction\n  | KeyringControllerGetKeyringsByTypeAction\n  | KeyringControllerPersistAllKeyringsAction\n  | KeyringControllerImportAccountWithStrategyAction\n  | KeyringControllerRemoveAccountAction\n  | KeyringControllerSetLockedAction\n  | KeyringControllerSignMessageAction\n  | KeyringControllerSignEip7702AuthorizationAction\n  | KeyringControllerSignPersonalMessageAction\n  | KeyringControllerSignTypedMessageAction\n  | KeyringControllerSignTransactionAction\n  | KeyringControllerPrepareUserOperationAction\n  | KeyringControllerPatchUserOperationAction\n  | KeyringControllerSignUserOperationAction\n  | KeyringControllerChangePasswordAction\n  | KeyringControllerSubmitEncryptionKeyAction\n  | KeyringControllerExportEncryptionKeyAction\n  | KeyringControllerSubmitPasswordAction\n  | KeyringControllerWithKeyringAction\n  | KeyringControllerWithKeyringUnsafeAction\n  | KeyringControllerWithKeyringV2Action\n  | KeyringControllerWithKeyringV2UnsafeAction\n  | KeyringControllerWithControllerAction\n  | KeyringControllerGetAccountKeyringTypeAction;\n"]}