@ledgerhq/revault-sdk 0.20.0 → 0.21.1

package/lib/crypto.js

@@ -1,260 +1,6 @@
-// src/crypto/utils.ts
-import crypto from "crypto";
-import elliptic2 from "elliptic";
-
-// src/crypto/key-encoder.ts
-import asn1 from "asn1.js";
-import BN from "bn.js";
-import elliptic from "elliptic";
-var ECPrivateKeyASN = asn1.define("ECPrivateKey", function() {
-  const self = this;
-  self.seq().obj(
-    self.key("version").int(),
-    self.key("privateKey").octstr(),
-    self.key("parameters").explicit(0).objid().optional(),
-    self.key("publicKey").explicit(1).bitstr().optional()
-  );
-});
-var ECPrivateKey8ASN = asn1.define(
-  "ECPrivateKey",
-  /* v8 ignore start */
-  function() {
-    const self = this;
-    self.seq().obj(
-      self.key("version").int(),
-      self.key("privateKeyAlgorithm").seq().obj(self.key("ecPublicKey").objid(), self.key("curve").objid()),
-      self.key("privateKey").octstr().contains(ECPrivateKeyASN),
-      self.key("attributes").explicit(0).bitstr().optional()
-    );
-  }
-  /* v8 ignore stop */
-);
-var SubjectPublicKeyInfoASN = asn1.define("SubjectPublicKeyInfo", function() {
-  const self = this;
-  self.seq().obj(
-    self.key("algorithm").seq().obj(self.key("id").objid(), self.key("curve").objid()),
-    self.key("pub").bitstr()
-  );
-});
-var curves = {
-  secp256k1: {
-    curveParameters: [1, 3, 132, 0, 10],
-    privatePEMOptions: { label: "EC PRIVATE KEY" },
-    publicPEMOptions: { label: "PUBLIC KEY" },
-    curve: new elliptic.ec("secp256k1")
-  },
-  p256: {
-    curveParameters: [1, 2, 840, 10045, 3, 1, 7],
-    // OID for p256 curve
-    privatePEMOptions: { label: "EC PRIVATE KEY" },
-    publicPEMOptions: { label: "PUBLIC KEY" },
-    curve: new elliptic.ec("p256")
-  }
-};
-var KeyEncoder = class {
-  algorithmID;
-  options;
-  constructor(options) {
-    if (typeof options === "string") {
-      if (options !== "secp256k1" && options !== "p256") {
-        throw new Error("Unknown curve " + options);
-      }
-      options = curves[options];
-    }
-    this.options = options;
-    this.algorithmID = [1, 2, 840, 10045, 2, 1];
-  }
-  /* v8 ignore start */
-  PKCS1toPKCS8(privateKey) {
-    return {
-      version: new BN(0),
-      privateKey,
-      privateKeyAlgorithm: {
-        ecPublicKey: this.algorithmID,
-        curve: privateKey.parameters
-      }
-    };
-  }
-  /* v8 ignore stop */
-  privateKeyObject(rawPrivateKey, rawPublicKey) {
-    const privateKeyObject = {
-      version: new BN(1),
-      privateKey: Buffer.from(rawPrivateKey, "hex"),
-      parameters: this.options.curveParameters
-    };
-    if (rawPublicKey) {
-      privateKeyObject.publicKey = {
-        unused: 0,
-        data: Buffer.from(rawPublicKey, "hex")
-      };
-    }
-    return privateKeyObject;
-  }
-  publicKeyObject(rawPublicKey) {
-    return {
-      algorithm: {
-        id: this.algorithmID,
-        curve: this.options.curveParameters
-      },
-      pub: {
-        unused: 0,
-        data: Buffer.from(rawPublicKey, "hex")
-      }
-    };
-  }
-  encodePrivate(privateKey, originalFormat, destinationFormat, destinationFormatType = "pkcs1") {
-    let privateKeyObject;
-    switch (originalFormat) {
-      case "raw": {
-        if (typeof privateKey !== "string") {
-          throw new Error("private key must be a string");
-        }
-        const keyPair = this.options.curve.keyFromPrivate(privateKey, "hex");
-        const rawPublicKey = keyPair.getPublic("hex");
-        privateKeyObject = this.privateKeyObject(privateKey, rawPublicKey);
-        break;
-      }
-      case "der":
-        if (typeof privateKey === "string") {
-          privateKey = Buffer.from(privateKey, "hex");
-        }
-        privateKeyObject = ECPrivateKeyASN.decode(privateKey, "der");
-        break;
-      case "pem":
-        if (typeof privateKey !== "string") {
-          throw new Error("private key must be a string");
-        }
-        privateKeyObject = ECPrivateKeyASN.decode(
-          privateKey,
-          "pem",
-          this.options.privatePEMOptions
-        );
-        break;
-      /* v8 ignore start */
-      default:
-        throw new Error("invalid private key format");
-    }
-    switch (destinationFormat) {
-      case "raw":
-        if (destinationFormatType === "pkcs1") {
-          return privateKeyObject.privateKey.toString("hex");
-        } else if (destinationFormatType === "pkcs8") {
-          return this.PKCS1toPKCS8(privateKeyObject).privateKey.privateKey.toString("hex");
-        }
-        break;
-      case "der":
-        if (destinationFormatType === "pkcs1") {
-          return ECPrivateKeyASN.encode(privateKeyObject, "der").toString("hex");
-        } else if (destinationFormatType === "pkcs8") {
-          return ECPrivateKey8ASN.encode(this.PKCS1toPKCS8(privateKeyObject), "der").toString(
-            "hex"
-          );
-        }
-        break;
-      case "pem":
-        if (destinationFormatType === "pkcs1") {
-          return ECPrivateKeyASN.encode(privateKeyObject, "pem", this.options.privatePEMOptions);
-        } else if (destinationFormatType === "pkcs8") {
-          return ECPrivateKey8ASN.encode(this.PKCS1toPKCS8(privateKeyObject), "pem", {
-            ...this.options.privatePEMOptions,
-            label: "PRIVATE KEY"
-          });
-        }
-        break;
-      /* v8 ignore start */
-      default:
-        throw new Error("invalid destination format for private key");
-    }
-    throw new Error("unsupported destination format or type");
-  }
-  encodePublic(publicKey, originalFormat, destinationFormat) {
-    let publicKeyObject;
-    switch (originalFormat) {
-      case "raw":
-        if (typeof publicKey !== "string") {
-          throw new Error("public key must be a string");
-        }
-        publicKeyObject = this.publicKeyObject(publicKey);
-        break;
-      case "der":
-        if (typeof publicKey === "string") {
-          publicKey = Buffer.from(publicKey, "hex");
-        }
-        publicKeyObject = SubjectPublicKeyInfoASN.decode(publicKey, "der");
-        break;
-      case "pem":
-        if (typeof publicKey !== "string") {
-          throw new Error("public key must be a string");
-        }
-        publicKeyObject = SubjectPublicKeyInfoASN.decode(
-          publicKey,
-          "pem",
-          this.options.publicPEMOptions
-        );
-        break;
-      /* v8 ignore start */
-      default:
-        throw new Error("invalid public key format");
-    }
-    switch (destinationFormat) {
-      case "raw":
-        return publicKeyObject.pub.data.toString("hex");
-      case "der":
-        return SubjectPublicKeyInfoASN.encode(publicKeyObject, "der").toString("hex");
-      case "pem":
-        return SubjectPublicKeyInfoASN.encode(
-          publicKeyObject,
-          "pem",
-          this.options.publicPEMOptions
-        );
-      /* v8 ignore start */
-      default:
-        throw new Error("invalid destination format for public key");
-    }
-  }
-};
-
-// src/crypto/utils.ts
-function extractPublicKey(pemKey) {
-  const pem = pemKey.split("\n");
-  pem.shift();
-  pem.pop();
-  const keyBuffer = Buffer.from(pem.join(""), "base64");
-  const actualKeyBuffer = keyBuffer.slice(26);
-  return actualKeyBuffer.toString("hex");
-}
-function hexToPem(hexString, { isPrivate = true } = {}) {
-  const keyEncoder = new KeyEncoder("p256");
-  if (isPrivate) {
-    return keyEncoder.encodePrivate(hexString, "raw", "pem");
-  }
-  return keyEncoder.encodePublic(hexString, "raw", "pem");
-}
-function genKeys(entropy) {
-  if (entropy) {
-    const ec = new elliptic2.ec("p256");
-    const hashedEntropy = crypto.createHash("sha256").update(entropy).digest("hex");
-    const keyPair = ec.genKeyPair({
-      entropy: Buffer.from(hashedEntropy, "hex")
-    });
-    return {
-      privateKey: String(hexToPem(keyPair.getPrivate("hex"))),
-      publicKey: String(hexToPem(keyPair.getPublic("hex"), { isPrivate: false })),
-      hexPubKey: extractPublicKey(String(hexToPem(keyPair.getPublic("hex"), { isPrivate: false })))
-    };
-  }
-  const { publicKey, privateKey } = crypto.generateKeyPairSync("ec", {
-    namedCurve: "P-256",
-    publicKeyEncoding: { type: "spki", format: "pem" },
-    privateKeyEncoding: { type: "sec1", format: "pem" }
-  });
-  const hexPubKey = extractPublicKey(publicKey);
-  return {
-    privateKey,
-    publicKey,
-    hexPubKey
-  };
-}
+import {
+  genKeys
+} from "./chunk-CZLZUISN.js";
 export {
   genKeys
 };

package/lib/crypto.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/crypto/utils.ts","../src/crypto/key-encoder.ts"],"sourcesContent":["import crypto from \"crypto\";\nimport elliptic from \"elliptic\";\n\nimport { KeyEncoder } from \"./key-encoder\";\nimport type { GeneratedKeys } from \"./types\";\n\nfunction extractPublicKey(pemKey: string): string {\n  // convert the PEM formatted public key to raw public key in X9.62 uncompressed format\n  // this is an oversimplified method and may not work with different curves or PEM formats\n  const pem = pemKey.split(\"\\n\");\n  pem.shift(); // remove the first line (BEGIN PUBLIC KEY)\n  pem.pop(); // remove the last line (END PUBLIC KEY)\n  // convert base64 to buffer\n  const keyBuffer = Buffer.from(pem.join(\"\"), \"base64\");\n  // assuming the first 26 bytes are the header for the SPKI formatted key.\n  // the actual key should begin after this header.\n  const actualKeyBuffer = keyBuffer.slice(26);\n  return actualKeyBuffer.toString(\"hex\");\n}\n\nfunction hexToPem(hexString: string, { isPrivate = true } = {}): string {\n  const keyEncoder = new KeyEncoder(\"p256\");\n  if (isPrivate) {\n    return keyEncoder.encodePrivate(hexString, \"raw\", \"pem\");\n  }\n  return keyEncoder.encodePublic(hexString, \"raw\", \"pem\");\n}\n\n/**\n * If `entropy` is passed, will generate keys pair deterministically\n * else, random keys pair generated\n */\nexport function genKeys(entropy?: string): GeneratedKeys {\n  if (entropy) {\n    const ec = new elliptic.ec(\"p256\");\n    const hashedEntropy = crypto.createHash(\"sha256\").update(entropy).digest(\"hex\");\n    const keyPair = ec.genKeyPair({\n      entropy: Buffer.from(hashedEntropy, \"hex\"),\n    });\n    return {\n      privateKey: String(hexToPem(keyPair.getPrivate(\"hex\"))),\n      publicKey: String(hexToPem(keyPair.getPublic(\"hex\"), { isPrivate: false })),\n      hexPubKey: extractPublicKey(String(hexToPem(keyPair.getPublic(\"hex\"), { isPrivate: false }))),\n    };\n  }\n  const { publicKey, privateKey } = crypto.generateKeyPairSync(\"ec\", {\n    namedCurve: \"P-256\",\n    publicKeyEncoding: { type: \"spki\", format: \"pem\" },\n    privateKeyEncoding: { type: \"sec1\", format: \"pem\" },\n  });\n  const hexPubKey = extractPublicKey(publicKey);\n  return {\n    privateKey,\n    publicKey,\n    hexPubKey,\n  };\n}\n","// ========================================================================== //\n//                                                                            //\n//                                 DISCLAIMER                                 //\n//                                                                            //\n//                This code has been blindly copy-pasted from:                //\n//                    https://github.com/LedgerHQ/pkey-ts                     //\n//                                                                            //\n// ========================================================================== //\n//\n// @ts-expect-error this library does not ship types\nimport asn1 from \"asn1.js\";\nimport BN from \"bn.js\";\nimport elliptic from \"elliptic\";\n\n/* cspell:disable */\nconst ECPrivateKeyASN = asn1.define(\"ECPrivateKey\", function () {\n  // @ts-expect-error pure black box\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unnecessary-type-assertion\n  const self = this as any;\n  self\n    .seq()\n    .obj(\n      self.key(\"version\").int(),\n      self.key(\"privateKey\").octstr(),\n      self.key(\"parameters\").explicit(0).objid().optional(),\n      self.key(\"publicKey\").explicit(1).bitstr().optional(),\n    );\n});\n\nconst ECPrivateKey8ASN = asn1.define(\n  \"ECPrivateKey\",\n  /* v8 ignore start */\n  function () {\n    // @ts-expect-error pure black box\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unnecessary-type-assertion\n    const self = this as any;\n    self\n      .seq()\n      .obj(\n        self.key(\"version\").int(),\n        self\n          .key(\"privateKeyAlgorithm\")\n          .seq()\n          .obj(self.key(\"ecPublicKey\").objid(), self.key(\"curve\").objid()),\n        self.key(\"privateKey\").octstr().contains(ECPrivateKeyASN),\n        self.key(\"attributes\").explicit(0).bitstr().optional(),\n      );\n  },\n  /* v8 ignore stop */\n);\n\nconst SubjectPublicKeyInfoASN = asn1.define(\"SubjectPublicKeyInfo\", function () {\n  // @ts-expect-error pure black box\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unnecessary-type-assertion\n  const self = this as any;\n  self\n    .seq()\n    .obj(\n      self.key(\"algorithm\").seq().obj(self.key(\"id\").objid(), self.key(\"curve\").objid()),\n      self.key(\"pub\").bitstr(),\n    );\n});\n\ntype CurveOptions = {\n  curveParameters: number[];\n  privatePEMOptions: { label: string };\n  publicPEMOptions: { label: string };\n  curve: elliptic.ec;\n};\n\nconst curves: Record<string, CurveOptions> = {\n  secp256k1: {\n    curveParameters: [1, 3, 132, 0, 10],\n    privatePEMOptions: { label: \"EC PRIVATE KEY\" },\n    publicPEMOptions: { label: \"PUBLIC KEY\" },\n    curve: new elliptic.ec(\"secp256k1\"),\n  },\n  p256: {\n    curveParameters: [1, 2, 840, 10045, 3, 1, 7], // OID for p256 curve\n    privatePEMOptions: { label: \"EC PRIVATE KEY\" },\n    publicPEMOptions: { label: \"PUBLIC KEY\" },\n    curve: new elliptic.ec(\"p256\"),\n  },\n};\n\ntype PrivateKeyPKCS1 = {\n  version: BN;\n  privateKey: Buffer;\n  parameters: number[];\n  publicKey?: {\n    unused: number;\n    data: Buffer;\n  };\n};\n\ntype PrivateKeyPKCS8 = {\n  version: BN;\n  privateKey: PrivateKeyPKCS1;\n  privateKeyAlgorithm: { ecPublicKey: number[]; curve: number[] };\n};\n\nexport type KeyFormat = \"raw\" | \"pem\" | \"der\";\n\nexport class KeyEncoder {\n  algorithmID: number[];\n  options: CurveOptions;\n\n  constructor(options: string | CurveOptions) {\n    if (typeof options === \"string\") {\n      /* v8 ignore start */\n      if (options !== \"secp256k1\" && options !== \"p256\") {\n        throw new Error(\"Unknown curve \" + options);\n      }\n      /* v8 ignore stop */\n      options = curves[options]!;\n    }\n    this.options = options;\n    this.algorithmID = [1, 2, 840, 10045, 2, 1];\n  }\n\n  /* v8 ignore start */\n  private PKCS1toPKCS8(privateKey: PrivateKeyPKCS1): PrivateKeyPKCS8 {\n    return {\n      version: new BN(0),\n      privateKey,\n      privateKeyAlgorithm: {\n        ecPublicKey: this.algorithmID,\n        curve: privateKey.parameters,\n      },\n    };\n  }\n  /* v8 ignore stop */\n\n  privateKeyObject(rawPrivateKey: string, rawPublicKey: string): PrivateKeyPKCS1 {\n    const privateKeyObject: PrivateKeyPKCS1 = {\n      version: new BN(1),\n      privateKey: Buffer.from(rawPrivateKey, \"hex\"),\n      parameters: this.options.curveParameters,\n    };\n\n    if (rawPublicKey) {\n      privateKeyObject.publicKey = {\n        unused: 0,\n        data: Buffer.from(rawPublicKey, \"hex\"),\n      };\n    }\n\n    return privateKeyObject;\n  }\n\n  publicKeyObject(rawPublicKey: string): {\n    algorithm: { id: number[]; curve: number[] };\n    pub: { unused: number; data: Buffer };\n  } {\n    return {\n      algorithm: {\n        id: this.algorithmID,\n        curve: this.options.curveParameters,\n      },\n      pub: {\n        unused: 0,\n        data: Buffer.from(rawPublicKey, \"hex\"),\n      },\n    };\n  }\n\n  encodePrivate(\n    privateKey: string | Buffer,\n    originalFormat: KeyFormat,\n    destinationFormat: KeyFormat,\n    destinationFormatType: \"pkcs8\" | \"pkcs1\" = \"pkcs1\",\n  ): string {\n    let privateKeyObject: PrivateKeyPKCS1;\n\n    /* Parse the incoming private key and convert it to a private key object */\n    switch (originalFormat) {\n      case \"raw\": {\n        if (typeof privateKey !== \"string\") {\n          throw new Error(\"private key must be a string\");\n        }\n        const keyPair = this.options.curve.keyFromPrivate(privateKey, \"hex\");\n        const rawPublicKey = keyPair.getPublic(\"hex\");\n        privateKeyObject = this.privateKeyObject(privateKey, rawPublicKey);\n        break;\n      }\n      case \"der\":\n        if (typeof privateKey === \"string\") {\n          privateKey = Buffer.from(privateKey, \"hex\");\n        }\n        privateKeyObject = ECPrivateKeyASN.decode(privateKey, \"der\");\n        break;\n      case \"pem\":\n        if (typeof privateKey !== \"string\") {\n          throw new Error(\"private key must be a string\");\n        }\n        privateKeyObject = ECPrivateKeyASN.decode(\n          privateKey,\n          \"pem\",\n          this.options.privatePEMOptions,\n        );\n        break;\n      /* v8 ignore start */\n      default:\n        throw new Error(\"invalid private key format\");\n      /* v8 ignore stop */\n    }\n\n    /* Export the private key object to the desired format */\n    switch (destinationFormat) {\n      case \"raw\":\n        if (destinationFormatType === \"pkcs1\") {\n          return privateKeyObject.privateKey.toString(\"hex\");\n        } else if (destinationFormatType === \"pkcs8\") {\n          return this.PKCS1toPKCS8(privateKeyObject).privateKey.privateKey.toString(\"hex\");\n        }\n        break;\n      case \"der\":\n        if (destinationFormatType === \"pkcs1\") {\n          return ECPrivateKeyASN.encode(privateKeyObject, \"der\").toString(\"hex\");\n        } else if (destinationFormatType === \"pkcs8\") {\n          return ECPrivateKey8ASN.encode(this.PKCS1toPKCS8(privateKeyObject), \"der\").toString(\n            \"hex\",\n          );\n        }\n        break;\n      case \"pem\":\n        if (destinationFormatType === \"pkcs1\") {\n          return ECPrivateKeyASN.encode(privateKeyObject, \"pem\", this.options.privatePEMOptions);\n        } else if (destinationFormatType === \"pkcs8\") {\n          return ECPrivateKey8ASN.encode(this.PKCS1toPKCS8(privateKeyObject), \"pem\", {\n            ...this.options.privatePEMOptions,\n            label: \"PRIVATE KEY\",\n          });\n        }\n        break;\n      /* v8 ignore start */\n      default:\n        throw new Error(\"invalid destination format for private key\");\n      /* v8 ignore stop */\n    }\n\n    throw new Error(\"unsupported destination format or type\");\n  }\n\n  encodePublic(\n    publicKey: string | Buffer,\n    originalFormat: KeyFormat,\n    destinationFormat: KeyFormat,\n  ): string {\n    let publicKeyObject;\n\n    switch (originalFormat) {\n      case \"raw\":\n        if (typeof publicKey !== \"string\") {\n          throw new Error(\"public key must be a string\");\n        }\n        publicKeyObject = this.publicKeyObject(publicKey);\n        break;\n      case \"der\":\n        if (typeof publicKey === \"string\") {\n          publicKey = Buffer.from(publicKey, \"hex\");\n        }\n        publicKeyObject = SubjectPublicKeyInfoASN.decode(publicKey, \"der\");\n        break;\n      case \"pem\":\n        if (typeof publicKey !== \"string\") {\n          throw new Error(\"public key must be a string\");\n        }\n        publicKeyObject = SubjectPublicKeyInfoASN.decode(\n          publicKey,\n          \"pem\",\n          this.options.publicPEMOptions,\n        );\n        break;\n      /* v8 ignore start */\n      default:\n        throw new Error(\"invalid public key format\");\n      /* v8 ignore stop */\n    }\n\n    /* Export the private key object to the desired format */\n    switch (destinationFormat) {\n      case \"raw\":\n        return publicKeyObject.pub.data.toString(\"hex\");\n      case \"der\":\n        return SubjectPublicKeyInfoASN.encode(publicKeyObject, \"der\").toString(\"hex\");\n      case \"pem\":\n        return SubjectPublicKeyInfoASN.encode(\n          publicKeyObject,\n          \"pem\",\n          this.options.publicPEMOptions,\n        );\n      /* v8 ignore start */\n      default:\n        throw new Error(\"invalid destination format for public key\");\n      /* v8 ignore stop */\n    }\n  }\n}\n/* cspell:enable */\n"],"mappings":";AAAA,OAAO,YAAY;AACnB,OAAOA,eAAc;;;ACSrB,OAAO,UAAU;AACjB,OAAO,QAAQ;AACf,OAAO,cAAc;AAGrB,IAAM,kBAAkB,KAAK,OAAO,gBAAgB,WAAY;AAG9D,QAAM,OAAO;AACb,OACG,IAAI,EACJ;AAAA,IACC,KAAK,IAAI,SAAS,EAAE,IAAI;AAAA,IACxB,KAAK,IAAI,YAAY,EAAE,OAAO;AAAA,IAC9B,KAAK,IAAI,YAAY,EAAE,SAAS,CAAC,EAAE,MAAM,EAAE,SAAS;AAAA,IACpD,KAAK,IAAI,WAAW,EAAE,SAAS,CAAC,EAAE,OAAO,EAAE,SAAS;AAAA,EACtD;AACJ,CAAC;AAED,IAAM,mBAAmB,KAAK;AAAA,EAC5B;AAAA;AAAA,EAEA,WAAY;AAGV,UAAM,OAAO;AACb,SACG,IAAI,EACJ;AAAA,MACC,KAAK,IAAI,SAAS,EAAE,IAAI;AAAA,MACxB,KACG,IAAI,qBAAqB,EACzB,IAAI,EACJ,IAAI,KAAK,IAAI,aAAa,EAAE,MAAM,GAAG,KAAK,IAAI,OAAO,EAAE,MAAM,CAAC;AAAA,MACjE,KAAK,IAAI,YAAY,EAAE,OAAO,EAAE,SAAS,eAAe;AAAA,MACxD,KAAK,IAAI,YAAY,EAAE,SAAS,CAAC,EAAE,OAAO,EAAE,SAAS;AAAA,IACvD;AAAA,EACJ;AAAA;AAEF;AAEA,IAAM,0BAA0B,KAAK,OAAO,wBAAwB,WAAY;AAG9E,QAAM,OAAO;AACb,OACG,IAAI,EACJ;AAAA,IACC,KAAK,IAAI,WAAW,EAAE,IAAI,EAAE,IAAI,KAAK,IAAI,IAAI,EAAE,MAAM,GAAG,KAAK,IAAI,OAAO,EAAE,MAAM,CAAC;AAAA,IACjF,KAAK,IAAI,KAAK,EAAE,OAAO;AAAA,EACzB;AACJ,CAAC;AASD,IAAM,SAAuC;AAAA,EAC3C,WAAW;AAAA,IACT,iBAAiB,CAAC,GAAG,GAAG,KAAK,GAAG,EAAE;AAAA,IAClC,mBAAmB,EAAE,OAAO,iBAAiB;AAAA,IAC7C,kBAAkB,EAAE,OAAO,aAAa;AAAA,IACxC,OAAO,IAAI,SAAS,GAAG,WAAW;AAAA,EACpC;AAAA,EACA,MAAM;AAAA,IACJ,iBAAiB,CAAC,GAAG,GAAG,KAAK,OAAO,GAAG,GAAG,CAAC;AAAA;AAAA,IAC3C,mBAAmB,EAAE,OAAO,iBAAiB;AAAA,IAC7C,kBAAkB,EAAE,OAAO,aAAa;AAAA,IACxC,OAAO,IAAI,SAAS,GAAG,MAAM;AAAA,EAC/B;AACF;AAoBO,IAAM,aAAN,MAAiB;AAAA,EACtB;AAAA,EACA;AAAA,EAEA,YAAY,SAAgC;AAC1C,QAAI,OAAO,YAAY,UAAU;AAE/B,UAAI,YAAY,eAAe,YAAY,QAAQ;AACjD,cAAM,IAAI,MAAM,mBAAmB,OAAO;AAAA,MAC5C;AAEA,gBAAU,OAAO,OAAO;AAAA,IAC1B;AACA,SAAK,UAAU;AACf,SAAK,cAAc,CAAC,GAAG,GAAG,KAAK,OAAO,GAAG,CAAC;AAAA,EAC5C;AAAA;AAAA,EAGQ,aAAa,YAA8C;AACjE,WAAO;AAAA,MACL,SAAS,IAAI,GAAG,CAAC;AAAA,MACjB;AAAA,MACA,qBAAqB;AAAA,QACnB,aAAa,KAAK;AAAA,QAClB,OAAO,WAAW;AAAA,MACpB;AAAA,IACF;AAAA,EACF;AAAA;AAAA,EAGA,iBAAiB,eAAuB,cAAuC;AAC7E,UAAM,mBAAoC;AAAA,MACxC,SAAS,IAAI,GAAG,CAAC;AAAA,MACjB,YAAY,OAAO,KAAK,eAAe,KAAK;AAAA,MAC5C,YAAY,KAAK,QAAQ;AAAA,IAC3B;AAEA,QAAI,cAAc;AAChB,uBAAiB,YAAY;AAAA,QAC3B,QAAQ;AAAA,QACR,MAAM,OAAO,KAAK,cAAc,KAAK;AAAA,MACvC;AAAA,IACF;AAEA,WAAO;AAAA,EACT;AAAA,EAEA,gBAAgB,cAGd;AACA,WAAO;AAAA,MACL,WAAW;AAAA,QACT,IAAI,KAAK;AAAA,QACT,OAAO,KAAK,QAAQ;AAAA,MACtB;AAAA,MACA,KAAK;AAAA,QACH,QAAQ;AAAA,QACR,MAAM,OAAO,KAAK,cAAc,KAAK;AAAA,MACvC;AAAA,IACF;AAAA,EACF;AAAA,EAEA,cACE,YACA,gBACA,mBACA,wBAA2C,SACnC;AACR,QAAI;AAGJ,YAAQ,gBAAgB;AAAA,MACtB,KAAK,OAAO;AACV,YAAI,OAAO,eAAe,UAAU;AAClC,gBAAM,IAAI,MAAM,8BAA8B;AAAA,QAChD;AACA,cAAM,UAAU,KAAK,QAAQ,MAAM,eAAe,YAAY,KAAK;AACnE,cAAM,eAAe,QAAQ,UAAU,KAAK;AAC5C,2BAAmB,KAAK,iBAAiB,YAAY,YAAY;AACjE;AAAA,MACF;AAAA,MACA,KAAK;AACH,YAAI,OAAO,eAAe,UAAU;AAClC,uBAAa,OAAO,KAAK,YAAY,KAAK;AAAA,QAC5C;AACA,2BAAmB,gBAAgB,OAAO,YAAY,KAAK;AAC3D;AAAA,MACF,KAAK;AACH,YAAI,OAAO,eAAe,UAAU;AAClC,gBAAM,IAAI,MAAM,8BAA8B;AAAA,QAChD;AACA,2BAAmB,gBAAgB;AAAA,UACjC;AAAA,UACA;AAAA,UACA,KAAK,QAAQ;AAAA,QACf;AACA;AAAA;AAAA,MAEF;AACE,cAAM,IAAI,MAAM,4BAA4B;AAAA,IAEhD;AAGA,YAAQ,mBAAmB;AAAA,MACzB,KAAK;AACH,YAAI,0BAA0B,SAAS;AACrC,iBAAO,iBAAiB,WAAW,SAAS,KAAK;AAAA,QACnD,WAAW,0BAA0B,SAAS;AAC5C,iBAAO,KAAK,aAAa,gBAAgB,EAAE,WAAW,WAAW,SAAS,KAAK;AAAA,QACjF;AACA;AAAA,MACF,KAAK;AACH,YAAI,0BAA0B,SAAS;AACrC,iBAAO,gBAAgB,OAAO,kBAAkB,KAAK,EAAE,SAAS,KAAK;AAAA,QACvE,WAAW,0BAA0B,SAAS;AAC5C,iBAAO,iBAAiB,OAAO,KAAK,aAAa,gBAAgB,GAAG,KAAK,EAAE;AAAA,YACzE;AAAA,UACF;AAAA,QACF;AACA;AAAA,MACF,KAAK;AACH,YAAI,0BAA0B,SAAS;AACrC,iBAAO,gBAAgB,OAAO,kBAAkB,OAAO,KAAK,QAAQ,iBAAiB;AAAA,QACvF,WAAW,0BAA0B,SAAS;AAC5C,iBAAO,iBAAiB,OAAO,KAAK,aAAa,gBAAgB,GAAG,OAAO;AAAA,YACzE,GAAG,KAAK,QAAQ;AAAA,YAChB,OAAO;AAAA,UACT,CAAC;AAAA,QACH;AACA;AAAA;AAAA,MAEF;AACE,cAAM,IAAI,MAAM,4CAA4C;AAAA,IAEhE;AAEA,UAAM,IAAI,MAAM,wCAAwC;AAAA,EAC1D;AAAA,EAEA,aACE,WACA,gBACA,mBACQ;AACR,QAAI;AAEJ,YAAQ,gBAAgB;AAAA,MACtB,KAAK;AACH,YAAI,OAAO,cAAc,UAAU;AACjC,gBAAM,IAAI,MAAM,6BAA6B;AAAA,QAC/C;AACA,0BAAkB,KAAK,gBAAgB,SAAS;AAChD;AAAA,MACF,KAAK;AACH,YAAI,OAAO,cAAc,UAAU;AACjC,sBAAY,OAAO,KAAK,WAAW,KAAK;AAAA,QAC1C;AACA,0BAAkB,wBAAwB,OAAO,WAAW,KAAK;AACjE;AAAA,MACF,KAAK;AACH,YAAI,OAAO,cAAc,UAAU;AACjC,gBAAM,IAAI,MAAM,6BAA6B;AAAA,QAC/C;AACA,0BAAkB,wBAAwB;AAAA,UACxC;AAAA,UACA;AAAA,UACA,KAAK,QAAQ;AAAA,QACf;AACA;AAAA;AAAA,MAEF;AACE,cAAM,IAAI,MAAM,2BAA2B;AAAA,IAE/C;AAGA,YAAQ,mBAAmB;AAAA,MACzB,KAAK;AACH,eAAO,gBAAgB,IAAI,KAAK,SAAS,KAAK;AAAA,MAChD,KAAK;AACH,eAAO,wBAAwB,OAAO,iBAAiB,KAAK,EAAE,SAAS,KAAK;AAAA,MAC9E,KAAK;AACH,eAAO,wBAAwB;AAAA,UAC7B;AAAA,UACA;AAAA,UACA,KAAK,QAAQ;AAAA,QACf;AAAA;AAAA,MAEF;AACE,cAAM,IAAI,MAAM,2CAA2C;AAAA,IAE/D;AAAA,EACF;AACF;;;ADpSA,SAAS,iBAAiB,QAAwB;AAGhD,QAAM,MAAM,OAAO,MAAM,IAAI;AAC7B,MAAI,MAAM;AACV,MAAI,IAAI;AAER,QAAM,YAAY,OAAO,KAAK,IAAI,KAAK,EAAE,GAAG,QAAQ;AAGpD,QAAM,kBAAkB,UAAU,MAAM,EAAE;AAC1C,SAAO,gBAAgB,SAAS,KAAK;AACvC;AAEA,SAAS,SAAS,WAAmB,EAAE,YAAY,KAAK,IAAI,CAAC,GAAW;AACtE,QAAM,aAAa,IAAI,WAAW,MAAM;AACxC,MAAI,WAAW;AACb,WAAO,WAAW,cAAc,WAAW,OAAO,KAAK;AAAA,EACzD;AACA,SAAO,WAAW,aAAa,WAAW,OAAO,KAAK;AACxD;AAMO,SAAS,QAAQ,SAAiC;AACvD,MAAI,SAAS;AACX,UAAM,KAAK,IAAIC,UAAS,GAAG,MAAM;AACjC,UAAM,gBAAgB,OAAO,WAAW,QAAQ,EAAE,OAAO,OAAO,EAAE,OAAO,KAAK;AAC9E,UAAM,UAAU,GAAG,WAAW;AAAA,MAC5B,SAAS,OAAO,KAAK,eAAe,KAAK;AAAA,IAC3C,CAAC;AACD,WAAO;AAAA,MACL,YAAY,OAAO,SAAS,QAAQ,WAAW,KAAK,CAAC,CAAC;AAAA,MACtD,WAAW,OAAO,SAAS,QAAQ,UAAU,KAAK,GAAG,EAAE,WAAW,MAAM,CAAC,CAAC;AAAA,MAC1E,WAAW,iBAAiB,OAAO,SAAS,QAAQ,UAAU,KAAK,GAAG,EAAE,WAAW,MAAM,CAAC,CAAC,CAAC;AAAA,IAC9F;AAAA,EACF;AACA,QAAM,EAAE,WAAW,WAAW,IAAI,OAAO,oBAAoB,MAAM;AAAA,IACjE,YAAY;AAAA,IACZ,mBAAmB,EAAE,MAAM,QAAQ,QAAQ,MAAM;AAAA,IACjD,oBAAoB,EAAE,MAAM,QAAQ,QAAQ,MAAM;AAAA,EACpD,CAAC;AACD,QAAM,YAAY,iBAAiB,SAAS;AAC5C,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;","names":["elliptic","elliptic"]}
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/lib/device.cjs

@@ -3,11 +3,11 @@
 
 
 
-var _chunkUCQR7XCKcjs = require('./chunk-UCQR7XCK.cjs');
+var _chunkPHC5IG6Pcjs = require('./chunk-PHC5IG6P.cjs');
 
 
 
 
 
-exports.createApiDevice = _chunkUCQR7XCKcjs.createApiDevice; exports.isDeviceCancelError = _chunkUCQR7XCKcjs.isDeviceCancelError; exports.isTransportStatusError = _chunkUCQR7XCKcjs.isTransportStatusError; exports.registerTransportModule = _chunkUCQR7XCKcjs.registerTransportModule;
+exports.createApiDevice = _chunkPHC5IG6Pcjs.createApiDevice; exports.isDeviceCancelError = _chunkPHC5IG6Pcjs.isDeviceCancelError; exports.isTransportStatusError = _chunkPHC5IG6Pcjs.isTransportStatusError; exports.registerTransportModule = _chunkPHC5IG6Pcjs.registerTransportModule;
 //# sourceMappingURL=device.cjs.map

package/lib/device.d.cts

@@ -1,4 +1,4 @@
-import { L as Logger } from './types-DNEewSJL.cjs';
+import { L as Logger } from './logger-C-TPbnjv.cjs';
 import { D as Device } from './types-DJfbanPz.cjs';
 import { TransportStatusError } from '@ledgerhq/errors';
 import Transport from '@ledgerhq/hw-transport';

package/lib/device.d.ts

@@ -1,4 +1,4 @@
-import { L as Logger } from './types-DNEewSJL.js';
+import { L as Logger } from './logger-C-TPbnjv.js';
 import { D as Device } from './types-DJfbanPz.js';
 import { TransportStatusError } from '@ledgerhq/errors';
 import Transport from '@ledgerhq/hw-transport';

package/lib/device.js

@@ -3,7 +3,7 @@ import {
   isDeviceCancelError,
   isTransportStatusError,
   registerTransportModule
-} from "./chunk-7F2SX4FL.js";
+} from "./chunk-VMABO6WZ.js";
 export {
   createApiDevice,
   isDeviceCancelError,

package/lib/engine.cjs

@@ -14,7 +14,7 @@ var _chunkWVCYFF2Zcjs = require('./chunk-WVCYFF2Z.cjs');
 
 
 
-var _chunkUCQR7XCKcjs = require('./chunk-UCQR7XCK.cjs');
+var _chunkPHC5IG6Pcjs = require('./chunk-PHC5IG6P.cjs');
 
 // src/engine/index.ts
 var _invariant = require('invariant'); var _invariant2 = _interopRequireDefault(_invariant);
@@ -38,7 +38,7 @@ var splitChunks = (chunk, buffer) => {
   }
   return chunks;
 };
-var removeStatus = (result) => result.slice(0, result.length - _chunkUCQR7XCKcjs.STATUS_LENGTH);
+var removeStatus = (result) => result.slice(0, result.length - _chunkPHC5IG6Pcjs.STATUS_LENGTH);
 var sendByChunk = async (transport, command, data, chunkSize = MAX_CHUNK_LENGTH) => {
   const chunks = splitChunks(chunkSize, data);
   let response = Buffer.from([]);
@@ -48,7 +48,7 @@ var sendByChunk = async (transport, command, data, chunkSize = MAX_CHUNK_LENGTH)
     apdu[2] = i && 128;
     response = await transport.send(apdu[0], apdu[1], apdu[2], apdu[3], chunk, [
       36864,
-      ..._chunkUCQR7XCKcjs.PAGINATED_STATUS
+      ..._chunkPHC5IG6Pcjs.PAGINATED_STATUS
     ]);
   }
   return response;
@@ -91,7 +91,7 @@ var buildAttestation = (params) => {
 };
 var genericRetryOnError = (err) => {
   if (err instanceof _errors.LockedDeviceError) return true;
-  if (_chunkUCQR7XCKcjs.isTransportStatusError.call(void 0, err) && err.statusCode === 27913) return true;
+  if (_chunkPHC5IG6Pcjs.isTransportStatusError.call(void 0, err) && err.statusCode === 27913) return true;
   if (err instanceof _errors.DisconnectedDevice) return true;
   return false;
 };
@@ -99,7 +99,7 @@ function createRealDevice(options, logger) {
   const { transportId } = options;
   async function run(job, retryOnError = genericRetryOnError) {
     return _rxjs.lastValueFrom.call(void 0, 
-      _chunkUCQR7XCKcjs.withDevicePolling.call(void 0, transportId)((transport) => _rxjs.from.call(void 0, job(transport)), retryOnError)
+      _chunkPHC5IG6Pcjs.withDevicePolling.call(void 0, transportId)((transport) => _rxjs.from.call(void 0, job(transport)), retryOnError)
     );
   }
   const noRetry = () => false;
@@ -112,10 +112,10 @@ function createRealDevice(options, logger) {
       _nullishCoalesce(opts.retryOnError, () => ( alwaysRetry))
     );
     try {
-      await getPublicKey(_chunkUCQR7XCKcjs.PATHS.U2F, { secp256k1: true, retryOnError: noRetry });
+      await getPublicKey(_chunkPHC5IG6Pcjs.PATHS.U2F, { secp256k1: true, retryOnError: noRetry });
       return { isAppOpened: true };
     } catch (err) {
-      if (_chunkUCQR7XCKcjs.isTransportStatusError.call(void 0, err) && genericRetryOnError(err)) {
+      if (_chunkPHC5IG6Pcjs.isTransportStatusError.call(void 0, err) && genericRetryOnError(err)) {
         return { isAppOpened: false };
       }
       throw err;
@@ -146,18 +146,18 @@ function createRealDevice(options, logger) {
     );
     const pubKeyLength = response.readInt8(0);
     const pubKey = response.slice(1, pubKeyLength + 1).toString("hex").toUpperCase();
-    const signature = response.slice(pubKeyLength + 1, response.length - _chunkUCQR7XCKcjs.STATUS_LENGTH).toString("base64");
+    const signature = response.slice(pubKeyLength + 1, response.length - _chunkPHC5IG6Pcjs.STATUS_LENGTH).toString("base64");
     return { pubKey, signature };
   };
   const device = {
     authenticate: async ({ challenge: { challenge, name, role, keyHandle }, workspaceName }) => {
       logger.info(`[device] Authenticate`);
       _invariant2.default.call(void 0, role !== "READ_ONLY_API_KEY", "Invalid role for authenticate: READ_ONLY_API_KEY");
-      const applicationBuffer = Buffer.from(_chunkUCQR7XCKcjs.APPID_VAULT_ADMINISTRATOR, "hex");
+      const applicationBuffer = Buffer.from(_chunkPHC5IG6Pcjs.APPID_VAULT_ADMINISTRATOR, "hex");
       const nameBuffer = Buffer.from(name);
       const workspaceBuffer = Buffer.from(workspaceName);
       const keyHandleData = Buffer.concat([
-        Buffer.from(_chunkUCQR7XCKcjs.STR_ROLES[role], "hex"),
+        Buffer.from(_chunkPHC5IG6Pcjs.STR_ROLES[role], "hex"),
         Buffer.from([nameBuffer.length]),
         nameBuffer,
         Buffer.from([workspaceBuffer.length]),
@@ -211,10 +211,10 @@ function createRealDevice(options, logger) {
         confidentialityKeySignature: sig.toString("hex")
       };
     },
-    getConfidentialityPubKey: () => getPublicKey(_chunkUCQR7XCKcjs.PATHS.CONFIDENTIALITY, { secp256k1: true }),
+    getConfidentialityPubKey: () => getPublicKey(_chunkPHC5IG6Pcjs.PATHS.CONFIDENTIALITY, { secp256k1: true }),
     getDeviceUserId: FIXME_NOT_IMPLEMENTED("getDeviceUserId"),
-    getU2FPubKey: () => getPublicKey(_chunkUCQR7XCKcjs.PATHS.U2F, { secp256k1: false }),
-    getValidationPubKey: () => getPublicKey(_chunkUCQR7XCKcjs.PATHS.VALIDATION, { secp256k1: true }),
+    getU2FPubKey: () => getPublicKey(_chunkPHC5IG6Pcjs.PATHS.U2F, { secp256k1: false }),
+    getValidationPubKey: () => getPublicKey(_chunkPHC5IG6Pcjs.PATHS.VALIDATION, { secp256k1: true }),
     hasPairing: async () => {
       logger.info(`[device] hasPairing`);
       const apdu = [224, 81, 0, 0, 181];
@@ -226,7 +226,7 @@ function createRealDevice(options, logger) {
       const res = await run((transport) => transport.send(224, 70, 0, 0));
       const pubKeyLength = res.readInt8(0);
       const pubKey = res.slice(1, pubKeyLength + 1).toString("hex").toUpperCase();
-      const signature = res.slice(pubKeyLength + 1, res.length - _chunkUCQR7XCKcjs.STATUS_LENGTH).toString("base64");
+      const signature = res.slice(pubKeyLength + 1, res.length - _chunkPHC5IG6Pcjs.STATUS_LENGTH).toString("base64");
       return { pubKey, signature };
     },
     openSession: FIXME_NOT_IMPLEMENTED("openSession"),
@@ -234,11 +234,11 @@ function createRealDevice(options, logger) {
       const { challenge: strChallenge, u2fRegisterData: _, name, role } = params;
       const challenge = Buffer.from(strChallenge, "hex");
       _invariant2.default.call(void 0, challenge.length === 32, "challenge hex is expected to have 32 bytes");
-      const applicationBuf = Buffer.from(_chunkUCQR7XCKcjs.APPID_VAULT_ADMINISTRATOR, "hex");
+      const applicationBuf = Buffer.from(_chunkPHC5IG6Pcjs.APPID_VAULT_ADMINISTRATOR, "hex");
       _invariant2.default.call(void 0, applicationBuf.length === 32, "application hex is expected to have 32 bytes");
       const userNameBuff = Buffer.from(name);
       const keyHandleData = Buffer.concat([
-        Buffer.from(_chunkUCQR7XCKcjs.STR_ROLES[role], "hex"),
+        Buffer.from(_chunkPHC5IG6Pcjs.STR_ROLES[role], "hex"),
         Buffer.from([userNameBuff.length]),
         userNameBuff
       ]);
@@ -280,12 +280,12 @@ function createRealDevice(options, logger) {
       logger.info(`[device] startKPatternAsResponder`);
       const data = buildAttestation(params);
       await run(
-        (transport) => sendByChunk(transport, [224, 73, 0, _chunkUCQR7XCKcjs.SCRIPT_IDS.ACCOUNT_MANAGER_SESSION], data)
+        (transport) => sendByChunk(transport, [224, 73, 0, _chunkPHC5IG6Pcjs.SCRIPT_IDS.ACCOUNT_MANAGER_SESSION], data)
       );
     },
     validateVaultOperation: async (params) => {
       logger.info(`[device] validateVaultOperation`);
-      const path = getPathFromPathString(_chunkUCQR7XCKcjs.PATHS.VALIDATION);
+      const path = getPathFromPathString(_chunkPHC5IG6Pcjs.PATHS.VALIDATION);
       const paths = Buffer.concat([
         Buffer.from([path.length]),
         ...path.map((derivation) => {
@@ -306,9 +306,9 @@ function createRealDevice(options, logger) {
         );
         const responseType = response.readInt8(0);
         let responseStatus = response.readUInt16BE(response.length - 2);
-        if (responseType === _chunkUCQR7XCKcjs.STREAMING_NEXT_ACTION) {
+        if (responseType === _chunkPHC5IG6Pcjs.STREAMING_NEXT_ACTION) {
           nextActionId = response.readUIntBE(1, 2);
-        } else if (responseType === _chunkUCQR7XCKcjs.STREAMING_RESPONSE) {
+        } else if (responseType === _chunkPHC5IG6Pcjs.STREAMING_RESPONSE) {
           finalResponse = response.slice(3, response.length - 2);
           while (responseStatus !== 36864) {
             const resp = await run((transport) => transport.send(0, 192, 0, 0));
@@ -426,7 +426,7 @@ function createEngine(options, logger) {
     baseUrl: options.baseUrl
   };
   const client = createClient(clientOptions);
-  const apiDevice = _chunkUCQR7XCKcjs.createApiDevice.call(void 0, options, logger);
+  const apiDevice = _chunkPHC5IG6Pcjs.createApiDevice.call(void 0, options, logger);
   const base = {
     client,
     createClient: (overrides) => createClient({ ...clientOptions, ...overrides })