@mtcute/core 0.1.0 → 0.1.2

package/esm/storage/memory.test.js

@@ -0,0 +1,45 @@
+import { describe, expect, it } from 'vitest';
+import { testStateStorage, testStorage } from '@mtcute/test';
+import { MemoryStorage } from './memory.js';
+describe('MemoryStorage', () => {
+    testStorage(new MemoryStorage());
+    testStateStorage(new MemoryStorage());
+    describe('extending', () => {
+        it('should allow populating from an object', () => {
+            class ExtendedMemoryStorage extends MemoryStorage {
+                constructor() {
+                    super();
+                    this._setStateFrom({
+                        $version: 1,
+                        defaultDcs: null,
+                        authKeys: new Map(),
+                        authKeysTemp: new Map(),
+                        authKeysTempExpiry: new Map(),
+                        entities: new Map(),
+                        phoneIndex: new Map(),
+                        usernameIndex: new Map(),
+                        gpts: [1, 2, 3, 4],
+                        pts: new Map(),
+                        fsm: new Map(),
+                        rl: new Map(),
+                        self: null,
+                    });
+                }
+            }
+            const s = new ExtendedMemoryStorage();
+            expect(s.getUpdatesState()).toEqual([1, 2, 3, 4]);
+        });
+        it('should silently fail if version is wrong', () => {
+            class ExtendedMemoryStorage extends MemoryStorage {
+                constructor() {
+                    super();
+                    // eslint-disable-next-line
+                    this._setStateFrom({ $version: 0 });
+                }
+            }
+            const s = new ExtendedMemoryStorage();
+            expect(s.getUpdatesState()).toEqual(null);
+        });
+    });
+});
+//# sourceMappingURL=memory.test.js.map

package/esm/storage/memory.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.test.js","sourceRoot":"","sources":["../../../src/storage/memory.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,QAAQ,CAAA;AAE7C,OAAO,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAE5D,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAE3C,QAAQ,CAAC,eAAe,EAAE,GAAG,EAAE;IAC3B,WAAW,CAAC,IAAI,aAAa,EAAE,CAAC,CAAA;IAChC,gBAAgB,CAAC,IAAI,aAAa,EAAE,CAAC,CAAA;IAErC,QAAQ,CAAC,WAAW,EAAE,GAAG,EAAE;QACvB,EAAE,CAAC,wCAAwC,EAAE,GAAG,EAAE;YAC9C,MAAM,qBAAsB,SAAQ,aAAa;gBAC7C;oBACI,KAAK,EAAE,CAAA;oBACP,IAAI,CAAC,aAAa,CAAC;wBACf,QAAQ,EAAE,CAAC;wBACX,UAAU,EAAE,IAAI;wBAChB,QAAQ,EAAE,IAAI,GAAG,EAAE;wBACnB,YAAY,EAAE,IAAI,GAAG,EAAE;wBACvB,kBAAkB,EAAE,IAAI,GAAG,EAAE;wBAC7B,QAAQ,EAAE,IAAI,GAAG,EAAE;wBACnB,UAAU,EAAE,IAAI,GAAG,EAAE;wBACrB,aAAa,EAAE,IAAI,GAAG,EAAE;wBACxB,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;wBAClB,GAAG,EAAE,IAAI,GAAG,EAAE;wBACd,GAAG,EAAE,IAAI,GAAG,EAAE;wBACd,EAAE,EAAE,IAAI,GAAG,EAAE;wBACb,IAAI,EAAE,IAAI;qBACb,CAAC,CAAA;gBACN,CAAC;aACJ;YAED,MAAM,CAAC,GAAG,IAAI,qBAAqB,EAAE,CAAA;YAErC,MAAM,CAAC,CAAC,CAAC,eAAe,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;QACrD,CAAC,CAAC,CAAA;QAEF,EAAE,CAAC,0CAA0C,EAAE,GAAG,EAAE;YAChD,MAAM,qBAAsB,SAAQ,aAAa;gBAC7C;oBACI,KAAK,EAAE,CAAA;oBACP,2BAA2B;oBAC3B,IAAI,CAAC,aAAa,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAS,CAAC,CAAA;gBAC9C,CAAC;aACJ;YAED,MAAM,CAAC,GAAG,IAAI,qBAAqB,EAAE,CAAA;YAErC,MAAM,CAAC,CAAC,CAAC,eAAe,EAAE,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,CAAA;QAC7C,CAAC,CAAC,CAAA;IACN,CAAC,CAAC,CAAA;AACN,CAAC,CAAC,CAAA","sourcesContent":["import { describe, expect, it } from 'vitest'\n\nimport { testStateStorage, testStorage } from '@mtcute/test'\n\nimport { MemoryStorage } from './memory.js'\n\ndescribe('MemoryStorage', () => {\n    testStorage(new MemoryStorage())\n    testStateStorage(new MemoryStorage())\n\n    describe('extending', () => {\n        it('should allow populating from an object', () => {\n            class ExtendedMemoryStorage extends MemoryStorage {\n                constructor() {\n                    super()\n                    this._setStateFrom({\n                        $version: 1,\n                        defaultDcs: null,\n                        authKeys: new Map(),\n                        authKeysTemp: new Map(),\n                        authKeysTempExpiry: new Map(),\n                        entities: new Map(),\n                        phoneIndex: new Map(),\n                        usernameIndex: new Map(),\n                        gpts: [1, 2, 3, 4],\n                        pts: new Map(),\n                        fsm: new Map(),\n                        rl: new Map(),\n                        self: null,\n                    })\n                }\n            }\n\n            const s = new ExtendedMemoryStorage()\n\n            expect(s.getUpdatesState()).toEqual([1, 2, 3, 4])\n        })\n\n        it('should silently fail if version is wrong', () => {\n            class ExtendedMemoryStorage extends MemoryStorage {\n                constructor() {\n                    super()\n                    // eslint-disable-next-line\n                    this._setStateFrom({ $version: 0 } as any)\n                }\n            }\n\n            const s = new ExtendedMemoryStorage()\n\n            expect(s.getUpdatesState()).toEqual(null)\n        })\n    })\n})\n"]}

package/esm/utils/async-lock.test.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/utils/async-lock.test.js

@@ -0,0 +1,23 @@
+import { describe, expect, it } from 'vitest';
+import { AsyncLock } from './async-lock.js';
+import { sleep } from './misc-utils.js';
+describe('AsyncLock', () => {
+    it('should correctly lock execution', async () => {
+        const lock = new AsyncLock();
+        const log = [];
+        await Promise.all(Array.from({ length: 10 }, (_, idx) => lock.with(async () => {
+            await sleep(10 - idx);
+            log.push(idx);
+        })));
+        expect(log).toEqual([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
+    });
+    it('should correctly propagate errors', async () => {
+        const lock = new AsyncLock();
+        await expect(async () => {
+            await lock.with(() => {
+                throw new Error('test');
+            });
+        }).rejects.toThrow('test');
+    });
+});
+//# sourceMappingURL=async-lock.test.js.map

package/esm/utils/async-lock.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-lock.test.js","sourceRoot":"","sources":["../../../src/utils/async-lock.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,QAAQ,CAAA;AAE7C,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAC3C,OAAO,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAA;AAEvC,QAAQ,CAAC,WAAW,EAAE,GAAG,EAAE;IACvB,EAAE,CAAC,iCAAiC,EAAE,KAAK,IAAI,EAAE;QAC7C,MAAM,IAAI,GAAG,IAAI,SAAS,EAAE,CAAA;QAE5B,MAAM,GAAG,GAAa,EAAE,CAAA;QACxB,MAAM,OAAO,CAAC,GAAG,CACb,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,EAAE,CAClC,IAAI,CAAC,IAAI,CAAC,KAAK,IAAI,EAAE;YACjB,MAAM,KAAK,CAAC,EAAE,GAAG,GAAG,CAAC,CAAA;YACrB,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;QACjB,CAAC,CAAC,CACL,CACJ,CAAA;QAED,MAAM,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;IACvD,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,mCAAmC,EAAE,KAAK,IAAI,EAAE;QAC/C,MAAM,IAAI,GAAG,IAAI,SAAS,EAAE,CAAA;QAE5B,MAAM,MAAM,CAAC,KAAK,IAAI,EAAE;YACpB,MAAM,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE;gBACjB,MAAM,IAAI,KAAK,CAAC,MAAM,CAAC,CAAA;YAC3B,CAAC,CAAC,CAAA;QACN,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,CAAA;IAC9B,CAAC,CAAC,CAAA;AACN,CAAC,CAAC,CAAA","sourcesContent":["import { describe, expect, it } from 'vitest'\n\nimport { AsyncLock } from './async-lock.js'\nimport { sleep } from './misc-utils.js'\n\ndescribe('AsyncLock', () => {\n    it('should correctly lock execution', async () => {\n        const lock = new AsyncLock()\n\n        const log: number[] = []\n        await Promise.all(\n            Array.from({ length: 10 }, (_, idx) =>\n                lock.with(async () => {\n                    await sleep(10 - idx)\n                    log.push(idx)\n                }),\n            ),\n        )\n\n        expect(log).toEqual([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])\n    })\n\n    it('should correctly propagate errors', async () => {\n        const lock = new AsyncLock()\n\n        await expect(async () => {\n            await lock.with(() => {\n                throw new Error('test')\n            })\n        }).rejects.toThrow('test')\n    })\n})\n"]}

package/esm/utils/bigint-utils.d.ts

@@ -1,40 +1,47 @@
-import bigInt, { BigInteger } from 'big-integer';
+import { ICryptoProvider } from './crypto/abstract.js';
+/**
+ * Get the minimum number of bits required to represent a number
+ */
+export declare function bigIntBitLength(n: bigint): number;
 /**
  * Convert a big integer to a buffer
  *
  * @param value  Value to convert
- * @param length  Length of the resulting buffer (by default it's computed automatically)
+ * @param length  Length of the resulting buffer (by default it's the minimum required)
  * @param le  Whether to use little-endian encoding
  */
-export declare function bigIntToBuffer(value: BigInteger, length?: number, le?: boolean): Uint8Array;
+export declare function bigIntToBuffer(value: bigint, length?: number, le?: boolean): Uint8Array;
 /**
  * Convert a buffer to a big integer
  *
  * @param buffer  Buffer to convert
- * @param offset  Offset to start reading from
- * @param length  Length to read
  * @param le  Whether to use little-endian encoding
  */
-export declare function bufferToBigInt(buffer: Uint8Array, offset?: number, length?: number, le?: boolean): BigInteger;
+export declare function bufferToBigInt(buffer: Uint8Array, le?: boolean): bigint;
 /**
- * Generate a random big integer of the given size (in bytes)
+ * Generate a cryptographically safe random big integer of the given size (in bytes)
  * @param size  Size in bytes
  */
-export declare function randomBigInt(size: number): BigInteger;
+export declare function randomBigInt(crypto: ICryptoProvider, size: number): bigint;
 /**
  * Generate a random big integer of the given size (in bits)
  * @param bits
  */
-export declare function randomBigIntBits(bits: number): BigInteger;
+export declare function randomBigIntBits(crypto: ICryptoProvider, bits: number): bigint;
 /**
  * Generate a random big integer in the range [min, max)
  *
  * @param max  Maximum value (exclusive)
  * @param min  Minimum value (inclusive)
  */
-export declare function randomBigIntInRange(max: BigInteger, min?: bigInt.BigInteger): BigInteger;
+export declare function randomBigIntInRange(crypto: ICryptoProvider, max: bigint, min?: bigint): bigint;
 /**
  * Compute the multiplicity of 2 in the prime factorization of n
  * @param n
  */
-export declare function twoMultiplicity(n: BigInteger): BigInteger;
+export declare function twoMultiplicity(n: bigint): bigint;
+export declare function bigIntMin(a: bigint, b: bigint): bigint;
+export declare function bigIntAbs(a: bigint): bigint;
+export declare function bigIntGcd(a: bigint, b: bigint): bigint;
+export declare function bigIntModPow(base: bigint, exp: bigint, mod: bigint): bigint;
+export declare function bigIntModInv(a: bigint, n: bigint): bigint;

package/esm/utils/bigint-utils.js

@@ -1,59 +1,87 @@
-import bigInt from 'big-integer';
-import { randomBytes } from './buffer-utils.js';
+import { bufferToReversed } from './buffer-utils.js';
+/**
+ * Get the minimum number of bits required to represent a number
+ */
+export function bigIntBitLength(n) {
+    // not the fastest way, but at least not .toString(2) and not too complex
+    // taken from: https://stackoverflow.com/a/76616288/22656950
+    const i = (n.toString(16).length - 1) * 4;
+    return i + 32 - Math.clz32(Number(n >> BigInt(i)));
+}
 /**
  * Convert a big integer to a buffer
  *
  * @param value  Value to convert
- * @param length  Length of the resulting buffer (by default it's computed automatically)
+ * @param length  Length of the resulting buffer (by default it's the minimum required)
  * @param le  Whether to use little-endian encoding
  */
 export function bigIntToBuffer(value, length = 0, le = false) {
-    const array = value.toArray(256).value;
-    if (length !== 0 && array.length > length) {
+    const bits = bigIntBitLength(value);
+    const bytes = Math.ceil(bits / 8);
+    if (length !== 0 && bytes > length) {
         throw new Error('Value out of bounds');
     }
-    if (length !== 0) {
-        // padding
-        while (array.length !== length)
-            array.unshift(0);
+    if (length === 0)
+        length = bytes;
+    const buf = new ArrayBuffer(length);
+    const u8 = new Uint8Array(buf);
+    const unaligned = length % 8;
+    const dv = new DataView(buf, 0, length - unaligned);
+    // it is faster to work with 64-bit words than with bytes directly
+    for (let i = 0; i < dv.byteLength; i += 8) {
+        dv.setBigUint64(i, value & 0xffffffffffffffffn, true);
+        value >>= 64n;
     }
-    if (le)
-        array.reverse();
-    const buffer = new Uint8Array(length || array.length);
-    buffer.set(array, 0);
-    return buffer;
+    if (unaligned > 0) {
+        for (let i = length - unaligned; i < length; i++) {
+            u8[i] = Number(value & 0xffn);
+            value >>= 8n;
+        }
+    }
+    if (!le)
+        u8.reverse();
+    return u8;
 }
 /**
  * Convert a buffer to a big integer
  *
  * @param buffer  Buffer to convert
- * @param offset  Offset to start reading from
- * @param length  Length to read
  * @param le  Whether to use little-endian encoding
  */
-export function bufferToBigInt(buffer, offset = 0, length = buffer.length, le = false) {
-    const arr = [...buffer.subarray(offset, offset + length)];
+export function bufferToBigInt(buffer, le = false) {
     if (le)
-        arr.reverse();
-    return bigInt.fromArray(arr, 256);
+        buffer = bufferToReversed(buffer);
+    const unaligned = buffer.length % 8;
+    const dv = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength - unaligned);
+    let res = 0n;
+    // it is faster to work with 64-bit words than with bytes directly
+    for (let i = 0; i < dv.byteLength; i += 8) {
+        res = (res << 64n) | BigInt(dv.getBigUint64(i, false));
+    }
+    if (unaligned > 0) {
+        for (let i = buffer.length - unaligned; i < buffer.length; i++) {
+            res = (res << 8n) | BigInt(buffer[i]);
+        }
+    }
+    return res;
 }
 /**
- * Generate a random big integer of the given size (in bytes)
+ * Generate a cryptographically safe random big integer of the given size (in bytes)
  * @param size  Size in bytes
  */
-export function randomBigInt(size) {
-    return bufferToBigInt(randomBytes(size));
+export function randomBigInt(crypto, size) {
+    return bufferToBigInt(crypto.randomBytes(size));
 }
 /**
  * Generate a random big integer of the given size (in bits)
  * @param bits
  */
-export function randomBigIntBits(bits) {
-    let num = randomBigInt(Math.ceil(bits / 8));
-    const bitLength = num.bitLength();
-    if (bitLength.gt(bits)) {
-        const toTrim = bigInt.randBetween(bitLength.minus(bits), 8);
-        num = num.shiftRight(toTrim);
+export function randomBigIntBits(crypto, bits) {
+    let num = randomBigInt(crypto, Math.ceil(bits / 8));
+    const bitLength = bigIntBitLength(num);
+    if (bitLength > bits) {
+        const toTrim = bitLength - bits;
+        num >>= BigInt(toTrim);
     }
     return num;
 }
@@ -63,30 +91,100 @@ export function randomBigIntBits(bits) {
  * @param max  Maximum value (exclusive)
  * @param min  Minimum value (inclusive)
  */
-export function randomBigIntInRange(max, min = bigInt.one) {
-    const interval = max.minus(min);
-    if (interval.isNegative())
+export function randomBigIntInRange(crypto, max, min = 1n) {
+    const interval = max - min;
+    if (interval < 0n)
         throw new Error('expected min < max');
-    const byteSize = interval.bitLength().divide(8).toJSNumber();
-    let result = randomBigInt(byteSize);
-    while (result.gt(interval))
-        result = result.minus(interval);
-    return min.plus(result);
+    const byteSize = bigIntBitLength(interval) / 8;
+    let result = randomBigInt(crypto, byteSize);
+    while (result > interval)
+        result -= interval;
+    return min + result;
 }
 /**
  * Compute the multiplicity of 2 in the prime factorization of n
  * @param n
  */
 export function twoMultiplicity(n) {
-    if (n === bigInt.zero)
-        return bigInt.zero;
-    let m = bigInt.zero;
-    let pow = bigInt.one;
+    if (n === 0n)
+        return 0n;
+    let m = 0n;
+    let pow = 1n;
     while (true) {
-        if (!n.and(pow).isZero())
+        if ((n & pow) !== 0n)
             return m;
-        m = m.plus(bigInt.one);
-        pow = pow.shiftLeft(1);
+        m += 1n;
+        pow <<= 1n;
+    }
+}
+export function bigIntMin(a, b) {
+    return a < b ? a : b;
+}
+export function bigIntAbs(a) {
+    return a < 0n ? -a : a;
+}
+export function bigIntGcd(a, b) {
+    // using euclidean algorithm is fast enough on smaller numbers
+    // https://en.wikipedia.org/wiki/Euclidean_algorithm#Implementations
+    while (b !== 0n) {
+        const t = b;
+        b = a % b;
+        a = t;
+    }
+    return a;
+}
+export function bigIntModPow(base, exp, mod) {
+    // using the binary method is good enough for our use case
+    // https://en.wikipedia.org/wiki/Modular_exponentiation#Right-to-left_binary_method
+    base %= mod;
+    let result = 1n;
+    while (exp > 0n) {
+        if (exp % 2n === 1n) {
+            result = (result * base) % mod;
+        }
+        exp >>= 1n;
+        base = base ** 2n % mod;
+    }
+    return result;
+}
+// below code is based on https://github.com/juanelas/bigint-mod-arith, MIT license
+function eGcd(a, b) {
+    let x = 0n;
+    let y = 1n;
+    let u = 1n;
+    let v = 0n;
+    while (a !== 0n) {
+        const q = b / a;
+        const r = b % a;
+        const m = x - u * q;
+        const n = y - v * q;
+        b = a;
+        a = r;
+        x = u;
+        y = v;
+        u = m;
+        v = n;
+    }
+    return [b, x, y];
+}
+function toZn(a, n) {
+    if (typeof a === 'number')
+        a = BigInt(a);
+    if (typeof n === 'number')
+        n = BigInt(n);
+    if (n <= 0n) {
+        throw new RangeError('n must be > 0');
+    }
+    const aZn = a % n;
+    return aZn < 0n ? aZn + n : aZn;
+}
+export function bigIntModInv(a, n) {
+    const [g, x] = eGcd(toZn(a, n), n);
+    if (g !== 1n) {
+        throw new RangeError(`${a.toString()} does not have inverse modulo ${n.toString()}`); // modular inverse does not exist
+    }
+    else {
+        return toZn(x, n);
     }
 }
 //# sourceMappingURL=bigint-utils.js.map

package/esm/utils/bigint-utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"bigint-utils.js","sourceRoot":"","sources":["../../../src/utils/bigint-utils.ts"],"names":[],"mappings":"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","sourcesContent":["import bigInt, { BigInteger } from 'big-integer'\n\nimport { randomBytes } from './buffer-utils.js'\n\n/**\n * Convert a big integer to a buffer\n *\n * @param value  Value to convert\n * @param length  Length of the resulting buffer (by default it's computed automatically)\n * @param le  Whether to use little-endian encoding\n */\nexport function bigIntToBuffer(value: BigInteger, length = 0, le = false): Uint8Array {\n    const array = value.toArray(256).value\n\n    if (length !== 0 && array.length > length) {\n        throw new Error('Value out of bounds')\n    }\n\n    if (length !== 0) {\n        // padding\n        while (array.length !== length) array.unshift(0)\n    }\n\n    if (le) array.reverse()\n\n    const buffer = new Uint8Array(length || array.length)\n    buffer.set(array, 0)\n\n    return buffer\n}\n\n/**\n * Convert a buffer to a big integer\n *\n * @param buffer  Buffer to convert\n * @param offset  Offset to start reading from\n * @param length  Length to read\n * @param le  Whether to use little-endian encoding\n */\nexport function bufferToBigInt(buffer: Uint8Array, offset = 0, length = buffer.length, le = false): BigInteger {\n    const arr = [...buffer.subarray(offset, offset + length)]\n\n    if (le) arr.reverse()\n\n    return bigInt.fromArray(arr as unknown as number[], 256)\n}\n\n/**\n * Generate a random big integer of the given size (in bytes)\n * @param size  Size in bytes\n */\nexport function randomBigInt(size: number): BigInteger {\n    return bufferToBigInt(randomBytes(size))\n}\n\n/**\n * Generate a random big integer of the given size (in bits)\n * @param bits\n */\nexport function randomBigIntBits(bits: number): BigInteger {\n    let num = randomBigInt(Math.ceil(bits / 8))\n\n    const bitLength = num.bitLength()\n\n    if (bitLength.gt(bits)) {\n        const toTrim = bigInt.randBetween(bitLength.minus(bits), 8)\n        num = num.shiftRight(toTrim)\n    }\n\n    return num\n}\n\n/**\n * Generate a random big integer in the range [min, max)\n *\n * @param max  Maximum value (exclusive)\n * @param min  Minimum value (inclusive)\n */\nexport function randomBigIntInRange(max: BigInteger, min = bigInt.one): BigInteger {\n    const interval = max.minus(min)\n    if (interval.isNegative()) throw new Error('expected min < max')\n\n    const byteSize = interval.bitLength().divide(8).toJSNumber()\n\n    let result = randomBigInt(byteSize)\n    while (result.gt(interval)) result = result.minus(interval)\n\n    return min.plus(result)\n}\n\n/**\n * Compute the multiplicity of 2 in the prime factorization of n\n * @param n\n */\nexport function twoMultiplicity(n: BigInteger): BigInteger {\n    if (n === bigInt.zero) return bigInt.zero\n\n    let m = bigInt.zero\n    let pow = bigInt.one\n\n    while (true) {\n        if (!n.and(pow).isZero()) return m\n        m = m.plus(bigInt.one)\n        pow = pow.shiftLeft(1)\n    }\n}\n"]}
+{"version":3,"file":"bigint-utils.js","sourceRoot":"","sources":["../../../src/utils/bigint-utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { bufferToReversed } from './buffer-utils.js'\nimport { ICryptoProvider } from './crypto/abstract.js'\n\n/**\n * Get the minimum number of bits required to represent a number\n */\nexport function bigIntBitLength(n: bigint) {\n    // not the fastest way, but at least not .toString(2) and not too complex\n    // taken from: https://stackoverflow.com/a/76616288/22656950\n\n    const i = (n.toString(16).length - 1) * 4\n\n    return i + 32 - Math.clz32(Number(n >> BigInt(i)))\n}\n\n/**\n * Convert a big integer to a buffer\n *\n * @param value  Value to convert\n * @param length  Length of the resulting buffer (by default it's the minimum required)\n * @param le  Whether to use little-endian encoding\n */\nexport function bigIntToBuffer(value: bigint, length = 0, le = false): Uint8Array {\n    const bits = bigIntBitLength(value)\n    const bytes = Math.ceil(bits / 8)\n\n    if (length !== 0 && bytes > length) {\n        throw new Error('Value out of bounds')\n    }\n\n    if (length === 0) length = bytes\n\n    const buf = new ArrayBuffer(length)\n    const u8 = new Uint8Array(buf)\n\n    const unaligned = length % 8\n    const dv = new DataView(buf, 0, length - unaligned)\n\n    // it is faster to work with 64-bit words than with bytes directly\n    for (let i = 0; i < dv.byteLength; i += 8) {\n        dv.setBigUint64(i, value & 0xffffffffffffffffn, true)\n        value >>= 64n\n    }\n\n    if (unaligned > 0) {\n        for (let i = length - unaligned; i < length; i++) {\n            u8[i] = Number(value & 0xffn)\n            value >>= 8n\n        }\n    }\n\n    if (!le) u8.reverse()\n\n    return u8\n}\n\n/**\n * Convert a buffer to a big integer\n *\n * @param buffer  Buffer to convert\n * @param le  Whether to use little-endian encoding\n */\nexport function bufferToBigInt(buffer: Uint8Array, le = false): bigint {\n    if (le) buffer = bufferToReversed(buffer)\n\n    const unaligned = buffer.length % 8\n    const dv = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength - unaligned)\n\n    let res = 0n\n\n    // it is faster to work with 64-bit words than with bytes directly\n    for (let i = 0; i < dv.byteLength; i += 8) {\n        res = (res << 64n) | BigInt(dv.getBigUint64(i, false))\n    }\n\n    if (unaligned > 0) {\n        for (let i = buffer.length - unaligned; i < buffer.length; i++) {\n            res = (res << 8n) | BigInt(buffer[i])\n        }\n    }\n\n    return res\n}\n\n/**\n * Generate a cryptographically safe random big integer of the given size (in bytes)\n * @param size  Size in bytes\n */\nexport function randomBigInt(crypto: ICryptoProvider, size: number): bigint {\n    return bufferToBigInt(crypto.randomBytes(size))\n}\n\n/**\n * Generate a random big integer of the given size (in bits)\n * @param bits\n */\nexport function randomBigIntBits(crypto: ICryptoProvider, bits: number): bigint {\n    let num = randomBigInt(crypto, Math.ceil(bits / 8))\n\n    const bitLength = bigIntBitLength(num)\n\n    if (bitLength > bits) {\n        const toTrim = bitLength - bits\n        num >>= BigInt(toTrim)\n    }\n\n    return num\n}\n\n/**\n * Generate a random big integer in the range [min, max)\n *\n * @param max  Maximum value (exclusive)\n * @param min  Minimum value (inclusive)\n */\nexport function randomBigIntInRange(crypto: ICryptoProvider, max: bigint, min = 1n): bigint {\n    const interval = max - min\n    if (interval < 0n) throw new Error('expected min < max')\n\n    const byteSize = bigIntBitLength(interval) / 8\n\n    let result = randomBigInt(crypto, byteSize)\n    while (result > interval) result -= interval\n\n    return min + result\n}\n\n/**\n * Compute the multiplicity of 2 in the prime factorization of n\n * @param n\n */\nexport function twoMultiplicity(n: bigint): bigint {\n    if (n === 0n) return 0n\n\n    let m = 0n\n    let pow = 1n\n\n    while (true) {\n        if ((n & pow) !== 0n) return m\n        m += 1n\n        pow <<= 1n\n    }\n}\n\nexport function bigIntMin(a: bigint, b: bigint): bigint {\n    return a < b ? a : b\n}\n\nexport function bigIntAbs(a: bigint): bigint {\n    return a < 0n ? -a : a\n}\n\nexport function bigIntGcd(a: bigint, b: bigint): bigint {\n    // using euclidean algorithm is fast enough on smaller numbers\n    // https://en.wikipedia.org/wiki/Euclidean_algorithm#Implementations\n\n    while (b !== 0n) {\n        const t = b\n        b = a % b\n        a = t\n    }\n\n    return a\n}\n\nexport function bigIntModPow(base: bigint, exp: bigint, mod: bigint): bigint {\n    // using the binary method is good enough for our use case\n    // https://en.wikipedia.org/wiki/Modular_exponentiation#Right-to-left_binary_method\n\n    base %= mod\n\n    let result = 1n\n\n    while (exp > 0n) {\n        if (exp % 2n === 1n) {\n            result = (result * base) % mod\n        }\n\n        exp >>= 1n\n        base = base ** 2n % mod\n    }\n\n    return result\n}\n\n// below code is based on https://github.com/juanelas/bigint-mod-arith, MIT license\n\nfunction eGcd(a: bigint, b: bigint): [bigint, bigint, bigint] {\n    let x = 0n\n    let y = 1n\n    let u = 1n\n    let v = 0n\n\n    while (a !== 0n) {\n        const q = b / a\n        const r: bigint = b % a\n        const m = x - u * q\n        const n = y - v * q\n        b = a\n        a = r\n        x = u\n        y = v\n        u = m\n        v = n\n    }\n\n    return [b, x, y]\n}\n\nfunction toZn(a: number | bigint, n: number | bigint): bigint {\n    if (typeof a === 'number') a = BigInt(a)\n    if (typeof n === 'number') n = BigInt(n)\n\n    if (n <= 0n) {\n        throw new RangeError('n must be > 0')\n    }\n\n    const aZn = a % n\n\n    return aZn < 0n ? aZn + n : aZn\n}\n\nexport function bigIntModInv(a: bigint, n: bigint): bigint {\n    const [g, x] = eGcd(toZn(a, n), n)\n\n    if (g !== 1n) {\n        throw new RangeError(`${a.toString()} does not have inverse modulo ${n.toString()}`) // modular inverse does not exist\n    } else {\n        return toZn(x, n)\n    }\n}\n"]}

package/esm/utils/bigint-utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/utils/bigint-utils.test.js

@@ -0,0 +1,148 @@
+import { describe, expect, it } from 'vitest';
+import { defaultTestCryptoProvider } from '@mtcute/test';
+import { hexDecodeToBuffer } from '@mtcute/tl-runtime';
+import { bigIntBitLength, bigIntGcd, bigIntModInv, bigIntModPow, bigIntToBuffer, bufferToBigInt, randomBigInt, randomBigIntBits, randomBigIntInRange, twoMultiplicity, } from './index.js';
+describe('bigIntBitLength', () => {
+    it('should correctly calculate bit length', () => {
+        expect(bigIntBitLength(0n)).eq(0);
+        expect(bigIntBitLength(1n)).eq(1);
+        expect(bigIntBitLength(2n)).eq(2);
+        expect(bigIntBitLength(255n)).eq(8);
+        expect(bigIntBitLength(256n)).eq(9);
+    });
+});
+describe('bigIntToBuffer', () => {
+    it('should handle writing to BE', () => {
+        expect([...bigIntToBuffer(BigInt('10495708'), 0, false)]).eql([0xa0, 0x26, 0xdc]);
+        expect([...bigIntToBuffer(BigInt('10495708'), 4, false)]).eql([0x00, 0xa0, 0x26, 0xdc]);
+        expect([...bigIntToBuffer(BigInt('10495708'), 8, false)]).eql([0x00, 0x00, 0x00, 0x00, 0x00, 0xa0, 0x26, 0xdc]);
+        expect([...bigIntToBuffer(BigInt('3038102549'), 4, false)]).eql([0xb5, 0x15, 0xc4, 0x15]);
+        expect([...bigIntToBuffer(BigInt('9341376580368336208'), 8, false)]).eql([
+            ...hexDecodeToBuffer('81A33C81D2020550'),
+        ]);
+    });
+    it('should handle writing to LE', () => {
+        expect([...bigIntToBuffer(BigInt('10495708'), 0, true)]).eql([0xdc, 0x26, 0xa0]);
+        expect([...bigIntToBuffer(BigInt('10495708'), 4, true)]).eql([0xdc, 0x26, 0xa0, 0x00]);
+        expect([...bigIntToBuffer(BigInt('10495708'), 8, true)]).eql([0xdc, 0x26, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x00]);
+        expect([...bigIntToBuffer(BigInt('3038102549'), 4, true)]).eql([0x15, 0xc4, 0x15, 0xb5]);
+        expect([...bigIntToBuffer(BigInt('9341376580368336208'), 8, true)]).eql([
+            ...hexDecodeToBuffer('81A33C81D2020550').reverse(),
+        ]);
+    });
+    it('should handle large integers', () => {
+        const buf = hexDecodeToBuffer('1a981ce8bf86bf4a1bd79c2ef829914172f8d0e54cb7ad807552d56977e1c946872e2c7bd77052be30e7e9a7a35c4feff848a25759f5f2f5b0e96538');
+        const num = BigInt('0x1a981ce8bf86bf4a1bd79c2ef829914172f8d0e54cb7ad807552d56977e1c946872e2c7bd77052be30e7e9a7a35c4feff848a25759f5f2f5b0e96538');
+        expect([...bigIntToBuffer(num, 0, false)]).eql([...buf]);
+        expect([...bigIntToBuffer(num, 0, true)]).eql([...buf.reverse()]);
+    });
+});
+describe('bufferToBigInt', () => {
+    it('should handle reading BE', () => {
+        expect(bufferToBigInt(new Uint8Array([0xa0, 0x26, 0xdc]), false).toString()).eq('10495708');
+        expect(bufferToBigInt(new Uint8Array([0x00, 0xa0, 0x26, 0xdc]), false).toString()).eq('10495708');
+        expect(bufferToBigInt(new Uint8Array([0xb5, 0x15, 0xc4, 0x15]), false).toString()).eq('3038102549');
+    });
+    it('should handle reading LE', () => {
+        expect(bufferToBigInt(new Uint8Array([0xdc, 0x26, 0xa0]), true).toString()).eq('10495708');
+        expect(bufferToBigInt(new Uint8Array([0xdc, 0x26, 0xa0, 0x00]), true).toString()).eq('10495708');
+        expect(bufferToBigInt(new Uint8Array([0x15, 0xc4, 0x15, 0xb5]), true).toString()).eq('3038102549');
+    });
+    it('should handle large integers', () => {
+        const buf = hexDecodeToBuffer('1a981ce8bf86bf4a1bd79c2ef829914172f8d0e54cb7ad807552d56977e1c946872e2c7bd77052be30e7e9a7a35c4feff848a25759f5f2f5b0e96538');
+        const num = BigInt('0x1a981ce8bf86bf4a1bd79c2ef829914172f8d0e54cb7ad807552d56977e1c946872e2c7bd77052be30e7e9a7a35c4feff848a25759f5f2f5b0e96538');
+        expect(bufferToBigInt(buf, false).toString()).eq(num.toString());
+        expect(bufferToBigInt(buf.reverse(), true).toString()).eq(num.toString());
+    });
+});
+describe('randomBigInt', async () => {
+    const c = await defaultTestCryptoProvider();
+    it('should return a random bigint', () => {
+        const a = randomBigInt(c, 32);
+        const b = randomBigInt(c, 32);
+        expect(a).not.toEqual(b);
+    });
+    it('should return a random bigint up to specified byte length', () => {
+        const a = randomBigInt(c, 32);
+        const b = randomBigInt(c, 64);
+        expect(bigIntBitLength(a)).toBeLessThanOrEqual(32 * 8);
+        expect(bigIntBitLength(b)).toBeLessThanOrEqual(64 * 8);
+    });
+});
+describe('randomBigIntBits', async () => {
+    const c = await defaultTestCryptoProvider();
+    it('should return a random bigint', () => {
+        const a = randomBigIntBits(c, 32);
+        const b = randomBigIntBits(c, 32);
+        expect(a).not.toEqual(b);
+    });
+    it('should return a random bigint up to specified bit length', () => {
+        const a = randomBigIntBits(c, 32);
+        const b = randomBigIntBits(c, 64);
+        expect(bigIntBitLength(a)).toBeLessThanOrEqual(32);
+        expect(bigIntBitLength(b)).toBeLessThanOrEqual(64);
+    });
+});
+describe('randomBigIntInRange', async () => {
+    const c = await defaultTestCryptoProvider();
+    it('should return a random bigint', () => {
+        const a = randomBigIntInRange(c, 10000n);
+        const b = randomBigIntInRange(c, 10000n);
+        expect(a).not.toEqual(b);
+    });
+    it('should return a bigint within a given range', () => {
+        const a = randomBigIntInRange(c, 200n, 100n);
+        expect(a).toBeGreaterThanOrEqual(100n);
+        expect(a).toBeLessThan(200n);
+    });
+});
+describe('twoMultiplicity', () => {
+    it('should return the multiplicity of 2 in the prime factorization of n', () => {
+        expect(twoMultiplicity(0n)).toEqual(0n);
+        expect(twoMultiplicity(1n)).toEqual(0n);
+        expect(twoMultiplicity(2n)).toEqual(1n);
+        expect(twoMultiplicity(4n)).toEqual(2n);
+        expect(twoMultiplicity(65536n)).toEqual(16n);
+        expect(twoMultiplicity(65537n)).toEqual(0n);
+    });
+});
+describe('bigIntGcd', () => {
+    it('should return the greatest common divisor of a and b', () => {
+        expect(bigIntGcd(123n, 456n)).toEqual(3n);
+    });
+    it('should correctly handle zeros', () => {
+        expect(bigIntGcd(0n, 0n)).toEqual(0n);
+        expect(bigIntGcd(0n, 1n)).toEqual(1n);
+        expect(bigIntGcd(1n, 0n)).toEqual(1n);
+    });
+    it('should correctly handle equal values', () => {
+        expect(bigIntGcd(1n, 1n)).toEqual(1n);
+    });
+});
+describe('bigIntModPow', () => {
+    it('should correctly calculate modular exponentiation', () => {
+        expect(bigIntModPow(2n, 3n, 5n)).toEqual(3n);
+        expect(bigIntModPow(2n, 3n, 6n)).toEqual(2n);
+        expect(bigIntModPow(2n, 3n, 7n)).toEqual(1n);
+        expect(bigIntModPow(2n, 3n, 8n)).toEqual(0n);
+    });
+    it('should correctly handle very large numbers', () => {
+        // calculating this with BigInt would either take forever or error with "Maximum BigInt size exceeded
+        expect(bigIntModPow(2n, 100000000000n, 100n)).toEqual(76n);
+    });
+});
+describe('bigIntModInv', () => {
+    it('should correctly calculate modular inverse', () => {
+        expect(bigIntModInv(2n, 5n)).toEqual(3n);
+        expect(bigIntModInv(2n, 7n)).toEqual(4n);
+    });
+    it("should error if there's no modular inverse", () => {
+        expect(() => bigIntModInv(2n, 6n)).toThrow(RangeError);
+        expect(() => bigIntModInv(2n, 8n)).toThrow(RangeError);
+    });
+    it('should correctly handle very large numbers', () => {
+        // calculating this with BigInt would either take forever or error with "Maximum BigInt size exceeded
+        expect(bigIntModInv(123123123123n, 1829n)).toEqual(318n);
+    });
+});
+//# sourceMappingURL=bigint-utils.test.js.map

package/esm/utils/bigint-utils.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bigint-utils.test.js","sourceRoot":"","sources":["../../../src/utils/bigint-utils.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,QAAQ,CAAA;AAE7C,OAAO,EAAE,yBAAyB,EAAE,MAAM,cAAc,CAAA;AACxD,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAA;AAEtD,OAAO,EACH,eAAe,EACf,SAAS,EACT,YAAY,EACZ,YAAY,EACZ,cAAc,EACd,cAAc,EACd,YAAY,EACZ,gBAAgB,EAChB,mBAAmB,EACnB,eAAe,GAClB,MAAM,YAAY,CAAA;AAEnB,QAAQ,CAAC,iBAAiB,EAAE,GAAG,EAAE;IAC7B,EAAE,CAAC,uCAAuC,EAAE,GAAG,EAAE;QAC7C,MAAM,CAAC,eAAe,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;QACjC,MAAM,CAAC,eAAe,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;QACjC,MAAM,CAAC,eAAe,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;QACjC,MAAM,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;QACnC,MAAM,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;IACvC,CAAC,CAAC,CAAA;AACN,CAAC,CAAC,CAAA;AAEF,QAAQ,CAAC,gBAAgB,EAAE,GAAG,EAAE;IAC5B,EAAE,CAAC,6BAA6B,EAAE,GAAG,EAAE;QACnC,MAAM,CAAC,CAAC,GAAG,cAAc,CAAC,MAAM,CAAC,UAAU,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,CAAA;QACjF,MAAM,CAAC,CAAC,GAAG,cAAc,CAAC,MAAM,CAAC,UAAU,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,CAAA;QACvF,MAAM,CAAC,CAAC,GAAG,cAAc,CAAC,MAAM,CAAC,UAAU,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,CAAA;QAC/G,MAAM,CAAC,CAAC,GAAG,cAAc,CAAC,MAAM,CAAC,YAAY,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,CAAA;QACzF,MAAM,CAAC,CAAC,GAAG,cAAc,CAAC,MAAM,CAAC,qBAAqB,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC;YACrE,GAAG,iBAAiB,CAAC,kBAAkB,CAAC;SAC3C,CAAC,CAAA;IACN,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,6BAA6B,EAAE,GAAG,EAAE;QACnC,MAAM,CAAC,CAAC,GAAG,cAAc,CAAC,MAAM,CAAC,UAAU,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,CAAA;QAChF,MAAM,CAAC,CAAC,GAAG,cAAc,CAAC,MAAM,CAAC,UAAU,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,CAAA;QACtF,MAAM,CAAC,CAAC,GAAG,cAAc,CAAC,MAAM,CAAC,UAAU,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,CAAA;QAC9G,MAAM,CAAC,CAAC,GAAG,cAAc,CAAC,MAAM,CAAC,YAAY,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,CAAA;QACxF,MAAM,CAAC,CAAC,GAAG,cAAc,CAAC,MAAM,CAAC,qBAAqB,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC;YACpE,GAAG,iBAAiB,CAAC,kBAAkB,CAAC,CAAC,OAAO,EAAE;SACrD,CAAC,CAAA;IACN,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,8BAA8B,EAAE,GAAG,EAAE;QACpC,MAAM,GAAG,GAAG,iBAAiB,CACzB,0HAA0H,CAC7H,CAAA;QACD,MAAM,GAAG,GAAG,MAAM,CACd,4HAA4H,CAC/H,CAAA;QAED,MAAM,CAAC,CAAC,GAAG,cAAc,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,CAAA;QACxD,MAAM,CAAC,CAAC,GAAG,cAAc,CAAC,GAAG,EAAE,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC,CAAA;IACrE,CAAC,CAAC,CAAA;AACN,CAAC,CAAC,CAAA;AAEF,QAAQ,CAAC,gBAAgB,EAAE,GAAG,EAAE;IAC5B,EAAE,CAAC,0BAA0B,EAAE,GAAG,EAAE;QAChC,MAAM,CAAC,cAAc,CAAC,IAAI,UAAU,CAAC,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,QAAQ,EAAE,CAAC,CAAC,EAAE,CAAC,UAAU,CAAC,CAAA;QAC3F,MAAM,CAAC,cAAc,CAAC,IAAI,UAAU,CAAC,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,QAAQ,EAAE,CAAC,CAAC,EAAE,CAAC,UAAU,CAAC,CAAA;QACjG,MAAM,CAAC,cAAc,CAAC,IAAI,UAAU,CAAC,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,QAAQ,EAAE,CAAC,CAAC,EAAE,CAAC,YAAY,CAAC,CAAA;IACvG,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,0BAA0B,EAAE,GAAG,EAAE;QAChC,MAAM,CAAC,cAAc,CAAC,IAAI,UAAU,CAAC,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,QAAQ,EAAE,CAAC,CAAC,EAAE,CAAC,UAAU,CAAC,CAAA;QAC1F,MAAM,CAAC,cAAc,CAAC,IAAI,UAAU,CAAC,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,QAAQ,EAAE,CAAC,CAAC,EAAE,CAAC,UAAU,CAAC,CAAA;QAChG,MAAM,CAAC,cAAc,CAAC,IAAI,UAAU,CAAC,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,QAAQ,EAAE,CAAC,CAAC,EAAE,CAAC,YAAY,CAAC,CAAA;IACtG,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,8BAA8B,EAAE,GAAG,EAAE;QACpC,MAAM,GAAG,GAAG,iBAAiB,CACzB,0HAA0H,CAC7H,CAAA;QACD,MAAM,GAAG,GAAG,MAAM,CACd,4HAA4H,CAC/H,CAAA;QAED,MAAM,CAAC,cAAc,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,QAAQ,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAC,CAAA;QAChE,MAAM,CAAC,cAAc,CAAC,GAAG,CAAC,OAAO,EAAE,EAAE,IAAI,CAAC,CAAC,QAAQ,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAC,CAAA;IAC7E,CAAC,CAAC,CAAA;AACN,CAAC,CAAC,CAAA;AAEF,QAAQ,CAAC,cAAc,EAAE,KAAK,IAAI,EAAE;IAChC,MAAM,CAAC,GAAG,MAAM,yBAAyB,EAAE,CAAA;IAE3C,EAAE,CAAC,+BAA+B,EAAE,GAAG,EAAE;QACrC,MAAM,CAAC,GAAG,YAAY,CAAC,CAAC,EAAE,EAAE,CAAC,CAAA;QAC7B,MAAM,CAAC,GAAG,YAAY,CAAC,CAAC,EAAE,EAAE,CAAC,CAAA;QAE7B,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,CAAA;IAC5B,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,2DAA2D,EAAE,GAAG,EAAE;QACjE,MAAM,CAAC,GAAG,YAAY,CAAC,CAAC,EAAE,EAAE,CAAC,CAAA;QAC7B,MAAM,CAAC,GAAG,YAAY,CAAC,CAAC,EAAE,EAAE,CAAC,CAAA;QAE7B,MAAM,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC,mBAAmB,CAAC,EAAE,GAAG,CAAC,CAAC,CAAA;QACtD,MAAM,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC,mBAAmB,CAAC,EAAE,GAAG,CAAC,CAAC,CAAA;IAC1D,CAAC,CAAC,CAAA;AACN,CAAC,CAAC,CAAA;AAEF,QAAQ,CAAC,kBAAkB,EAAE,KAAK,IAAI,EAAE;IACpC,MAAM,CAAC,GAAG,MAAM,yBAAyB,EAAE,CAAA;IAE3C,EAAE,CAAC,+BAA+B,EAAE,GAAG,EAAE;QACrC,MAAM,CAAC,GAAG,gBAAgB,CAAC,CAAC,EAAE,EAAE,CAAC,CAAA;QACjC,MAAM,CAAC,GAAG,gBAAgB,CAAC,CAAC,EAAE,EAAE,CAAC,CAAA;QAEjC,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,CAAA;IAC5B,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,0DAA0D,EAAE,GAAG,EAAE;QAChE,MAAM,CAAC,GAAG,gBAAgB,CAAC,CAAC,EAAE,EAAE,CAAC,CAAA;QACjC,MAAM,CAAC,GAAG,gBAAgB,CAAC,CAAC,EAAE,EAAE,CAAC,CAAA;QAEjC,MAAM,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC,mBAAmB,CAAC,EAAE,CAAC,CAAA;QAClD,MAAM,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC,mBAAmB,CAAC,EAAE,CAAC,CAAA;IACtD,CAAC,CAAC,CAAA;AACN,CAAC,CAAC,CAAA;AAEF,QAAQ,CAAC,qBAAqB,EAAE,KAAK,IAAI,EAAE;IACvC,MAAM,CAAC,GAAG,MAAM,yBAAyB,EAAE,CAAA;IAE3C,EAAE,CAAC,+BAA+B,EAAE,GAAG,EAAE;QACrC,MAAM,CAAC,GAAG,mBAAmB,CAAC,CAAC,EAAE,MAAM,CAAC,CAAA;QACxC,MAAM,CAAC,GAAG,mBAAmB,CAAC,CAAC,EAAE,MAAM,CAAC,CAAA;QAExC,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,CAAA;IAC5B,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,6CAA6C,EAAE,GAAG,EAAE;QACnD,MAAM,CAAC,GAAG,mBAAmB,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;QAE5C,MAAM,CAAC,CAAC,CAAC,CAAC,sBAAsB,CAAC,IAAI,CAAC,CAAA;QACtC,MAAM,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC,IAAI,CAAC,CAAA;IAChC,CAAC,CAAC,CAAA;AACN,CAAC,CAAC,CAAA;AAEF,QAAQ,CAAC,iBAAiB,EAAE,GAAG,EAAE;IAC7B,EAAE,CAAC,qEAAqE,EAAE,GAAG,EAAE;QAC3E,MAAM,CAAC,eAAe,CAAC,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC,CAAA;QACvC,MAAM,CAAC,eAAe,CAAC,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC,CAAA;QACvC,MAAM,CAAC,eAAe,CAAC,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC,CAAA;QACvC,MAAM,CAAC,eAAe,CAAC,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC,CAAA;QACvC,MAAM,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,CAAA;QAC5C,MAAM,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC,CAAA;IAC/C,CAAC,CAAC,CAAA;AACN,CAAC,CAAC,CAAA;AAEF,QAAQ,CAAC,WAAW,EAAE,GAAG,EAAE;IACvB,EAAE,CAAC,sDAAsD,EAAE,GAAG,EAAE;QAC5D,MAAM,CAAC,SAAS,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC,CAAA;IAC7C,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,+BAA+B,EAAE,GAAG,EAAE;QACrC,MAAM,CAAC,SAAS,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC,CAAA;QACrC,MAAM,CAAC,SAAS,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC,CAAA;QACrC,MAAM,CAAC,SAAS,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC,CAAA;IACzC,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,sCAAsC,EAAE,GAAG,EAAE;QAC5C,MAAM,CAAC,SAAS,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC,CAAA;IACzC,CAAC,CAAC,CAAA;AACN,CAAC,CAAC,CAAA;AAEF,QAAQ,CAAC,cAAc,EAAE,GAAG,EAAE;IAC1B,EAAE,CAAC,mDAAmD,EAAE,GAAG,EAAE;QACzD,MAAM,CAAC,YAAY,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC,CAAA;QAC5C,MAAM,CAAC,YAAY,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC,CAAA;QAC5C,MAAM,CAAC,YAAY,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC,CAAA;QAC5C,MAAM,CAAC,YAAY,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC,CAAA;IAChD,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,4CAA4C,EAAE,GAAG,EAAE;QAClD,qGAAqG;QACrG,MAAM,CAAC,YAAY,CAAC,EAAE,EAAE,aAAa,EAAE,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,CAAA;IAC9D,CAAC,CAAC,CAAA;AACN,CAAC,CAAC,CAAA;AAEF,QAAQ,CAAC,cAAc,EAAE,GAAG,EAAE;IAC1B,EAAE,CAAC,4CAA4C,EAAE,GAAG,EAAE;QAClD,MAAM,CAAC,YAAY,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC,CAAA;QACxC,MAAM,CAAC,YAAY,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC,CAAA;IAC5C,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,4CAA4C,EAAE,GAAG,EAAE;QAClD,MAAM,CAAC,GAAG,EAAE,CAAC,YAAY,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,UAAU,CAAC,CAAA;QACtD,MAAM,CAAC,GAAG,EAAE,CAAC,YAAY,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,UAAU,CAAC,CAAA;IAC1D,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,4CAA4C,EAAE,GAAG,EAAE;QAClD,qGAAqG;QACrG,MAAM,CAAC,YAAY,CAAC,aAAa,EAAE,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,CAAA;IAC5D,CAAC,CAAC,CAAA;AACN,CAAC,CAAC,CAAA","sourcesContent":["import { describe, expect, it } from 'vitest'\n\nimport { defaultTestCryptoProvider } from '@mtcute/test'\nimport { hexDecodeToBuffer } from '@mtcute/tl-runtime'\n\nimport {\n    bigIntBitLength,\n    bigIntGcd,\n    bigIntModInv,\n    bigIntModPow,\n    bigIntToBuffer,\n    bufferToBigInt,\n    randomBigInt,\n    randomBigIntBits,\n    randomBigIntInRange,\n    twoMultiplicity,\n} from './index.js'\n\ndescribe('bigIntBitLength', () => {\n    it('should correctly calculate bit length', () => {\n        expect(bigIntBitLength(0n)).eq(0)\n        expect(bigIntBitLength(1n)).eq(1)\n        expect(bigIntBitLength(2n)).eq(2)\n        expect(bigIntBitLength(255n)).eq(8)\n        expect(bigIntBitLength(256n)).eq(9)\n    })\n})\n\ndescribe('bigIntToBuffer', () => {\n    it('should handle writing to BE', () => {\n        expect([...bigIntToBuffer(BigInt('10495708'), 0, false)]).eql([0xa0, 0x26, 0xdc])\n        expect([...bigIntToBuffer(BigInt('10495708'), 4, false)]).eql([0x00, 0xa0, 0x26, 0xdc])\n        expect([...bigIntToBuffer(BigInt('10495708'), 8, false)]).eql([0x00, 0x00, 0x00, 0x00, 0x00, 0xa0, 0x26, 0xdc])\n        expect([...bigIntToBuffer(BigInt('3038102549'), 4, false)]).eql([0xb5, 0x15, 0xc4, 0x15])\n        expect([...bigIntToBuffer(BigInt('9341376580368336208'), 8, false)]).eql([\n            ...hexDecodeToBuffer('81A33C81D2020550'),\n        ])\n    })\n\n    it('should handle writing to LE', () => {\n        expect([...bigIntToBuffer(BigInt('10495708'), 0, true)]).eql([0xdc, 0x26, 0xa0])\n        expect([...bigIntToBuffer(BigInt('10495708'), 4, true)]).eql([0xdc, 0x26, 0xa0, 0x00])\n        expect([...bigIntToBuffer(BigInt('10495708'), 8, true)]).eql([0xdc, 0x26, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x00])\n        expect([...bigIntToBuffer(BigInt('3038102549'), 4, true)]).eql([0x15, 0xc4, 0x15, 0xb5])\n        expect([...bigIntToBuffer(BigInt('9341376580368336208'), 8, true)]).eql([\n            ...hexDecodeToBuffer('81A33C81D2020550').reverse(),\n        ])\n    })\n\n    it('should handle large integers', () => {\n        const buf = hexDecodeToBuffer(\n            '1a981ce8bf86bf4a1bd79c2ef829914172f8d0e54cb7ad807552d56977e1c946872e2c7bd77052be30e7e9a7a35c4feff848a25759f5f2f5b0e96538',\n        )\n        const num = BigInt(\n            '0x1a981ce8bf86bf4a1bd79c2ef829914172f8d0e54cb7ad807552d56977e1c946872e2c7bd77052be30e7e9a7a35c4feff848a25759f5f2f5b0e96538',\n        )\n\n        expect([...bigIntToBuffer(num, 0, false)]).eql([...buf])\n        expect([...bigIntToBuffer(num, 0, true)]).eql([...buf.reverse()])\n    })\n})\n\ndescribe('bufferToBigInt', () => {\n    it('should handle reading BE', () => {\n        expect(bufferToBigInt(new Uint8Array([0xa0, 0x26, 0xdc]), false).toString()).eq('10495708')\n        expect(bufferToBigInt(new Uint8Array([0x00, 0xa0, 0x26, 0xdc]), false).toString()).eq('10495708')\n        expect(bufferToBigInt(new Uint8Array([0xb5, 0x15, 0xc4, 0x15]), false).toString()).eq('3038102549')\n    })\n\n    it('should handle reading LE', () => {\n        expect(bufferToBigInt(new Uint8Array([0xdc, 0x26, 0xa0]), true).toString()).eq('10495708')\n        expect(bufferToBigInt(new Uint8Array([0xdc, 0x26, 0xa0, 0x00]), true).toString()).eq('10495708')\n        expect(bufferToBigInt(new Uint8Array([0x15, 0xc4, 0x15, 0xb5]), true).toString()).eq('3038102549')\n    })\n\n    it('should handle large integers', () => {\n        const buf = hexDecodeToBuffer(\n            '1a981ce8bf86bf4a1bd79c2ef829914172f8d0e54cb7ad807552d56977e1c946872e2c7bd77052be30e7e9a7a35c4feff848a25759f5f2f5b0e96538',\n        )\n        const num = BigInt(\n            '0x1a981ce8bf86bf4a1bd79c2ef829914172f8d0e54cb7ad807552d56977e1c946872e2c7bd77052be30e7e9a7a35c4feff848a25759f5f2f5b0e96538',\n        )\n\n        expect(bufferToBigInt(buf, false).toString()).eq(num.toString())\n        expect(bufferToBigInt(buf.reverse(), true).toString()).eq(num.toString())\n    })\n})\n\ndescribe('randomBigInt', async () => {\n    const c = await defaultTestCryptoProvider()\n\n    it('should return a random bigint', () => {\n        const a = randomBigInt(c, 32)\n        const b = randomBigInt(c, 32)\n\n        expect(a).not.toEqual(b)\n    })\n\n    it('should return a random bigint up to specified byte length', () => {\n        const a = randomBigInt(c, 32)\n        const b = randomBigInt(c, 64)\n\n        expect(bigIntBitLength(a)).toBeLessThanOrEqual(32 * 8)\n        expect(bigIntBitLength(b)).toBeLessThanOrEqual(64 * 8)\n    })\n})\n\ndescribe('randomBigIntBits', async () => {\n    const c = await defaultTestCryptoProvider()\n\n    it('should return a random bigint', () => {\n        const a = randomBigIntBits(c, 32)\n        const b = randomBigIntBits(c, 32)\n\n        expect(a).not.toEqual(b)\n    })\n\n    it('should return a random bigint up to specified bit length', () => {\n        const a = randomBigIntBits(c, 32)\n        const b = randomBigIntBits(c, 64)\n\n        expect(bigIntBitLength(a)).toBeLessThanOrEqual(32)\n        expect(bigIntBitLength(b)).toBeLessThanOrEqual(64)\n    })\n})\n\ndescribe('randomBigIntInRange', async () => {\n    const c = await defaultTestCryptoProvider()\n\n    it('should return a random bigint', () => {\n        const a = randomBigIntInRange(c, 10000n)\n        const b = randomBigIntInRange(c, 10000n)\n\n        expect(a).not.toEqual(b)\n    })\n\n    it('should return a bigint within a given range', () => {\n        const a = randomBigIntInRange(c, 200n, 100n)\n\n        expect(a).toBeGreaterThanOrEqual(100n)\n        expect(a).toBeLessThan(200n)\n    })\n})\n\ndescribe('twoMultiplicity', () => {\n    it('should return the multiplicity of 2 in the prime factorization of n', () => {\n        expect(twoMultiplicity(0n)).toEqual(0n)\n        expect(twoMultiplicity(1n)).toEqual(0n)\n        expect(twoMultiplicity(2n)).toEqual(1n)\n        expect(twoMultiplicity(4n)).toEqual(2n)\n        expect(twoMultiplicity(65536n)).toEqual(16n)\n        expect(twoMultiplicity(65537n)).toEqual(0n)\n    })\n})\n\ndescribe('bigIntGcd', () => {\n    it('should return the greatest common divisor of a and b', () => {\n        expect(bigIntGcd(123n, 456n)).toEqual(3n)\n    })\n\n    it('should correctly handle zeros', () => {\n        expect(bigIntGcd(0n, 0n)).toEqual(0n)\n        expect(bigIntGcd(0n, 1n)).toEqual(1n)\n        expect(bigIntGcd(1n, 0n)).toEqual(1n)\n    })\n\n    it('should correctly handle equal values', () => {\n        expect(bigIntGcd(1n, 1n)).toEqual(1n)\n    })\n})\n\ndescribe('bigIntModPow', () => {\n    it('should correctly calculate modular exponentiation', () => {\n        expect(bigIntModPow(2n, 3n, 5n)).toEqual(3n)\n        expect(bigIntModPow(2n, 3n, 6n)).toEqual(2n)\n        expect(bigIntModPow(2n, 3n, 7n)).toEqual(1n)\n        expect(bigIntModPow(2n, 3n, 8n)).toEqual(0n)\n    })\n\n    it('should correctly handle very large numbers', () => {\n        // calculating this with BigInt would either take forever or error with \"Maximum BigInt size exceeded\n        expect(bigIntModPow(2n, 100000000000n, 100n)).toEqual(76n)\n    })\n})\n\ndescribe('bigIntModInv', () => {\n    it('should correctly calculate modular inverse', () => {\n        expect(bigIntModInv(2n, 5n)).toEqual(3n)\n        expect(bigIntModInv(2n, 7n)).toEqual(4n)\n    })\n\n    it(\"should error if there's no modular inverse\", () => {\n        expect(() => bigIntModInv(2n, 6n)).toThrow(RangeError)\n        expect(() => bigIntModInv(2n, 8n)).toThrow(RangeError)\n    })\n\n    it('should correctly handle very large numbers', () => {\n        // calculating this with BigInt would either take forever or error with \"Maximum BigInt size exceeded\n        expect(bigIntModInv(123123123123n, 1829n)).toEqual(318n)\n    })\n})\n"]}

package/esm/utils/buffer-utils.d.ts

@@ -1,4 +1,3 @@
-export { _randomBytes as randomBytes } from './platform/random.js';
 /**
  * Check if two buffers are equal
  *
@@ -18,4 +17,11 @@ export declare function cloneBuffer(buf: Uint8Array, start?: number, end?: numbe
  * Concatenate multiple buffers into one
  */
 export declare function concatBuffers(buffers: Uint8Array[]): Uint8Array;
+/**
+ * Shortcut for creating a DataView from a Uint8Array
+ */
 export declare function dataViewFromBuffer(buf: Uint8Array): DataView;
+/**
+ * Reverse a buffer (or a part of it) into a new buffer
+ */
+export declare function bufferToReversed(buf: Uint8Array, start?: number, end?: number): Uint8Array;