Merge in demo-3

Author: ricochet1k

_qr.js

@@ -0,0 +1,156 @@
+"use strict";
+
+import QrCode from "qrcode-svg";
+
+/**
+ * @typedef QrOpts
+ * @property {String} [background]
+ * @property {String} [color]
+ * @property {String} [ecl]
+ * @property {Number} [height]
+ * @property {Number} [indent]
+ * @property {Number} [padding]
+ * @property {"full" | "mini" | "micro"} [size]
+ * @property {Number} [width]
+ */
+
+/**
+ * @param {String} data
+ * @param {QrOpts} opts
+ */
+function _create(data, opts) {
+  //@ts-ignore
+  return new QrCode({
+    content: data,
+    padding: opts?.padding || 4,
+    width: opts?.width || 256,
+    height: opts?.height || 256,
+    color: opts?.color || "#000000",
+    background: opts?.background || "#ffffff",
+    ecl: opts?.ecl || "M",
+  });
+};
+
+/**
+ * @typedef {Object.<String, String>} BlockMap
+ */
+
+/**
+ * Encoded as top-left, top-right, bottom-left, bottom-right
+ * @type {Object.<"mini" | "micro", BlockMap>}
+ */
+let charMaps = {
+  micro: {
+    0b0000: " ",
+    0b0001: "▗",
+    0b0010: "▖",
+    0b0011: "▄",
+    0b0100: "▝",
+    0b0101: "▐",
+    0b0110: "▞",
+    0b0111: "▟",
+    0b1000: "▘",
+    0b1001: "▚",
+    0b1010: "▌",
+    0b1011: "▙",
+    0b1100: "▀",
+    0b1101: "▜",
+    0b1110: "▛",
+    0b1111: "█",
+  },
+  mini: {
+    0b0000: "  ",
+    0b0001: " ▄",
+    0b0010: "▄ ",
+    0b0011: "▄▄",
+    0b0100: " ▀",
+    0b0101: " █",
+    0b0110: "▄▀",
+    0b0111: "▄█",
+    0b1000: "▀ ",
+    0b1001: "▀▄",
+    0b1010: "█ ",
+    0b1011: "█▄",
+    0b1100: "▀▀",
+    0b1101: "▀█",
+    0b1110: "█▀",
+    0b1111: "██",
+  },
+};
+
+/**
+ * @param {String} data
+ * @param {QrOpts} opts
+ */
+export function quadAscii(data, opts) {
+  let charMap = charMaps[opts.size || "mini"];
+  let qrcode = _create(data, opts);
+  let indent = opts?.indent ?? 4;
+  let modules = qrcode.qrcode.modules;
+
+  let lines = [];
+  let length = modules.length;
+  for (let y = 0; y < length; y += 2) {
+    let line = ``.padStart(indent, " ");
+    for (let x = 0; x < length; x += 2) {
+      let count = 0;
+      // qr codes can be odd numbers
+      if (x >= length) {
+        line += charMap[count];
+        continue;
+      }
+      if (modules[x][y]) {
+        count += 8;
+      }
+      if (modules[x][y + 1]) {
+        count += 2;
+      }
+
+      if (x + 1 >= length) {
+        line += charMap[count];
+        continue;
+      }
+      if (modules[x + 1][y]) {
+        count += 4;
+      }
+      if (modules[x + 1][y + 1]) {
+        count += 1;
+      }
+      line += charMap[count];
+    }
+    lines.push(line);
+  }
+  return lines.join("\n");
+};
+
+/**
+ * @param {String} data
+ * @param {QrOpts} opts
+ */
+export function ascii(data, opts) {
+  if (!opts.size) {
+    opts.size = "mini";
+  }
+  if (["mini", "micro"].includes(opts.size)) {
+    return quadAscii(data, opts);
+  }
+
+  let qrcode = _create(data, opts);
+  let indent = opts?.indent ?? 4;
+  let modules = qrcode.qrcode.modules;
+
+  let lines = [];
+  let length = modules.length;
+  for (let y = 0; y < length; y += 1) {
+    let line = ``.padStart(indent, " ");
+    for (let x = 0; x < length; x += 1) {
+      let block = "  ";
+      if (modules[x][y]) {
+        block = "██";
+      }
+      line += block;
+    }
+    lines.push(line);
+  }
+  return lines.join("\n");
+};

bincode_types.ts

@@ -11,7 +11,7 @@ export type Option<T> = T | null | undefined;
  */
 export type FixedBytes<N extends number> = Uint8Array;
 
-export type Hash = typeof Bincode.Bytes; //FixedBytes<32>;
+export type Hash = Uint8Array; //FixedBytes<32>;
 
 export type SocketAddr = typeof Bincode.SocketAddr extends Bincode.BinCodeable<infer T> ? T : never;
 

dashhd-utils.js

@@ -0,0 +1,214 @@
+import DashHd from "dashhd";
+
+/** @typedef {Number} Uint32 */
+
+// https://github.com/dashpay/dips/blob/master/dip-0009.md
+const PURPOSE_FEATURE_PATHS = "9'"; // DIP9
+// https://github.com/dashpay/dips/blob/master/dip-0013.md
+const FEATURE_IDENTITY = "5'"; // DIP13
+// https://github.com/satoshilabs/slips/blob/master/slip-0044.md
+const COIN_TYPE_DASH = "5'"; // SLIP44
+const COIN_TYPE_TESTNET = "1'"; // SLIP44
+const SUB_FEATURE_AUTH = "0'"; // DIP13
+const KEY_TYPE_ECDSA = "0'"; // DIP13
+const KEY_TYPE_BLS = "1'"; // DIP13
+const SUB_FEATURE_REG = "1'"; // DIP13
+const SUB_FEATURE_TOPUP = "2'"; // DIP13
+
+// m/9'/<coin-type>/5'/<sub-feature>
+// const PREFIX_IDENT = `m/${PURPOSE_FEATURE_PATHS}/${COIN_TYPE_DASH}/${FEATURE_IDENTITY}`;
+// const PREFIX_IDENT_TESTNET = `m/${PURPOSE_FEATURE_PATHS}/${COIN_TYPE_TESTNET}/${FEATURE_IDENTITY}`;
+// const PREFIX_AUTH = `${PREFIX_IDENT}/${SUB_FEATURE_AUTH}/${KEY_TYPE_ECDSA}`;
+// const PREFIX_AUTH_TESTNET = `${PREFIX_IDENT_TESTNET}/${SUB_FEATURE_AUTH}/${KEY_TYPE_ECDSA}`;
+// const PREFIX_REG = `${PREFIX_IDENT}/${SUB_FEATURE_REG}`;
+// const PREFIX_REG_TESTNET = `${PREFIX_IDENT_TESTNET}/${SUB_FEATURE_REG}`;
+// const PREFIX_TOPUP = `${PREFIX_IDENT}/${SUB_FEATURE_TOPUP}`;
+// const PREFIX_TOPUP_TESTNET = `${PREFIX_IDENT_TESTNET}/${SUB_FEATURE_TOPUP}`;
+
+/**
+ * Returns the Identity Auth Wallet, which can be used to derive Identity Auth Keys
+ * @param {import('dashhd').HDWallet} walletKey
+ * @param {String} path
+ */
+//@ts-expect-error - monkey-patch
+DashHd.deriveIdentAuthWalletPath = async function (walletKey, path) {
+  let hdpath = _parseIdentityWallet(path);
+  let identAuthKey = await _deriveIdentAuthPath(walletKey, hdpath);
+
+  return identAuthKey;
+};
+
+/**
+ * Returns a fully-derived Identity Auth Key
+ * @param {import('dashhd').HDWallet} walletKey
+ * @param {String} path
+ */
+//@ts-expect-error - monkey-patch
+DashHd.deriveIdentAuthKeyPath = async function (walletKey, path) {
+  const INDEX_AUTH_IDENTITY_KEY = 7;
+
+  let hdpath = _parseIdentityWallet(path);
+  let hasAuthKey =
+    hdpath.paths.length > INDEX_AUTH_IDENTITY_KEY &&
+    hdpath.paths[INDEX_AUTH_IDENTITY_KEY].endsWith("'");
+  if (!hasAuthKey) {
+    throw new Error(
+      `an auth wallet key path must be in the form \`m/9'/<coin-type>/5'/0'/<key-type>/<identity-index>/<key-index>' where the key index must have a trailing apostrophe`,
+    );
+  }
+
+  let authWalletKey = await _deriveIdentAuthPath(walletKey, hdpath);
+  let authKey = await authWalletKey.deriveAuthKey(hdpath);
+
+  return authKey;
+};
+
+/**
+ * @typedef HDPathPlatform
+ * @prop {String} path
+ * @prop {Array<String>} paths
+ * @prop {"m"|"m'"} m
+ * @prop {"9'"} purpose
+ * @prop {"5'"|"1'"} coinType
+ * @prop {"5'"} feature
+ * @prop {"0'"|"1'"|"2'"} subFeature
+ * @prop {"0'"|"1'"} [keyType]
+ * @prop {String} [identityIndex]
+ * @prop {String} [keyIndex]
+ * @prop {String} [topupIndex]
+ * @prop {String} [fundRegIndex]
+ */
+
+/**
+ * @param {import('dashhd').HDWallet} walletKey
+ * @param {HDPathPlatform} hdpath
+ */
+async function _deriveIdentAuthPath(walletKey, hdpath) {
+  const INDEX_KEY_TYPE = 5;
+  const INDEX_AUTH_IDENTITY = 6;
+
+  let keyType = hdpath.paths[INDEX_KEY_TYPE];
+  let isValidKeyType = keyType === KEY_TYPE_ECDSA || keyType === KEY_TYPE_BLS;
+  let hasIdentity =
+    hdpath.paths.length > INDEX_AUTH_IDENTITY &&
+    hdpath.paths[INDEX_AUTH_IDENTITY].endsWith("'");
+  let isIdentity = isValidKeyType && hasIdentity;
+  if (!isIdentity) {
+    throw new Error(
+      `an identity wallet identity auth path must be in the form \`m/9'/<coin-type>/5'/0'/<key-type>/<identity-index>' where coin-type is 5' (DASH mainnet) or 1' (testnet), key-type is 0' (ECDSA) or 1' (BLS), and identity index must have a trailing apostrophe`,
+    );
+  }
+
+  // 0=m/1=purpose'/2=coin-type'/3=feature'/4=sub-feature'/5=key-type'/6=identity-index'
+  let authWalletPath = `m/9'/${hdpath.coinType}/5'/0'/${keyType}/${hdpath.paths[INDEX_AUTH_IDENTITY]}`;
+  let _authWalletKey = await DashHd.derivePath(walletKey, authWalletPath);
+
+  let authWalletKey = Object.assign(_authWalletKey, {
+    /** @param {Uint32} authKeyIndex */
+    deriveAuthKey: async function (authKeyIndex) {
+      let authKey = await DashHd.deriveChild(
+        _authWalletKey,
+        authKeyIndex,
+        DashHd.HARDENED,
+      );
+      return authKey;
+    },
+  });
+
+  return authWalletKey;
+}
+
+/**
+ * Returns a fully-derived Identity Registration Funding Key
+ * @param {import('dashhd').HDWallet} walletKey
+ * @param {String} path
+ */
+//@ts-expect-error - monkey-patch
+DashHd.deriveIdentRegFundKeyPath = async function (walletKey, path) {
+  const INDEX_REG_FUND_KEY = 5;
+
+  let hdpath = _parseIdentityWallet(path);
+  let hasIdentity =
+    hdpath.paths.length > INDEX_REG_FUND_KEY &&
+    !hdpath.paths[INDEX_REG_FUND_KEY].endsWith("'");
+  if (!hasIdentity) {
+    throw new Error(
+      `an identity wallet identity reg path must be in the form \`m/9'/<coin-type>/5'/1'/<identity-index>' where the identity index MUST NOT have a trailing apostrophe`,
+    );
+  }
+
+  // 0=m/1=purpose'/2=coin-type'/3=feature'/4=sub-feature'/5=identity-index
+  let identRegFundPath = `m/9'/${hdpath.coinType}/5'/1'/${hdpath.paths[INDEX_REG_FUND_KEY]}`;
+  let identRegFundKey = await DashHd.derivePath(walletKey, identRegFundPath);
+
+  return identRegFundKey;
+};
+
+// async function deriveIdentTopupWallet(walletKey, path) {
+// }
+
+/**
+ * Returns a fully-derived Topup Funding Key
+ * @param {import('dashhd').HDWallet} walletKey
+ * @param {String} path
+ */
+//@ts-expect-error - monkey-patch
+DashHd.deriveIdentTopupKeyPath = async function (walletKey, path) {
+  const INDEX_TOPUP_KEY = 5;
+
+  let hdpath = _parseIdentityWallet(path);
+  let hasIdentity =
+    hdpath.paths.length > INDEX_TOPUP_KEY &&
+    !hdpath.paths[INDEX_TOPUP_KEY].endsWith("'");
+  if (!hasIdentity) {
+    throw new Error(
+      `an identity wallet identity reg path must be in the form \`m/9'/<coin-type>/5'/2'/<topup-index>' where the topup index MUST NOT have a trailing apostrophe`,
+    );
+  }
+
+  // 0=m/1=purpose'/2=coin-type'/3=feature'/4=sub-feature'/5=topup-index
+  let identTopupPath = `m/9'/${hdpath.coinType}/5'/2'/${hdpath.paths[INDEX_TOPUP_KEY]}`;
+  let identTopupKey = await DashHd.derivePath(walletKey, identTopupPath);
+
+  return identTopupKey;
+};
+
+/**
+ * @param {String} path
+ * @returns {HDPathPlatform}
+ */
+function _parseIdentityWallet(path) {
+  let paths = path.split("/");
+  let [m, purpose, coinType, feature, subFeature] = paths;
+  let hasMaster = m === "m" || m === "m'";
+  let hasPurpose = purpose === PURPOSE_FEATURE_PATHS;
+  let hasCoinType =
+    coinType === COIN_TYPE_DASH || coinType === COIN_TYPE_TESTNET;
+  let hasFeature = feature === FEATURE_IDENTITY;
+  let hasSubFeature = [
+    SUB_FEATURE_AUTH,
+    SUB_FEATURE_REG,
+    SUB_FEATURE_TOPUP,
+  ].includes(subFeature);
+
+  let hasValidPrefix =
+    hasMaster && hasPurpose && hasCoinType && hasFeature && hasSubFeature;
+  if (!hasValidPrefix) {
+    throw new Error(
+      `identity wallet paths must be in the form \`m/9'/<coin-type>/5'/<sub-feature>' where coin-type is 5' (DASH mainnet) or 1' (testnet) and sub-feature is 0' (auth), 1' (registration), or 2' (topup)`,
+    );
+  }
+
+  //@ts-expect-error - these have been type checked
+  return { path, paths, m, purpose, coinType, feature, subFeature };
+}
+
+export default DashHd;
+//@ts-expect-error - monkey patch
+export let deriveIdentTopupKeyPath = DashHd.deriveIdentTopupKeyPath;
+//@ts-expect-error - monkey patch
+export let deriveIdentRegFundKeyPath = DashHd.deriveIdentRegFundKeyPath;
+//@ts-expect-error - monkey patch
+export let deriveIdentAuthKeyPath = DashHd.deriveIdentAuthKeyPath;
+//@ts-expect-error - monkey patch
+export let deriveIdentAuthWalletPath = DashHd.deriveIdentAuthWalletPath;