myxl-core 1.0.0

package/dist/config.d.ts

@@ -0,0 +1,14 @@
+export declare const BASE_API_URL: string;
+export declare const BASE_CIAM_URL: string;
+export declare const BASIC_AUTH: string;
+export declare const AX_FP_KEY: string;
+export declare const UA: string;
+export declare const API_KEY: string;
+export declare const ENCRYPTED_FIELD_KEY: string;
+export declare const XDATA_KEY: string;
+export declare const AX_API_SIG_KEY: string;
+export declare const X_API_BASE_SECRET: string;
+export declare const CIRCLE_MSISDN_KEY: string;
+export declare const DEFAULT_AX_DEVICE_ID = "a9698fc65ed122e1b0efb2b7e9d93728";
+export declare const DEFAULT_AX_FP = "LDMGk/l1xEViBHOOsQb/CtVyh6FI0QvxXGfsoizEhr7ms1SBTYN07kcmSY3CWDlkG39iSV4p0AuafPoIL+pyoI+1StGif01C7Z/3Lprtkn+WHS3QAKHuAb8LQGe9/2pn";
+export declare const X_APP_VERSION = "8.9.0";

package/dist/config.js

@@ -0,0 +1,70 @@
+// @bun
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/lib/encrypt-helper.ts
+var init_encrypt_helper = __esm(() => {
+  init_config();
+});
+
+// src/encrypt.ts
+var init_encrypt = __esm(() => {
+  init_config();
+  init_encrypt_helper();
+  init_encrypt_helper();
+});
+
+// src/lib/utils.ts
+import axios from "axios";
+import { v4 as uuidv4 } from "uuid";
+import { DateTime } from "luxon";
+function unseal(getter, fallback) {
+  try {
+    const hex = getter();
+    if (!hex || typeof __SEED__ === "undefined")
+      return fallback;
+    const seed = Buffer.from(__SEED__, "hex");
+    const data = Buffer.from(hex, "hex");
+    return Buffer.from(data.map((b, i) => b ^ seed[i % seed.length])).toString("utf8");
+  } catch {
+    return fallback;
+  }
+}
+var init_utils = __esm(() => {
+  init_config();
+  init_encrypt();
+});
+
+// src/config.ts
+var BASE_API_URL, BASE_CIAM_URL, BASIC_AUTH, AX_FP_KEY, UA, API_KEY, ENCRYPTED_FIELD_KEY, XDATA_KEY, AX_API_SIG_KEY, X_API_BASE_SECRET, CIRCLE_MSISDN_KEY, DEFAULT_AX_DEVICE_ID = "a9698fc65ed122e1b0efb2b7e9d93728", DEFAULT_AX_FP = "LDMGk/l1xEViBHOOsQb/CtVyh6FI0QvxXGfsoizEhr7ms1SBTYN07kcmSY3CWDlkG39iSV4p0AuafPoIL+pyoI+1StGif01C7Z/3Lprtkn+WHS3QAKHuAb8LQGe9/2pn", X_APP_VERSION = "8.9.0";
+var init_config = __esm(() => {
+  init_utils();
+  BASE_API_URL = unseal(() => __E_BASE_API_URL__, "https://api.myxl.xlaxiata.co.id");
+  BASE_CIAM_URL = unseal(() => __E_BASE_CIAM_URL__, "https://gede.ciam.xlaxiata.co.id");
+  BASIC_AUTH = unseal(() => __E_BASIC_AUTH__, "OWZjOTdlZDEtNmEzMC00OGQ1LTk1MTYtNjBjNTNjZTNhMTM1OllEV21GNExKajlYSUt3UW56eTJlMmxiMHRKUWIyOW8z");
+  AX_FP_KEY = unseal(() => __E_AX_FP_KEY__, "18b4d589826af50241177961590e6693");
+  UA = unseal(() => __E_UA__, "myXL / 8.9.0(1202); com.android.vending; (samsung; SM-N935F; SDK 33; Android 13)");
+  API_KEY = unseal(() => __E_API_KEY__, "vT8tINqHaOxXbGE7eOWAhA==");
+  ENCRYPTED_FIELD_KEY = unseal(() => __E_ENCRYPTED_FIELD_KEY__, "5dccbf08920a5527");
+  XDATA_KEY = unseal(() => __E_XDATA_KEY__, "5dccbf08920a5527b99e222789c34bb7");
+  AX_API_SIG_KEY = unseal(() => __E_AX_API_SIG_KEY__, "18b4d589826af50241177961590e6693");
+  X_API_BASE_SECRET = unseal(() => __E_X_API_BASE_SECRET__, "mU1Y4n1vBjf3M7tMnRkFU08mVyUJHed8B5En3EAniu1mXLixeuASmBmKnkyzVziOye7rG5nIekMdthensbQMcOJ6SLnrkGyfXALD7mrBC6vuWv6G01pmD3XlU5rT7Tzx");
+  CIRCLE_MSISDN_KEY = unseal(() => __E_CIRCLE_MSISDN_KEY__, "5dccbf08920a5527");
+});
+init_config();
+
+export {
+  X_APP_VERSION,
+  X_API_BASE_SECRET,
+  XDATA_KEY,
+  UA,
+  ENCRYPTED_FIELD_KEY,
+  DEFAULT_AX_FP,
+  DEFAULT_AX_DEVICE_ID,
+  CIRCLE_MSISDN_KEY,
+  BASIC_AUTH,
+  BASE_CIAM_URL,
+  BASE_API_URL,
+  AX_FP_KEY,
+  AX_API_SIG_KEY,
+  API_KEY
+};

package/dist/device.d.ts

@@ -0,0 +1,23 @@
+export type DeviceInfo = {
+    manufacturer: string;
+    model: string;
+    lang: string;
+    resolution: string;
+    tz_short: string;
+    ip: string;
+    font_scale: number;
+    android_release: string;
+    msisdn: string;
+};
+export declare function buildFingerprintPlain(dev: DeviceInfo): string;
+export declare function axFingerprint(dev: DeviceInfo, secretKey32Ascii: string): string;
+/**
+ * Equivalent to Python `load_ax_fp()`
+ * - kalau file ada & isinya tidak kosong -> return isinya
+ * - kalau tidak -> generate DeviceInfo random, encrypt, simpan, return
+ */
+export declare function generateAxFp(params?: {
+    ip?: string;
+    msisdn?: string;
+}): string;
+export declare function getAxDeviceId(axFp: string): string;

package/dist/device.js

@@ -0,0 +1,107 @@
+// @bun
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/lib/encrypt-helper.ts
+var init_encrypt_helper = __esm(() => {
+  init_config();
+});
+
+// src/encrypt.ts
+var init_encrypt = __esm(() => {
+  init_config();
+  init_encrypt_helper();
+  init_encrypt_helper();
+});
+
+// src/lib/utils.ts
+import axios from "axios";
+import { v4 as uuidv4 } from "uuid";
+import { DateTime } from "luxon";
+function unseal(getter, fallback) {
+  try {
+    const hex = getter();
+    if (!hex || typeof __SEED__ === "undefined")
+      return fallback;
+    const seed = Buffer.from(__SEED__, "hex");
+    const data = Buffer.from(hex, "hex");
+    return Buffer.from(data.map((b, i) => b ^ seed[i % seed.length])).toString("utf8");
+  } catch {
+    return fallback;
+  }
+}
+var init_utils = __esm(() => {
+  init_config();
+  init_encrypt();
+});
+
+// src/config.ts
+var BASE_API_URL, BASE_CIAM_URL, BASIC_AUTH, AX_FP_KEY, UA, API_KEY, ENCRYPTED_FIELD_KEY, XDATA_KEY, AX_API_SIG_KEY, X_API_BASE_SECRET, CIRCLE_MSISDN_KEY;
+var init_config = __esm(() => {
+  init_utils();
+  BASE_API_URL = unseal(() => __E_BASE_API_URL__, "https://api.myxl.xlaxiata.co.id");
+  BASE_CIAM_URL = unseal(() => __E_BASE_CIAM_URL__, "https://gede.ciam.xlaxiata.co.id");
+  BASIC_AUTH = unseal(() => __E_BASIC_AUTH__, "OWZjOTdlZDEtNmEzMC00OGQ1LTk1MTYtNjBjNTNjZTNhMTM1OllEV21GNExKajlYSUt3UW56eTJlMmxiMHRKUWIyOW8z");
+  AX_FP_KEY = unseal(() => __E_AX_FP_KEY__, "18b4d589826af50241177961590e6693");
+  UA = unseal(() => __E_UA__, "myXL / 8.9.0(1202); com.android.vending; (samsung; SM-N935F; SDK 33; Android 13)");
+  API_KEY = unseal(() => __E_API_KEY__, "vT8tINqHaOxXbGE7eOWAhA==");
+  ENCRYPTED_FIELD_KEY = unseal(() => __E_ENCRYPTED_FIELD_KEY__, "5dccbf08920a5527");
+  XDATA_KEY = unseal(() => __E_XDATA_KEY__, "5dccbf08920a5527b99e222789c34bb7");
+  AX_API_SIG_KEY = unseal(() => __E_AX_API_SIG_KEY__, "18b4d589826af50241177961590e6693");
+  X_API_BASE_SECRET = unseal(() => __E_X_API_BASE_SECRET__, "mU1Y4n1vBjf3M7tMnRkFU08mVyUJHed8B5En3EAniu1mXLixeuASmBmKnkyzVziOye7rG5nIekMdthensbQMcOJ6SLnrkGyfXALD7mrBC6vuWv6G01pmD3XlU5rT7Tzx");
+  CIRCLE_MSISDN_KEY = unseal(() => __E_CIRCLE_MSISDN_KEY__, "5dccbf08920a5527");
+});
+
+// src/device.ts
+init_config();
+import crypto from "crypto";
+function randint(min, max) {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+function buildFingerprintPlain(dev) {
+  return `${dev.manufacturer}|${dev.model}|${dev.lang}|${dev.resolution}|` + `${dev.tz_short}|${dev.ip}|${dev.font_scale}|Android ${dev.android_release}|${dev.msisdn}`;
+}
+function pkcs7Pad(buf, blockSize = 16) {
+  const padLen = blockSize - (buf.length % blockSize || blockSize);
+  const padByte = padLen;
+  const padding = Buffer.alloc(padLen, padByte);
+  return Buffer.concat([buf, padding]);
+}
+function axFingerprint(dev, secretKey32Ascii) {
+  const key = Buffer.from(secretKey32Ascii, "ascii");
+  if (![16, 24, 32].includes(key.length)) {
+    throw new Error(`AX_FP_KEY invalid length: got ${key.length} bytes. Expected 16/24/32 ASCII chars.`);
+  }
+  const iv = Buffer.alloc(16, 0);
+  const pt = Buffer.from(buildFingerprintPlain(dev), "utf8");
+  const padded = pkcs7Pad(pt, 16);
+  const cipher = crypto.createCipheriv(key.length === 16 ? "aes-128-cbc" : key.length === 24 ? "aes-192-cbc" : "aes-256-cbc", key, iv);
+  cipher.setAutoPadding(false);
+  const ct = Buffer.concat([cipher.update(padded), cipher.final()]);
+  return ct.toString("base64");
+}
+function generateAxFp(params) {
+  const dev = {
+    manufacturer: "samsung" + String(randint(1000, 9999)),
+    model: "SM-N93" + String(randint(1000, 9999)),
+    lang: "en",
+    resolution: "720x1540",
+    tz_short: "GMT07:00",
+    ip: params?.ip ?? "192.169.69.69",
+    font_scale: 1,
+    android_release: "13",
+    msisdn: params?.msisdn ?? "6281398370564"
+  };
+  const fp = axFingerprint(dev, AX_FP_KEY);
+  return fp;
+}
+function getAxDeviceId(axFp) {
+  if (!axFp || !axFp.trim())
+    throw new Error("AX_FP is empty");
+  return crypto.createHash("md5").update(axFp, "utf8").digest("hex");
+}
+export {
+  getAxDeviceId,
+  generateAxFp,
+  buildFingerprintPlain,
+  axFingerprint
+};

package/dist/encrypt.d.ts

@@ -0,0 +1,37 @@
+/**
+ * encrypt.ts  (pure-TS replacement)
+ *
+ * Port of xldor/encrypt.py → TypeScript.
+ * All crypto runs locally via Node.js `crypto` — no HTTP request to Python server.
+ */
+export type EncryptedBody = {
+    xdata: string;
+    xtime: number;
+};
+export type EncryptSignResult = {
+    x_signature: string;
+    encrypted_body: EncryptedBody;
+};
+/**
+ * Encrypt + sign an API payload.
+ *
+ * Previously called the Python server. Now runs inline.
+ */
+export declare function encryptSignXData(method: string, path: string, idToken: string, payload: unknown): EncryptSignResult;
+/**
+ * Decrypt API response xdata.
+ *
+ * @param xdata     URL-safe base64 ciphertext from the API response
+ * @param xtimeMs   xtime value from the API response (epoch ms)
+ * @returns Parsed JSON object
+ */
+export declare function decryptXDataSync(xdata: string, xtimeMs: number): any;
+export declare function decryptXData(xdata: string, xtimeMs: number): Promise<any>;
+/**
+ * Build an encrypted-field token (empty-plaintext AES-CBC).
+ *
+ * @param ivHex16    Optional 16-char hex IV; random if omitted.
+ * @param urlsafeB64 Use URL-safe base64 encoding.
+ */
+export declare function buildEncryptedField(ivHex16?: string | null, urlsafeB64?: boolean): string;
+export { makeXSignaturePayment, makeAxApiSignature, makeXSignatureBounty, makeXSignatureLoyalty, makeXSignatureBountyAllotment, makeXSignatureBasic, encryptEncryptedField, decryptEncryptedField, } from "./lib/encrypt-helper";

package/dist/encrypt.js

@@ -0,0 +1,259 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/lib/utils.ts
+import axios from "axios";
+import { v4 as uuidv4 } from "uuid";
+import { DateTime } from "luxon";
+function unseal(getter, fallback) {
+  try {
+    const hex = getter();
+    if (!hex || typeof __SEED__ === "undefined")
+      return fallback;
+    const seed = Buffer.from(__SEED__, "hex");
+    const data = Buffer.from(hex, "hex");
+    return Buffer.from(data.map((b, i) => b ^ seed[i % seed.length])).toString("utf8");
+  } catch {
+    return fallback;
+  }
+}
+var init_utils = __esm(() => {
+  init_config();
+  init_encrypt();
+});
+
+// src/config.ts
+var BASE_API_URL, BASE_CIAM_URL, BASIC_AUTH, AX_FP_KEY, UA, API_KEY, ENCRYPTED_FIELD_KEY, XDATA_KEY, AX_API_SIG_KEY, X_API_BASE_SECRET, CIRCLE_MSISDN_KEY;
+var init_config = __esm(() => {
+  init_utils();
+  BASE_API_URL = unseal(() => __E_BASE_API_URL__, "https://api.myxl.xlaxiata.co.id");
+  BASE_CIAM_URL = unseal(() => __E_BASE_CIAM_URL__, "https://gede.ciam.xlaxiata.co.id");
+  BASIC_AUTH = unseal(() => __E_BASIC_AUTH__, "OWZjOTdlZDEtNmEzMC00OGQ1LTk1MTYtNjBjNTNjZTNhMTM1OllEV21GNExKajlYSUt3UW56eTJlMmxiMHRKUWIyOW8z");
+  AX_FP_KEY = unseal(() => __E_AX_FP_KEY__, "18b4d589826af50241177961590e6693");
+  UA = unseal(() => __E_UA__, "myXL / 8.9.0(1202); com.android.vending; (samsung; SM-N935F; SDK 33; Android 13)");
+  API_KEY = unseal(() => __E_API_KEY__, "vT8tINqHaOxXbGE7eOWAhA==");
+  ENCRYPTED_FIELD_KEY = unseal(() => __E_ENCRYPTED_FIELD_KEY__, "5dccbf08920a5527");
+  XDATA_KEY = unseal(() => __E_XDATA_KEY__, "5dccbf08920a5527b99e222789c34bb7");
+  AX_API_SIG_KEY = unseal(() => __E_AX_API_SIG_KEY__, "18b4d589826af50241177961590e6693");
+  X_API_BASE_SECRET = unseal(() => __E_X_API_BASE_SECRET__, "mU1Y4n1vBjf3M7tMnRkFU08mVyUJHed8B5En3EAniu1mXLixeuASmBmKnkyzVziOye7rG5nIekMdthensbQMcOJ6SLnrkGyfXALD7mrBC6vuWv6G01pmD3XlU5rT7Tzx");
+  CIRCLE_MSISDN_KEY = unseal(() => __E_CIRCLE_MSISDN_KEY__, "5dccbf08920a5527");
+});
+
+// src/lib/encrypt-helper.ts
+var exports_encrypt_helper = {};
+__export(exports_encrypt_helper, {
+  makeXSignaturePayment: () => makeXSignaturePayment,
+  makeXSignatureLoyalty: () => makeXSignatureLoyalty,
+  makeXSignatureBountyAllotment: () => makeXSignatureBountyAllotment,
+  makeXSignatureBounty: () => makeXSignatureBounty,
+  makeXSignatureBasic: () => makeXSignatureBasic,
+  makeXSignature: () => makeXSignature,
+  makeAxApiSignature: () => makeAxApiSignature,
+  encryptXData: () => encryptXData,
+  encryptEncryptedField: () => encryptEncryptedField,
+  decryptXData: () => decryptXData2,
+  decryptEncryptedField: () => decryptEncryptedField
+});
+import crypto from "crypto";
+function pkcs7Pad(buf, blockSize = 16) {
+  const pad = blockSize - buf.length % blockSize;
+  const padBuf = Buffer.alloc(pad, pad);
+  return Buffer.concat([buf, padBuf]);
+}
+function pkcs7Unpad(buf) {
+  const pad = buf[buf.length - 1] ?? 16;
+  if (pad < 1 || pad > 16)
+    throw new Error("Invalid PKCS7 padding");
+  return buf.slice(0, buf.length - pad);
+}
+function deriveIv(xtimeMs) {
+  const sha = crypto.createHash("sha256").update(String(xtimeMs)).digest("hex");
+  return Buffer.from(sha.slice(0, 16), "ascii");
+}
+function urlsafeB64Encode(buf) {
+  return buf.toString("base64").replace(/\+/g, "-").replace(/\//g, "_");
+}
+function urlsafeB64Decode(s) {
+  const b64 = s.replace(/-/g, "+").replace(/_/g, "/");
+  const padded = b64 + "=".repeat((4 - b64.length % 4) % 4);
+  return Buffer.from(padded, "base64");
+}
+function encryptXData(plaintext, xtimeMs) {
+  const key = Buffer.from(XDATA_KEY, "ascii");
+  const iv = deriveIv(xtimeMs);
+  const padded = pkcs7Pad(Buffer.from(plaintext, "utf-8"));
+  const cipher = crypto.createCipheriv("aes-256-cbc", key, iv);
+  cipher.setAutoPadding(false);
+  const ct = Buffer.concat([cipher.update(padded), cipher.final()]);
+  return urlsafeB64Encode(ct);
+}
+function decryptXData2(xdata, xtimeMs) {
+  const key = Buffer.from(XDATA_KEY, "ascii");
+  const iv = deriveIv(xtimeMs);
+  const ct = urlsafeB64Decode(xdata);
+  const decipher = crypto.createDecipheriv("aes-256-cbc", key, iv);
+  decipher.setAutoPadding(false);
+  const pt = Buffer.concat([decipher.update(ct), decipher.final()]);
+  return pkcs7Unpad(pt).toString("utf-8");
+}
+function makeXSignature(idToken, method, path, sigTimeSec) {
+  const keyStr = `${X_API_BASE_SECRET};${idToken};${method};${path};${sigTimeSec}`;
+  const msg = `${idToken};${sigTimeSec};`;
+  return crypto.createHmac("sha512", keyStr).update(msg).digest("hex");
+}
+function makeXSignaturePayment(accessToken, sigTimeSec, packageCode, tokenPayment, paymentMethod, paymentFor, path) {
+  const keyStr = `${X_API_BASE_SECRET};${sigTimeSec}#ae-hei_9Tee6he+Ik3Gais5=;POST;${path};${sigTimeSec}`;
+  const msg = `${accessToken};${tokenPayment};${sigTimeSec};${paymentFor};${paymentMethod};${packageCode};`;
+  return crypto.createHmac("sha512", keyStr).update(msg).digest("hex");
+}
+function makeXSignatureBounty(accessToken, sigTimeSec, packageCode, tokenPayment) {
+  const path = "api/v8/personalization/bounties-exchange";
+  const keyStr = `${X_API_BASE_SECRET};${accessToken};${sigTimeSec}#ae-hei_9Tee6he+Ik3Gais5=;POST;${path};${sigTimeSec}`;
+  const msg = `${accessToken};${tokenPayment};${sigTimeSec};${packageCode};`;
+  return crypto.createHmac("sha512", keyStr).update(msg).digest("hex");
+}
+function makeXSignatureLoyalty(sigTimeSec, packageCode, tokenConfirmation, path) {
+  const keyStr = `${X_API_BASE_SECRET};${sigTimeSec}#ae-hei_9Tee6he+Ik3Gais5=;POST;${path};${sigTimeSec}`;
+  const msg = `${tokenConfirmation};${sigTimeSec};${packageCode};`;
+  return crypto.createHmac("sha512", keyStr).update(msg).digest("hex");
+}
+function makeXSignatureBountyAllotment(sigTimeSec, packageCode, tokenConfirmation, path, destinationMsisdn) {
+  const keyStr = `${X_API_BASE_SECRET};${sigTimeSec}#ae-hei_9Tee6he+Ik3Gais5=;${destinationMsisdn};POST;${path};${sigTimeSec}`;
+  const msg = `${tokenConfirmation};${sigTimeSec};${destinationMsisdn};${packageCode};`;
+  return crypto.createHmac("sha512", keyStr).update(msg).digest("hex");
+}
+function makeXSignatureBasic(method, path, sigTimeSec) {
+  const keyStr = `${X_API_BASE_SECRET};${method};${path};${sigTimeSec}`;
+  const msg = `${sigTimeSec};en;`;
+  return crypto.createHmac("sha512", keyStr).update(msg).digest("hex");
+}
+function makeAxApiSignature(tsForSign, contact, code, contactType) {
+  const preimage = `${tsForSign}password${contactType}${contact}${code}openid`;
+  const digest = crypto.createHmac("sha256", Buffer.from(AX_API_SIG_KEY, "ascii")).update(preimage).digest();
+  return digest.toString("base64");
+}
+function decryptEncryptedField(encryptedB64) {
+  const ivAscii = encryptedB64.slice(-16);
+  const b64Part = encryptedB64.slice(0, -16);
+  const key = Buffer.from(ENCRYPTED_FIELD_KEY, "ascii");
+  const iv = Buffer.from(ivAscii, "ascii");
+  const ct = urlsafeB64Decode(b64Part);
+  const decipher = crypto.createDecipheriv("aes-128-cbc", key, iv);
+  decipher.setAutoPadding(false);
+  const pt = Buffer.concat([decipher.update(ct), decipher.final()]);
+  return pkcs7Unpad(pt).toString("utf-8");
+}
+function encryptEncryptedField(plaintext) {
+  const key = Buffer.from(ENCRYPTED_FIELD_KEY, "ascii");
+  const ivHex = crypto.randomBytes(8).toString("hex");
+  const iv = Buffer.from(ivHex, "ascii");
+  const padded = pkcs7Pad(Buffer.from(plaintext, "utf-8"));
+  const cipher = crypto.createCipheriv("aes-128-cbc", key, iv);
+  cipher.setAutoPadding(false);
+  const ct = Buffer.concat([cipher.update(padded), cipher.final()]);
+  return urlsafeB64Encode(ct) + ivHex;
+}
+var init_encrypt_helper = __esm(() => {
+  init_config();
+});
+
+// src/encrypt.ts
+import crypto2 from "crypto";
+function encryptSignXData(method, path, idToken, payload) {
+  const plainBody = JSON.stringify(payload);
+  const xtime = Date.now();
+  const xdata = encryptXData(plainBody, xtime);
+  const sigTimeSec = Math.floor(xtime / 1000);
+  const xSignature = makeXSignature(idToken, method, path, sigTimeSec);
+  return {
+    x_signature: xSignature,
+    encrypted_body: { xdata, xtime }
+  };
+}
+function decryptXDataSync(xdata, xtimeMs) {
+  const { decryptXData: decryptXData3 } = (init_encrypt_helper(), __toCommonJS(exports_encrypt_helper));
+  const plaintext = decryptXData3(xdata, xtimeMs);
+  return JSON.parse(plaintext);
+}
+async function decryptXData(xdata, xtimeMs) {
+  const { decryptXData: _decrypt } = (init_encrypt_helper(), __toCommonJS(exports_encrypt_helper));
+  return JSON.parse(_decrypt(xdata, xtimeMs));
+}
+function randomIvHex16() {
+  return crypto2.randomBytes(8).toString("hex");
+}
+function b64(data, urlsafe) {
+  const b64str = data.toString("base64");
+  if (urlsafe) {
+    return b64str.replace(/\+/g, "-").replace(/\//g, "_");
+  }
+  return b64str;
+}
+function buildEncryptedField(ivHex16 = null, urlsafeB64 = false) {
+  const key = Buffer.from(ENCRYPTED_FIELD_KEY, "ascii");
+  const ivHex = ivHex16 ?? randomIvHex16();
+  const iv = Buffer.from(ivHex, "ascii");
+  const pt = Buffer.alloc(16, 16);
+  const cipher = crypto2.createCipheriv("aes-128-cbc", key, iv);
+  cipher.setAutoPadding(false);
+  const ct = Buffer.concat([cipher.update(pt), cipher.final()]);
+  return b64(ct, urlsafeB64) + ivHex;
+}
+var init_encrypt = __esm(() => {
+  init_config();
+  init_encrypt_helper();
+  init_encrypt_helper();
+});
+init_encrypt();
+
+export {
+  makeXSignaturePayment,
+  makeXSignatureLoyalty,
+  makeXSignatureBountyAllotment,
+  makeXSignatureBounty,
+  makeXSignatureBasic,
+  makeAxApiSignature,
+  encryptSignXData,
+  encryptEncryptedField,
+  decryptXDataSync,
+  decryptXData,
+  decryptEncryptedField,
+  buildEncryptedField
+};

package/dist/family-plan.d.ts

@@ -0,0 +1,28 @@
+export declare function getFamilyData(idToken: string): Promise<any>;
+export type ValidateMsisdnData = {
+    subscription_type: string;
+    subscriber_id: string;
+    msisdn: string;
+    has_prio_flex: boolean;
+    status: string;
+    suspended_status: string;
+    is_enterprise: boolean;
+    is_registered: boolean;
+    has_family_plan: boolean;
+    family_plan_role: string;
+    plan_type: string;
+    has_bizon: boolean;
+    has_bizon_in_same_company: boolean;
+    has_bizoptimus_package: boolean;
+    is_bizoptimus_same_company: boolean;
+    is_member_optimus: boolean;
+};
+export type ValidateMsisdnResponse = {
+    code: string;
+    status: string;
+    data: ValidateMsisdnData;
+};
+export declare function validateMsisdn(idToken: string, msisdn: string): Promise<ValidateMsisdnResponse>;
+export declare function changeMember(idToken: string, parentAlias: string, alias: string, slotId: number, familyMemberId: string, newMsisdn: string): Promise<any>;
+export declare function removeMember(idToken: string, familyMemberId: string): Promise<any>;
+export declare function setQuotaLimit(idToken: string, originalAllocation: number, newAllocation: number, familyMemberId: string): Promise<any>;