@cubist-labs/cubesigner-sdk-key-import 0.4.68-0

package/src/mnemonic.ts

@@ -0,0 +1,91 @@
+import { encode as mpEncode } from "msgpackr";
+import { wordlist } from "@scure/bip39/wordlists/english";
+import * as bip39 from "@scure/bip39";
+
+// The KeyPackage type from CubeSigner
+export type MnemonicKeyPackage = {
+  EnglishMnemonic: {
+    mnemonic: {
+      entropy: Uint8Array;
+    };
+    der_path: {
+      path: number[];
+    };
+    password: string;
+  };
+};
+
+/**
+ * A BIP39 mnemonic to be imported, plus optional BIP39 password
+ * and BIP32 derivation path.
+ */
+export type MnemonicToImport = {
+  mnemonic: string;
+  derivationPath?: string;
+  password?: string;
+};
+
+/**
+ * Create a new MnemonicKeyPackage value
+ *
+ * @param { MnemonicToImport } mne A BIP39 mnemonic and optional BIP39 password and BIP32 derivation path
+ * @return { Uint8Array } A serialized key package for import to CubeSigner
+ */
+export function newMnemonicKeyPackage(mne: MnemonicToImport): Uint8Array {
+  const entropy = bip39.mnemonicToEntropy(mne.mnemonic, wordlist);
+  const path = !mne.derivationPath ? [] : parseDerivationPath(mne.derivationPath);
+  const password = mne.password ?? "";
+  const mnePkg = {
+    EnglishMnemonic: {
+      mnemonic: {
+        entropy,
+      },
+      der_path: {
+        path,
+      },
+      password,
+    },
+  };
+  return mpEncode(mnePkg);
+}
+
+// constants for derivation path parsing
+const DER_HARDENED = 1n << 31n;
+const DER_MAX = 1n << 32n;
+
+/**
+ * Parse a derivation path into a sequence of 32-bit integers
+ *
+ * @param { string } derp The derivation path to parse; must start with 'm/'
+ * @return { number[] } The parsed path
+ */
+export function parseDerivationPath(derp: string): number[] {
+  derp = derp.toLowerCase();
+  if (derp === "m") {
+    return [];
+  }
+  if (!derp.startsWith("m/")) {
+    throw new Error('Derivation path must start with "m/"');
+  }
+  const parts = derp.slice(2).split("/");
+  const ret = [];
+  for (let part of parts) {
+    let hardened = false;
+    if (part.endsWith("'") || part.endsWith("h")) {
+      hardened = true;
+      part = part.slice(0, part.length - 1);
+    }
+    if (part === "") {
+      throw new Error("Invalid derivation path: empty element");
+    }
+    let value = BigInt(part);
+    if (value >= DER_MAX) {
+      throw new Error("Derivation path element greater than 2^32 is invalid");
+    }
+    if (hardened) {
+      value = value | DER_HARDENED;
+    }
+    ret.push(Number(value));
+  }
+  return ret;
+}

package/src/util.ts

@@ -0,0 +1,47 @@
+/**
+ * Converts a bigint to a big-endian Uint8Array of a specified length
+ *
+ * @param { bigint } n The value to convert
+ * @param { number } l The length in bytes
+ * @return { Uint8Array } The big-endian bytes
+ */
+export function toBigEndian(n: bigint, l: number): Uint8Array {
+  if (n >= 1n << (8n * BigInt(l))) {
+    throw new Error(`Cannot convert ${n} to ${l} big-endian bytes (overflow)`);
+  }
+  let nn = n;
+  const ret = new Uint8Array(l);
+  for (let i = l - 1; i >= 0; --i) {
+    ret[i] = Number(nn % 256n);
+    nn = nn >> 8n;
+  }
+  return ret;
+}
+
+/**
+ * Concatenates an array of Uint8Arrays into a single array
+ *
+ * @param { Uint8Array[] } parts The parts to be concatenated
+ * @return { Uint8Array } The concatenated array
+ */
+export function concatArrays(parts: Uint8Array[]): Uint8Array {
+  const totalLen = parts.reduce((len, part) => len + part.length, 0);
+
+  let lenSoFar = 0;
+  const ret = new Uint8Array(totalLen);
+  parts.forEach((part) => {
+    ret.set(part, lenSoFar);
+    lenSoFar += part.length;
+  });
+
+  return ret;
+}
+
+/**
+ * Get the current time in seconds since UNIX epoch
+ *
+ * @return { BigInt } Seconds since UNIX epoch
+ */
+export function nowEpochMillis(): bigint {
+  return BigInt(Date.now());
+}