@ledgerhq/revault-sdk 0.25.0 → 0.26.0

package/lib/chunk-2WGM7EWA.cjs

@@ -1,282 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }// src/crypto/gen-seed.ts
-var _sha2js = require('@noble/hashes/sha2.js');
-var _bip39 = require('@scure/bip39');
-var _englishjs = require('@scure/bip39/wordlists/english.js');
-function genSeed(salt, index) {
-  const input = new TextEncoder().encode(`${salt}_${index}`);
-  const entropy = _sha2js.sha256.call(void 0, input);
-  return _bip39.entropyToMnemonic.call(void 0, entropy, _englishjs.wordlist);
-}
-
-// src/crypto/utils.ts
-var _elliptic = require('elliptic'); var _elliptic2 = _interopRequireDefault(_elliptic);
-var _jose = require('jose'); var jose = _interopRequireWildcard(_jose);
-
-// src/crypto/key-encoder.ts
-var _asn1js = require('asn1.js'); var _asn1js2 = _interopRequireDefault(_asn1js);
-var _bnjs = require('bn.js'); var _bnjs2 = _interopRequireDefault(_bnjs);
-
-var ECPrivateKeyASN = _asn1js2.default.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 = _asn1js2.default.define(
-  "ECPrivateKey",
-  /* v8 ignore next -- @preserve */
-  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()
-    );
-  }
-);
-var SubjectPublicKeyInfoASN = _asn1js2.default.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 _elliptic2.default.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 _elliptic2.default.ec("p256")
-  }
-};
-var KeyEncoder = class {
-  
-  
-  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 next -- @preserve */
-  PKCS1toPKCS8(privateKey) {
-    return {
-      version: new (0, _bnjs2.default)(0),
-      privateKey,
-      privateKeyAlgorithm: {
-        ecPublicKey: this.algorithmID,
-        curve: privateKey.parameters
-      }
-    };
-  }
-  privateKeyObject(rawPrivateKey, rawPublicKey) {
-    const privateKeyObject = {
-      version: new (0, _bnjs2.default)(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;
-      }
-      /* v8 ignore next -- @preserve */
-      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 next -- @preserve */
-      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 next -- @preserve */
-      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;
-      /* v8 ignore next -- @preserve */
-      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 next -- @preserve */
-      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 next -- @preserve */
-      default:
-        throw new Error("invalid destination format for public key");
-    }
-  }
-};
-
-// src/crypto/utils.ts
-var _crypto = require('crypto'); var _crypto2 = _interopRequireDefault(_crypto);
-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").toUpperCase();
-}
-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.default.ec("p256");
-    const hashedEntropy = _crypto2.default.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 } = _crypto2.default.generateKeyPairSync("ec", {
-    namedCurve: "P-256",
-    publicKeyEncoding: { type: "spki", format: "pem" },
-    privateKeyEncoding: { type: "sec1", format: "pem" }
-  });
-  const hexPubKey = extractPublicKey(publicKey);
-  return {
-    privateKey,
-    publicKey,
-    hexPubKey
-  };
-}
-var sign = async (privateKeyPem, base64Challenge) => {
-  const challengeDataBytes = jose.base64url.decode(base64Challenge);
-  const privateKey = _crypto2.default.createPrivateKey(privateKeyPem);
-  return await new jose.CompactSign(challengeDataBytes).setProtectedHeader({ alg: "ES256", typ: "JWT" }).sign(privateKey);
-};
-
-
-
-
-
-exports.genSeed = genSeed; exports.genKeys = genKeys; exports.sign = sign;
-/* v8 ignore else -- @preserve */
-/* v8 ignore if -- @preserve */
-//# sourceMappingURL=chunk-2WGM7EWA.cjs.map

package/lib/chunk-2WGM7EWA.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["/home/runner/_work/revault/revault/packages/sdk/lib/chunk-2WGM7EWA.cjs","../src/crypto/gen-seed.ts","../src/crypto/utils.ts","../src/crypto/key-encoder.ts"],"names":[],"mappings":"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","file":"/home/runner/_work/revault/revault/packages/sdk/lib/chunk-2WGM7EWA.cjs","sourcesContent":[null,"import { sha256 } from \"@noble/hashes/sha2.js\";\nimport { entropyToMnemonic } from \"@scure/bip39\";\nimport { wordlist } from \"@scure/bip39/wordlists/english.js\";\n\n/**\n * Generate a deterministic BIP39 mnemonic from a salt and device index.\n *\n * Produces `entropyToMnemonic(SHA256(salt + \"_\" + index))`, matching\n * the behavior of `@ledgerhq/vault-common`'s `genSeed`.\n *\n * @param salt  The workspace salt\n * @param index The device index (1-based)\n * @returns A 24-word BIP39 mnemonic string\n */\nexport function genSeed(salt: string, index: number): string {\n  const input = new TextEncoder().encode(`${salt}_${index}`);\n  const entropy = sha256(input);\n  return entropyToMnemonic(entropy, wordlist);\n}\n","import elliptic from \"elliptic\";\nimport * as jose from \"jose\";\n\nimport { KeyEncoder } from \"./key-encoder\";\nimport type { GeneratedKeys } from \"./types\";\nimport crypto from \"node:crypto\";\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\").toUpperCase();\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\nexport const sign = async (privateKeyPem: string, base64Challenge: string): Promise<string> => {\n  // Decode base64url challenge to bytes\n  const challengeDataBytes = jose.base64url.decode(base64Challenge);\n\n  // For EC private key format, we need to use a different import method\n  // Since jose doesn't support SEC1 format directly, let's use Node.js crypto\n  // Create a KeyObject from the EC private key\n  const privateKey = crypto.createPrivateKey(privateKeyPem);\n\n  // Use jose with the KeyObject\n  return await new jose.CompactSign(challengeDataBytes)\n    .setProtectedHeader({ alg: \"ES256\", typ: \"JWT\" })\n    .sign(privateKey);\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  // biome-ignore lint/suspicious/noExplicitAny: black box\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 next -- @preserve */\n  function () {\n    // @ts-expect-error pure black box\n    // biome-ignore lint/suspicious/noExplicitAny: black box\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);\n\nconst SubjectPublicKeyInfoASN = asn1.define(\"SubjectPublicKeyInfo\", function () {\n  // @ts-expect-error pure black box\n  // biome-ignore lint/suspicious/noExplicitAny: black box\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    /* v8 ignore else -- @preserve */\n    if (typeof options === \"string\") {\n      /* v8 ignore if -- @preserve */\n      if (options !== \"secp256k1\" && options !== \"p256\") {\n        throw new Error(`Unknown curve ${options}`);\n      }\n      options = curves[options]!;\n    }\n    this.options = options;\n    this.algorithmID = [1, 2, 840, 10045, 2, 1];\n  }\n\n  /* v8 ignore next -- @preserve */\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\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    /* v8 ignore else -- @preserve */\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      /* v8 ignore next -- @preserve */\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 next -- @preserve */\n      default:\n        throw new Error(\"invalid private key format\");\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 next -- @preserve */\n      default:\n        throw new Error(\"invalid destination format for private key\");\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    // biome-ignore lint/suspicious/noImplicitAnyLet: melting pot object\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      /* v8 ignore next -- @preserve */\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 next -- @preserve */\n      default:\n        throw new Error(\"invalid public key format\");\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 next -- @preserve */\n      default:\n        throw new Error(\"invalid destination format for public key\");\n    }\n  }\n}\n/* cspell:enable */\n"]}

package/lib/chunk-AXI72NFY.js

@@ -1,50 +0,0 @@
-// src/utils.ts
-import invariant from "invariant";
-async function fetchAll(queryFn, query, trpcContext) {
-  const res = [];
-  let page = 1;
-  while (page) {
-    const partial = await queryFn({ ...query, page }, trpcContext);
-    res.push(...partial.results);
-    page = partial.next;
-  }
-  return res;
-}
-async function fetchAllCursor(queryFn, query) {
-  const res = [];
-  let cursor = null;
-  do {
-    const partial = await queryFn({ ...query, ...cursor === null ? {} : { cursor } });
-    res.push(...partial.results);
-    cursor = partial.next;
-  } while (cursor);
-  return res;
-}
-function createDeviceIndexResolver(engine) {
-  const _deviceUserIdByDeviceIndexCache = {};
-  return async function findDeviceIndex(deviceUserId) {
-    let deviceIndex = null;
-    for (let i = 4; i < 50; i++) {
-      const promise = i in _deviceUserIdByDeviceIndexCache ? _deviceUserIdByDeviceIndexCache[i] : engine.withDeviceIndex(i).device.getDeviceUserId();
-      _deviceUserIdByDeviceIndexCache[i] = promise;
-      const candidate = await promise;
-      if (candidate.toUpperCase() === deviceUserId.toUpperCase()) {
-        deviceIndex = i;
-        break;
-      }
-    }
-    invariant(deviceIndex, `Could not find index for device user id ${deviceUserId}`);
-    return deviceIndex;
-  };
-}
-function buildTrpcContext(opts) {
-  return opts?.correlationId ? { context: { headers: { "x-correlation-id": opts.correlationId } } } : void 0;
-}
-
-export {
-  fetchAll,
-  fetchAllCursor,
-  createDeviceIndexResolver,
-  buildTrpcContext
-};
-//# sourceMappingURL=chunk-AXI72NFY.js.map

package/lib/chunk-AXI72NFY.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/utils.ts"],"sourcesContent":["import type { CursorPaginated, Paginated } from \"@ledgerhq/revault-api\";\nimport invariant from \"invariant\";\n\nimport type { CorrelationIdOpts, Engine, WithWorkspace } from \"./engine/types\";\nimport type { TRPCContext } from \"./trpc\";\n\n/**\n * Utility function that collect results on all pages until there is no more next page\n */\nexport async function fetchAll<TData, TQuery extends { page?: number }>(\n  queryFn: (query: TQuery, trpcContext?: TRPCContext) => Promise<Paginated<TData>>,\n  query: TQuery,\n  trpcContext?: TRPCContext,\n): Promise<TData[]> {\n  const res: TData[] = [];\n  let page: number | null = 1;\n  while (page) {\n    const partial = await queryFn({ ...query, page }, trpcContext);\n    res.push(...partial.results);\n    page = partial.next;\n  }\n  return res;\n}\n\n/**\n * Utility function that collect results on all cursors until cursor is null\n */\nexport async function fetchAllCursor<TData, TQuery extends { cursor?: number | string }>(\n  queryFn: (query: TQuery) => Promise<CursorPaginated<TData>>,\n  query: TQuery,\n): Promise<TData[]> {\n  const res: TData[] = [];\n  let cursor: number | string | null = null;\n  do {\n    const partial = await queryFn({ ...query, ...(cursor === null ? {} : { cursor }) });\n    res.push(...partial.results);\n    cursor = partial.next;\n  } while (cursor);\n  return res;\n}\n\n/**\n * Return a function that retrieve a device index based on a given deviceUserId\n * Holds a cache of found indexes to avoid spamming device-api\n */\nexport function createDeviceIndexResolver(engine: Engine<WithWorkspace>) {\n  // Cache to avoid spamming device-api when seeking for same index multiple times\n  const _deviceUserIdByDeviceIndexCache: Record<string, Promise<string>> = {};\n\n  return async function findDeviceIndex(deviceUserId: string): Promise<number> {\n    let deviceIndex: number | null = null;\n    for (let i = 4; i < 50; i++) {\n      const promise =\n        i in _deviceUserIdByDeviceIndexCache\n          ? _deviceUserIdByDeviceIndexCache[i]!\n          : engine.withDeviceIndex(i).device.getDeviceUserId();\n      _deviceUserIdByDeviceIndexCache[i] = promise;\n      const candidate = await promise;\n      // /!\\ we need to decide in which casing we want this information\n      // -> device-api returns it in uppercase\n      // -> we save it in lowercase in revault-api DB\n      // -> doing \"safe\" comparison here by always user the uppercase version, but hey!\n      if (candidate.toUpperCase() === deviceUserId.toUpperCase()) {\n        deviceIndex = i;\n        break;\n      }\n    }\n    invariant(deviceIndex, `Could not find index for device user id ${deviceUserId}`);\n    return deviceIndex;\n  };\n}\n\nexport function buildTrpcContext(opts?: CorrelationIdOpts) {\n  return opts?.correlationId\n    ? { context: { headers: { \"x-correlation-id\": opts.correlationId } } }\n    : undefined;\n}\n"],"mappings":";AACA,OAAO,eAAe;AAQtB,eAAsB,SACpB,SACA,OACA,aACkB;AAClB,QAAM,MAAe,CAAC;AACtB,MAAI,OAAsB;AAC1B,SAAO,MAAM;AACX,UAAM,UAAU,MAAM,QAAQ,EAAE,GAAG,OAAO,KAAK,GAAG,WAAW;AAC7D,QAAI,KAAK,GAAG,QAAQ,OAAO;AAC3B,WAAO,QAAQ;AAAA,EACjB;AACA,SAAO;AACT;AAKA,eAAsB,eACpB,SACA,OACkB;AAClB,QAAM,MAAe,CAAC;AACtB,MAAI,SAAiC;AACrC,KAAG;AACD,UAAM,UAAU,MAAM,QAAQ,EAAE,GAAG,OAAO,GAAI,WAAW,OAAO,CAAC,IAAI,EAAE,OAAO,EAAG,CAAC;AAClF,QAAI,KAAK,GAAG,QAAQ,OAAO;AAC3B,aAAS,QAAQ;AAAA,EACnB,SAAS;AACT,SAAO;AACT;AAMO,SAAS,0BAA0B,QAA+B;AAEvE,QAAM,kCAAmE,CAAC;AAE1E,SAAO,eAAe,gBAAgB,cAAuC;AAC3E,QAAI,cAA6B;AACjC,aAAS,IAAI,GAAG,IAAI,IAAI,KAAK;AAC3B,YAAM,UACJ,KAAK,kCACD,gCAAgC,CAAC,IACjC,OAAO,gBAAgB,CAAC,EAAE,OAAO,gBAAgB;AACvD,sCAAgC,CAAC,IAAI;AACrC,YAAM,YAAY,MAAM;AAKxB,UAAI,UAAU,YAAY,MAAM,aAAa,YAAY,GAAG;AAC1D,sBAAc;AACd;AAAA,MACF;AAAA,IACF;AACA,cAAU,aAAa,2CAA2C,YAAY,EAAE;AAChF,WAAO;AAAA,EACT;AACF;AAEO,SAAS,iBAAiB,MAA0B;AACzD,SAAO,MAAM,gBACT,EAAE,SAAS,EAAE,SAAS,EAAE,oBAAoB,KAAK,cAAc,EAAE,EAAE,IACnE;AACN;","names":[]}