@tma.js/init-data-node 1.4.0 → 2.0.1

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2023 Telegram Mini Apps
+Copyright (c) 2025 Vladislav Kibenko
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -4,20 +4,20 @@
 
 [docs-badge]: https://img.shields.io/badge/documentation-blue?logo=gitbook&logoColor=white
 
-[init-data-node-code-link]: https://github.com/Telegram-Mini-Apps/tma.js/tree/master/packages/init-data-node
+[code-link]: https://github.com/Telegram-Mini-Apps/telegram-apps/tree/master/tma.js/init-data-node
 
-[init-data-node-docs-link]: https://docs.telegram-mini-apps.com/packages/tma-js-init-data-node
+[docs-link]: https://docs.telegram-mini-apps.com/packages/tma-js-init-data-node
 
-[init-data-node-npm-link]: https://npmjs.com/package/@tma.js/init-data-node
+[npm-link]: https://npmjs.com/package/@tma.js/init-data-node
 
-[init-data-node-npm-badge]: https://img.shields.io/npm/v/@tma.js/init-data-node?logo=npm
+[npm-badge]: https://img.shields.io/npm/v/@tma.js/init-data-node?logo=npm
 
-[init-data-node-size-badge]: https://img.shields.io/bundlephobia/minzip/@tma.js/init-data-node
+[size-badge]: https://img.shields.io/bundlephobia/minzip/@tma.js/init-data-node
 
-[![NPM][init-data-node-npm-badge]][init-data-node-npm-link]
-![Size][init-data-node-size-badge]
-[![docs-badge]][init-data-node-docs-link]
-[![code-badge]][init-data-node-code-link]
+[![NPM][npm-badge]][npm-link]
+![Size][size-badge]
+[![docs-badge]][docs-link]
+[![code-badge]][code-link]
 
 The package provides utilities to work with the initialization data of Telegram Mini Apps on the
 server side. To learn more about the initialization data and its usage, please refer to

package/dist/buf-converters.d.ts

@@ -0,0 +1,13 @@
+import { HexStringLengthInvalidError } from './errors.js';
+import * as E from 'fp-ts/Either';
+/**
+ * Converts a hex string to ArrayBuffer.
+ * @param hexString - value to convert.
+ */
+export declare function hexToArrayBuffer(hexString: string): E.Either<InstanceType<typeof HexStringLengthInvalidError>, ArrayBuffer>;
+/**
+ * Converts array buffer to hex.
+ * @param arrBuf - buffer to convert
+ */
+export declare function arrayBufferToHex(arrBuf: ArrayBuffer): string;
+export declare function bufferToArrayBuffer(buf: Buffer): ArrayBuffer;

package/dist/entries/node.cjs

@@ -1,26 +1,98 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const E = require("fp-ts/Either");
+const function_js = require("fp-ts/lib/function.js");
 const node_crypto = require("node:crypto");
-const index = require("./index-DQxFLF1J.cjs");
+const parsing = require("./parsing-Cj_BXCnv.cjs");
+const toolkit = require("@tma.js/toolkit");
+function _interopNamespaceDefault(e) {
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const E__namespace = /* @__PURE__ */ _interopNamespaceDefault(E);
+function textToBuffer(text) {
+  return Buffer.from(typeof text === "string" ? text : new Uint8Array(text));
+}
 const createHmac = (data, key) => {
-  return node_crypto.createHmac("sha256", key).update(data).digest();
+  return parsing.bufferToArrayBuffer(
+    node_crypto.createHmac("sha256", textToBuffer(key)).update(textToBuffer(data)).digest()
+  );
 };
 function hashToken(token) {
-  return index.hashToken(token, createHmac);
+  return Buffer.from(parsing.hashToken(token, createHmac));
+}
+function isValid(value, token, options) {
+  return function_js.pipe(
+    validateFp(value, token, options),
+    E__namespace.match(() => false, () => true)
+  );
+}
+function signFp(data, key, authDate, options) {
+  return parsing.signFp(data, key, authDate, signDataFp, options);
 }
 function sign(data, key, authDate, options) {
-  return index.sign(data, key, authDate, signData, options);
+  return function_js.pipe(
+    signFp(data, key, authDate, options),
+    E__namespace.match((e) => {
+      throw e;
+    }, (v) => v)
+  );
+}
+function signDataFp(data, key, options) {
+  return parsing.signDataFp(false, data, key, createHmac, options);
 }
 function signData(data, key, options) {
-  return index.signData(data, key, createHmac, options);
+  return function_js.pipe(
+    signDataFp(data, key, options),
+    E__namespace.match((e) => {
+      throw e;
+    }, (v) => v)
+  );
+}
+function validateFp(value, token, options) {
+  return parsing.validateFp(false, value, token, signDataFp, options);
 }
 function validate(value, token, options) {
-  return index.validate(value, token, signData, options);
+  function_js.pipe(
+    validateFp(value, token, options),
+    E__namespace.mapLeft((error) => {
+      throw error;
+    })
+  );
 }
-exports.initDataToSearchParams = index.initDataToSearchParams;
-exports.parse = index.cs;
+exports.AuthDateInvalidError = parsing.AuthDateInvalidError;
+exports.ExpiredError = parsing.ExpiredError;
+exports.HexStringLengthInvalidError = parsing.HexStringLengthInvalidError;
+exports.SignatureInvalidError = parsing.SignatureInvalidError;
+exports.SignatureMissingError = parsing.SignatureMissingError;
+exports.isValid3rd = parsing.isValid3rd;
+exports.isValid3rdFp = parsing.isValid3rdFp;
+exports.parse = parsing.parse;
+exports.parseFp = parsing.parseFp;
+exports.validate3rd = parsing.validate3rd;
+exports.validate3rdFp = parsing.validate3rdFp;
+Object.defineProperty(exports, "deepSnakeToCamelObjKeys", {
+  enumerable: true,
+  get: () => toolkit.deepSnakeToCamelObjKeys
+});
 exports.hashToken = hashToken;
+exports.isValid = isValid;
 exports.sign = sign;
 exports.signData = signData;
+exports.signDataFp = signDataFp;
+exports.signFp = signFp;
 exports.validate = validate;
+exports.validateFp = validateFp;
 //# sourceMappingURL=node.cjs.map

package/dist/entries/node.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"node.cjs","sources":["../../src/entries/node.ts"],"sourcesContent":["import { createHmac as nodeCreateHmac } from 'node:crypto';\nimport { InitData, InitDataParsed } from '@tma.js/sdk';\n\nimport { hashToken as baseHashToken } from '../hashToken.js';\nimport { sign as baseSign, SignOptions } from '../sign.js';\nimport { signData as baseSignData, SignDataOptions } from '../signData.js';\nimport { validate as baseValidate } from '../validate.js';\nimport type { ValidateOptions } from '../validate.js';\nimport type { CreateHmacFn, SignData, Text } from '../types.js';\n\nconst createHmac: CreateHmacFn<false> = (data, key) => {\n  return nodeCreateHmac('sha256', key).update(data).digest();\n};\n\n/**\n * Hashes specified token using a string, expected during init data sign.\n * @param token - token to hash.\n */\nexport function hashToken(token: Text): Buffer {\n  return baseHashToken(token, createHmac);\n}\n\n/**\n * Signs specified init data.\n * @param data - init data to sign.\n * @param authDate - date, when this init data should be signed.\n * @param key - private key.\n * @param options - additional options.\n * @returns Signed init data presented as query parameters.\n */\nexport function sign(data: SignData, key: Text, authDate: Date, options?: SignOptions): string {\n  return baseSign(data, key, authDate, signData, options);\n}\n\n/**\n * Signs specified data with the passed token.\n * @param data - data to sign.\n * @param key - private key.\n * @param options - additional options.\n * @returns Data sign.\n */\nexport function signData(data: Text, key: Text, options?: SignDataOptions): string {\n  return baseSignData(data, key, createHmac, options);\n}\n\n/**\n * Validates passed init data.\n * @param value - value to check.\n * @param token - bot secret token.\n * @param options - additional validation options.\n * @throws {TypeError} \"auth_date\" should present integer\n * @throws {Error} \"hash\" is empty or not found\n * @throws {Error} \"auth_date\" is empty or not found\n * @throws {Error} Init data expired\n */\nexport function validate(\n  value: InitData | InitDataParsed | string | URLSearchParams,\n  token: Text,\n  options?: ValidateOptions,\n): void {\n  return baseValidate(value, token, signData, options);\n}\n\nexport * from './shared.js';\n"],"names":["nodeCreateHmac","baseHashToken","baseSign","baseSignData","baseValidate"],"mappings":";;;;AAUA,MAAM,aAAkC,CAAC,MAAM,QAAQ;AACrD,SAAOA,YAAAA,WAAe,UAAU,GAAG,EAAE,OAAO,IAAI,EAAE;AACpD;AAMO,SAAS,UAAU,OAAqB;AACtC,SAAAC,MAAA,UAAc,OAAO,UAAU;AACxC;AAUO,SAAS,KAAK,MAAgB,KAAW,UAAgB,SAA+B;AAC7F,SAAOC,MAAAA,KAAS,MAAM,KAAK,UAAU,UAAU,OAAO;AACxD;AASgB,SAAA,SAAS,MAAY,KAAW,SAAmC;AACjF,SAAOC,MAAa,SAAA,MAAM,KAAK,YAAY,OAAO;AACpD;AAYgB,SAAA,SACd,OACA,OACA,SACM;AACN,SAAOC,MAAa,SAAA,OAAO,OAAO,UAAU,OAAO;AACrD;;;;;;;"}
+{"version":3,"file":"node.cjs","sources":["../../src/entries/node.ts"],"sourcesContent":["import * as E from 'fp-ts/Either';\nimport { pipe } from 'fp-ts/lib/function.js';\nimport { createHmac as nodeCreateHmac } from 'node:crypto';\n\nimport { bufferToArrayBuffer } from '../buf-converters.js';\nimport { hashToken as _hashToken } from '../hashToken.js';\nimport { signDataFp as _signDataFp, SignDataError, type SignDataOptions } from '../signDataFp.js';\nimport {\n  signFp as _signFp,\n  type SignableData,\n  type SignOptions,\n} from '../signFp.js';\nimport type { CreateHmacFn, Text } from '../types.js';\nimport {\n  validateFp as _validateFp,\n  type ValidateError,\n  type ValidateOptions,\n  type ValidateValue,\n} from '../validation.js';\n\n/**\n * Converts Text to Node.js Buffer.\n * @param text - text to convert\n */\nfunction textToBuffer(text: Text): Buffer {\n  return Buffer.from(typeof text === 'string' ? text : new Uint8Array(text));\n}\n\nconst createHmac: CreateHmacFn<false> = (data, key) => {\n  return bufferToArrayBuffer(\n    nodeCreateHmac('sha256', textToBuffer(key))\n      .update(textToBuffer(data))\n      .digest(),\n  );\n};\n\n/**\n * Hashes specified token using a string, expected during init data sign.\n * @param token - token to hash.\n */\nexport function hashToken(token: Text): Buffer {\n  return Buffer.from(_hashToken(token, createHmac));\n}\n\n/**\n * @param value - value to check.\n * @param token - bot secret token.\n * @param options - additional validation options.\n * @returns True is specified init data is valid.\n */\nexport function isValid(value: ValidateValue, token: Text, options?: ValidateOptions): boolean {\n  return pipe(\n    validateFp(value, token, options),\n    E.match(() => false, () => true),\n  );\n}\n\n/**\n * Signs specified init data.\n * @param data - init data to sign.\n * @param authDate - date, when this init data should be signed.\n * @param key - private key.\n * @param options - additional options.\n * @returns Signed init data presented as query parameters.\n */\nexport function signFp(\n  data: SignableData,\n  key: Text,\n  authDate: Date,\n  options?: SignOptions,\n): E.Either<SignDataError, string> {\n  return _signFp(data, key, authDate, signDataFp, options);\n}\n\n/**\n * @see signFp\n */\nexport function sign(data: SignableData, key: Text, authDate: Date, options?: SignOptions): string {\n  return pipe(\n    signFp(data, key, authDate, options),\n    E.match(e => {\n      throw e;\n    }, v => v),\n  );\n}\n\n/**\n * Signs specified data with the passed token.\n * @param data - data to sign.\n * @param key - private key.\n * @param options - additional options.\n * @returns Data sign.\n */\nexport function signDataFp(\n  data: Text,\n  key: Text,\n  options?: SignDataOptions,\n): E.Either<SignDataError, string> {\n  return _signDataFp(false, data, key, createHmac, options);\n}\n\n/**\n * @see signDataFp\n */\nexport function signData(data: Text, key: Text, options?: SignDataOptions): string {\n  return pipe(\n    signDataFp(data, key, options),\n    E.match(e => {\n      throw e;\n    }, v => v),\n  );\n}\n\n/**\n * Validates passed init data.\n * @param value - value to check.\n * @param token - bot secret token.\n * @param options - additional validation options.\n */\nexport function validateFp(\n  value: ValidateValue,\n  token: Text,\n  options?: ValidateOptions,\n): E.Either<ValidateError, void> {\n  return _validateFp(false, value, token, signDataFp, options);\n}\n\n/**\n * @see validateFp\n */\nexport function validate(value: ValidateValue, token: Text, options?: ValidateOptions): void {\n  pipe(\n    validateFp(value, token, options),\n    E.mapLeft(error => {\n      throw error;\n    }),\n  );\n}\n\nexport * from './shared.js';\n"],"names":["bufferToArrayBuffer","nodeCreateHmac","_hashToken","pipe","E","_signFp","_signDataFp","_validateFp"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAwBA,SAAS,aAAa,MAAoB;AACjC,SAAA,OAAO,KAAK,OAAO,SAAS,WAAW,OAAO,IAAI,WAAW,IAAI,CAAC;AAC3E;AAEA,MAAM,aAAkC,CAAC,MAAM,QAAQ;AAC9C,SAAAA,QAAA;AAAA,IACLC,uBAAe,UAAU,aAAa,GAAG,CAAC,EACvC,OAAO,aAAa,IAAI,CAAC,EACzB,OAAO;AAAA,EACZ;AACF;AAMO,SAAS,UAAU,OAAqB;AAC7C,SAAO,OAAO,KAAKC,QAAW,UAAA,OAAO,UAAU,CAAC;AAClD;AAQgB,SAAA,QAAQ,OAAsB,OAAa,SAAoC;AACtF,SAAAC,YAAA;AAAA,IACL,WAAW,OAAO,OAAO,OAAO;AAAA,IAChCC,aAAE,MAAM,MAAM,OAAO,MAAM,IAAI;AAAA,EACjC;AACF;AAUO,SAAS,OACd,MACA,KACA,UACA,SACiC;AACjC,SAAOC,QAAAA,OAAQ,MAAM,KAAK,UAAU,YAAY,OAAO;AACzD;AAKO,SAAS,KAAK,MAAoB,KAAW,UAAgB,SAA+B;AAC1F,SAAAF,YAAA;AAAA,IACL,OAAO,MAAM,KAAK,UAAU,OAAO;AAAA,IACnCC,aAAE,MAAM,CAAK,MAAA;AACL,YAAA;AAAA,IAAA,GACL,OAAK,CAAC;AAAA,EACX;AACF;AASgB,SAAA,WACd,MACA,KACA,SACiC;AACjC,SAAOE,QAAAA,WAAY,OAAO,MAAM,KAAK,YAAY,OAAO;AAC1D;AAKgB,SAAA,SAAS,MAAY,KAAW,SAAmC;AAC1E,SAAAH,YAAA;AAAA,IACL,WAAW,MAAM,KAAK,OAAO;AAAA,IAC7BC,aAAE,MAAM,CAAK,MAAA;AACL,YAAA;AAAA,IAAA,GACL,OAAK,CAAC;AAAA,EACX;AACF;AAQgB,SAAA,WACd,OACA,OACA,SAC+B;AAC/B,SAAOG,QAAAA,WAAY,OAAO,OAAO,OAAO,YAAY,OAAO;AAC7D;AAKgB,SAAA,SAAS,OAAsB,OAAa,SAAiC;AAC3FJ,cAAA;AAAA,IACE,WAAW,OAAO,OAAO,OAAO;AAAA,IAChCC,aAAE,QAAQ,CAAS,UAAA;AACX,YAAA;AAAA,IACP,CAAA;AAAA,EACH;AACF;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/entries/node.d.ts

@@ -1,14 +1,20 @@
-import { InitData, InitDataParsed } from '@tma.js/sdk';
-import { SignOptions } from '../sign.js';
-import { SignDataOptions } from '../signData.js';
-import { ValidateOptions } from '../validate.js';
-import { SignData, Text } from '../types.js';
-
+import { SignDataError, SignDataOptions } from '../signDataFp.js';
+import { SignableData, SignOptions } from '../signFp.js';
+import { Text } from '../types.js';
+import { ValidateError, ValidateOptions, ValidateValue } from '../validation.js';
+import * as E from 'fp-ts/Either';
 /**
  * Hashes specified token using a string, expected during init data sign.
  * @param token - token to hash.
  */
 export declare function hashToken(token: Text): Buffer;
+/**
+ * @param value - value to check.
+ * @param token - bot secret token.
+ * @param options - additional validation options.
+ * @returns True is specified init data is valid.
+ */
+export declare function isValid(value: ValidateValue, token: Text, options?: ValidateOptions): boolean;
 /**
  * Signs specified init data.
  * @param data - init data to sign.
@@ -17,7 +23,11 @@ export declare function hashToken(token: Text): Buffer;
  * @param options - additional options.
  * @returns Signed init data presented as query parameters.
  */
-export declare function sign(data: SignData, key: Text, authDate: Date, options?: SignOptions): string;
+export declare function signFp(data: SignableData, key: Text, authDate: Date, options?: SignOptions): E.Either<SignDataError, string>;
+/**
+ * @see signFp
+ */
+export declare function sign(data: SignableData, key: Text, authDate: Date, options?: SignOptions): string;
 /**
  * Signs specified data with the passed token.
  * @param data - data to sign.
@@ -25,16 +35,20 @@ export declare function sign(data: SignData, key: Text, authDate: Date, options?
  * @param options - additional options.
  * @returns Data sign.
  */
+export declare function signDataFp(data: Text, key: Text, options?: SignDataOptions): E.Either<SignDataError, string>;
+/**
+ * @see signDataFp
+ */
 export declare function signData(data: Text, key: Text, options?: SignDataOptions): string;
 /**
  * Validates passed init data.
  * @param value - value to check.
  * @param token - bot secret token.
  * @param options - additional validation options.
- * @throws {TypeError} "auth_date" should present integer
- * @throws {Error} "hash" is empty or not found
- * @throws {Error} "auth_date" is empty or not found
- * @throws {Error} Init data expired
  */
-export declare function validate(value: InitData | InitDataParsed | string | URLSearchParams, token: Text, options?: ValidateOptions): void;
+export declare function validateFp(value: ValidateValue, token: Text, options?: ValidateOptions): E.Either<ValidateError, void>;
+/**
+ * @see validateFp
+ */
+export declare function validate(value: ValidateValue, token: Text, options?: ValidateOptions): void;
 export * from './shared.js';

package/dist/entries/node.js

@@ -1,27 +1,79 @@
+import * as E from "fp-ts/Either";
+import { pipe } from "fp-ts/lib/function.js";
 import { createHmac as createHmac$1 } from "node:crypto";
-import { h as hashToken$1, s as sign$1, a as signData$1, v as validate$1 } from "./index-B-IiSE5b.js";
-import { i, c } from "./index-B-IiSE5b.js";
+import { h as hashToken$1, s as signFp$1, a as signDataFp$1, v as validateFp$1, b as bufferToArrayBuffer } from "./parsing-eczkSd-W.js";
+import { A, E as E2, H, S, c, i, e, p, d, f, g } from "./parsing-eczkSd-W.js";
+import { deepSnakeToCamelObjKeys } from "@tma.js/toolkit";
+function textToBuffer(text) {
+  return Buffer.from(typeof text === "string" ? text : new Uint8Array(text));
+}
 const createHmac = (data, key) => {
-  return createHmac$1("sha256", key).update(data).digest();
+  return bufferToArrayBuffer(
+    createHmac$1("sha256", textToBuffer(key)).update(textToBuffer(data)).digest()
+  );
 };
 function hashToken(token) {
-  return hashToken$1(token, createHmac);
+  return Buffer.from(hashToken$1(token, createHmac));
+}
+function isValid(value, token, options) {
+  return pipe(
+    validateFp(value, token, options),
+    E.match(() => false, () => true)
+  );
+}
+function signFp(data, key, authDate, options) {
+  return signFp$1(data, key, authDate, signDataFp, options);
 }
 function sign(data, key, authDate, options) {
-  return sign$1(data, key, authDate, signData, options);
+  return pipe(
+    signFp(data, key, authDate, options),
+    E.match((e2) => {
+      throw e2;
+    }, (v) => v)
+  );
+}
+function signDataFp(data, key, options) {
+  return signDataFp$1(false, data, key, createHmac, options);
 }
 function signData(data, key, options) {
-  return signData$1(data, key, createHmac, options);
+  return pipe(
+    signDataFp(data, key, options),
+    E.match((e2) => {
+      throw e2;
+    }, (v) => v)
+  );
+}
+function validateFp(value, token, options) {
+  return validateFp$1(false, value, token, signDataFp, options);
 }
 function validate(value, token, options) {
-  return validate$1(value, token, signData, options);
+  pipe(
+    validateFp(value, token, options),
+    E.mapLeft((error) => {
+      throw error;
+    })
+  );
 }
 export {
+  A as AuthDateInvalidError,
+  E2 as ExpiredError,
+  H as HexStringLengthInvalidError,
+  S as SignatureInvalidError,
+  c as SignatureMissingError,
+  deepSnakeToCamelObjKeys,
   hashToken,
-  i as initDataToSearchParams,
-  c as parse,
+  isValid,
+  i as isValid3rd,
+  e as isValid3rdFp,
+  p as parse,
+  d as parseFp,
   sign,
   signData,
-  validate
+  signDataFp,
+  signFp,
+  validate,
+  f as validate3rd,
+  g as validate3rdFp,
+  validateFp
 };
 //# sourceMappingURL=node.js.map

package/dist/entries/node.js.map

@@ -1 +1 @@
-{"version":3,"file":"node.js","sources":["../../src/entries/node.ts"],"sourcesContent":["import { createHmac as nodeCreateHmac } from 'node:crypto';\nimport { InitData, InitDataParsed } from '@tma.js/sdk';\n\nimport { hashToken as baseHashToken } from '../hashToken.js';\nimport { sign as baseSign, SignOptions } from '../sign.js';\nimport { signData as baseSignData, SignDataOptions } from '../signData.js';\nimport { validate as baseValidate } from '../validate.js';\nimport type { ValidateOptions } from '../validate.js';\nimport type { CreateHmacFn, SignData, Text } from '../types.js';\n\nconst createHmac: CreateHmacFn<false> = (data, key) => {\n  return nodeCreateHmac('sha256', key).update(data).digest();\n};\n\n/**\n * Hashes specified token using a string, expected during init data sign.\n * @param token - token to hash.\n */\nexport function hashToken(token: Text): Buffer {\n  return baseHashToken(token, createHmac);\n}\n\n/**\n * Signs specified init data.\n * @param data - init data to sign.\n * @param authDate - date, when this init data should be signed.\n * @param key - private key.\n * @param options - additional options.\n * @returns Signed init data presented as query parameters.\n */\nexport function sign(data: SignData, key: Text, authDate: Date, options?: SignOptions): string {\n  return baseSign(data, key, authDate, signData, options);\n}\n\n/**\n * Signs specified data with the passed token.\n * @param data - data to sign.\n * @param key - private key.\n * @param options - additional options.\n * @returns Data sign.\n */\nexport function signData(data: Text, key: Text, options?: SignDataOptions): string {\n  return baseSignData(data, key, createHmac, options);\n}\n\n/**\n * Validates passed init data.\n * @param value - value to check.\n * @param token - bot secret token.\n * @param options - additional validation options.\n * @throws {TypeError} \"auth_date\" should present integer\n * @throws {Error} \"hash\" is empty or not found\n * @throws {Error} \"auth_date\" is empty or not found\n * @throws {Error} Init data expired\n */\nexport function validate(\n  value: InitData | InitDataParsed | string | URLSearchParams,\n  token: Text,\n  options?: ValidateOptions,\n): void {\n  return baseValidate(value, token, signData, options);\n}\n\nexport * from './shared.js';\n"],"names":["nodeCreateHmac","baseHashToken","baseSign","baseSignData","baseValidate"],"mappings":";;;AAUA,MAAM,aAAkC,CAAC,MAAM,QAAQ;AACrD,SAAOA,aAAe,UAAU,GAAG,EAAE,OAAO,IAAI,EAAE;AACpD;AAMO,SAAS,UAAU,OAAqB;AACtC,SAAAC,YAAc,OAAO,UAAU;AACxC;AAUO,SAAS,KAAK,MAAgB,KAAW,UAAgB,SAA+B;AAC7F,SAAOC,OAAS,MAAM,KAAK,UAAU,UAAU,OAAO;AACxD;AASgB,SAAA,SAAS,MAAY,KAAW,SAAmC;AACjF,SAAOC,WAAa,MAAM,KAAK,YAAY,OAAO;AACpD;AAYgB,SAAA,SACd,OACA,OACA,SACM;AACN,SAAOC,WAAa,OAAO,OAAO,UAAU,OAAO;AACrD;"}
+{"version":3,"file":"node.js","sources":["../../src/entries/node.ts"],"sourcesContent":["import * as E from 'fp-ts/Either';\nimport { pipe } from 'fp-ts/lib/function.js';\nimport { createHmac as nodeCreateHmac } from 'node:crypto';\n\nimport { bufferToArrayBuffer } from '../buf-converters.js';\nimport { hashToken as _hashToken } from '../hashToken.js';\nimport { signDataFp as _signDataFp, SignDataError, type SignDataOptions } from '../signDataFp.js';\nimport {\n  signFp as _signFp,\n  type SignableData,\n  type SignOptions,\n} from '../signFp.js';\nimport type { CreateHmacFn, Text } from '../types.js';\nimport {\n  validateFp as _validateFp,\n  type ValidateError,\n  type ValidateOptions,\n  type ValidateValue,\n} from '../validation.js';\n\n/**\n * Converts Text to Node.js Buffer.\n * @param text - text to convert\n */\nfunction textToBuffer(text: Text): Buffer {\n  return Buffer.from(typeof text === 'string' ? text : new Uint8Array(text));\n}\n\nconst createHmac: CreateHmacFn<false> = (data, key) => {\n  return bufferToArrayBuffer(\n    nodeCreateHmac('sha256', textToBuffer(key))\n      .update(textToBuffer(data))\n      .digest(),\n  );\n};\n\n/**\n * Hashes specified token using a string, expected during init data sign.\n * @param token - token to hash.\n */\nexport function hashToken(token: Text): Buffer {\n  return Buffer.from(_hashToken(token, createHmac));\n}\n\n/**\n * @param value - value to check.\n * @param token - bot secret token.\n * @param options - additional validation options.\n * @returns True is specified init data is valid.\n */\nexport function isValid(value: ValidateValue, token: Text, options?: ValidateOptions): boolean {\n  return pipe(\n    validateFp(value, token, options),\n    E.match(() => false, () => true),\n  );\n}\n\n/**\n * Signs specified init data.\n * @param data - init data to sign.\n * @param authDate - date, when this init data should be signed.\n * @param key - private key.\n * @param options - additional options.\n * @returns Signed init data presented as query parameters.\n */\nexport function signFp(\n  data: SignableData,\n  key: Text,\n  authDate: Date,\n  options?: SignOptions,\n): E.Either<SignDataError, string> {\n  return _signFp(data, key, authDate, signDataFp, options);\n}\n\n/**\n * @see signFp\n */\nexport function sign(data: SignableData, key: Text, authDate: Date, options?: SignOptions): string {\n  return pipe(\n    signFp(data, key, authDate, options),\n    E.match(e => {\n      throw e;\n    }, v => v),\n  );\n}\n\n/**\n * Signs specified data with the passed token.\n * @param data - data to sign.\n * @param key - private key.\n * @param options - additional options.\n * @returns Data sign.\n */\nexport function signDataFp(\n  data: Text,\n  key: Text,\n  options?: SignDataOptions,\n): E.Either<SignDataError, string> {\n  return _signDataFp(false, data, key, createHmac, options);\n}\n\n/**\n * @see signDataFp\n */\nexport function signData(data: Text, key: Text, options?: SignDataOptions): string {\n  return pipe(\n    signDataFp(data, key, options),\n    E.match(e => {\n      throw e;\n    }, v => v),\n  );\n}\n\n/**\n * Validates passed init data.\n * @param value - value to check.\n * @param token - bot secret token.\n * @param options - additional validation options.\n */\nexport function validateFp(\n  value: ValidateValue,\n  token: Text,\n  options?: ValidateOptions,\n): E.Either<ValidateError, void> {\n  return _validateFp(false, value, token, signDataFp, options);\n}\n\n/**\n * @see validateFp\n */\nexport function validate(value: ValidateValue, token: Text, options?: ValidateOptions): void {\n  pipe(\n    validateFp(value, token, options),\n    E.mapLeft(error => {\n      throw error;\n    }),\n  );\n}\n\nexport * from './shared.js';\n"],"names":["nodeCreateHmac","_hashToken","_signFp","e","_signDataFp","_validateFp"],"mappings":";;;;;;AAwBA,SAAS,aAAa,MAAoB;AACjC,SAAA,OAAO,KAAK,OAAO,SAAS,WAAW,OAAO,IAAI,WAAW,IAAI,CAAC;AAC3E;AAEA,MAAM,aAAkC,CAAC,MAAM,QAAQ;AAC9C,SAAA;AAAA,IACLA,aAAe,UAAU,aAAa,GAAG,CAAC,EACvC,OAAO,aAAa,IAAI,CAAC,EACzB,OAAO;AAAA,EACZ;AACF;AAMO,SAAS,UAAU,OAAqB;AAC7C,SAAO,OAAO,KAAKC,YAAW,OAAO,UAAU,CAAC;AAClD;AAQgB,SAAA,QAAQ,OAAsB,OAAa,SAAoC;AACtF,SAAA;AAAA,IACL,WAAW,OAAO,OAAO,OAAO;AAAA,IAChC,EAAE,MAAM,MAAM,OAAO,MAAM,IAAI;AAAA,EACjC;AACF;AAUO,SAAS,OACd,MACA,KACA,UACA,SACiC;AACjC,SAAOC,SAAQ,MAAM,KAAK,UAAU,YAAY,OAAO;AACzD;AAKO,SAAS,KAAK,MAAoB,KAAW,UAAgB,SAA+B;AAC1F,SAAA;AAAA,IACL,OAAO,MAAM,KAAK,UAAU,OAAO;AAAA,IACnC,EAAE,MAAM,CAAKC,OAAA;AACL,YAAAA;AAAA,IAAA,GACL,OAAK,CAAC;AAAA,EACX;AACF;AASgB,SAAA,WACd,MACA,KACA,SACiC;AACjC,SAAOC,aAAY,OAAO,MAAM,KAAK,YAAY,OAAO;AAC1D;AAKgB,SAAA,SAAS,MAAY,KAAW,SAAmC;AAC1E,SAAA;AAAA,IACL,WAAW,MAAM,KAAK,OAAO;AAAA,IAC7B,EAAE,MAAM,CAAKD,OAAA;AACL,YAAAA;AAAA,IAAA,GACL,OAAK,CAAC;AAAA,EACX;AACF;AAQgB,SAAA,WACd,OACA,OACA,SAC+B;AAC/B,SAAOE,aAAY,OAAO,OAAO,OAAO,YAAY,OAAO;AAC7D;AAKgB,SAAA,SAAS,OAAsB,OAAa,SAAiC;AAC3F;AAAA,IACE,WAAW,OAAO,OAAO,OAAO;AAAA,IAChC,EAAE,QAAQ,CAAS,UAAA;AACX,YAAA;AAAA,IACP,CAAA;AAAA,EACH;AACF;"}

package/dist/entries/parsing-Cj_BXCnv.cjs

@@ -0,0 +1,258 @@
+"use strict";
+const E = require("fp-ts/Either");
+const TE = require("fp-ts/TaskEither");
+const function_js = require("fp-ts/lib/function.js");
+const transformers = require("@tma.js/transformers");
+const _function = require("fp-ts/function");
+const betterPromises = require("better-promises");
+const errorKid = require("error-kid");
+function _interopNamespaceDefault(e) {
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const E__namespace = /* @__PURE__ */ _interopNamespaceDefault(E);
+const TE__namespace = /* @__PURE__ */ _interopNamespaceDefault(TE);
+class AuthDateInvalidError extends errorKid.errorClassWithData(
+  "AuthDateInvalidError",
+  (value) => ({ value }),
+  (value) => [`"auth_date" is invalid: ${value || "value is missing"}`]
+) {
+}
+class SignatureInvalidError extends errorKid.errorClass("SignatureInvalidError") {
+}
+class HexStringLengthInvalidError extends errorKid.errorClass(
+  "HexStringLengthInvalidError"
+) {
+}
+class SignatureMissingError extends errorKid.errorClass(
+  "SignatureMissingError",
+  (thirdParty) => [`"${thirdParty ? "signature" : "hash"}" parameter is missing`]
+) {
+}
+class ExpiredError extends errorKid.errorClassWithData(
+  "ExpiredError",
+  (issuedAt, expiresAt) => ({ issuedAt, expiresAt }),
+  (issuedAt, expiresAt, now) => [
+    `Init data expired. Issued at ${issuedAt.toISOString()}, expires at ${expiresAt.toISOString()}, now is ${now.toISOString()}`
+  ]
+) {
+}
+function hexToArrayBuffer(hexString) {
+  if (hexString.length % 2 !== 0) {
+    return E__namespace.left(new HexStringLengthInvalidError());
+  }
+  const buffer = new ArrayBuffer(hexString.length / 2);
+  const uint8Array = new Uint8Array(buffer);
+  for (let i = 0; i < hexString.length; i += 2) {
+    uint8Array[i / 2] = parseInt(hexString.substring(i, i + 2), 16);
+  }
+  return E__namespace.right(buffer);
+}
+function arrayBufferToHex(arrBuf) {
+  return new Uint8Array(arrBuf).reduce((acc, byte) => {
+    return acc + byte.toString(16).padStart(2, "0");
+  }, "");
+}
+function bufferToArrayBuffer(buf) {
+  const ab = new ArrayBuffer(buf.length);
+  buf.copy(new Uint8Array(ab));
+  return ab;
+}
+function hashToken(token, createHmac) {
+  return createHmac(token, "WebAppData");
+}
+function signDataFp(async, data, key, createHmac, options = {}) {
+  const keyHmac = options.tokenHashed ? typeof key === "string" ? hexToArrayBuffer(key) : E__namespace.right(key) : function_js.pipe(
+    E__namespace.right(hashToken(key, createHmac)),
+    E__namespace.match(() => null, (v) => {
+      return v instanceof Promise ? TE__namespace.tryCatch(() => v, (err) => err) : E__namespace.right(v);
+    })
+  );
+  if (async || typeof keyHmac === "function") {
+    return function_js.pipe(
+      typeof keyHmac === "function" ? keyHmac : TE__namespace.fromEither(keyHmac),
+      TE__namespace.chain((v) => TE__namespace.tryCatch(
+        () => Promise.resolve(createHmac(data, v)).then(arrayBufferToHex),
+        (err) => err
+      ))
+    );
+  }
+  return function_js.pipe(
+    keyHmac,
+    // In this branch createHmac can't be asynchronous. If it is, keyHmac would be Promise and the
+    // result would be returned in the previous "if" statement.
+    E__namespace.chain((v) => E__namespace.right(
+      arrayBufferToHex(createHmac(data, v))
+    ))
+  );
+}
+function signFp(data, key, authDate, signData, options) {
+  const query = new URLSearchParams(transformers.serializeInitDataQuery({ ...data, auth_date: authDate }));
+  const pairs = [...query.entries()].map(([name, value]) => `${name}=${value}`).sort();
+  const queryWithHash = (signature) => {
+    query.append("hash", signature);
+    return query.toString();
+  };
+  const eitherHash = signData(pairs.join("\n"), key, options);
+  return typeof eitherHash === "function" ? function_js.pipe(eitherHash, TE__namespace.chain((hash) => TE__namespace.right(queryWithHash(hash)))) : function_js.pipe(eitherHash, E__namespace.chain((hash) => E__namespace.right(queryWithHash(hash))));
+}
+function validate3rdFp(value, botId, options = {}) {
+  let authDate;
+  let authDateString;
+  let signature;
+  const pairs = [];
+  (typeof value === "string" ? new URLSearchParams(value) : value).forEach((value2, key) => {
+    if (key === "hash") {
+      return;
+    }
+    if (key === "signature") {
+      signature = value2;
+      return;
+    }
+    if (key === "auth_date") {
+      authDateString = value2;
+      const authDateNum = parseInt(value2, 10);
+      if (!Number.isNaN(authDateNum)) {
+        authDate = new Date(authDateNum * 1e3);
+      }
+    }
+    pairs.push(`${key}=${value2}`);
+  });
+  if (!signature) {
+    return TE__namespace.left(new SignatureMissingError(true));
+  }
+  if (!authDate) {
+    return TE__namespace.left(new AuthDateInvalidError(authDateString));
+  }
+  const { expiresIn = 86400 } = options;
+  if (expiresIn > 0) {
+    const expiresAtTs = authDate.getTime() + expiresIn * 1e3;
+    const nowTs = Date.now();
+    if (expiresAtTs < nowTs) {
+      return TE__namespace.left(new ExpiredError(authDate, new Date(expiresAtTs), new Date(nowTs)));
+    }
+  }
+  return _function.pipe(
+    TE__namespace.tryCatch(
+      () => {
+        return betterPromises.BetterPromise.fn(async () => {
+          return crypto.subtle.verify(
+            "Ed25519",
+            await crypto.subtle.importKey(
+              "raw",
+              Buffer.from(
+                options.test ? "40055058a4ee38156a06562e52eece92a771bcd8346a8c4615cb7376eddf72ec" : "e7bf03a2fa4602af4580703d88dda5bb59f32ed8b02a56c187fe7d34caed242d",
+                "hex"
+              ),
+              "Ed25519",
+              false,
+              ["verify"]
+            ),
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+            Buffer.from(signature, "base64"),
+            Buffer.from(`${botId}:WebAppData
+${pairs.sort().join("\n")}`)
+          );
+        }, options);
+      },
+      (e) => e
+    ),
+    TE__namespace.chainW((isVerified) => {
+      return isVerified ? TE__namespace.right(void 0) : TE__namespace.left(new SignatureInvalidError());
+    })
+  );
+}
+function validate3rd(value, botId, options) {
+  return betterPromises.BetterPromise.fn(async () => {
+    await _function.pipe(
+      validate3rdFp(value, botId, options),
+      TE__namespace.mapLeft((error) => {
+        throw error;
+      })
+    )();
+  });
+}
+function isValid3rdFp(value, botId, options) {
+  return _function.pipe(validate3rdFp(value, botId, options), TE__namespace.match(
+    () => E__namespace.right(false),
+    () => E__namespace.right(true)
+  ));
+}
+function isValid3rd(value, botId, options) {
+  return betterPromises.BetterPromise.fn(() => _function.pipe(
+    isValid3rdFp(value, botId, options),
+    TE__namespace.match(() => false, (v) => v)
+  )());
+}
+function validateFp(async, value, token, signData, options = {}) {
+  let authDate;
+  let authDateString;
+  let hash;
+  const pairs = [];
+  (typeof value === "string" ? new URLSearchParams(value) : value).forEach((value2, key) => {
+    if (key === "hash") {
+      hash = value2;
+      return;
+    }
+    if (key === "auth_date") {
+      authDateString = value2;
+      const authDateNum = parseInt(value2, 10);
+      if (!Number.isNaN(authDateNum)) {
+        authDate = new Date(authDateNum * 1e3);
+      }
+    }
+    pairs.push(`${key}=${value2}`);
+  });
+  if (!hash) {
+    return (async ? TE__namespace.left : E__namespace.left)(new SignatureMissingError(false));
+  }
+  if (!authDate) {
+    return (async ? TE__namespace.left : E__namespace.left)(new AuthDateInvalidError(authDateString));
+  }
+  const { expiresIn = 86400 } = options;
+  if (expiresIn > 0) {
+    const expiresAtTs = authDate.getTime() + expiresIn * 1e3;
+    const nowTs = Date.now();
+    if (expiresAtTs < nowTs) {
+      return (async ? TE__namespace.left : E__namespace.left)(
+        new ExpiredError(authDate, new Date(expiresAtTs), new Date(nowTs))
+      );
+    }
+  }
+  pairs.sort();
+  const eitherSignature = signData(pairs.join("\n"), token, options);
+  const onLeft = (error) => E__namespace.left(error);
+  const onRight = (signature) => signature === hash ? E__namespace.right(void 0) : E__namespace.left(new SignatureInvalidError());
+  return typeof eitherSignature === "function" ? _function.pipe(eitherSignature, TE__namespace.matchW(onLeft, onRight)) : _function.pipe(eitherSignature, E__namespace.matchW(onLeft, onRight));
+}
+const parse = transformers.parseInitDataQuery;
+const parseFp = transformers.parseInitDataQueryFp;
+exports.AuthDateInvalidError = AuthDateInvalidError;
+exports.ExpiredError = ExpiredError;
+exports.HexStringLengthInvalidError = HexStringLengthInvalidError;
+exports.SignatureInvalidError = SignatureInvalidError;
+exports.SignatureMissingError = SignatureMissingError;
+exports.bufferToArrayBuffer = bufferToArrayBuffer;
+exports.hashToken = hashToken;
+exports.isValid3rd = isValid3rd;
+exports.isValid3rdFp = isValid3rdFp;
+exports.parse = parse;
+exports.parseFp = parseFp;
+exports.signDataFp = signDataFp;
+exports.signFp = signFp;
+exports.validate3rd = validate3rd;
+exports.validate3rdFp = validate3rdFp;
+exports.validateFp = validateFp;
+//# sourceMappingURL=parsing-Cj_BXCnv.cjs.map