@metamask-previews/utils 11.12.1-preview-9962b7e

package/dist/keyring.d.ts

@@ -0,0 +1,243 @@
+import type { TypedTransaction, LegacyTxData } from '@ethereumjs/tx';
+import type { Eip1024EncryptedData } from './encryption-types.js';
+import type { Hex } from './hex.js';
+import type { Json } from './json.js';
+/**
+ * A Keyring class.
+ *
+ * This type is used to validate the constructor signature and the `type`
+ * static property on Keyring classes. See the {@link Keyring} type for more
+ * information.
+ *
+ * @deprecated This type has been moved to the `@metamask/keyring-utils` package.
+ * See {@link https://github.com/MetaMask/accounts/tree/main/packages/keyring-utils Keyring Utils}.
+ */
+export type KeyringClass<State extends Json> = {
+    /**
+     * The Keyring constructor. Takes a single parameter, an "options" object.
+     * See the documentation for the specific keyring for more information about
+     * what these options are.
+     *
+     * @param options - The constructor options. Differs between keyring
+     * implementations.
+     */
+    new (options?: Record<string, unknown>): Keyring<State>;
+    /**
+     * The name of this type of keyring. This must uniquely identify the
+     * keyring type.
+     */
+    type: string;
+};
+/**
+ * A keyring is something that can sign messages. Keyrings are used to add new
+ * signing strategies; each strategy is a new keyring.
+ *
+ * Each keyring manages a collection of key pairs, which we call "accounts".
+ * Each account is referred to by its "address", which is a unique identifier
+ * derived from the public key. The address is always a "0x"-prefixed
+ * hexidecimal string.
+ *
+ * The keyring might store the private key for each account as well, but it's
+ * not guaranteed. Some keyrings delegate signing, so they don't need the
+ * private key directly. The keyring (and in particular the keyring state)
+ * should be treated with care though, just in case it does contain sensitive
+ * material such as a private key.
+ *
+ * @deprecated This type has been moved to the `@metamask/keyring-utils` package.
+ * See {@link https://github.com/MetaMask/accounts/tree/main/packages/keyring-utils Keyring Utils}.
+ */
+export type Keyring<State extends Json> = {
+    /**
+     * The name of this type of keyring. This must match the `type` property of
+     * the keyring class.
+     */
+    type: string;
+    /**
+     * Get the addresses for all accounts in this keyring.
+     *
+     * @returns A list of the account addresses for this keyring
+     */
+    getAccounts(): Promise<Hex[]>;
+    /**
+     * Add an account to the keyring.
+     *
+     * @param number - The number of accounts to add. Usually defaults to 1.
+     * @returns A list of the newly added account addresses.
+     */
+    addAccounts(number: number): Promise<Hex[]>;
+    /**
+     * Serialize the keyring state as a JSON-serializable object.
+     *
+     * @returns A JSON-serializable representation of the keyring state.
+     */
+    serialize(): Promise<State>;
+    /**
+     * Deserialize the given keyring state, overwriting any existing state with
+     * the serialized state provided.
+     *
+     * @param state - A JSON-serializable representation of the keyring state.
+     */
+    deserialize(state: State): Promise<void>;
+    /**
+     * Method to include asynchronous configuration.
+     */
+    init?(): Promise<void>;
+    /**
+     * Remove an account from the keyring.
+     *
+     * @param address - The address of the account to remove.
+     */
+    removeAccount?(address: Hex): void;
+    /**
+     * Export the private key for one of the keyring accounts.
+     *
+     * Some keyrings accept an "options" parameter as well. See the documentation
+     * for the specific keyring for more information about what these options
+     * are. For some keyrings, the options parameter is used to allow exporting a
+     * private key that is derived from the given account, rather than exporting
+     * that account's private key directly.
+     *
+     * @param address - The address of the account to export.
+     * @param options - Export options; differs between keyrings.
+     * @returns The non-prefixed, hex-encoded private key that was requested.
+     */
+    exportAccount?(address: Hex, options?: Record<string, unknown>): Promise<string>;
+    /**
+     * Get the "app key" address for the given account and origin. An app key is
+     * an application-specific key pair. See {@link https://eips.ethereum.org/EIPS/eip-1775|EIP-1775}
+     * for more information. The {@link https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Origin|origin}
+     * is used as the unique identifier for the application, and it's used as
+     * part of the key derivation process.
+     *
+     * @param address - The address of the account the app key is derived from.
+     * @param origin - The origin of the application.
+     * @returns The address of the app key for the given account and origin.
+     */
+    getAppKeyAddress?(address: Hex, origin: string): Promise<Hex>;
+    /**
+     * Sign a transaction. This is equivalent to the `eth_signTransaction`
+     * Ethereum JSON-RPC method. See the Ethereum JSON-RPC API documentation for
+     * more details.
+     *
+     * Some keyrings accept an "options" parameter as well. See the documentation
+     * for the specific keyring for more information about what these options
+     * are. For some keyrings, the options parameter can even change which key is
+     * used for signing (e.g. signing with app keys).
+     *
+     * @param address - The address of the account to use for signing.
+     * @param transaction - The transaction to sign.
+     * @param options - Signing options; differs between keyrings.
+     * @returns The signed transaction.
+     */
+    signTransaction?(address: Hex, transaction: TypedTransaction, options?: Record<string, unknown>): Promise<LegacyTxData>;
+    /**
+     * Sign a message. This is equivalent to an older version of the the
+     * `eth_sign` Ethereum JSON-RPC method. The message is signed using ECDSA,
+     * using the curve secp256k1 the Keccak-256 hash function.
+     *
+     * For more information about this method and why we still support it, see
+     * the {@link https://docs.metamask.io/guide/signing-data.html|MetaMask Docs}.
+     *
+     * Some keyrings accept an "options" parameter as well. See the documentation
+     * for the specific keyring for more information about what these options
+     * are. For some keyrings, the options parameter can even change which key is
+     * used for signing (e.g. signing with app keys).
+     *
+     * @param address - The address of the account to use for signing.
+     * @param message - The message to sign.
+     * @param options - Signing options; differs between keyrings.
+     * @returns The signed message.
+     */
+    signMessage?(address: Hex, message: string, options?: Record<string, unknown>): Promise<string>;
+    /**
+     * Sign an EIP-7702 authorization. This is a signing method for authorizing a
+     * specific contract on a specific chain.
+     *
+     * @param address - The address of the account to use for signing.
+     * @param authorization - An array containing the chain ID, contract address,
+     * and nonce.
+     * @param options - Signing options; differs between keyrings.
+     * @returns The signed authorization as a hex string.
+     */
+    signEip7702Authorization?(address: Hex, authorization: [chainId: number, contractAddress: Hex, nonce: number], options?: Record<string, unknown>): Promise<string>;
+    /**
+     * Sign a message. This is equivalent to the `eth_sign` Ethereum JSON-RPC
+     * method, which is exposed by MetaMask as the method `personal_sign`. See
+     * the Ethereum JSON-RPC API documentation for more details.
+     *
+     * For more information about this method and why we call it `personal_sign`,
+     * see the {@link https://docs.metamask.io/guide/signing-data.html|MetaMask Docs}.
+     *
+     * Some keyrings accept an "options" parameter as well. See the documentation
+     * for the specific keyring for more information about what these options
+     * are. For some keyrings, the options parameter can even change which key is
+     * used for signing (e.g. signing with app keys).
+     *
+     * @param address - The address of the account to use for signing.
+     * @param message - The message to sign.
+     * @param options - Signing options; differs between keyrings.
+     * @returns The signed message.
+     */
+    signPersonalMessage?(address: Hex, message: Hex, options?: {
+        version?: string;
+    } & Record<string, unknown>): Promise<string>;
+    /**
+     * Sign a message. This is equivalent to the `eth_signTypedData` Ethereum
+     * JSON-RPC method. See {@link https://github.com/ethereum/EIPs/blob/master/EIPS/eip-712.md|EIP-712}
+     * for more details.
+     *
+     * The "version" option dictates which version of `eth_signTypedData` is
+     * used. The latest version reflects the specification most closely, whereas
+     * earlier versions reflect earlier drafts of the specification that are
+     * still supported for backwards-compatibility reasons. For more information
+     * about why we support multiple versions, see the {@link https://docs.metamask.io/guide/signing-data.html|MetaMask Docs}.
+     *
+     * Some keyrings accept additional options as well. See the documentation for
+     * the specific keyring for more information about what these options are.
+     * For some keyrings, the options parameter can even change which key is used
+     * for signing (e.g. signing with app keys).
+     *
+     * @param address - The address of the account to use for signing.
+     * @param typedData - The data to sign.
+     * @param options - Signing options; differs between keyrings.
+     * @returns The signed message.
+     */
+    signTypedData?(address: Hex, typedData: Record<string, unknown>, options?: Record<string, unknown>): Promise<string>;
+    /**
+     * Get a public key to use for encryption. This is equivalent to the
+     * ` eth_getEncryptionPublicKey` JSON-RPC method. See the {@link https://docs.metamask.io/guide/rpc-api.html#eth-getencryptionpublickey|MetaMask Docs}
+     * for more information.
+     *
+     * Some keyrings accept an "options" parameter as well. See the documentation
+     * for the specific keyring for more information about what these options
+     * are. For some keyrings, the options parameter can even change which key is
+     * used (e.g. encrypting with app keys).
+     *
+     * @param account - The address of the account you want the encryption key for.
+     * @param options - Options; differs between keyrings.
+     */
+    getEncryptionPublicKey?(account: Hex, options?: Record<string, unknown>): Promise<string>;
+    /**
+     * Decrypt an encrypted message. This is equivalent to the `  eth_decrypt`
+     * JSON-RPC method. See the {@link https://docs.metamask.io/guide/rpc-api.html#eth-decrypt|MetaMask Docs}
+     * for more information.
+     *
+     * @param account - The address of the account you want to use to decrypt
+     * the message.
+     * @param encryptedData - The encrypted data that you want to decrypt.
+     * @returns The decrypted data.
+     */
+    decryptMessage?(account: Hex, encryptedData: Eip1024EncryptedData): Promise<string>;
+    /**
+     * Generates the properties for the keyring based on the given
+     * BIP39-compliant mnemonic.
+     *
+     * @returns A promise resolving when the keyring has generated the properties.
+     */
+    generateRandomMnemonic?(): Promise<void>;
+    /**
+     * Destroy the keyring.
+     */
+    destroy?(): Promise<void>;
+};
+//# sourceMappingURL=keyring.d.ts.map

package/dist/keyring.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyring.d.ts","sourceRoot":"","sources":["../src/keyring.ts"],"names":[],"mappings":"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"}

package/dist/keyring.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=keyring.js.map

package/dist/keyring.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyring.js","sourceRoot":"","sources":["../src/keyring.ts"],"names":[],"mappings":"","sourcesContent":["import type { TypedTransaction, LegacyTxData } from '@ethereumjs/tx';\n\nimport type { Eip1024EncryptedData } from './encryption-types.js';\nimport type { Hex } from './hex.js';\nimport type { Json } from './json.js';\n\n/**\n * A Keyring class.\n *\n * This type is used to validate the constructor signature and the `type`\n * static property on Keyring classes. See the {@link Keyring} type for more\n * information.\n *\n * @deprecated This type has been moved to the `@metamask/keyring-utils` package.\n * See {@link https://github.com/MetaMask/accounts/tree/main/packages/keyring-utils Keyring Utils}.\n */\nexport type KeyringClass<State extends Json> = {\n  /**\n   * The Keyring constructor. Takes a single parameter, an \"options\" object.\n   * See the documentation for the specific keyring for more information about\n   * what these options are.\n   *\n   * @param options - The constructor options. Differs between keyring\n   * implementations.\n   */\n  new (options?: Record<string, unknown>): Keyring<State>;\n\n  /**\n   * The name of this type of keyring. This must uniquely identify the\n   * keyring type.\n   */\n  type: string;\n};\n\n/**\n * A keyring is something that can sign messages. Keyrings are used to add new\n * signing strategies; each strategy is a new keyring.\n *\n * Each keyring manages a collection of key pairs, which we call \"accounts\".\n * Each account is referred to by its \"address\", which is a unique identifier\n * derived from the public key. The address is always a \"0x\"-prefixed\n * hexidecimal string.\n *\n * The keyring might store the private key for each account as well, but it's\n * not guaranteed. Some keyrings delegate signing, so they don't need the\n * private key directly. The keyring (and in particular the keyring state)\n * should be treated with care though, just in case it does contain sensitive\n * material such as a private key.\n *\n * @deprecated This type has been moved to the `@metamask/keyring-utils` package.\n * See {@link https://github.com/MetaMask/accounts/tree/main/packages/keyring-utils Keyring Utils}.\n */\nexport type Keyring<State extends Json> = {\n  /**\n   * The name of this type of keyring. This must match the `type` property of\n   * the keyring class.\n   */\n  type: string;\n\n  /**\n   * Get the addresses for all accounts in this keyring.\n   *\n   * @returns A list of the account addresses for this keyring\n   */\n  getAccounts(): Promise<Hex[]>;\n\n  /**\n   * Add an account to the keyring.\n   *\n   * @param number - The number of accounts to add. Usually defaults to 1.\n   * @returns A list of the newly added account addresses.\n   */\n  addAccounts(number: number): Promise<Hex[]>;\n\n  /**\n   * Serialize the keyring state as a JSON-serializable object.\n   *\n   * @returns A JSON-serializable representation of the keyring state.\n   */\n  serialize(): Promise<State>;\n\n  /**\n   * Deserialize the given keyring state, overwriting any existing state with\n   * the serialized state provided.\n   *\n   * @param state - A JSON-serializable representation of the keyring state.\n   */\n  deserialize(state: State): Promise<void>;\n\n  /**\n   * Method to include asynchronous configuration.\n   */\n  init?(): Promise<void>;\n\n  /**\n   * Remove an account from the keyring.\n   *\n   * @param address - The address of the account to remove.\n   */\n  removeAccount?(address: Hex): void;\n\n  /**\n   * Export the private key for one of the keyring accounts.\n   *\n   * Some keyrings accept an \"options\" parameter as well. See the documentation\n   * for the specific keyring for more information about what these options\n   * are. For some keyrings, the options parameter is used to allow exporting a\n   * private key that is derived from the given account, rather than exporting\n   * that account's private key directly.\n   *\n   * @param address - The address of the account to export.\n   * @param options - Export options; differs between keyrings.\n   * @returns The non-prefixed, hex-encoded private key that was requested.\n   */\n  exportAccount?(\n    address: Hex,\n    options?: Record<string, unknown>,\n  ): Promise<string>;\n\n  /**\n   * Get the \"app key\" address for the given account and origin. An app key is\n   * an application-specific key pair. See {@link https://eips.ethereum.org/EIPS/eip-1775|EIP-1775}\n   * for more information. The {@link https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Origin|origin}\n   * is used as the unique identifier for the application, and it's used as\n   * part of the key derivation process.\n   *\n   * @param address - The address of the account the app key is derived from.\n   * @param origin - The origin of the application.\n   * @returns The address of the app key for the given account and origin.\n   */\n  getAppKeyAddress?(address: Hex, origin: string): Promise<Hex>;\n\n  /**\n   * Sign a transaction. This is equivalent to the `eth_signTransaction`\n   * Ethereum JSON-RPC method. See the Ethereum JSON-RPC API documentation for\n   * more details.\n   *\n   * Some keyrings accept an \"options\" parameter as well. See the documentation\n   * for the specific keyring for more information about what these options\n   * are. For some keyrings, the options parameter can even change which key is\n   * used for signing (e.g. signing with app keys).\n   *\n   * @param address - The address of the account to use for signing.\n   * @param transaction - The transaction to sign.\n   * @param options - Signing options; differs between keyrings.\n   * @returns The signed transaction.\n   */\n  signTransaction?(\n    address: Hex,\n    transaction: TypedTransaction,\n    options?: Record<string, unknown>,\n  ): Promise<LegacyTxData>;\n\n  /**\n   * Sign a message. This is equivalent to an older version of the the\n   * `eth_sign` Ethereum JSON-RPC method. The message is signed using ECDSA,\n   * using the curve secp256k1 the Keccak-256 hash function.\n   *\n   * For more information about this method and why we still support it, see\n   * the {@link https://docs.metamask.io/guide/signing-data.html|MetaMask Docs}.\n   *\n   * Some keyrings accept an \"options\" parameter as well. See the documentation\n   * for the specific keyring for more information about what these options\n   * are. For some keyrings, the options parameter can even change which key is\n   * used for signing (e.g. signing with app keys).\n   *\n   * @param address - The address of the account to use for signing.\n   * @param message - The message to sign.\n   * @param options - Signing options; differs between keyrings.\n   * @returns The signed message.\n   */\n  signMessage?(\n    address: Hex,\n    message: string,\n    options?: Record<string, unknown>,\n  ): Promise<string>;\n\n  /**\n   * Sign an EIP-7702 authorization. This is a signing method for authorizing a\n   * specific contract on a specific chain.\n   *\n   * @param address - The address of the account to use for signing.\n   * @param authorization - An array containing the chain ID, contract address,\n   * and nonce.\n   * @param options - Signing options; differs between keyrings.\n   * @returns The signed authorization as a hex string.\n   */\n  signEip7702Authorization?(\n    address: Hex,\n    authorization: [chainId: number, contractAddress: Hex, nonce: number],\n    options?: Record<string, unknown>,\n  ): Promise<string>;\n\n  /**\n   * Sign a message. This is equivalent to the `eth_sign` Ethereum JSON-RPC\n   * method, which is exposed by MetaMask as the method `personal_sign`. See\n   * the Ethereum JSON-RPC API documentation for more details.\n   *\n   * For more information about this method and why we call it `personal_sign`,\n   * see the {@link https://docs.metamask.io/guide/signing-data.html|MetaMask Docs}.\n   *\n   * Some keyrings accept an \"options\" parameter as well. See the documentation\n   * for the specific keyring for more information about what these options\n   * are. For some keyrings, the options parameter can even change which key is\n   * used for signing (e.g. signing with app keys).\n   *\n   * @param address - The address of the account to use for signing.\n   * @param message - The message to sign.\n   * @param options - Signing options; differs between keyrings.\n   * @returns The signed message.\n   */\n  signPersonalMessage?(\n    address: Hex,\n    message: Hex,\n    options?: { version?: string } & Record<string, unknown>,\n  ): Promise<string>;\n\n  /**\n   * Sign a message. This is equivalent to the `eth_signTypedData` Ethereum\n   * JSON-RPC method. See {@link https://github.com/ethereum/EIPs/blob/master/EIPS/eip-712.md|EIP-712}\n   * for more details.\n   *\n   * The \"version\" option dictates which version of `eth_signTypedData` is\n   * used. The latest version reflects the specification most closely, whereas\n   * earlier versions reflect earlier drafts of the specification that are\n   * still supported for backwards-compatibility reasons. For more information\n   * about why we support multiple versions, see the {@link https://docs.metamask.io/guide/signing-data.html|MetaMask Docs}.\n   *\n   * Some keyrings accept additional options as well. See the documentation for\n   * the specific keyring for more information about what these options are.\n   * For some keyrings, the options parameter can even change which key is used\n   * for signing (e.g. signing with app keys).\n   *\n   * @param address - The address of the account to use for signing.\n   * @param typedData - The data to sign.\n   * @param options - Signing options; differs between keyrings.\n   * @returns The signed message.\n   */\n  signTypedData?(\n    address: Hex,\n    typedData: Record<string, unknown>,\n    options?: Record<string, unknown>,\n  ): Promise<string>;\n\n  /**\n   * Get a public key to use for encryption. This is equivalent to the\n   * ` eth_getEncryptionPublicKey` JSON-RPC method. See the {@link https://docs.metamask.io/guide/rpc-api.html#eth-getencryptionpublickey|MetaMask Docs}\n   * for more information.\n   *\n   * Some keyrings accept an \"options\" parameter as well. See the documentation\n   * for the specific keyring for more information about what these options\n   * are. For some keyrings, the options parameter can even change which key is\n   * used (e.g. encrypting with app keys).\n   *\n   * @param account - The address of the account you want the encryption key for.\n   * @param options - Options; differs between keyrings.\n   */\n  getEncryptionPublicKey?(\n    account: Hex,\n    options?: Record<string, unknown>,\n  ): Promise<string>;\n\n  /**\n   * Decrypt an encrypted message. This is equivalent to the `  eth_decrypt`\n   * JSON-RPC method. See the {@link https://docs.metamask.io/guide/rpc-api.html#eth-decrypt|MetaMask Docs}\n   * for more information.\n   *\n   * @param account - The address of the account you want to use to decrypt\n   * the message.\n   * @param encryptedData - The encrypted data that you want to decrypt.\n   * @returns The decrypted data.\n   */\n  decryptMessage?(\n    account: Hex,\n    encryptedData: Eip1024EncryptedData,\n  ): Promise<string>;\n\n  /**\n   * Generates the properties for the keyring based on the given\n   * BIP39-compliant mnemonic.\n   *\n   * @returns A promise resolving when the keyring has generated the properties.\n   */\n  generateRandomMnemonic?(): Promise<void>;\n\n  /**\n   * Destroy the keyring.\n   */\n  destroy?(): Promise<void>;\n};\n"]}

package/dist/logging.d.ts

@@ -0,0 +1,30 @@
+import type { Debugger } from 'debug';
+/**
+ * Creates a logger via the `debug` library whose log messages will be tagged
+ * using the name of your project. By default, such messages will be
+ * suppressed, but you can reveal them by setting the `DEBUG` environment
+ * variable to `metamask:<projectName>`. You can also set this variable to
+ * `metamask:*` if you want to see log messages from all MetaMask projects that
+ * are also using this function to create their loggers.
+ *
+ * @param projectName - The name of your project. This should be the name of
+ * your NPM package if you're developing one.
+ * @returns An instance of `debug`.
+ */
+export declare function createProjectLogger(projectName: string): Debugger;
+/**
+ * Creates a logger via the `debug` library which is derived from the logger for
+ * the whole project whose log messages will be tagged using the name of your
+ * module. By default, such messages will be suppressed, but you can reveal them
+ * by setting the `DEBUG` environment variable to
+ * `metamask:<projectName>:<moduleName>`. You can also set this variable to
+ * `metamask:<projectName>:*` if you want to see log messages from the project,
+ * or `metamask:*` if you want to see log messages from all MetaMask projects.
+ *
+ * @param projectLogger - The logger created via {@link createProjectLogger}.
+ * @param moduleName - The name of your module. You could use the name of the
+ * file where you're using this logger or some other name.
+ * @returns An instance of `debug`.
+ */
+export declare function createModuleLogger(projectLogger: Debugger, moduleName: string): Debugger;
+//# sourceMappingURL=logging.d.ts.map

package/dist/logging.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logging.d.ts","sourceRoot":"","sources":["../src/logging.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAKtC;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,MAAM,GAAG,QAAQ,CAEjE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAChC,aAAa,EAAE,QAAQ,EACvB,UAAU,EAAE,MAAM,GACjB,QAAQ,CAEV"}

package/dist/logging.js

@@ -0,0 +1,35 @@
+import debug from 'debug';
+const globalLogger = debug('metamask');
+/**
+ * Creates a logger via the `debug` library whose log messages will be tagged
+ * using the name of your project. By default, such messages will be
+ * suppressed, but you can reveal them by setting the `DEBUG` environment
+ * variable to `metamask:<projectName>`. You can also set this variable to
+ * `metamask:*` if you want to see log messages from all MetaMask projects that
+ * are also using this function to create their loggers.
+ *
+ * @param projectName - The name of your project. This should be the name of
+ * your NPM package if you're developing one.
+ * @returns An instance of `debug`.
+ */
+export function createProjectLogger(projectName) {
+    return globalLogger.extend(projectName);
+}
+/**
+ * Creates a logger via the `debug` library which is derived from the logger for
+ * the whole project whose log messages will be tagged using the name of your
+ * module. By default, such messages will be suppressed, but you can reveal them
+ * by setting the `DEBUG` environment variable to
+ * `metamask:<projectName>:<moduleName>`. You can also set this variable to
+ * `metamask:<projectName>:*` if you want to see log messages from the project,
+ * or `metamask:*` if you want to see log messages from all MetaMask projects.
+ *
+ * @param projectLogger - The logger created via {@link createProjectLogger}.
+ * @param moduleName - The name of your module. You could use the name of the
+ * file where you're using this logger or some other name.
+ * @returns An instance of `debug`.
+ */
+export function createModuleLogger(projectLogger, moduleName) {
+    return projectLogger.extend(moduleName);
+}
+//# sourceMappingURL=logging.js.map

package/dist/logging.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logging.js","sourceRoot":"","sources":["../src/logging.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B,MAAM,YAAY,GAAG,KAAK,CAAC,UAAU,CAAC,CAAC;AAEvC;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,mBAAmB,CAAC,WAAmB;IACrD,OAAO,YAAY,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;AAC1C,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,kBAAkB,CAChC,aAAuB,EACvB,UAAkB;IAElB,OAAO,aAAa,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;AAC1C,CAAC","sourcesContent":["import type { Debugger } from 'debug';\nimport debug from 'debug';\n\nconst globalLogger = debug('metamask');\n\n/**\n * Creates a logger via the `debug` library whose log messages will be tagged\n * using the name of your project. By default, such messages will be\n * suppressed, but you can reveal them by setting the `DEBUG` environment\n * variable to `metamask:<projectName>`. You can also set this variable to\n * `metamask:*` if you want to see log messages from all MetaMask projects that\n * are also using this function to create their loggers.\n *\n * @param projectName - The name of your project. This should be the name of\n * your NPM package if you're developing one.\n * @returns An instance of `debug`.\n */\nexport function createProjectLogger(projectName: string): Debugger {\n  return globalLogger.extend(projectName);\n}\n\n/**\n * Creates a logger via the `debug` library which is derived from the logger for\n * the whole project whose log messages will be tagged using the name of your\n * module. By default, such messages will be suppressed, but you can reveal them\n * by setting the `DEBUG` environment variable to\n * `metamask:<projectName>:<moduleName>`. You can also set this variable to\n * `metamask:<projectName>:*` if you want to see log messages from the project,\n * or `metamask:*` if you want to see log messages from all MetaMask projects.\n *\n * @param projectLogger - The logger created via {@link createProjectLogger}.\n * @param moduleName - The name of your module. You could use the name of the\n * file where you're using this logger or some other name.\n * @returns An instance of `debug`.\n */\nexport function createModuleLogger(\n  projectLogger: Debugger,\n  moduleName: string,\n): Debugger {\n  return projectLogger.extend(moduleName);\n}\n"]}

package/dist/misc.d.ts

@@ -0,0 +1,127 @@
+/**
+ * Makes every specified property of the specified object type mutable.
+ *
+ * @template ObjectValue - The object whose readonly properties to make mutable.
+ * @template TargetKey - The property key(s) to make mutable.
+ */
+export type Mutable<ObjectValue extends Record<string, unknown>, TargetKey extends keyof ObjectValue> = {
+    -readonly [Key in keyof Pick<ObjectValue, TargetKey>]: ObjectValue[Key];
+} & {
+    [Key in keyof Omit<ObjectValue, TargetKey>]: ObjectValue[Key];
+};
+/**
+ * Get a type representing the public interface of the given type. The
+ * returned type will have all public properties, but will omit private
+ * properties.
+ *
+ * @template Interface - The interface to return a public representation of.
+ */
+export type PublicInterface<Interface> = Pick<Interface, keyof Interface>;
+/**
+ * Useful for representing some value that _might_ be present and / or complete.
+ *
+ * @template Value - The value that might be present or complete.
+ */
+export type PartialOrAbsent<Value> = Partial<Value> | null | undefined;
+/**
+ * Like {@link Array}, but always non-empty.
+ *
+ * @template Element - The non-empty array member type.
+ */
+export type NonEmptyArray<Element> = [Element, ...Element[]];
+/**
+ * A JavaScript object that is not `null`, a function, or an array.
+ */
+export type RuntimeObject = Record<PropertyKey, unknown>;
+/**
+ * A {@link NonEmptyArray} type guard.
+ *
+ * @template Element - The non-empty array member type.
+ * @param value - The value to check.
+ * @returns Whether the value is a non-empty array.
+ */
+export declare function isNonEmptyArray<Element>(value: Element[]): value is NonEmptyArray<Element>;
+/**
+ * Type guard for "nullishness".
+ *
+ * @param value - Any value.
+ * @returns `true` if the value is null or undefined, `false` otherwise.
+ */
+export declare function isNullOrUndefined(value: unknown): value is null | undefined;
+/**
+ * A type guard for {@link RuntimeObject}.
+ *
+ * @param value - The value to check.
+ * @returns Whether the specified value has a runtime type of `object` and is
+ * neither `null` nor an `Array`.
+ */
+export declare function isObject(value: unknown): value is RuntimeObject;
+/**
+ * A type guard for ensuring an object has a property.
+ *
+ * @param objectToCheck - The object to check.
+ * @param name - The property name to check for.
+ * @returns Whether the specified object has an own property with the specified
+ * name, regardless of whether it is enumerable or not.
+ */
+export declare const hasProperty: <ObjectToCheck extends Object, Property extends PropertyKey>(objectToCheck: ObjectToCheck, name: Property) => objectToCheck is ObjectToCheck & Record<Property, Property extends keyof ObjectToCheck ? ObjectToCheck[Property] : unknown>;
+/**
+ * `Object.getOwnPropertyNames()` is intentionally generic: it returns the
+ * immediate property names of an object, but it cannot make guarantees about
+ * the contents of that object, so the type of the property names is merely
+ * `string[]`. While this is technically accurate, it is also unnecessary if we
+ * have an object with a type that we own (such as an enum).
+ *
+ * @param object - The plain object.
+ * @returns The own property names of the object which are assigned a type
+ * derived from the object itself.
+ */
+export declare function getKnownPropertyNames<Key extends PropertyKey>(object: Partial<Record<Key, any>>): Key[];
+export type PlainObject = Record<number | string | symbol, unknown>;
+/**
+ * Predefined sizes (in Bytes) of specific parts of JSON structure.
+ */
+export declare enum JsonSize {
+    Null = 4,
+    Comma = 1,
+    Wrapper = 1,
+    True = 4,
+    False = 5,
+    Quote = 1,
+    Colon = 1,
+    Date = 24
+}
+/**
+ * Regular expression with pattern matching for (special) escaped characters.
+ */
+export declare const ESCAPE_CHARACTERS_REGEXP: RegExp;
+/**
+ * Check if the value is plain object.
+ *
+ * @param value - Value to be checked.
+ * @returns True if an object is the plain JavaScript object,
+ * false if the object is not plain (e.g. function).
+ */
+export declare function isPlainObject(value: unknown): value is PlainObject;
+/**
+ * Check if character is ASCII.
+ *
+ * @param character - Character.
+ * @returns True if a character code is ASCII, false if not.
+ */
+export declare function isASCII(character: string): boolean;
+/**
+ * Calculate string size.
+ *
+ * @param value - String value to calculate size.
+ * @returns Number of bytes used to store whole string value.
+ */
+export declare function calculateStringSize(value: string): number;
+/**
+ * Calculate size of a number ofter JSON serialization.
+ *
+ * @param value - Number value to calculate size.
+ * @returns Number of bytes used to store whole number in JSON.
+ */
+export declare function calculateNumberSize(value: number): number;
+//# sourceMappingURL=misc.d.ts.map

package/dist/misc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"misc.d.ts","sourceRoot":"","sources":["../src/misc.ts"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,MAAM,MAAM,OAAO,CACjB,WAAW,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC3C,SAAS,SAAS,MAAM,WAAW,IACjC;IACF,CAAC,UAAU,GAAG,IAAI,MAAM,IAAI,CAAC,WAAW,EAAE,SAAS,CAAC,GAAG,WAAW,CAAC,GAAG,CAAC;CACxE,GAAG;KACD,GAAG,IAAI,MAAM,IAAI,CAAC,WAAW,EAAE,SAAS,CAAC,GAAG,WAAW,CAAC,GAAG,CAAC;CAC9D,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,MAAM,eAAe,CAAC,SAAS,IAAI,IAAI,CAAC,SAAS,EAAE,MAAM,SAAS,CAAC,CAAC;AAE1E;;;;GAIG;AACH,MAAM,MAAM,eAAe,CAAC,KAAK,IAAI,OAAO,CAAC,KAAK,CAAC,GAAG,IAAI,GAAG,SAAS,CAAC;AAEvE;;;;GAIG;AACH,MAAM,MAAM,aAAa,CAAC,OAAO,IAAI,CAAC,OAAO,EAAE,GAAG,OAAO,EAAE,CAAC,CAAC;AAE7D;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;AAMzD;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,OAAO,EACrC,KAAK,EAAE,OAAO,EAAE,GACf,KAAK,IAAI,aAAa,CAAC,OAAO,CAAC,CAEjC;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,IAAI,GAAG,SAAS,CAE3E;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,aAAa,CAE/D;AAMD;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,GAEtB,aAAa,SAAS,MAAM,EAC5B,QAAQ,SAAS,WAAW,iBAEb,aAAa,QACtB,QAAQ,KACb,aAAa,IAAI,aAAa,GAC/B,MAAM,CACJ,QAAQ,EACR,QAAQ,SAAS,MAAM,aAAa,GAAG,aAAa,CAAC,QAAQ,CAAC,GAAG,OAAO,CACtB,CAAC;AAEvD;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,SAAS,WAAW,EAC3D,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,GAChC,GAAG,EAAE,CAEP;AAED,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,GAAG,MAAM,GAAG,MAAM,EAAE,OAAO,CAAC,CAAC;AAEpE;;GAEG;AAKH,oBAAY,QAAQ;IAClB,IAAI,IAAI;IACR,KAAK,IAAI;IACT,OAAO,IAAI;IACX,IAAI,IAAI;IACR,KAAK,IAAI;IACT,KAAK,IAAI;IACT,KAAK,IAAI;IAET,IAAI,KAAK;CACV;AAGD;;GAEG;AACH,eAAO,MAAM,wBAAwB,QAAoB,CAAC;AAE1D;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,WAAW,CAelE;AAED;;;;;GAKG;AACH,wBAAgB,OAAO,CAAC,SAAS,EAAE,MAAM,WAExC;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAUzD;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEzD"}

package/dist/misc.js

@@ -0,0 +1,142 @@
+//
+// Types
+//
+//
+// Type Guards
+//
+/**
+ * A {@link NonEmptyArray} type guard.
+ *
+ * @template Element - The non-empty array member type.
+ * @param value - The value to check.
+ * @returns Whether the value is a non-empty array.
+ */
+export function isNonEmptyArray(value) {
+    return Array.isArray(value) && value.length > 0;
+}
+/**
+ * Type guard for "nullishness".
+ *
+ * @param value - Any value.
+ * @returns `true` if the value is null or undefined, `false` otherwise.
+ */
+export function isNullOrUndefined(value) {
+    return value === null || value === undefined;
+}
+/**
+ * A type guard for {@link RuntimeObject}.
+ *
+ * @param value - The value to check.
+ * @returns Whether the specified value has a runtime type of `object` and is
+ * neither `null` nor an `Array`.
+ */
+export function isObject(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+//
+// Other utility functions
+//
+/**
+ * A type guard for ensuring an object has a property.
+ *
+ * @param objectToCheck - The object to check.
+ * @param name - The property name to check for.
+ * @returns Whether the specified object has an own property with the specified
+ * name, regardless of whether it is enumerable or not.
+ */
+export const hasProperty = (objectToCheck, name) => Object.hasOwnProperty.call(objectToCheck, name);
+/**
+ * `Object.getOwnPropertyNames()` is intentionally generic: it returns the
+ * immediate property names of an object, but it cannot make guarantees about
+ * the contents of that object, so the type of the property names is merely
+ * `string[]`. While this is technically accurate, it is also unnecessary if we
+ * have an object with a type that we own (such as an enum).
+ *
+ * @param object - The plain object.
+ * @returns The own property names of the object which are assigned a type
+ * derived from the object itself.
+ */
+export function getKnownPropertyNames(object) {
+    return Object.getOwnPropertyNames(object);
+}
+/**
+ * Predefined sizes (in Bytes) of specific parts of JSON structure.
+ */
+/* eslint-disable @typescript-eslint/no-duplicate-enum-values --
+   These are byte sizes, so collisions are meaningful rather than mistakes:
+   a comma, a brace, a quote and a colon are all one byte, and `null` and
+   `true` are both four characters. */
+export var JsonSize;
+(function (JsonSize) {
+    JsonSize[JsonSize["Null"] = 4] = "Null";
+    JsonSize[JsonSize["Comma"] = 1] = "Comma";
+    JsonSize[JsonSize["Wrapper"] = 1] = "Wrapper";
+    JsonSize[JsonSize["True"] = 4] = "True";
+    JsonSize[JsonSize["False"] = 5] = "False";
+    JsonSize[JsonSize["Quote"] = 1] = "Quote";
+    JsonSize[JsonSize["Colon"] = 1] = "Colon";
+    // eslint-disable-next-line @typescript-eslint/no-shadow
+    JsonSize[JsonSize["Date"] = 24] = "Date";
+})(JsonSize || (JsonSize = {}));
+/* eslint-enable @typescript-eslint/no-duplicate-enum-values */
+/**
+ * Regular expression with pattern matching for (special) escaped characters.
+ */
+export const ESCAPE_CHARACTERS_REGEXP = /"|\\|\n|\r|\t/gu;
+/**
+ * Check if the value is plain object.
+ *
+ * @param value - Value to be checked.
+ * @returns True if an object is the plain JavaScript object,
+ * false if the object is not plain (e.g. function).
+ */
+export function isPlainObject(value) {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    try {
+        let proto = value;
+        while (Object.getPrototypeOf(proto) !== null) {
+            proto = Object.getPrototypeOf(proto);
+        }
+        return Object.getPrototypeOf(value) === proto;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if character is ASCII.
+ *
+ * @param character - Character.
+ * @returns True if a character code is ASCII, false if not.
+ */
+export function isASCII(character) {
+    return character.charCodeAt(0) <= 127;
+}
+/**
+ * Calculate string size.
+ *
+ * @param value - String value to calculate size.
+ * @returns Number of bytes used to store whole string value.
+ */
+export function calculateStringSize(value) {
+    const size = value.split('').reduce((total, character) => {
+        if (isASCII(character)) {
+            return total + 1;
+        }
+        return total + 2;
+    }, 0);
+    // Also detect characters that need backslash escape
+    return size + (value.match(ESCAPE_CHARACTERS_REGEXP) ?? []).length;
+}
+/**
+ * Calculate size of a number ofter JSON serialization.
+ *
+ * @param value - Number value to calculate size.
+ * @returns Number of bytes used to store whole number in JSON.
+ */
+export function calculateNumberSize(value) {
+    return value.toString().length;
+}
+//# sourceMappingURL=misc.js.map

package/dist/misc.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"misc.js","sourceRoot":"","sources":["../src/misc.ts"],"names":[],"mappings":"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","sourcesContent":["//\n// Types\n//\n\n/**\n * Makes every specified property of the specified object type mutable.\n *\n * @template ObjectValue - The object whose readonly properties to make mutable.\n * @template TargetKey - The property key(s) to make mutable.\n */\nexport type Mutable<\n  ObjectValue extends Record<string, unknown>,\n  TargetKey extends keyof ObjectValue,\n> = {\n  -readonly [Key in keyof Pick<ObjectValue, TargetKey>]: ObjectValue[Key];\n} & {\n  [Key in keyof Omit<ObjectValue, TargetKey>]: ObjectValue[Key];\n};\n\n/**\n * Get a type representing the public interface of the given type. The\n * returned type will have all public properties, but will omit private\n * properties.\n *\n * @template Interface - The interface to return a public representation of.\n */\nexport type PublicInterface<Interface> = Pick<Interface, keyof Interface>;\n\n/**\n * Useful for representing some value that _might_ be present and / or complete.\n *\n * @template Value - The value that might be present or complete.\n */\nexport type PartialOrAbsent<Value> = Partial<Value> | null | undefined;\n\n/**\n * Like {@link Array}, but always non-empty.\n *\n * @template Element - The non-empty array member type.\n */\nexport type NonEmptyArray<Element> = [Element, ...Element[]];\n\n/**\n * A JavaScript object that is not `null`, a function, or an array.\n */\nexport type RuntimeObject = Record<PropertyKey, unknown>;\n\n//\n// Type Guards\n//\n\n/**\n * A {@link NonEmptyArray} type guard.\n *\n * @template Element - The non-empty array member type.\n * @param value - The value to check.\n * @returns Whether the value is a non-empty array.\n */\nexport function isNonEmptyArray<Element>(\n  value: Element[],\n): value is NonEmptyArray<Element> {\n  return Array.isArray(value) && value.length > 0;\n}\n\n/**\n * Type guard for \"nullishness\".\n *\n * @param value - Any value.\n * @returns `true` if the value is null or undefined, `false` otherwise.\n */\nexport function isNullOrUndefined(value: unknown): value is null | undefined {\n  return value === null || value === undefined;\n}\n\n/**\n * A type guard for {@link RuntimeObject}.\n *\n * @param value - The value to check.\n * @returns Whether the specified value has a runtime type of `object` and is\n * neither `null` nor an `Array`.\n */\nexport function isObject(value: unknown): value is RuntimeObject {\n  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);\n}\n\n//\n// Other utility functions\n//\n\n/**\n * A type guard for ensuring an object has a property.\n *\n * @param objectToCheck - The object to check.\n * @param name - The property name to check for.\n * @returns Whether the specified object has an own property with the specified\n * name, regardless of whether it is enumerable or not.\n */\nexport const hasProperty = <\n  // eslint-disable-next-line @typescript-eslint/no-wrapper-object-types -- `Object` is deliberate: it accepts boxed primitives, so callers can pass a string or number. Narrowing to `object` would be a breaking change.\n  ObjectToCheck extends Object,\n  Property extends PropertyKey,\n>(\n  objectToCheck: ObjectToCheck,\n  name: Property,\n): objectToCheck is ObjectToCheck &\n  Record<\n    Property,\n    Property extends keyof ObjectToCheck ? ObjectToCheck[Property] : unknown\n  > => Object.hasOwnProperty.call(objectToCheck, name);\n\n/**\n * `Object.getOwnPropertyNames()` is intentionally generic: it returns the\n * immediate property names of an object, but it cannot make guarantees about\n * the contents of that object, so the type of the property names is merely\n * `string[]`. While this is technically accurate, it is also unnecessary if we\n * have an object with a type that we own (such as an enum).\n *\n * @param object - The plain object.\n * @returns The own property names of the object which are assigned a type\n * derived from the object itself.\n */\nexport function getKnownPropertyNames<Key extends PropertyKey>(\n  object: Partial<Record<Key, any>>,\n): Key[] {\n  return Object.getOwnPropertyNames(object) as Key[];\n}\n\nexport type PlainObject = Record<number | string | symbol, unknown>;\n\n/**\n * Predefined sizes (in Bytes) of specific parts of JSON structure.\n */\n/* eslint-disable @typescript-eslint/no-duplicate-enum-values --\n   These are byte sizes, so collisions are meaningful rather than mistakes:\n   a comma, a brace, a quote and a colon are all one byte, and `null` and\n   `true` are both four characters. */\nexport enum JsonSize {\n  Null = 4,\n  Comma = 1,\n  Wrapper = 1,\n  True = 4,\n  False = 5,\n  Quote = 1,\n  Colon = 1,\n  // eslint-disable-next-line @typescript-eslint/no-shadow\n  Date = 24,\n}\n/* eslint-enable @typescript-eslint/no-duplicate-enum-values */\n\n/**\n * Regular expression with pattern matching for (special) escaped characters.\n */\nexport const ESCAPE_CHARACTERS_REGEXP = /\"|\\\\|\\n|\\r|\\t/gu;\n\n/**\n * Check if the value is plain object.\n *\n * @param value - Value to be checked.\n * @returns True if an object is the plain JavaScript object,\n * false if the object is not plain (e.g. function).\n */\nexport function isPlainObject(value: unknown): value is PlainObject {\n  if (typeof value !== 'object' || value === null) {\n    return false;\n  }\n\n  try {\n    let proto = value;\n    while (Object.getPrototypeOf(proto) !== null) {\n      proto = Object.getPrototypeOf(proto);\n    }\n\n    return Object.getPrototypeOf(value) === proto;\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Check if character is ASCII.\n *\n * @param character - Character.\n * @returns True if a character code is ASCII, false if not.\n */\nexport function isASCII(character: string) {\n  return character.charCodeAt(0) <= 127;\n}\n\n/**\n * Calculate string size.\n *\n * @param value - String value to calculate size.\n * @returns Number of bytes used to store whole string value.\n */\nexport function calculateStringSize(value: string): number {\n  const size = value.split('').reduce((total, character) => {\n    if (isASCII(character)) {\n      return total + 1;\n    }\n    return total + 2;\n  }, 0);\n\n  // Also detect characters that need backslash escape\n  return size + (value.match(ESCAPE_CHARACTERS_REGEXP) ?? []).length;\n}\n\n/**\n * Calculate size of a number ofter JSON serialization.\n *\n * @param value - Number value to calculate size.\n * @returns Number of bytes used to store whole number in JSON.\n */\nexport function calculateNumberSize(value: number): number {\n  return value.toString().length;\n}\n"]}