@recoillink/cli 0.0.0-stage → 45.0.1

package/bundle/154.index.js

@@ -0,0 +1,462 @@
+export const id = 154;
+export const ids = [154];
+export const modules = {
+
+/***/ 93880:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  S: () => (/* binding */ convertTurnkeyApiKeyToJwk)
+});
+
+;// CONCATENATED MODULE: ../../node_modules/.pnpm/@turnkey+api-key-stamper@0.5.0/node_modules/@turnkey/api-key-stamper/dist/tink/bytes.mjs
+/**
+ * Code modified from https://github.com/google/tink/blob/6f74b99a2bfe6677e3670799116a57268fd067fa/javascript/subtle/bytes.ts
+ *
+ * @license
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Converts the hex string to a byte array.
+ *
+ * @param hex the input
+ * @return the byte array output
+ * @throws {!Error}
+ * @static
+ */
+function fromHex(hex) {
+    if (hex.length % 2 != 0) {
+        throw new Error("Hex string length must be multiple of 2");
+    }
+    const arr = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < hex.length; i += 2) {
+        arr[i / 2] = parseInt(hex.substring(i, i + 2), 16);
+    }
+    return arr;
+}
+/**
+ * Converts a byte array to hex.
+ *
+ * @param bytes the byte array input
+ * @return hex the output
+ * @static
+ */
+function toHex(bytes) {
+    let result = "";
+    for (let i = 0; i < bytes.length; i++) {
+        const hexByte = bytes[i].toString(16);
+        result += hexByte.length > 1 ? hexByte : "0" + hexByte;
+    }
+    return result;
+}
+/**
+ * Base64 encode a byte array.
+ *
+ * @param bytes the byte array input
+ * @param opt_webSafe True indicates we should use the alternative
+ *     alphabet, which does not require escaping for use in URLs.
+ * @return base64 output
+ * @static
+ */
+function toBase64(bytes, opt_webSafe) {
+    const encoded = btoa(
+    /* padding */
+    toByteString(bytes)).replace(/=/g, "");
+    {
+        return encoded.replace(/\+/g, "-").replace(/\//g, "_");
+    }
+}
+/**
+ * Turns a byte array into the string given by the concatenation of the
+ * characters to which the numbers correspond. Each byte is corresponding to a
+ * character. Does not support multi-byte characters.
+ *
+ * @param bytes Array of numbers representing
+ *     characters.
+ * @return Stringification of the array.
+ */
+function toByteString(bytes) {
+    let str = "";
+    for (let i = 0; i < bytes.length; i += 1) {
+        str += String.fromCharCode(bytes[i]);
+    }
+    return str;
+}
+
+
+//# sourceMappingURL=bytes.mjs.map
+
+;// CONCATENATED MODULE: ../../node_modules/.pnpm/@turnkey+api-key-stamper@0.5.0/node_modules/@turnkey/api-key-stamper/dist/tink/elliptic_curves.mjs
+
+
+/**
+ * Code modified from https://github.com/google/tink/blob/6f74b99a2bfe6677e3670799116a57268fd067fa/javascript/subtle/elliptic_curves.ts
+ * - The implementation of integerToByteArray has been modified to augment the resulting byte array to a certain length.
+ * - The implementation of PointDecode has been modified to decode both compressed and uncompressed points by checking for correct format
+ * - Method isP256CurvePoint added to check whether an uncompressed point is valid
+ *
+ * @license
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * P-256 only
+ */
+function getModulus() {
+    // https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.186-4.pdf (Appendix D).
+    return BigInt("115792089210356248762697446949407573530086143415290314195533631308" +
+        "867097853951");
+}
+/**
+ * P-256 only
+ */
+function getB() {
+    // https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.186-4.pdf (Appendix D).
+    return BigInt("0x5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604b");
+}
+/** Converts byte array to bigint. */
+function byteArrayToInteger(bytes) {
+    return BigInt("0x" + toHex(bytes));
+}
+/** Converts bigint to byte array. */
+function integerToByteArray(i, length) {
+    const input = i.toString(16);
+    const numHexChars = length * 2;
+    let padding = "";
+    if (numHexChars < input.length) {
+        throw new Error(`cannot pack integer with ${input.length} hex chars into ${length} bytes`);
+    }
+    else {
+        padding = "0".repeat(numHexChars - input.length);
+    }
+    return fromHex(padding + input);
+}
+/** Returns true iff the ith bit (in lsb order) of n is set. */
+function testBit(n, i) {
+    const m = BigInt(1) << BigInt(i);
+    return (n & m) !== BigInt(0);
+}
+/**
+ * Computes a modular exponent.  Since JavaScript BigInt operations are not
+ * constant-time, information about the inputs could leak.  Therefore, THIS
+ * METHOD SHOULD ONLY BE USED FOR POINT DECOMPRESSION.
+ *
+ * @param b base
+ * @param exp exponent
+ * @param p modulus
+ * @return b^exp modulo p
+ */
+function modPow(b, exp, p) {
+    if (exp === BigInt(0)) {
+        return BigInt(1);
+    }
+    let result = b;
+    const exponentBitString = exp.toString(2);
+    for (let i = 1; i < exponentBitString.length; ++i) {
+        result = (result * result) % p;
+        if (exponentBitString[i] === "1") {
+            result = (result * b) % p;
+        }
+    }
+    return result;
+}
+/**
+ * Computes a square root modulo an odd prime.  Since timing and exceptions can
+ * leak information about the inputs, THIS METHOD SHOULD ONLY BE USED FOR
+ * POINT DECOMPRESSION.
+ *
+ * @param x square
+ * @param p prime modulus
+ * @return square root of x modulo p
+ */
+function modSqrt(x, p) {
+    if (p <= BigInt(0)) {
+        throw new Error("p must be positive");
+    }
+    const base = x % p;
+    // The currently supported NIST curves P-256, P-384, and P-521 all satisfy
+    // p % 4 == 3.  However, although currently a no-op, the following check
+    // should be left in place in case other curves are supported in the future.
+    if (testBit(p, 0) && /* istanbul ignore next */ testBit(p, 1)) {
+        // Case p % 4 == 3 (applies to NIST curves P-256, P-384, and P-521)
+        // q = (p + 1) / 4
+        const q = (p + BigInt(1)) >> BigInt(2);
+        const squareRoot = modPow(base, q, p);
+        if ((squareRoot * squareRoot) % p !== base) {
+            throw new Error("could not find a modular square root");
+        }
+        return squareRoot;
+    }
+    // Skipping other elliptic curve types that require Cipolla's algorithm.
+    throw new Error("unsupported modulus value");
+}
+/**
+ * Computes the y-coordinate of a point on an elliptic curve given its
+ * x-coordinate.  Since timing and exceptions can leak information about the
+ * inputs, THIS METHOD SHOULD ONLY BE USED FOR POINT DECOMPRESSION.
+ *
+ * P-256 only
+ *
+ * @param x x-coordinate
+ * @param lsb least significant bit of the y-coordinate
+ * @return y-coordinate
+ */
+function getY(x, lsb) {
+    const p = getModulus();
+    const a = p - BigInt(3);
+    const b = getB();
+    const rhs = ((x * x + a) * x + b) % p;
+    let y = modSqrt(rhs, p);
+    if (lsb !== testBit(y, 0)) {
+        y = (p - y) % p;
+    }
+    return y;
+}
+/**
+ *
+ * Given x and y coordinates of a JWK, checks whether these are valid points on
+ * the P-256 elliptic curve.
+ *
+ * P-256 only
+ *
+ * @param x x-coordinate
+ * @param y y-coordinate
+ * @return boolean validity
+ */
+function isP256CurvePoint(x, y) {
+    const p = getModulus();
+    const a = p - BigInt(3);
+    const b = getB();
+    const rhs = ((x * x + a) * x + b) % p;
+    const lhs = y ** BigInt(2) % p;
+    return lhs === rhs;
+}
+/**
+ * Decodes a public key in _compressed_ OR _uncompressed_ format.
+ * Augmented to ensure that the x and y components are padded to fit 32 bytes.
+ *
+ * P-256 only
+ */
+function pointDecode(point) {
+    const fieldSize = fieldSizeInBytes();
+    const compressedLength = fieldSize + 1;
+    const uncompressedLength = 2 * fieldSize + 1;
+    if (point.length !== compressedLength &&
+        point.length !== uncompressedLength) {
+        throw new Error("Invalid length: point is not in compressed or uncompressed format");
+    }
+    // Decodes point if its length and first bit match the compressed format
+    if ((point[0] === 2 || point[0] === 3) && point.length == compressedLength) {
+        const lsb = point[0] === 3; // point[0] must be 2 (false) or 3 (true).
+        const x = byteArrayToInteger(point.subarray(1, point.length));
+        const p = getModulus();
+        if (x < BigInt(0) || x >= p) {
+            throw new Error("x is out of range");
+        }
+        const y = getY(x, lsb);
+        const result = {
+            kty: "EC",
+            crv: "P-256",
+            x: toBase64(integerToByteArray(x, 32)),
+            y: toBase64(integerToByteArray(y, 32)),
+            ext: true,
+        };
+        return result;
+        // Decodes point if its length and first bit match the uncompressed format
+    }
+    else if (point[0] === 4 && point.length == uncompressedLength) {
+        const x = byteArrayToInteger(point.subarray(1, fieldSize + 1));
+        const y = byteArrayToInteger(point.subarray(fieldSize + 1, 2 * fieldSize + 1));
+        const p = getModulus();
+        if (x < BigInt(0) ||
+            x >= p ||
+            y < BigInt(0) ||
+            y >= p ||
+            !isP256CurvePoint(x, y)) {
+            throw new Error("invalid uncompressed x and y coordinates");
+        }
+        const result = {
+            kty: "EC",
+            crv: "P-256",
+            x: toBase64(integerToByteArray(x, 32)),
+            y: toBase64(integerToByteArray(y, 32)),
+            ext: true,
+        };
+        return result;
+    }
+    throw new Error("invalid format");
+}
+/**
+ * P-256 only
+ */
+function fieldSizeInBytes() {
+    return 32;
+}
+
+
+//# sourceMappingURL=elliptic_curves.mjs.map
+
+// EXTERNAL MODULE: ../../node_modules/.pnpm/@turnkey+encoding@0.6.0/node_modules/@turnkey/encoding/dist/index.mjs + 6 modules
+var dist = __webpack_require__(56390);
+;// CONCATENATED MODULE: ../../node_modules/.pnpm/@turnkey+api-key-stamper@0.5.0/node_modules/@turnkey/api-key-stamper/dist/utils.mjs
+
+
+
+/**
+ * Converts a Turnkey API key pair into a JSON Web Key (JWK) format.
+ * This function accepts P-256 API keys only.
+ *
+ * @param {Object} input - The Turnkey API key components.
+ * @param {string} input.uncompressedPrivateKeyHex - Hexadecimal-encoded uncompressed private key (32-byte scalar).
+ * @param {string} input.compressedPublicKeyHex - Hexadecimal-encoded compressed public key (33 bytes).
+ * @returns {JsonWebKey} A JSON Web Key object representing the EC P-256 key.
+ */
+function convertTurnkeyApiKeyToJwk(input) {
+    const { uncompressedPrivateKeyHex, compressedPublicKeyHex } = input;
+    let jwk;
+    try {
+        jwk = pointDecode((0,dist/* uint8ArrayFromHexString */.Ks)(compressedPublicKeyHex));
+    }
+    catch (e) {
+        throw new Error(`unable to load API key: invalid public key. Did you switch your public and private key by accident? Is your public key a valid, compressed P-256 public key?`);
+    }
+    // Ensure that d is sufficiently padded
+    jwk.d = (0,dist/* hexStringToBase64url */.el)(uncompressedPrivateKeyHex, dist/* DEFAULT_JWK_MEMBER_BYTE_LENGTH */.Ev);
+    return jwk;
+}
+
+
+//# sourceMappingURL=utils.mjs.map
+
+
+/***/ }),
+
+/***/ 30154:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   signWithApiKey: () => (/* binding */ signWithApiKey)
+/* harmony export */ });
+/* harmony import */ var _utils_mjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(93880);
+/* harmony import */ var _turnkey_encoding__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(56390);
+
+
+
+/// <reference lib="dom" />
+const signWithApiKey = async (input) => {
+    const { content, publicKey, privateKey } = input;
+    const key = await importTurnkeyApiKey({
+        uncompressedPrivateKeyHex: privateKey,
+        compressedPublicKeyHex: publicKey,
+    });
+    return await signMessage({ key, content });
+};
+/**
+ * Imports a P-256 Turnkey API key into a WebCrypto `CryptoKey`.
+ *
+ * @param {Object} input - The Turnkey API key components.
+ * @param {string} input.uncompressedPrivateKeyHex - Hexadecimal-encoded uncompressed private key (32-byte scalar).
+ * @param {string} input.compressedPublicKeyHex - Hexadecimal-encoded compressed public key (33 bytes).
+ * @returns {Promise<CryptoKey>} A `CryptoKey` object representing a P-256 key.
+ */
+async function importTurnkeyApiKey(input) {
+    const { uncompressedPrivateKeyHex, compressedPublicKeyHex } = input;
+    const jwk = (0,_utils_mjs__WEBPACK_IMPORTED_MODULE_0__/* .convertTurnkeyApiKeyToJwk */ .S)({
+        uncompressedPrivateKeyHex,
+        compressedPublicKeyHex,
+    });
+    return await crypto.subtle.importKey("jwk", jwk, {
+        name: "ECDSA",
+        namedCurve: "P-256",
+    }, false, // not extractable
+    ["sign"]);
+}
+async function signMessage(input) {
+    const { key, content } = input;
+    const signatureIeee1363 = await crypto.subtle.sign({
+        name: "ECDSA",
+        hash: "SHA-256",
+    }, key, new TextEncoder().encode(content));
+    const signatureDer = convertEcdsaIeee1363ToDer(new Uint8Array(signatureIeee1363));
+    return (0,_turnkey_encoding__WEBPACK_IMPORTED_MODULE_1__/* .uint8ArrayToHexString */ .pD)(signatureDer);
+}
+/**
+ * `SubtleCrypto.sign(...)` outputs signature in IEEE P1363 format:
+ * - https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/sign#ecdsa
+ *
+ * Turnkey expects the signature encoding to be DER-encoded ASN.1:
+ * - https://github.com/tkhq/tkcli/blob/7f0159af5a73387ff050647180d1db4d3a3aa033/src/internal/apikey/apikey.go#L149
+ *
+ * Code modified from https://github.com/google/tink/blob/6f74b99a2bfe6677e3670799116a57268fd067fa/javascript/subtle/elliptic_curves.ts#L114
+ *
+ * Transform an ECDSA signature in IEEE 1363 encoding to DER encoding.
+ *
+ * @param ieee the ECDSA signature in IEEE encoding
+ * @return ECDSA signature in DER encoding
+ */
+function convertEcdsaIeee1363ToDer(ieee) {
+    if (ieee.length % 2 != 0 || ieee.length == 0 || ieee.length > 132) {
+        throw new Error("Invalid IEEE P1363 signature encoding. Length: " + ieee.length);
+    }
+    const r = toUnsignedBigNum(ieee.subarray(0, ieee.length / 2));
+    const s = toUnsignedBigNum(ieee.subarray(ieee.length / 2, ieee.length));
+    let offset = 0;
+    const length = 1 + 1 + r.length + 1 + 1 + s.length;
+    let der;
+    if (length >= 128) {
+        der = new Uint8Array(length + 3);
+        der[offset++] = 48;
+        der[offset++] = 128 + 1;
+        der[offset++] = length;
+    }
+    else {
+        der = new Uint8Array(length + 2);
+        der[offset++] = 48;
+        der[offset++] = length;
+    }
+    der[offset++] = 2;
+    der[offset++] = r.length;
+    der.set(r, offset);
+    offset += r.length;
+    der[offset++] = 2;
+    der[offset++] = s.length;
+    der.set(s, offset);
+    return der;
+}
+/**
+ * Code modified from https://github.com/google/tink/blob/6f74b99a2bfe6677e3670799116a57268fd067fa/javascript/subtle/elliptic_curves.ts#L311
+ *
+ * Transform a big integer in big endian to minimal unsigned form which has
+ * no extra zero at the beginning except when the highest bit is set.
+ */
+function toUnsignedBigNum(bytes) {
+    // Remove zero prefixes.
+    let start = 0;
+    while (start < bytes.length && bytes[start] == 0) {
+        start++;
+    }
+    if (start == bytes.length) {
+        start = bytes.length - 1;
+    }
+    let extraZero = 0;
+    // If the 1st bit is not zero, add 1 zero byte.
+    if ((bytes[start] & 128) == 128) {
+        // Add extra zero.
+        extraZero = 1;
+    }
+    const res = new Uint8Array(bytes.length - start + extraZero);
+    res.set(bytes.subarray(start), extraZero);
+    return res;
+}
+
+
+//# sourceMappingURL=webcrypto.mjs.map
+
+
+/***/ })
+
+};