@metamask/snaps-rpc-methods
Version:
MetaMask Snaps JSON-RPC method implementations
96 lines • 4.2 kB
JavaScript
import { PermissionType, SubjectType } from "@metamask/permission-controller";
import { rpcErrors } from "@metamask/rpc-errors";
import { bip32entropy, Bip32PathStruct, CurveStruct, SnapCaveatType } from "@metamask/snaps-utils";
import { boolean, object, optional, string } from "@metamask/superstruct";
import { assertStruct } from "@metamask/utils";
import { getValueFromEntropySource, getNodeFromMnemonic, getNodeFromSeed } from "../utils.mjs";
const targetName = 'snap_getBip32PublicKey';
export const Bip32PublicKeyArgsStruct = bip32entropy(object({
path: Bip32PathStruct,
curve: CurveStruct,
compressed: optional(boolean()),
source: optional(string()),
}));
/**
* The specification builder for the `snap_getBip32PublicKey` permission.
* `snap_getBip32PublicKey` lets the Snap retrieve public keys for a particular
* BIP-32 node.
*
* @param options - The specification builder options.
* @param options.methodHooks - The RPC method hooks needed by the method implementation.
* @returns The specification for the `snap_getBip32PublicKey` permission.
*/
const specificationBuilder = ({ methodHooks }) => {
return {
permissionType: PermissionType.RestrictedMethod,
targetName,
allowedCaveats: [SnapCaveatType.PermittedDerivationPaths],
methodImplementation: getBip32PublicKeyImplementation(methodHooks),
validator: ({ caveats }) => {
if (caveats?.length !== 1 ||
caveats[0].type !== SnapCaveatType.PermittedDerivationPaths) {
throw rpcErrors.invalidParams({
message: `Expected a single "${SnapCaveatType.PermittedDerivationPaths}" caveat.`,
});
}
},
subjectTypes: [SubjectType.Snap],
};
};
const methodHooks = {
getMnemonic: true,
getMnemonicSeed: true,
getUnlockPromise: true,
getClientCryptography: true,
};
export const getBip32PublicKeyBuilder = Object.freeze({
targetName,
specificationBuilder,
methodHooks,
});
/**
* Builds the method implementation for `snap_getBip32PublicKey`.
*
* @param hooks - The RPC method hooks.
* @param hooks.getMnemonic - A function to retrieve the Secret Recovery Phrase of the user.
* @param hooks.getMnemonicSeed - A function to retrieve the BIP-39 seed of the user.
* @param hooks.getUnlockPromise - A function that resolves once the MetaMask extension is unlocked
* and prompts the user to unlock their MetaMask if it is locked.
* @param hooks.getClientCryptography - A function to retrieve the cryptographic
* functions to use for the client.
* @returns The method implementation which returns a public key.
* @throws If the params are invalid.
*/
export function getBip32PublicKeyImplementation({ getMnemonic, getMnemonicSeed, getUnlockPromise, getClientCryptography, }) {
return async function getBip32PublicKey(args) {
await getUnlockPromise(true);
assertStruct(args.params, Bip32PublicKeyArgsStruct, 'Invalid BIP-32 public key params', rpcErrors.invalidParams);
const { params } = args;
// Using the seed is much faster, but we can only do it for these specific curves.
if (params.curve === 'secp256k1' || params.curve === 'ed25519') {
const seed = await getValueFromEntropySource(getMnemonicSeed, params.source);
const node = await getNodeFromSeed({
curve: params.curve,
path: params.path,
seed,
cryptographicFunctions: getClientCryptography(),
});
if (params.compressed) {
return node.compressedPublicKey;
}
return node.publicKey;
}
const secretRecoveryPhrase = await getValueFromEntropySource(getMnemonic, params.source);
const node = await getNodeFromMnemonic({
curve: params.curve,
path: params.path,
secretRecoveryPhrase,
cryptographicFunctions: getClientCryptography(),
});
if (params.compressed) {
return node.compressedPublicKey;
}
return node.publicKey;
};
}
//# sourceMappingURL=getBip32PublicKey.mjs.map