@metamask-previews/profile-sync-controller 29.0.0-preview-6b4bcdab3 → 29.0.0-preview-0b5bfc2

package/dist/shared/utils/message-signing.cjs

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signMessageWithMessageSigningKey = exports.getMessageSigningPublicKey = exports.deriveMessageSigningPrivateKey = exports.deriveSip6PrivateKey = exports.MESSAGE_SIGNING_SNAP_ID = void 0;
+const key_tree_1 = require("@metamask/key-tree");
+const utils_1 = require("@metamask/utils");
+const secp256k1_1 = require("@noble/curves/secp256k1");
+const hmac_1 = require("@noble/hashes/hmac");
+const sha2_1 = require("@noble/hashes/sha2");
+const sha3_1 = require("@noble/hashes/sha3");
+/**
+ * Native SIP-6 message-signing helpers for AuthenticationController /
+ * UserStorageController.
+ *
+ * These are intentional copies of the message-signing snap crypto path so auth
+ * and user-storage can derive/sign without booting
+ * `npm:@metamask/message-signing-snap`. Behavior must stay byte-identical to:
+ *
+ * - SIP-6 derivation:
+ *   `@metamask/snaps-rpc-methods` `deriveEntropyFromSeed` /
+ *   `getEntropyDerivationPath` / `getDerivationPathArray`
+ *   (https://github.com/MetaMask/snaps/blob/main/packages/snaps-rpc-methods/src/utils.ts)
+ * - Magic constant:
+ *   `@metamask/snaps-utils` `SIP_6_MAGIC_VALUE`
+ * - Pubkey + `metamask:…` signing:
+ *   `@metamask/message-signing-snap` `getPublicEntropyKey` /
+ *   `signMessageWithEntropyKey`
+ *   (https://github.com/MetaMask/message-signing-snap/blob/main/src/entropy-keys.ts)
+ *
+ * `deriveEntropyFromSeed` is not a public export of
+ * `@metamask/snaps-rpc-methods` today (and no core package depends on that
+ * package), so the SIP-6 math is vendored here rather than imported.
+ */
+/**
+ * Snap ID used as the SIP-6 `input` so derived keys match
+ * `@metamask/message-signing-snap` (`snap_getEntropy` origin).
+ */
+exports.MESSAGE_SIGNING_SNAP_ID = 'npm:@metamask/message-signing-snap';
+/**
+ * Copy of `@metamask/snaps-utils` `SIP_6_MAGIC_VALUE`
+ * (`0xd36e6170 - 0x80000000`).
+ *
+ * @see https://metamask.github.io/SIPs/SIPS/sip-6
+ */
+const SIP_6_MAGIC_VALUE = `1399742832'`;
+const HARDENED_VALUE = 0x80000000;
+/**
+ * HMAC-SHA-512 for `@metamask/key-tree`.
+ *
+ * Passed into `SLIP10Node.fromSeed` so SIP-6 never uses Web Crypto.
+ * `@metamask/key-tree` treats any `crypto.subtle` as complete and then HMAC
+ * via `importKey` / `sign`. React Native only implements `digest`; its
+ * SubtleCrypto cannot HMAC. Noble HMAC is byte-identical without SubtleCrypto.
+ */
+const NOBLE_HMAC_SHA512 = {
+    hmacSha512: async (key, data) => (0, hmac_1.hmac)(sha2_1.sha512, key, data),
+};
+/**
+ * Copy of `@metamask/snaps-rpc-methods` `getDerivationPathArray`.
+ *
+ * Maps a 32-byte hash to eight hardened BIP-32 indices for `@metamask/key-tree`.
+ *
+ * @param hash - 32-byte hash.
+ * @returns Hardened BIP-32 path nodes.
+ */
+function getDerivationPathArray(hash) {
+    const array = [];
+    const view = (0, utils_1.createDataView)(hash);
+    for (let index = 0; index < 8; index++) {
+        const uint32 = view.getUint32(index * 4);
+        // eslint-disable-next-line no-bitwise
+        const pathIndex = (uint32 | HARDENED_VALUE) >>> 0;
+        array.push(`bip32:${pathIndex - HARDENED_VALUE}'`);
+    }
+    return array;
+}
+/**
+ * Copy of `@metamask/snaps-rpc-methods` `deriveEntropyFromSeed` (SIP-6),
+ * returning raw private-key bytes instead of a `0x`-prefixed hex string.
+ *
+ * @param options - Derivation options.
+ * @param options.seed - BIP-39 mnemonic seed.
+ * @param options.input - SIP-6 input (snap ID for `snap_getEntropy`).
+ * @param options.salt - Optional salt. Internal auth uses `''`.
+ * @returns 32-byte private key.
+ */
+async function deriveSip6PrivateKey({ seed, input, salt = '', }) {
+    const hash = (0, sha3_1.keccak_256)((0, utils_1.concatBytes)([(0, utils_1.stringToBytes)(input), (0, sha3_1.keccak_256)((0, utils_1.stringToBytes)(salt))]));
+    const computedDerivationPath = getDerivationPathArray(hash);
+    const { privateKey } = await key_tree_1.SLIP10Node.fromSeed({
+        derivationPath: [
+            seed,
+            `bip32:${SIP_6_MAGIC_VALUE}`,
+            ...computedDerivationPath,
+        ],
+        curve: 'secp256k1',
+    }, NOBLE_HMAC_SHA512);
+    (0, utils_1.assert)(privateKey, 'Failed to derive SIP-6 entropy.');
+    return (0, utils_1.hexToBytes)(privateKey);
+}
+exports.deriveSip6PrivateKey = deriveSip6PrivateKey;
+/**
+ * Derives the message-signing private key via SIP-6, matching
+ * `snap_getEntropy` for the message-signing snap with empty salt
+ * (internal `metamask` origin).
+ *
+ * @param seed - BIP-39 mnemonic seed from an HD keyring.
+ * @param salt - Optional SIP-6 salt. Auth / user-storage use `''`.
+ * @returns 32-byte private key.
+ */
+async function deriveMessageSigningPrivateKey(seed, salt = '') {
+    return deriveSip6PrivateKey({
+        seed,
+        input: exports.MESSAGE_SIGNING_SNAP_ID,
+        salt,
+    });
+}
+exports.deriveMessageSigningPrivateKey = deriveMessageSigningPrivateKey;
+/**
+ * Copy of message-signing-snap `getPublicEntropyKey`: secp256k1 pubkey hex
+ * for the SIP-6 message-signing private key.
+ *
+ * @param seed - BIP-39 mnemonic seed from an HD keyring.
+ * @param salt - Optional SIP-6 salt. Auth / user-storage use `''`.
+ * @returns Public key hex with `0x` prefix.
+ */
+async function getMessageSigningPublicKey(seed, salt = '') {
+    const privateKey = await deriveMessageSigningPrivateKey(seed, salt);
+    return (0, utils_1.bytesToHex)(secp256k1_1.secp256k1.getPublicKey(privateKey));
+}
+exports.getMessageSigningPublicKey = getMessageSigningPublicKey;
+/**
+ * Copy of message-signing-snap `signMessageWithEntropyKey`: sha256(message)
+ * then compact secp256k1 signature.
+ *
+ * @param message - Message to sign (must be validated by the caller).
+ * @param seed - BIP-39 mnemonic seed from an HD keyring.
+ * @param salt - Optional SIP-6 salt. Auth / user-storage use `''`.
+ * @returns Compact secp256k1 signature hex with `0x` prefix.
+ */
+async function signMessageWithMessageSigningKey(message, seed, salt = '') {
+    const privateKey = await deriveMessageSigningPrivateKey(seed, salt);
+    const digest = (0, sha2_1.sha256)(message);
+    const signature = secp256k1_1.secp256k1.sign(digest, privateKey);
+    return `0x${signature.toCompactHex()}`;
+}
+exports.signMessageWithMessageSigningKey = signMessageWithMessageSigningKey;
+//# sourceMappingURL=message-signing.cjs.map

package/dist/shared/utils/message-signing.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"message-signing.cjs","sourceRoot":"","sources":["../../../src/shared/utils/message-signing.ts"],"names":[],"mappings":"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","sourcesContent":["import type { HardenedBIP32Node } from '@metamask/key-tree';\nimport { SLIP10Node } from '@metamask/key-tree';\nimport {\n  assert,\n  bytesToHex,\n  concatBytes,\n  createDataView,\n  hexToBytes,\n  stringToBytes,\n} from '@metamask/utils';\nimport { secp256k1 } from '@noble/curves/secp256k1';\nimport { hmac } from '@noble/hashes/hmac';\nimport { sha256, sha512 } from '@noble/hashes/sha2';\nimport { keccak_256 as keccak256 } from '@noble/hashes/sha3';\n\n/**\n * Native SIP-6 message-signing helpers for AuthenticationController /\n * UserStorageController.\n *\n * These are intentional copies of the message-signing snap crypto path so auth\n * and user-storage can derive/sign without booting\n * `npm:@metamask/message-signing-snap`. Behavior must stay byte-identical to:\n *\n * - SIP-6 derivation:\n *   `@metamask/snaps-rpc-methods` `deriveEntropyFromSeed` /\n *   `getEntropyDerivationPath` / `getDerivationPathArray`\n *   (https://github.com/MetaMask/snaps/blob/main/packages/snaps-rpc-methods/src/utils.ts)\n * - Magic constant:\n *   `@metamask/snaps-utils` `SIP_6_MAGIC_VALUE`\n * - Pubkey + `metamask:…` signing:\n *   `@metamask/message-signing-snap` `getPublicEntropyKey` /\n *   `signMessageWithEntropyKey`\n *   (https://github.com/MetaMask/message-signing-snap/blob/main/src/entropy-keys.ts)\n *\n * `deriveEntropyFromSeed` is not a public export of\n * `@metamask/snaps-rpc-methods` today (and no core package depends on that\n * package), so the SIP-6 math is vendored here rather than imported.\n */\n\n/**\n * Snap ID used as the SIP-6 `input` so derived keys match\n * `@metamask/message-signing-snap` (`snap_getEntropy` origin).\n */\nexport const MESSAGE_SIGNING_SNAP_ID = 'npm:@metamask/message-signing-snap';\n\n/**\n * Copy of `@metamask/snaps-utils` `SIP_6_MAGIC_VALUE`\n * (`0xd36e6170 - 0x80000000`).\n *\n * @see https://metamask.github.io/SIPs/SIPS/sip-6\n */\nconst SIP_6_MAGIC_VALUE = `1399742832'` as `${number}'`;\n\nconst HARDENED_VALUE = 0x80000000;\n\n/**\n * HMAC-SHA-512 for `@metamask/key-tree`.\n *\n * Passed into `SLIP10Node.fromSeed` so SIP-6 never uses Web Crypto.\n * `@metamask/key-tree` treats any `crypto.subtle` as complete and then HMAC\n * via `importKey` / `sign`. React Native only implements `digest`; its\n * SubtleCrypto cannot HMAC. Noble HMAC is byte-identical without SubtleCrypto.\n */\nconst NOBLE_HMAC_SHA512 = {\n  hmacSha512: async (key: Uint8Array, data: Uint8Array): Promise<Uint8Array> =>\n    hmac(sha512, key, data),\n};\n\n/**\n * Copy of `@metamask/snaps-rpc-methods` `getDerivationPathArray`.\n *\n * Maps a 32-byte hash to eight hardened BIP-32 indices for `@metamask/key-tree`.\n *\n * @param hash - 32-byte hash.\n * @returns Hardened BIP-32 path nodes.\n */\nfunction getDerivationPathArray(hash: Uint8Array): HardenedBIP32Node[] {\n  const array: HardenedBIP32Node[] = [];\n  const view = createDataView(hash);\n\n  for (let index = 0; index < 8; index++) {\n    const uint32 = view.getUint32(index * 4);\n    // eslint-disable-next-line no-bitwise\n    const pathIndex = (uint32 | HARDENED_VALUE) >>> 0;\n    array.push(`bip32:${pathIndex - HARDENED_VALUE}'` as const);\n  }\n\n  return array;\n}\n\n/**\n * Copy of `@metamask/snaps-rpc-methods` `deriveEntropyFromSeed` (SIP-6),\n * returning raw private-key bytes instead of a `0x`-prefixed hex string.\n *\n * @param options - Derivation options.\n * @param options.seed - BIP-39 mnemonic seed.\n * @param options.input - SIP-6 input (snap ID for `snap_getEntropy`).\n * @param options.salt - Optional salt. Internal auth uses `''`.\n * @returns 32-byte private key.\n */\nexport async function deriveSip6PrivateKey({\n  seed,\n  input,\n  salt = '',\n}: {\n  seed: Uint8Array;\n  input: string;\n  salt?: string;\n}): Promise<Uint8Array> {\n  const hash = keccak256(\n    concatBytes([stringToBytes(input), keccak256(stringToBytes(salt))]),\n  );\n  const computedDerivationPath = getDerivationPathArray(hash);\n\n  const { privateKey } = await SLIP10Node.fromSeed(\n    {\n      derivationPath: [\n        seed,\n        `bip32:${SIP_6_MAGIC_VALUE}`,\n        ...computedDerivationPath,\n      ],\n      curve: 'secp256k1',\n    },\n    NOBLE_HMAC_SHA512,\n  );\n\n  assert(privateKey, 'Failed to derive SIP-6 entropy.');\n  return hexToBytes(privateKey);\n}\n\n/**\n * Derives the message-signing private key via SIP-6, matching\n * `snap_getEntropy` for the message-signing snap with empty salt\n * (internal `metamask` origin).\n *\n * @param seed - BIP-39 mnemonic seed from an HD keyring.\n * @param salt - Optional SIP-6 salt. Auth / user-storage use `''`.\n * @returns 32-byte private key.\n */\nexport async function deriveMessageSigningPrivateKey(\n  seed: Uint8Array,\n  salt = '',\n): Promise<Uint8Array> {\n  return deriveSip6PrivateKey({\n    seed,\n    input: MESSAGE_SIGNING_SNAP_ID,\n    salt,\n  });\n}\n\n/**\n * Copy of message-signing-snap `getPublicEntropyKey`: secp256k1 pubkey hex\n * for the SIP-6 message-signing private key.\n *\n * @param seed - BIP-39 mnemonic seed from an HD keyring.\n * @param salt - Optional SIP-6 salt. Auth / user-storage use `''`.\n * @returns Public key hex with `0x` prefix.\n */\nexport async function getMessageSigningPublicKey(\n  seed: Uint8Array,\n  salt = '',\n): Promise<string> {\n  const privateKey = await deriveMessageSigningPrivateKey(seed, salt);\n  return bytesToHex(secp256k1.getPublicKey(privateKey));\n}\n\n/**\n * Copy of message-signing-snap `signMessageWithEntropyKey`: sha256(message)\n * then compact secp256k1 signature.\n *\n * @param message - Message to sign (must be validated by the caller).\n * @param seed - BIP-39 mnemonic seed from an HD keyring.\n * @param salt - Optional SIP-6 salt. Auth / user-storage use `''`.\n * @returns Compact secp256k1 signature hex with `0x` prefix.\n */\nexport async function signMessageWithMessageSigningKey(\n  message: string,\n  seed: Uint8Array,\n  salt = '',\n): Promise<string> {\n  const privateKey = await deriveMessageSigningPrivateKey(seed, salt);\n  const digest = sha256(message);\n  const signature = secp256k1.sign(digest, privateKey);\n  return `0x${signature.toCompactHex()}`;\n}\n"]}

package/dist/shared/utils/message-signing.d.cts

@@ -0,0 +1,73 @@
+/**
+ * Native SIP-6 message-signing helpers for AuthenticationController /
+ * UserStorageController.
+ *
+ * These are intentional copies of the message-signing snap crypto path so auth
+ * and user-storage can derive/sign without booting
+ * `npm:@metamask/message-signing-snap`. Behavior must stay byte-identical to:
+ *
+ * - SIP-6 derivation:
+ *   `@metamask/snaps-rpc-methods` `deriveEntropyFromSeed` /
+ *   `getEntropyDerivationPath` / `getDerivationPathArray`
+ *   (https://github.com/MetaMask/snaps/blob/main/packages/snaps-rpc-methods/src/utils.ts)
+ * - Magic constant:
+ *   `@metamask/snaps-utils` `SIP_6_MAGIC_VALUE`
+ * - Pubkey + `metamask:…` signing:
+ *   `@metamask/message-signing-snap` `getPublicEntropyKey` /
+ *   `signMessageWithEntropyKey`
+ *   (https://github.com/MetaMask/message-signing-snap/blob/main/src/entropy-keys.ts)
+ *
+ * `deriveEntropyFromSeed` is not a public export of
+ * `@metamask/snaps-rpc-methods` today (and no core package depends on that
+ * package), so the SIP-6 math is vendored here rather than imported.
+ */
+/**
+ * Snap ID used as the SIP-6 `input` so derived keys match
+ * `@metamask/message-signing-snap` (`snap_getEntropy` origin).
+ */
+export declare const MESSAGE_SIGNING_SNAP_ID = "npm:@metamask/message-signing-snap";
+/**
+ * Copy of `@metamask/snaps-rpc-methods` `deriveEntropyFromSeed` (SIP-6),
+ * returning raw private-key bytes instead of a `0x`-prefixed hex string.
+ *
+ * @param options - Derivation options.
+ * @param options.seed - BIP-39 mnemonic seed.
+ * @param options.input - SIP-6 input (snap ID for `snap_getEntropy`).
+ * @param options.salt - Optional salt. Internal auth uses `''`.
+ * @returns 32-byte private key.
+ */
+export declare function deriveSip6PrivateKey({ seed, input, salt, }: {
+    seed: Uint8Array;
+    input: string;
+    salt?: string;
+}): Promise<Uint8Array>;
+/**
+ * Derives the message-signing private key via SIP-6, matching
+ * `snap_getEntropy` for the message-signing snap with empty salt
+ * (internal `metamask` origin).
+ *
+ * @param seed - BIP-39 mnemonic seed from an HD keyring.
+ * @param salt - Optional SIP-6 salt. Auth / user-storage use `''`.
+ * @returns 32-byte private key.
+ */
+export declare function deriveMessageSigningPrivateKey(seed: Uint8Array, salt?: string): Promise<Uint8Array>;
+/**
+ * Copy of message-signing-snap `getPublicEntropyKey`: secp256k1 pubkey hex
+ * for the SIP-6 message-signing private key.
+ *
+ * @param seed - BIP-39 mnemonic seed from an HD keyring.
+ * @param salt - Optional SIP-6 salt. Auth / user-storage use `''`.
+ * @returns Public key hex with `0x` prefix.
+ */
+export declare function getMessageSigningPublicKey(seed: Uint8Array, salt?: string): Promise<string>;
+/**
+ * Copy of message-signing-snap `signMessageWithEntropyKey`: sha256(message)
+ * then compact secp256k1 signature.
+ *
+ * @param message - Message to sign (must be validated by the caller).
+ * @param seed - BIP-39 mnemonic seed from an HD keyring.
+ * @param salt - Optional SIP-6 salt. Auth / user-storage use `''`.
+ * @returns Compact secp256k1 signature hex with `0x` prefix.
+ */
+export declare function signMessageWithMessageSigningKey(message: string, seed: Uint8Array, salt?: string): Promise<string>;
+//# sourceMappingURL=message-signing.d.cts.map

package/dist/shared/utils/message-signing.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"message-signing.d.cts","sourceRoot":"","sources":["../../../src/shared/utils/message-signing.ts"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH;;;GAGG;AACH,eAAO,MAAM,uBAAuB,uCAAuC,CAAC;AA+C5E;;;;;;;;;GASG;AACH,wBAAsB,oBAAoB,CAAC,EACzC,IAAI,EACJ,KAAK,EACL,IAAS,GACV,EAAE;IACD,IAAI,EAAE,UAAU,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,GAAG,OAAO,CAAC,UAAU,CAAC,CAoBtB;AAED;;;;;;;;GAQG;AACH,wBAAsB,8BAA8B,CAClD,IAAI,EAAE,UAAU,EAChB,IAAI,SAAK,GACR,OAAO,CAAC,UAAU,CAAC,CAMrB;AAED;;;;;;;GAOG;AACH,wBAAsB,0BAA0B,CAC9C,IAAI,EAAE,UAAU,EAChB,IAAI,SAAK,GACR,OAAO,CAAC,MAAM,CAAC,CAGjB;AAED;;;;;;;;GAQG;AACH,wBAAsB,gCAAgC,CACpD,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,UAAU,EAChB,IAAI,SAAK,GACR,OAAO,CAAC,MAAM,CAAC,CAKjB"}

package/dist/shared/utils/message-signing.d.mts

@@ -0,0 +1,73 @@
+/**
+ * Native SIP-6 message-signing helpers for AuthenticationController /
+ * UserStorageController.
+ *
+ * These are intentional copies of the message-signing snap crypto path so auth
+ * and user-storage can derive/sign without booting
+ * `npm:@metamask/message-signing-snap`. Behavior must stay byte-identical to:
+ *
+ * - SIP-6 derivation:
+ *   `@metamask/snaps-rpc-methods` `deriveEntropyFromSeed` /
+ *   `getEntropyDerivationPath` / `getDerivationPathArray`
+ *   (https://github.com/MetaMask/snaps/blob/main/packages/snaps-rpc-methods/src/utils.ts)
+ * - Magic constant:
+ *   `@metamask/snaps-utils` `SIP_6_MAGIC_VALUE`
+ * - Pubkey + `metamask:…` signing:
+ *   `@metamask/message-signing-snap` `getPublicEntropyKey` /
+ *   `signMessageWithEntropyKey`
+ *   (https://github.com/MetaMask/message-signing-snap/blob/main/src/entropy-keys.ts)
+ *
+ * `deriveEntropyFromSeed` is not a public export of
+ * `@metamask/snaps-rpc-methods` today (and no core package depends on that
+ * package), so the SIP-6 math is vendored here rather than imported.
+ */
+/**
+ * Snap ID used as the SIP-6 `input` so derived keys match
+ * `@metamask/message-signing-snap` (`snap_getEntropy` origin).
+ */
+export declare const MESSAGE_SIGNING_SNAP_ID = "npm:@metamask/message-signing-snap";
+/**
+ * Copy of `@metamask/snaps-rpc-methods` `deriveEntropyFromSeed` (SIP-6),
+ * returning raw private-key bytes instead of a `0x`-prefixed hex string.
+ *
+ * @param options - Derivation options.
+ * @param options.seed - BIP-39 mnemonic seed.
+ * @param options.input - SIP-6 input (snap ID for `snap_getEntropy`).
+ * @param options.salt - Optional salt. Internal auth uses `''`.
+ * @returns 32-byte private key.
+ */
+export declare function deriveSip6PrivateKey({ seed, input, salt, }: {
+    seed: Uint8Array;
+    input: string;
+    salt?: string;
+}): Promise<Uint8Array>;
+/**
+ * Derives the message-signing private key via SIP-6, matching
+ * `snap_getEntropy` for the message-signing snap with empty salt
+ * (internal `metamask` origin).
+ *
+ * @param seed - BIP-39 mnemonic seed from an HD keyring.
+ * @param salt - Optional SIP-6 salt. Auth / user-storage use `''`.
+ * @returns 32-byte private key.
+ */
+export declare function deriveMessageSigningPrivateKey(seed: Uint8Array, salt?: string): Promise<Uint8Array>;
+/**
+ * Copy of message-signing-snap `getPublicEntropyKey`: secp256k1 pubkey hex
+ * for the SIP-6 message-signing private key.
+ *
+ * @param seed - BIP-39 mnemonic seed from an HD keyring.
+ * @param salt - Optional SIP-6 salt. Auth / user-storage use `''`.
+ * @returns Public key hex with `0x` prefix.
+ */
+export declare function getMessageSigningPublicKey(seed: Uint8Array, salt?: string): Promise<string>;
+/**
+ * Copy of message-signing-snap `signMessageWithEntropyKey`: sha256(message)
+ * then compact secp256k1 signature.
+ *
+ * @param message - Message to sign (must be validated by the caller).
+ * @param seed - BIP-39 mnemonic seed from an HD keyring.
+ * @param salt - Optional SIP-6 salt. Auth / user-storage use `''`.
+ * @returns Compact secp256k1 signature hex with `0x` prefix.
+ */
+export declare function signMessageWithMessageSigningKey(message: string, seed: Uint8Array, salt?: string): Promise<string>;
+//# sourceMappingURL=message-signing.d.mts.map

package/dist/shared/utils/message-signing.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"message-signing.d.mts","sourceRoot":"","sources":["../../../src/shared/utils/message-signing.ts"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH;;;GAGG;AACH,eAAO,MAAM,uBAAuB,uCAAuC,CAAC;AA+C5E;;;;;;;;;GASG;AACH,wBAAsB,oBAAoB,CAAC,EACzC,IAAI,EACJ,KAAK,EACL,IAAS,GACV,EAAE;IACD,IAAI,EAAE,UAAU,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,GAAG,OAAO,CAAC,UAAU,CAAC,CAoBtB;AAED;;;;;;;;GAQG;AACH,wBAAsB,8BAA8B,CAClD,IAAI,EAAE,UAAU,EAChB,IAAI,SAAK,GACR,OAAO,CAAC,UAAU,CAAC,CAMrB;AAED;;;;;;;GAOG;AACH,wBAAsB,0BAA0B,CAC9C,IAAI,EAAE,UAAU,EAChB,IAAI,SAAK,GACR,OAAO,CAAC,MAAM,CAAC,CAGjB;AAED;;;;;;;;GAQG;AACH,wBAAsB,gCAAgC,CACpD,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,UAAU,EAChB,IAAI,SAAK,GACR,OAAO,CAAC,MAAM,CAAC,CAKjB"}

package/dist/shared/utils/message-signing.mjs

@@ -0,0 +1,140 @@
+import { SLIP10Node } from "@metamask/key-tree";
+import { assert, bytesToHex, concatBytes, createDataView, hexToBytes, stringToBytes } from "@metamask/utils";
+import { secp256k1 } from "@noble/curves/secp256k1";
+import { hmac } from "@noble/hashes/hmac";
+import { sha256, sha512 } from "@noble/hashes/sha2";
+import { keccak_256 as keccak256 } from "@noble/hashes/sha3";
+/**
+ * Native SIP-6 message-signing helpers for AuthenticationController /
+ * UserStorageController.
+ *
+ * These are intentional copies of the message-signing snap crypto path so auth
+ * and user-storage can derive/sign without booting
+ * `npm:@metamask/message-signing-snap`. Behavior must stay byte-identical to:
+ *
+ * - SIP-6 derivation:
+ *   `@metamask/snaps-rpc-methods` `deriveEntropyFromSeed` /
+ *   `getEntropyDerivationPath` / `getDerivationPathArray`
+ *   (https://github.com/MetaMask/snaps/blob/main/packages/snaps-rpc-methods/src/utils.ts)
+ * - Magic constant:
+ *   `@metamask/snaps-utils` `SIP_6_MAGIC_VALUE`
+ * - Pubkey + `metamask:…` signing:
+ *   `@metamask/message-signing-snap` `getPublicEntropyKey` /
+ *   `signMessageWithEntropyKey`
+ *   (https://github.com/MetaMask/message-signing-snap/blob/main/src/entropy-keys.ts)
+ *
+ * `deriveEntropyFromSeed` is not a public export of
+ * `@metamask/snaps-rpc-methods` today (and no core package depends on that
+ * package), so the SIP-6 math is vendored here rather than imported.
+ */
+/**
+ * Snap ID used as the SIP-6 `input` so derived keys match
+ * `@metamask/message-signing-snap` (`snap_getEntropy` origin).
+ */
+export const MESSAGE_SIGNING_SNAP_ID = 'npm:@metamask/message-signing-snap';
+/**
+ * Copy of `@metamask/snaps-utils` `SIP_6_MAGIC_VALUE`
+ * (`0xd36e6170 - 0x80000000`).
+ *
+ * @see https://metamask.github.io/SIPs/SIPS/sip-6
+ */
+const SIP_6_MAGIC_VALUE = `1399742832'`;
+const HARDENED_VALUE = 0x80000000;
+/**
+ * HMAC-SHA-512 for `@metamask/key-tree`.
+ *
+ * Passed into `SLIP10Node.fromSeed` so SIP-6 never uses Web Crypto.
+ * `@metamask/key-tree` treats any `crypto.subtle` as complete and then HMAC
+ * via `importKey` / `sign`. React Native only implements `digest`; its
+ * SubtleCrypto cannot HMAC. Noble HMAC is byte-identical without SubtleCrypto.
+ */
+const NOBLE_HMAC_SHA512 = {
+    hmacSha512: async (key, data) => hmac(sha512, key, data),
+};
+/**
+ * Copy of `@metamask/snaps-rpc-methods` `getDerivationPathArray`.
+ *
+ * Maps a 32-byte hash to eight hardened BIP-32 indices for `@metamask/key-tree`.
+ *
+ * @param hash - 32-byte hash.
+ * @returns Hardened BIP-32 path nodes.
+ */
+function getDerivationPathArray(hash) {
+    const array = [];
+    const view = createDataView(hash);
+    for (let index = 0; index < 8; index++) {
+        const uint32 = view.getUint32(index * 4);
+        // eslint-disable-next-line no-bitwise
+        const pathIndex = (uint32 | HARDENED_VALUE) >>> 0;
+        array.push(`bip32:${pathIndex - HARDENED_VALUE}'`);
+    }
+    return array;
+}
+/**
+ * Copy of `@metamask/snaps-rpc-methods` `deriveEntropyFromSeed` (SIP-6),
+ * returning raw private-key bytes instead of a `0x`-prefixed hex string.
+ *
+ * @param options - Derivation options.
+ * @param options.seed - BIP-39 mnemonic seed.
+ * @param options.input - SIP-6 input (snap ID for `snap_getEntropy`).
+ * @param options.salt - Optional salt. Internal auth uses `''`.
+ * @returns 32-byte private key.
+ */
+export async function deriveSip6PrivateKey({ seed, input, salt = '', }) {
+    const hash = keccak256(concatBytes([stringToBytes(input), keccak256(stringToBytes(salt))]));
+    const computedDerivationPath = getDerivationPathArray(hash);
+    const { privateKey } = await SLIP10Node.fromSeed({
+        derivationPath: [
+            seed,
+            `bip32:${SIP_6_MAGIC_VALUE}`,
+            ...computedDerivationPath,
+        ],
+        curve: 'secp256k1',
+    }, NOBLE_HMAC_SHA512);
+    assert(privateKey, 'Failed to derive SIP-6 entropy.');
+    return hexToBytes(privateKey);
+}
+/**
+ * Derives the message-signing private key via SIP-6, matching
+ * `snap_getEntropy` for the message-signing snap with empty salt
+ * (internal `metamask` origin).
+ *
+ * @param seed - BIP-39 mnemonic seed from an HD keyring.
+ * @param salt - Optional SIP-6 salt. Auth / user-storage use `''`.
+ * @returns 32-byte private key.
+ */
+export async function deriveMessageSigningPrivateKey(seed, salt = '') {
+    return deriveSip6PrivateKey({
+        seed,
+        input: MESSAGE_SIGNING_SNAP_ID,
+        salt,
+    });
+}
+/**
+ * Copy of message-signing-snap `getPublicEntropyKey`: secp256k1 pubkey hex
+ * for the SIP-6 message-signing private key.
+ *
+ * @param seed - BIP-39 mnemonic seed from an HD keyring.
+ * @param salt - Optional SIP-6 salt. Auth / user-storage use `''`.
+ * @returns Public key hex with `0x` prefix.
+ */
+export async function getMessageSigningPublicKey(seed, salt = '') {
+    const privateKey = await deriveMessageSigningPrivateKey(seed, salt);
+    return bytesToHex(secp256k1.getPublicKey(privateKey));
+}
+/**
+ * Copy of message-signing-snap `signMessageWithEntropyKey`: sha256(message)
+ * then compact secp256k1 signature.
+ *
+ * @param message - Message to sign (must be validated by the caller).
+ * @param seed - BIP-39 mnemonic seed from an HD keyring.
+ * @param salt - Optional SIP-6 salt. Auth / user-storage use `''`.
+ * @returns Compact secp256k1 signature hex with `0x` prefix.
+ */
+export async function signMessageWithMessageSigningKey(message, seed, salt = '') {
+    const privateKey = await deriveMessageSigningPrivateKey(seed, salt);
+    const digest = sha256(message);
+    const signature = secp256k1.sign(digest, privateKey);
+    return `0x${signature.toCompactHex()}`;
+}
+//# sourceMappingURL=message-signing.mjs.map

package/dist/shared/utils/message-signing.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"message-signing.mjs","sourceRoot":"","sources":["../../../src/shared/utils/message-signing.ts"],"names":[],"mappings":"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","sourcesContent":["import type { HardenedBIP32Node } from '@metamask/key-tree';\nimport { SLIP10Node } from '@metamask/key-tree';\nimport {\n  assert,\n  bytesToHex,\n  concatBytes,\n  createDataView,\n  hexToBytes,\n  stringToBytes,\n} from '@metamask/utils';\nimport { secp256k1 } from '@noble/curves/secp256k1';\nimport { hmac } from '@noble/hashes/hmac';\nimport { sha256, sha512 } from '@noble/hashes/sha2';\nimport { keccak_256 as keccak256 } from '@noble/hashes/sha3';\n\n/**\n * Native SIP-6 message-signing helpers for AuthenticationController /\n * UserStorageController.\n *\n * These are intentional copies of the message-signing snap crypto path so auth\n * and user-storage can derive/sign without booting\n * `npm:@metamask/message-signing-snap`. Behavior must stay byte-identical to:\n *\n * - SIP-6 derivation:\n *   `@metamask/snaps-rpc-methods` `deriveEntropyFromSeed` /\n *   `getEntropyDerivationPath` / `getDerivationPathArray`\n *   (https://github.com/MetaMask/snaps/blob/main/packages/snaps-rpc-methods/src/utils.ts)\n * - Magic constant:\n *   `@metamask/snaps-utils` `SIP_6_MAGIC_VALUE`\n * - Pubkey + `metamask:…` signing:\n *   `@metamask/message-signing-snap` `getPublicEntropyKey` /\n *   `signMessageWithEntropyKey`\n *   (https://github.com/MetaMask/message-signing-snap/blob/main/src/entropy-keys.ts)\n *\n * `deriveEntropyFromSeed` is not a public export of\n * `@metamask/snaps-rpc-methods` today (and no core package depends on that\n * package), so the SIP-6 math is vendored here rather than imported.\n */\n\n/**\n * Snap ID used as the SIP-6 `input` so derived keys match\n * `@metamask/message-signing-snap` (`snap_getEntropy` origin).\n */\nexport const MESSAGE_SIGNING_SNAP_ID = 'npm:@metamask/message-signing-snap';\n\n/**\n * Copy of `@metamask/snaps-utils` `SIP_6_MAGIC_VALUE`\n * (`0xd36e6170 - 0x80000000`).\n *\n * @see https://metamask.github.io/SIPs/SIPS/sip-6\n */\nconst SIP_6_MAGIC_VALUE = `1399742832'` as `${number}'`;\n\nconst HARDENED_VALUE = 0x80000000;\n\n/**\n * HMAC-SHA-512 for `@metamask/key-tree`.\n *\n * Passed into `SLIP10Node.fromSeed` so SIP-6 never uses Web Crypto.\n * `@metamask/key-tree` treats any `crypto.subtle` as complete and then HMAC\n * via `importKey` / `sign`. React Native only implements `digest`; its\n * SubtleCrypto cannot HMAC. Noble HMAC is byte-identical without SubtleCrypto.\n */\nconst NOBLE_HMAC_SHA512 = {\n  hmacSha512: async (key: Uint8Array, data: Uint8Array): Promise<Uint8Array> =>\n    hmac(sha512, key, data),\n};\n\n/**\n * Copy of `@metamask/snaps-rpc-methods` `getDerivationPathArray`.\n *\n * Maps a 32-byte hash to eight hardened BIP-32 indices for `@metamask/key-tree`.\n *\n * @param hash - 32-byte hash.\n * @returns Hardened BIP-32 path nodes.\n */\nfunction getDerivationPathArray(hash: Uint8Array): HardenedBIP32Node[] {\n  const array: HardenedBIP32Node[] = [];\n  const view = createDataView(hash);\n\n  for (let index = 0; index < 8; index++) {\n    const uint32 = view.getUint32(index * 4);\n    // eslint-disable-next-line no-bitwise\n    const pathIndex = (uint32 | HARDENED_VALUE) >>> 0;\n    array.push(`bip32:${pathIndex - HARDENED_VALUE}'` as const);\n  }\n\n  return array;\n}\n\n/**\n * Copy of `@metamask/snaps-rpc-methods` `deriveEntropyFromSeed` (SIP-6),\n * returning raw private-key bytes instead of a `0x`-prefixed hex string.\n *\n * @param options - Derivation options.\n * @param options.seed - BIP-39 mnemonic seed.\n * @param options.input - SIP-6 input (snap ID for `snap_getEntropy`).\n * @param options.salt - Optional salt. Internal auth uses `''`.\n * @returns 32-byte private key.\n */\nexport async function deriveSip6PrivateKey({\n  seed,\n  input,\n  salt = '',\n}: {\n  seed: Uint8Array;\n  input: string;\n  salt?: string;\n}): Promise<Uint8Array> {\n  const hash = keccak256(\n    concatBytes([stringToBytes(input), keccak256(stringToBytes(salt))]),\n  );\n  const computedDerivationPath = getDerivationPathArray(hash);\n\n  const { privateKey } = await SLIP10Node.fromSeed(\n    {\n      derivationPath: [\n        seed,\n        `bip32:${SIP_6_MAGIC_VALUE}`,\n        ...computedDerivationPath,\n      ],\n      curve: 'secp256k1',\n    },\n    NOBLE_HMAC_SHA512,\n  );\n\n  assert(privateKey, 'Failed to derive SIP-6 entropy.');\n  return hexToBytes(privateKey);\n}\n\n/**\n * Derives the message-signing private key via SIP-6, matching\n * `snap_getEntropy` for the message-signing snap with empty salt\n * (internal `metamask` origin).\n *\n * @param seed - BIP-39 mnemonic seed from an HD keyring.\n * @param salt - Optional SIP-6 salt. Auth / user-storage use `''`.\n * @returns 32-byte private key.\n */\nexport async function deriveMessageSigningPrivateKey(\n  seed: Uint8Array,\n  salt = '',\n): Promise<Uint8Array> {\n  return deriveSip6PrivateKey({\n    seed,\n    input: MESSAGE_SIGNING_SNAP_ID,\n    salt,\n  });\n}\n\n/**\n * Copy of message-signing-snap `getPublicEntropyKey`: secp256k1 pubkey hex\n * for the SIP-6 message-signing private key.\n *\n * @param seed - BIP-39 mnemonic seed from an HD keyring.\n * @param salt - Optional SIP-6 salt. Auth / user-storage use `''`.\n * @returns Public key hex with `0x` prefix.\n */\nexport async function getMessageSigningPublicKey(\n  seed: Uint8Array,\n  salt = '',\n): Promise<string> {\n  const privateKey = await deriveMessageSigningPrivateKey(seed, salt);\n  return bytesToHex(secp256k1.getPublicKey(privateKey));\n}\n\n/**\n * Copy of message-signing-snap `signMessageWithEntropyKey`: sha256(message)\n * then compact secp256k1 signature.\n *\n * @param message - Message to sign (must be validated by the caller).\n * @param seed - BIP-39 mnemonic seed from an HD keyring.\n * @param salt - Optional SIP-6 salt. Auth / user-storage use `''`.\n * @returns Compact secp256k1 signature hex with `0x` prefix.\n */\nexport async function signMessageWithMessageSigningKey(\n  message: string,\n  seed: Uint8Array,\n  salt = '',\n): Promise<string> {\n  const privateKey = await deriveMessageSigningPrivateKey(seed, salt);\n  const digest = sha256(message);\n  const signature = secp256k1.sign(digest, privateKey);\n  return `0x${signature.toCompactHex()}`;\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@metamask-previews/profile-sync-controller",
-  "version": "29.0.0-preview-6b4bcdab3",
+  "version": "29.0.0-preview-0b5bfc2",
   "description": "The profile sync helps developers synchronize data across multiple clients and devices in a privacy-preserving way. All data saved in the user storage database is encrypted client-side to preserve privacy. The user storage provides a modular design, giving developers the flexibility to construct and manage their storage spaces in a way that best suits their needs",
   "keywords": [
     "Ethereum",
@@ -110,14 +110,13 @@
   "dependencies": {
     "@metamask/address-book-controller": "^7.1.2",
     "@metamask/base-controller": "^9.1.0",
+    "@metamask/key-tree": "^10.1.1",
     "@metamask/keyring-controller": "^27.1.1",
     "@metamask/messenger": "^2.0.0",
     "@metamask/seedless-onboarding-controller": "^10.1.1",
-    "@metamask/snaps-controllers": "^19.0.0",
-    "@metamask/snaps-sdk": "^11.0.0",
-    "@metamask/snaps-utils": "^12.1.2",
     "@metamask/utils": "^11.11.0",
     "@noble/ciphers": "^1.3.0",
+    "@noble/curves": "^1.9.2",
     "@noble/hashes": "^1.8.0",
     "immer": "^9.0.6",
     "loglevel": "^1.8.1",
@@ -127,6 +126,7 @@
     "@lavamoat/allow-scripts": "^3.0.4",
     "@lavamoat/preinstall-always-fail": "^2.1.0",
     "@metamask/auto-changelog": "^6.1.0",
+    "@metamask/eth-hd-keyring": "^15.0.0",
     "@metamask/keyring-api": "^24.0.0",
     "@metamask/keyring-internal-api": "^12.0.0",
     "@metamask/providers": "^22.1.0",

package/dist/controllers/authentication/auth-snap-requests.cjs

@@ -1,44 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSnapSignMessageRequest = exports.createSnapPublicKeyRequest = void 0;
-const snapId = 'npm:@metamask/message-signing-snap';
-/**
- * Constructs Request to Message Signing Snap to get Public Key
- *
- * @param entropySourceId - The source of entropy to use for key generation,
- * when multiple sources are available (Multi-SRP).
- * @returns Snap Public Key Request
- */
-function createSnapPublicKeyRequest(entropySourceId) {
-    return {
-        snapId,
-        origin: 'metamask',
-        handler: 'onRpcRequest',
-        request: {
-            method: 'getPublicKey',
-            ...(entropySourceId ? { params: { entropySourceId } } : {}),
-        },
-    };
-}
-exports.createSnapPublicKeyRequest = createSnapPublicKeyRequest;
-/**
- * Constructs Request to get Message Signing Snap to sign a message.
- *
- * @param message - message to sign
- * @param entropySourceId - The source of entropy to use for key generation,
- * when multiple sources are available (Multi-SRP).
- * @returns Snap Sign Message Request
- */
-function createSnapSignMessageRequest(message, entropySourceId) {
-    return {
-        snapId,
-        origin: 'metamask',
-        handler: 'onRpcRequest',
-        request: {
-            method: 'signMessage',
-            params: { message, ...(entropySourceId ? { entropySourceId } : {}) },
-        },
-    };
-}
-exports.createSnapSignMessageRequest = createSnapSignMessageRequest;
-//# sourceMappingURL=auth-snap-requests.cjs.map

package/dist/controllers/authentication/auth-snap-requests.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"auth-snap-requests.cjs","sourceRoot":"","sources":["../../../src/controllers/authentication/auth-snap-requests.ts"],"names":[],"mappings":";;;AAQA,MAAM,MAAM,GAAG,oCAA8C,CAAC;AAE9D;;;;;;GAMG;AACH,SAAgB,0BAA0B,CACxC,eAAwB;IAExB,OAAO;QACL,MAAM;QACN,MAAM,EAAE,UAAU;QAClB,OAAO,EAAE,cAAqB;QAC9B,OAAO,EAAE;YACP,MAAM,EAAE,cAAc;YACtB,GAAG,CAAC,eAAe,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,eAAe,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;SAC5D;KACF,CAAC;AACJ,CAAC;AAZD,gEAYC;AAED;;;;;;;GAOG;AACH,SAAgB,4BAA4B,CAC1C,OAA6B,EAC7B,eAAwB;IAExB,OAAO;QACL,MAAM;QACN,MAAM,EAAE,UAAU;QAClB,OAAO,EAAE,cAAqB;QAC9B,OAAO,EAAE;YACP,MAAM,EAAE,aAAa;YACrB,MAAM,EAAE,EAAE,OAAO,EAAE,GAAG,CAAC,eAAe,CAAC,CAAC,CAAC,EAAE,eAAe,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE;SACrE;KACF,CAAC;AACJ,CAAC;AAbD,oEAaC","sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport type { SnapControllerHandleRequestAction } from '@metamask/snaps-controllers';\nimport type { SnapId } from '@metamask/snaps-sdk';\n\ntype SnapRPCRequest = Parameters<\n  SnapControllerHandleRequestAction['handler']\n>[0];\n\nconst snapId = 'npm:@metamask/message-signing-snap' as SnapId;\n\n/**\n * Constructs Request to Message Signing Snap to get Public Key\n *\n * @param entropySourceId - The source of entropy to use for key generation,\n * when multiple sources are available (Multi-SRP).\n * @returns Snap Public Key Request\n */\nexport function createSnapPublicKeyRequest(\n  entropySourceId?: string,\n): SnapRPCRequest {\n  return {\n    snapId,\n    origin: 'metamask',\n    handler: 'onRpcRequest' as any,\n    request: {\n      method: 'getPublicKey',\n      ...(entropySourceId ? { params: { entropySourceId } } : {}),\n    },\n  };\n}\n\n/**\n * Constructs Request to get Message Signing Snap to sign a message.\n *\n * @param message - message to sign\n * @param entropySourceId - The source of entropy to use for key generation,\n * when multiple sources are available (Multi-SRP).\n * @returns Snap Sign Message Request\n */\nexport function createSnapSignMessageRequest(\n  message: `metamask:${string}`,\n  entropySourceId?: string,\n): SnapRPCRequest {\n  return {\n    snapId,\n    origin: 'metamask',\n    handler: 'onRpcRequest' as any,\n    request: {\n      method: 'signMessage',\n      params: { message, ...(entropySourceId ? { entropySourceId } : {}) },\n    },\n  };\n}\n"]}

package/dist/controllers/authentication/auth-snap-requests.d.cts

@@ -1,21 +0,0 @@
-import type { SnapControllerHandleRequestAction } from "@metamask/snaps-controllers";
-type SnapRPCRequest = Parameters<SnapControllerHandleRequestAction['handler']>[0];
-/**
- * Constructs Request to Message Signing Snap to get Public Key
- *
- * @param entropySourceId - The source of entropy to use for key generation,
- * when multiple sources are available (Multi-SRP).
- * @returns Snap Public Key Request
- */
-export declare function createSnapPublicKeyRequest(entropySourceId?: string): SnapRPCRequest;
-/**
- * Constructs Request to get Message Signing Snap to sign a message.
- *
- * @param message - message to sign
- * @param entropySourceId - The source of entropy to use for key generation,
- * when multiple sources are available (Multi-SRP).
- * @returns Snap Sign Message Request
- */
-export declare function createSnapSignMessageRequest(message: `metamask:${string}`, entropySourceId?: string): SnapRPCRequest;
-export {};
-//# sourceMappingURL=auth-snap-requests.d.cts.map

package/dist/controllers/authentication/auth-snap-requests.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"auth-snap-requests.d.cts","sourceRoot":"","sources":["../../../src/controllers/authentication/auth-snap-requests.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iCAAiC,EAAE,oCAAoC;AAGrF,KAAK,cAAc,GAAG,UAAU,CAC9B,iCAAiC,CAAC,SAAS,CAAC,CAC7C,CAAC,CAAC,CAAC,CAAC;AAIL;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CACxC,eAAe,CAAC,EAAE,MAAM,GACvB,cAAc,CAUhB;AAED;;;;;;;GAOG;AACH,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,YAAY,MAAM,EAAE,EAC7B,eAAe,CAAC,EAAE,MAAM,GACvB,cAAc,CAUhB"}

package/dist/controllers/authentication/auth-snap-requests.d.mts

@@ -1,21 +0,0 @@
-import type { SnapControllerHandleRequestAction } from "@metamask/snaps-controllers";
-type SnapRPCRequest = Parameters<SnapControllerHandleRequestAction['handler']>[0];
-/**
- * Constructs Request to Message Signing Snap to get Public Key
- *
- * @param entropySourceId - The source of entropy to use for key generation,
- * when multiple sources are available (Multi-SRP).
- * @returns Snap Public Key Request
- */
-export declare function createSnapPublicKeyRequest(entropySourceId?: string): SnapRPCRequest;
-/**
- * Constructs Request to get Message Signing Snap to sign a message.
- *
- * @param message - message to sign
- * @param entropySourceId - The source of entropy to use for key generation,
- * when multiple sources are available (Multi-SRP).
- * @returns Snap Sign Message Request
- */
-export declare function createSnapSignMessageRequest(message: `metamask:${string}`, entropySourceId?: string): SnapRPCRequest;
-export {};
-//# sourceMappingURL=auth-snap-requests.d.mts.map

package/dist/controllers/authentication/auth-snap-requests.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"auth-snap-requests.d.mts","sourceRoot":"","sources":["../../../src/controllers/authentication/auth-snap-requests.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iCAAiC,EAAE,oCAAoC;AAGrF,KAAK,cAAc,GAAG,UAAU,CAC9B,iCAAiC,CAAC,SAAS,CAAC,CAC7C,CAAC,CAAC,CAAC,CAAC;AAIL;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CACxC,eAAe,CAAC,EAAE,MAAM,GACvB,cAAc,CAUhB;AAED;;;;;;;GAOG;AACH,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,YAAY,MAAM,EAAE,EAC7B,eAAe,CAAC,EAAE,MAAM,GACvB,cAAc,CAUhB"}