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

package/dist/entries/web.js

@@ -1,39 +1,114 @@
-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 { BetterPromise } from "better-promises";
+import * as E from "fp-ts/Either";
+import * as TE from "fp-ts/TaskEither";
+import { pipe } from "fp-ts/lib/function.js";
+import { h as hashToken$1, A as AuthDateInvalidError, E as ExpiredError, S as SignatureInvalidError, c as SignatureMissingError, H as HexStringLengthInvalidError, s as signFp$1, a as signDataFp$1, v as validateFp$1 } from "./parsing-eczkSd-W.js";
+import { i, e, p, d, f, g } from "./parsing-eczkSd-W.js";
+import { deepSnakeToCamelObjKeys } from "@tma.js/toolkit";
 const createHmac = async (data, key) => {
   const encoder = new TextEncoder();
-  return Buffer.from(
-    await crypto.subtle.sign(
-      "HMAC",
-      await crypto.subtle.importKey(
-        "raw",
-        typeof key === "string" ? encoder.encode(key) : key,
-        { name: "HMAC", hash: "SHA-256" },
-        false,
-        ["sign", "verify"]
-      ),
-      encoder.encode(data.toString())
-    )
+  return crypto.subtle.sign(
+    "HMAC",
+    await crypto.subtle.importKey(
+      "raw",
+      typeof key === "string" ? encoder.encode(key) : key,
+      { name: "HMAC", hash: "SHA-256" },
+      false,
+      ["sign", "verify"]
+    ),
+    typeof data === "string" ? encoder.encode(data) : data
   );
 };
 function hashToken(token) {
   return hashToken$1(token, createHmac);
 }
+function isValidFp(value, token, options) {
+  return pipe(
+    validateFp(value, token, options),
+    TE.match(
+      (error) => {
+        return [
+          AuthDateInvalidError,
+          ExpiredError,
+          SignatureInvalidError,
+          SignatureMissingError,
+          HexStringLengthInvalidError
+        ].some((errorClass) => errorClass.is(error)) ? E.right(false) : E.left(error);
+      },
+      () => E.right(true)
+    )
+  );
+}
+function isValid(value, token, options) {
+  return BetterPromise.fn(() => {
+    return pipe(
+      isValidFp(value, token, options),
+      TE.match((error) => {
+        throw error;
+      }, (isValid2) => isValid2)
+    )();
+  });
+}
+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 BetterPromise.fn(() => {
+    return pipe(
+      signFp(data, key, authDate, options),
+      TE.match((e2) => {
+        throw e2;
+      }, (v) => v)
+    )();
+  });
+}
+function signDataFp(data, key, options) {
+  return signDataFp$1(true, data, key, createHmac, options);
+}
+function signData(data, key, options) {
+  return BetterPromise.fn(() => {
+    return pipe(
+      signDataFp(data, key, options),
+      TE.match((e2) => {
+        throw e2;
+      }, (v) => v)
+    )();
+  });
 }
-async function signData(data, key, options) {
-  return signData$1(data, key, createHmac, options);
+function validateFp(value, token, options) {
+  return validateFp$1(true, value, token, signDataFp, options);
 }
-async function validate(value, token, options) {
-  return validate$1(value, token, signData, options);
+function validate(value, token, options) {
+  return BetterPromise.fn(async () => {
+    await pipe(
+      validateFp(value, token, options),
+      TE.mapLeft((error) => {
+        throw error;
+      })
+    )();
+  });
 }
 export {
+  AuthDateInvalidError,
+  ExpiredError,
+  HexStringLengthInvalidError,
+  SignatureInvalidError,
+  SignatureMissingError,
+  deepSnakeToCamelObjKeys,
   hashToken,
-  i as initDataToSearchParams,
-  c as parse,
+  isValid,
+  i as isValid3rd,
+  e as isValid3rdFp,
+  isValidFp,
+  p as parse,
+  d as parseFp,
   sign,
   signData,
-  validate
+  signDataFp,
+  signFp,
+  validate,
+  f as validate3rd,
+  g as validate3rdFp,
+  validateFp
 };
 //# sourceMappingURL=web.js.map

package/dist/entries/web.js.map

@@ -1 +1 @@
-{"version":3,"file":"web.js","sources":["../../src/entries/web.ts"],"sourcesContent":["import { 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<true> = async (data, key) => {\n  const encoder = new TextEncoder();\n\n  return Buffer.from(\n    await crypto.subtle.sign(\n      'HMAC',\n      await crypto.subtle.importKey(\n        'raw',\n        typeof key === 'string' ? encoder.encode(key) : key,\n        { name: 'HMAC', hash: 'SHA-256' },\n        false,\n        ['sign', 'verify'],\n      ),\n      encoder.encode(data.toString()),\n    ),\n  );\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): Promise<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(\n  data: SignData,\n  key: Text,\n  authDate: Date,\n  options?: SignOptions\n): Promise<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 async function signData(data: Text, key: Text, options?: SignDataOptions): Promise<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 async function validate(\n  value: InitData | InitDataParsed | string | URLSearchParams,\n  token: Text,\n  options?: ValidateOptions,\n): Promise<void> {\n  return baseValidate(value, token, signData, options);\n}\n\nexport * from './shared.js';\n"],"names":["baseHashToken","baseSign","baseSignData","baseValidate"],"mappings":";;AASA,MAAM,aAAiC,OAAO,MAAM,QAAQ;AACpD,QAAA,UAAU,IAAI;AAEpB,SAAO,OAAO;AAAA,IACZ,MAAM,OAAO,OAAO;AAAA,MAClB;AAAA,MACA,MAAM,OAAO,OAAO;AAAA,QAClB;AAAA,QACA,OAAO,QAAQ,WAAW,QAAQ,OAAO,GAAG,IAAI;AAAA,QAChD,EAAE,MAAM,QAAQ,MAAM,UAAU;AAAA,QAChC;AAAA,QACA,CAAC,QAAQ,QAAQ;AAAA,MACnB;AAAA,MACA,QAAQ,OAAO,KAAK,UAAU;AAAA,IAChC;AAAA,EAAA;AAEJ;AAOO,SAAS,UAAU,OAA8B;AAC/C,SAAAA,YAAc,OAAO,UAAU;AACxC;AAUO,SAAS,KACd,MACA,KACA,UACA,SACiB;AACjB,SAAOC,OAAS,MAAM,KAAK,UAAU,UAAU,OAAO;AACxD;AASsB,eAAA,SAAS,MAAY,KAAW,SAA4C;AAChG,SAAOC,WAAa,MAAM,KAAK,YAAY,OAAO;AACpD;AAYsB,eAAA,SACpB,OACA,OACA,SACe;AACf,SAAOC,WAAa,OAAO,OAAO,UAAU,OAAO;AACrD;"}
+{"version":3,"file":"web.js","sources":["../../src/entries/web.ts"],"sourcesContent":["import { BetterPromise, type BetterPromiseRejectReason } from 'better-promises';\nimport * as E from 'fp-ts/Either';\nimport * as TE from 'fp-ts/TaskEither';\nimport { pipe } from 'fp-ts/lib/function.js';\n\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 ValidateValue,\n  type ValidateAsyncError,\n  type ValidateAsyncOptions,\n} from '../validation.js';\nimport {\n  AuthDateInvalidError,\n  ExpiredError,\n  SignatureInvalidError,\n  SignatureMissingError,\n  HexStringLengthInvalidError,\n} from '../errors.js';\n\nconst createHmac: CreateHmacFn<true> = async (data, key) => {\n  const encoder = new TextEncoder();\n\n  return crypto.subtle.sign(\n    'HMAC',\n    await crypto.subtle.importKey(\n      'raw',\n      typeof key === 'string' ? encoder.encode(key) : key,\n      { name: 'HMAC', hash: 'SHA-256' },\n      false,\n      ['sign', 'verify'],\n    ),\n    typeof data === 'string' ? encoder.encode(data) : data,\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): Promise<ArrayBuffer> {\n  return _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 isValidFp(\n  value: ValidateValue,\n  token: Text,\n  options?: ValidateAsyncOptions,\n): TE.TaskEither<BetterPromiseRejectReason, boolean> {\n  return pipe(\n    validateFp(value, token, options),\n    TE.match(\n      error => {\n        return [\n          AuthDateInvalidError,\n          ExpiredError,\n          SignatureInvalidError,\n          SignatureMissingError,\n          HexStringLengthInvalidError,\n        ].some(errorClass => errorClass.is(error))\n          ? E.right(false)\n          : E.left(error);\n      },\n      () => E.right(true),\n    ),\n  );\n}\n\n/**\n * @see isValidFp\n */\nexport function isValid(\n  value: ValidateValue,\n  token: Text,\n  options?: ValidateAsyncOptions,\n): BetterPromise<boolean> {\n  return BetterPromise.fn(() => {\n    return pipe(\n      isValidFp(value, token, options),\n      TE.match(error => {\n        throw error;\n      }, isValid => isValid),\n    )();\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): TE.TaskEither<SignDataError, string> {\n  return _signFp(data, key, authDate, signDataFp, options);\n}\n\n/**\n * @see signFp\n */\nexport function sign(\n  data: SignableData,\n  key: Text,\n  authDate: Date,\n  options?: SignOptions,\n): BetterPromise<string> {\n  return BetterPromise.fn(() => {\n    return pipe(\n      signFp(data, key, authDate, options),\n      TE.match(e => {\n        throw e;\n      }, v => v),\n    )();\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): TE.TaskEither<SignDataError, string> {\n  return _signDataFp(true, data, key, createHmac, options);\n}\n\n/**\n * @see signDataFp\n */\nexport function signData(data: Text, key: Text, options?: SignDataOptions): BetterPromise<string> {\n  return BetterPromise.fn(() => {\n    return pipe(\n      signDataFp(data, key, options),\n      TE.match(e => {\n        throw e;\n      }, v => v),\n    )();\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?: ValidateAsyncOptions,\n): TE.TaskEither<ValidateAsyncError, void> {\n  return _validateFp(true, value, token, signDataFp, options);\n}\n\n/**\n * @see validateFp\n */\nexport function validate(\n  value: ValidateValue,\n  token: Text,\n  options?: ValidateAsyncOptions,\n): BetterPromise<void> {\n  return BetterPromise.fn(async () => {\n    await pipe(\n      validateFp(value, token, options),\n      TE.mapLeft(error => {\n        throw error;\n      }),\n    )();\n  });\n}\n\nexport * from './shared.js';\n"],"names":["_hashToken","isValid","_signFp","e","_signDataFp","_validateFp"],"mappings":";;;;;;;AA2BA,MAAM,aAAiC,OAAO,MAAM,QAAQ;AACpD,QAAA,UAAU,IAAI,YAAY;AAEhC,SAAO,OAAO,OAAO;AAAA,IACnB;AAAA,IACA,MAAM,OAAO,OAAO;AAAA,MAClB;AAAA,MACA,OAAO,QAAQ,WAAW,QAAQ,OAAO,GAAG,IAAI;AAAA,MAChD,EAAE,MAAM,QAAQ,MAAM,UAAU;AAAA,MAChC;AAAA,MACA,CAAC,QAAQ,QAAQ;AAAA,IACnB;AAAA,IACA,OAAO,SAAS,WAAW,QAAQ,OAAO,IAAI,IAAI;AAAA,EACpD;AACF;AAMO,SAAS,UAAU,OAAmC;AACpD,SAAAA,YAAW,OAAO,UAAU;AACrC;AAQgB,SAAA,UACd,OACA,OACA,SACmD;AAC5C,SAAA;AAAA,IACL,WAAW,OAAO,OAAO,OAAO;AAAA,IAChC,GAAG;AAAA,MACD,CAAS,UAAA;AACA,eAAA;AAAA,UACL;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,QACA,EAAA,KAAK,CAAc,eAAA,WAAW,GAAG,KAAK,CAAC,IACrC,EAAE,MAAM,KAAK,IACb,EAAE,KAAK,KAAK;AAAA,MAClB;AAAA,MACA,MAAM,EAAE,MAAM,IAAI;AAAA,IAAA;AAAA,EAEtB;AACF;AAKgB,SAAA,QACd,OACA,OACA,SACwB;AACjB,SAAA,cAAc,GAAG,MAAM;AACrB,WAAA;AAAA,MACL,UAAU,OAAO,OAAO,OAAO;AAAA,MAC/B,GAAG,MAAM,CAAS,UAAA;AACV,cAAA;AAAA,MAAA,GACL,CAAAC,aAAWA,QAAO;AAAA,IAAA,EACrB;AAAA,EAAA,CACH;AACH;AAUO,SAAS,OACd,MACA,KACA,UACA,SACsC;AACtC,SAAOC,SAAQ,MAAM,KAAK,UAAU,YAAY,OAAO;AACzD;AAKO,SAAS,KACd,MACA,KACA,UACA,SACuB;AAChB,SAAA,cAAc,GAAG,MAAM;AACrB,WAAA;AAAA,MACL,OAAO,MAAM,KAAK,UAAU,OAAO;AAAA,MACnC,GAAG,MAAM,CAAKC,OAAA;AACN,cAAAA;AAAA,MAAA,GACL,OAAK,CAAC;AAAA,IAAA,EACT;AAAA,EAAA,CACH;AACH;AASgB,SAAA,WACd,MACA,KACA,SACsC;AACtC,SAAOC,aAAY,MAAM,MAAM,KAAK,YAAY,OAAO;AACzD;AAKgB,SAAA,SAAS,MAAY,KAAW,SAAkD;AACzF,SAAA,cAAc,GAAG,MAAM;AACrB,WAAA;AAAA,MACL,WAAW,MAAM,KAAK,OAAO;AAAA,MAC7B,GAAG,MAAM,CAAKD,OAAA;AACN,cAAAA;AAAA,MAAA,GACL,OAAK,CAAC;AAAA,IAAA,EACT;AAAA,EAAA,CACH;AACH;AAQgB,SAAA,WACd,OACA,OACA,SACyC;AACzC,SAAOE,aAAY,MAAM,OAAO,OAAO,YAAY,OAAO;AAC5D;AAKgB,SAAA,SACd,OACA,OACA,SACqB;AACd,SAAA,cAAc,GAAG,YAAY;AAC5B,UAAA;AAAA,MACJ,WAAW,OAAO,OAAO,OAAO;AAAA,MAChC,GAAG,QAAQ,CAAS,UAAA;AACZ,cAAA;AAAA,MACP,CAAA;AAAA,IAAA,EACD;AAAA,EAAA,CACH;AACH;"}

package/dist/errors.d.ts

@@ -0,0 +1,21 @@
+declare const AuthDateInvalidError_base: import('error-kid').ErrorClassWithData<[value?: string | undefined], {
+    value: string | undefined;
+}>;
+export declare class AuthDateInvalidError extends AuthDateInvalidError_base {
+}
+declare const SignatureInvalidError_base: import('error-kid').ErrorClass<[]>;
+export declare class SignatureInvalidError extends SignatureInvalidError_base {
+}
+declare const HexStringLengthInvalidError_base: import('error-kid').ErrorClass<[]>;
+export declare class HexStringLengthInvalidError extends HexStringLengthInvalidError_base {
+}
+declare const SignatureMissingError_base: import('error-kid').ErrorClass<[thirdParty: boolean]>;
+export declare class SignatureMissingError extends SignatureMissingError_base {
+}
+declare const ExpiredError_base: import('error-kid').ErrorClassWithData<[issuedAt: Date, expiresAt: Date, now: Date], {
+    issuedAt: Date;
+    expiresAt: Date;
+}>;
+export declare class ExpiredError extends ExpiredError_base {
+}
+export {};

package/dist/hashToken.d.ts

@@ -1,3 +1,2 @@
-import { CreateHmacFn } from './types.js';
-
-export declare function hashToken<H extends CreateHmacFn<any>>(token: string | Buffer, createHmac: H): ReturnType<H>;
+import { CreateHmacFn, Text } from './types.js';
+export declare function hashToken<H extends CreateHmacFn<any>>(token: Text, createHmac: H): ReturnType<H>;

package/dist/parsing.d.ts

@@ -0,0 +1,58 @@
+import { parseInitDataQueryFp, ParseInitDataQueryError } from '@tma.js/transformers';
+/**
+ * Parses an incoming value as init data.
+ */
+export declare const parse: (value: string | URLSearchParams) => {
+    auth_date: Date;
+    can_send_after?: number | undefined;
+    chat?: ({
+        id: number;
+        photo_url?: string | undefined;
+        type: string;
+        title: string;
+        username?: string | undefined;
+    } & {
+        [key: string]: unknown;
+    }) | undefined;
+    chat_type?: string | undefined;
+    chat_instance?: string | undefined;
+    hash: string;
+    query_id?: string | undefined;
+    receiver?: ({
+        added_to_attachment_menu?: boolean | undefined;
+        allows_write_to_pm?: boolean | undefined;
+        first_name: string;
+        id: number;
+        is_bot?: boolean | undefined;
+        is_premium?: boolean | undefined;
+        last_name?: string | undefined;
+        language_code?: string | undefined;
+        photo_url?: string | undefined;
+        username?: string | undefined;
+    } & {
+        [key: string]: unknown;
+    }) | undefined;
+    start_param?: string | undefined;
+    signature: string;
+    user?: ({
+        added_to_attachment_menu?: boolean | undefined;
+        allows_write_to_pm?: boolean | undefined;
+        first_name: string;
+        id: number;
+        is_bot?: boolean | undefined;
+        is_premium?: boolean | undefined;
+        last_name?: string | undefined;
+        language_code?: string | undefined;
+        photo_url?: string | undefined;
+        username?: string | undefined;
+    } & {
+        [key: string]: unknown;
+    }) | undefined;
+} & {
+    [key: string]: unknown;
+};
+/**
+ * Parses an incoming value as init data.
+ */
+export declare const parseFp: typeof parseInitDataQueryFp;
+export { ParseInitDataQueryError as ParseError };

package/dist/signDataFp.d.ts

@@ -0,0 +1,13 @@
+import { hexToArrayBuffer } from './buf-converters.js';
+import { CreateHmacFn, Text } from './types.js';
+import * as E from 'fp-ts/Either';
+import * as TE from 'fp-ts/TaskEither';
+export interface SignDataOptions {
+    /**
+     * True, if token is already hashed and doesn't require hashing using HMAC-SHA-256.
+     */
+    tokenHashed?: boolean;
+}
+export type SignDataError = ReturnType<typeof hexToArrayBuffer> extends E.Either<infer U, any> ? U : never;
+export declare function signDataFp(async: false, data: Text, key: Text, createHmac: CreateHmacFn<false>, options?: SignDataOptions): E.Either<SignDataError, string>;
+export declare function signDataFp(async: true, data: Text, key: Text, createHmac: CreateHmacFn<true>, options?: SignDataOptions): TE.TaskEither<SignDataError, string>;

package/dist/signFp.d.ts

@@ -0,0 +1,35 @@
+import { InitDataLike } from '@tma.js/transformers';
+import { Text } from './types.js';
+import * as E from 'fp-ts/Either';
+import * as TE from 'fp-ts/TaskEither';
+export type SignableData = Omit<InitDataLike, 'auth_date' | 'hash' | 'signature'>;
+export interface SignOptions {
+    /**
+     * True, if token is already hashed and doesn't require hashing using HMAC-SHA-256.
+     */
+    tokenHashed?: boolean;
+}
+interface SignDataFpArg<Async extends boolean, Left> {
+    (data: Text, key: Text, options?: SignOptions): Async extends true ? TE.TaskEither<Left, string> : E.Either<Left, string>;
+}
+/**
+ * Signs specified init data.
+ * @param data - init data to sign.
+ * @param authDate - date, when this init data should be signed.
+ * @param key - private key.
+ * @param signData - function signing data.
+ * @param options - additional options.
+ * @returns Signed init data presented as query parameters.
+ */
+export declare function signFp<Left>(data: SignableData, key: Text, authDate: Date, signData: SignDataFpArg<false, Left>, options?: SignOptions): E.Either<Left, string>;
+/**
+ * Signs specified init data.
+ * @param data - init data to sign.
+ * @param authDate - date, when this init data should be signed.
+ * @param key - private key.
+ * @param signData - function signing data.
+ * @param options - additional options.
+ * @returns Signed init data presented as query parameters.
+ */
+export declare function signFp<Left>(data: SignableData, key: Text, authDate: Date, signData: SignDataFpArg<true, Left>, options?: SignOptions): TE.TaskEither<Left, string>;
+export {};

package/dist/types.d.ts

@@ -1,24 +1,7 @@
-import { InitDataParsed } from '@tma.js/sdk';
-import { SignDataOptions } from './signData.js';
-
-export type Text = string | Buffer;
-export type SignData = Omit<InitDataParsed, 'authDate' | 'hash'>;
-export interface SignDataSyncFn {
-    (data: Text, key: Text, options?: SignDataOptions): string;
-}
-export interface SignDataAsyncFn {
-    (data: Text, key: Text, options?: SignDataOptions): Promise<string>;
-}
+export type Text = string | ArrayBuffer;
 /**
  * SHA-256 hashing function.
  */
 export interface CreateHmacFn<Async extends boolean> {
-    (data: Text, key: Text): Async extends true ? Promise<Buffer> : Buffer;
-}
-export interface SharedOptions {
-    /**
-     * True, if token is already hashed.
-     * @default false
-     */
-    tokenHashed?: boolean;
+    (data: Text, key: Text): Async extends true ? Promise<ArrayBuffer> : ArrayBuffer;
 }

package/dist/validation.d.ts

@@ -0,0 +1,67 @@
+import { BetterPromise, BetterPromiseOptions, BetterPromiseRejectReason } from 'better-promises';
+import { AuthDateInvalidError, ExpiredError, SignatureInvalidError, SignatureMissingError } from './errors.js';
+import { Text } from './types.js';
+import * as E from 'fp-ts/Either';
+import * as TE from 'fp-ts/TaskEither';
+type OmittedPromiseOptions = Omit<BetterPromiseOptions, 'abortOnResolve' | 'abortOnReject'>;
+export type ValidateValue = string | URLSearchParams;
+export type Validate3rdValue = string | URLSearchParams;
+export type ValidateError = SignatureMissingError | SignatureInvalidError | AuthDateInvalidError | ExpiredError;
+export type ValidateAsyncError = ValidateError | BetterPromiseRejectReason;
+export type Validate3rdError = SignatureMissingError | SignatureInvalidError | AuthDateInvalidError | ExpiredError | BetterPromiseRejectReason;
+interface ValidateSignDataFpArg<Async extends boolean, Left> {
+    (data: Text, key: Text, options?: ValidateOptions): Async extends true ? TE.TaskEither<Left, string> : E.Either<Left, string>;
+}
+interface SharedValidateOptions {
+    /**
+     * Time in seconds which states, how long from creation time init data is considered valid.
+     *
+     * In other words, in case when authDate + expiresIn is before current time, init data is
+     * recognized as expired.
+     *
+     * In case this value is equal to 0, the function does not check init data expiration.
+     * @default 86400 (1 day)
+     */
+    expiresIn?: number;
+}
+export interface ValidateOptions extends SharedValidateOptions {
+    /**
+     * True, if token is already hashed.
+     * @default false
+     */
+    tokenHashed?: boolean;
+}
+export interface ValidateAsyncOptions extends ValidateOptions, OmittedPromiseOptions {
+}
+export interface Validate3rdOptions extends SharedValidateOptions, OmittedPromiseOptions {
+    /**
+     * When true, uses the test environment public key to validate init data.
+     * @default false
+     */
+    test?: boolean;
+}
+/**
+ * Validates passed init data using a publicly known Ee25519 key.
+ * @param value - value to check.
+ * @param botId - bot identifier
+ * @param options - additional validation options.
+ */
+export declare function validate3rdFp(value: Validate3rdValue, botId: number, options?: Validate3rdOptions): TE.TaskEither<Validate3rdError, void>;
+/**
+ * @see validate3rdFp
+ */
+export declare function validate3rd(value: Validate3rdValue, botId: number, options?: Validate3rdOptions): BetterPromise<void>;
+/**
+ * @param value - value to check.
+ * @param botId - bot identifier
+ * @param options - additional validation options.
+ * @returns True is specified init data is signed by Telegram.
+ */
+export declare function isValid3rdFp(value: Validate3rdValue, botId: number, options?: Validate3rdOptions): TE.TaskEither<void, boolean>;
+/**
+ * @see isValid3rdFp
+ */
+export declare function isValid3rd(value: Validate3rdValue, botId: number, options?: Validate3rdOptions): BetterPromise<boolean>;
+export declare function validateFp<Left>(async: false, value: ValidateValue, token: Text, signData: ValidateSignDataFpArg<false, Left>, options?: ValidateOptions): E.Either<Left | ValidateError, void>;
+export declare function validateFp<Left>(async: true, value: ValidateValue, token: Text, signData: ValidateSignDataFpArg<true, Left>, options?: ValidateAsyncOptions): TE.TaskEither<Left | ValidateAsyncError, void>;
+export {};

package/package.json

@@ -1,16 +1,16 @@
 {
   "name": "@tma.js/init-data-node",
-  "version": "1.4.0",
+  "version": "2.0.1",
   "description": "TypeScript Node library to operate with Telegram init data.",
   "author": "Vladislav Kibenko <wolfram.deus@gmail.com>",
-  "homepage": "https://github.com/Telegram-Mini-Apps/tma.js#readme",
+  "homepage": "https://github.com/Telegram-Mini-Apps/telegram-apps#readme",
   "repository": {
     "type": "git",
-    "url": "git@github.com:Telegram-Mini-Apps/tma.js.git",
-    "directory": "packages/init-data-node"
+    "url": "git@github.com:Telegram-Mini-Apps/telegram-apps.git",
+    "directory": "tma.js/init-data-node"
   },
   "bugs": {
-    "url": "https://github.com/Telegram-Mini-Apps/tma.js/issues"
+    "url": "https://github.com/Telegram-Mini-Apps/telegram-apps/issues"
   },
   "keywords": [
     "telegram-mini-apps",
@@ -42,18 +42,24 @@
     }
   },
   "devDependencies": {
-    "@types/node": "^20.0.0",
-    "tsconfig": "0.0.2"
+    "@types/node": "^22.9.0",
+    "tsconfig": "0.0.2",
+    "test-utils": "0.0.1"
   },
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
-    "@tma.js/sdk": "^2.7.0"
+    "better-promises": "^1.0.0",
+    "error-kid": "^1.0.2",
+    "fp-ts": "^2.16.11",
+    "@tma.js/types": "^1.0.0",
+    "@tma.js/transformers": "^1.0.1",
+    "@tma.js/toolkit": "^1.0.1"
   },
   "scripts": {
     "test": "vitest --run",
-    "lint": "cd ../.. && eslint packages/init-data-node/src --ignore-pattern **/*.test.ts",
+    "lint": "cd ../.. && eslint tma.js/init-data-node/src --ignore-pattern **/*.test.ts",
     "lint:fix": "pnpm run lint --fix",
     "typecheck": "tsc --noEmit",
     "build:node": "vite build --ssr src/entries/node.ts",