@layerswap/widget 0.1.18 → 1.0.0-alpha0.1

package/dist/lib/loopring/jubjub.d.ts

@@ -0,0 +1,19 @@
+import { BigNumber } from "ethers";
+import { FQ } from "./field";
+export declare class jubjub {
+    static JUBJUB_Q: BigNumber;
+    static JUBJUB_E: BigNumber;
+    static JUBJUB_C: BigNumber;
+    static JUBJUB_L: BigNumber;
+    static JUBJUB_A: BigNumber;
+    static JUBJUB_D: BigNumber;
+}
+export declare class Point {
+    x: FQ;
+    y: FQ;
+    constructor(x: FQ, y: FQ);
+    static generate(): Point;
+    mul(scaler: BigNumber): Point;
+    add(other: Point): Point;
+    static infinity(): Point;
+}

package/dist/lib/loopring/jubjub.js

@@ -0,0 +1,79 @@
+/*
+This module implements the extended twisted edwards and extended affine coordinates
+described in the paper "Twisted Edwards Curves Revisited":
+
+ - https://iacr.org/archive/asiacrypt2008/53500329/53500329.pdf
+   Huseyin Hisil, Kenneth Koon-Ho Wong, Gary Carter, and Ed Dawson
+
+        Information Security Institute,
+        Queensland University of Technology, QLD, 4000, Australia
+        {h.hisil, kk.wong, g.carter, e.dawson}@qut.edu.au
+
+By using the extended coordinate system we can avoid expensive modular exponentiation
+calls, for example - a scalar multiplication call (or multiple...) may perform only
+one 3d->2d projection at the point where affine coordinates are necessary, and every
+intermediate uses a much faster form.
+
+# XXX: none of these functions are constant time, they should not be used interactively!
+*/
+import { BigNumber } from "ethers";
+import { field, FQ } from "./field";
+export class jubjub {
+}
+jubjub.JUBJUB_Q = field.SNARK_SCALAR_FIELD;
+jubjub.JUBJUB_E = BigNumber.from("21888242871839275222246405745257275088614511777268538073601725287587578984328");
+jubjub.JUBJUB_C = BigNumber.from("8"); // Cofactor
+jubjub.JUBJUB_L = jubjub.JUBJUB_E.div(jubjub.JUBJUB_C); // L*B = 0, and (2^C)*L == #E
+jubjub.JUBJUB_A = BigNumber.from("168700"); // Coefficient A
+jubjub.JUBJUB_D = BigNumber.from("168696"); // Coefficient D
+export class Point {
+    constructor(x, y) {
+        this.x = x;
+        this.y = y;
+    }
+    static generate() {
+        const xBigInt = BigNumber.from("16540640123574156134436876038791482806971768689494387082833631921987005038935");
+        const yBigInt = BigNumber.from("20819045374670962167435360035096875258406992893633759881276124905556507972311");
+        const point = new Point(new FQ(xBigInt), new FQ(yBigInt));
+        return point;
+    }
+    mul(scaler) {
+        let p = new Point(this.x, this.y);
+        let a = Point.infinity();
+        let i = 0;
+        while (!scaler.eq(BigNumber.from("0"))) {
+            const bitwiseAnd = scaler.and(BigNumber.from("1"));
+            if (!bitwiseAnd.eq(BigNumber.from("0"))) {
+                a = a.add(p);
+            }
+            let copyP1 = new Point(p.x, p.y);
+            let copyP2 = new Point(p.x, p.y);
+            p = copyP1.add(copyP2);
+            scaler = scaler.div(BigNumber.from("2"));
+            i = i + 1;
+        }
+        return a;
+    }
+    add(other) {
+        if (this.x.n.eq(BigNumber.from("0")) && this.y.n.eq(BigNumber.from("0"))) {
+            return other;
+        }
+        const u1 = this.x;
+        const v1 = this.y;
+        const u2 = other.x;
+        const v2 = other.y;
+        const u3_tmp0 = (u1.mul(v2.n)).add(v1.mul(u2.n).n);
+        const u3_tmp1 = u1.mul(u2.n).mul(v1.n).mul(v2.n).mul(jubjub.JUBJUB_D);
+        const u3_tmp2 = FQ.one().add(u3_tmp1.n);
+        const u3 = u3_tmp0.div(u3_tmp2.n);
+        const v3_tmp0 = v1.mul(v2.n);
+        const v3_tmp1 = u1.mul(u2.n).mul(jubjub.JUBJUB_A);
+        const v3_tmp3 = v3_tmp0.sub(v3_tmp1.n);
+        const v3_tmp5 = FQ.one().sub(u3_tmp1.n);
+        const v3 = v3_tmp3.div(v3_tmp5.n);
+        return new Point(u3, v3);
+    }
+    static infinity() {
+        return new Point(new FQ(BigNumber.from("0")), new FQ(BigNumber.from("1")));
+    }
+}

package/dist/lib/loopring/permutation.d.ts

@@ -0,0 +1,22 @@
+import { BigNumber } from 'ethers';
+export declare class PoseidonParams {
+    p: BigNumber;
+    t: number;
+    nRoundsF: number;
+    nRoundsP: number;
+    seed: string;
+    e: BigNumber;
+    constants_C: [BigNumber];
+    constants_M: [[BigNumber]];
+    security_target: number;
+    constructor(p: BigNumber, t: number, nRoundsF: number, nRoundsP: number, seed: string, e: BigNumber, constants_C: [BigNumber] | null, constants_M: [[BigNumber]] | null, security_target: number);
+}
+export declare class permunation {
+    static H(arg: string): BigNumber;
+    static H_Bigint(arg: BigNumber): BigNumber;
+    static poseidon_constants(p: BigNumber, seed: string, n: number): any;
+    static poseidon_matrix(p: BigNumber, seed: string, t: number): any;
+    static poseidon_sbox(state: [BigNumber], i: number, params: PoseidonParams): [BigNumber];
+    static poseidon_mix(state: [BigNumber], M: [[BigNumber]], p: BigNumber): any;
+    static poseidon(inputs: [BigNumber], params: PoseidonParams): any;
+}

package/dist/lib/loopring/permutation.js

@@ -0,0 +1,198 @@
+/*
+ Implements the Poseidon permutation:
+
+ Starkad and Poseidon: New Hash Functions for Zero Knowledge Proof Systems
+  - Lorenzo Grassi, Daniel Kales, Dmitry Khovratovich, Arnab Roy, Christian Rechberger, and Markus Schofnegger
+  - https://eprint.iacr.org/2019/458.pdf
+
+ Other implementations:
+
+  - https://github.com/shamatar/PoseidonTree/
+  - https://github.com/iden3/circomlib/blob/master/src/poseidon.js
+  - https://github.com/dusk-network/poseidon252
+ */
+import { BigNumber } from 'ethers';
+import { SignatureScheme } from './eddsa';
+import { modulo } from './field';
+import { TextEncoder } from 'web-encoding';
+import blake2b from 'blake2b';
+export class PoseidonParams {
+    constructor(p, t, nRoundsF, nRoundsP, seed, e, constants_C, constants_M, security_target) {
+        this.p = p;
+        this.t = t;
+        this.nRoundsF = nRoundsF;
+        this.nRoundsP = nRoundsP;
+        this.seed = seed;
+        this.e = e;
+        if (constants_C == null) {
+            this.constants_C = permunation.poseidon_constants(p, `${seed}_constants`, nRoundsF + nRoundsP);
+        }
+        else {
+            this.constants_C = constants_C;
+        }
+        if (constants_M == null) {
+            this.constants_M = permunation.poseidon_matrix(p, `${seed}_matrix_0000`, t);
+        }
+        else {
+            this.constants_M = constants_M;
+        }
+        this.security_target = security_target;
+    }
+}
+export class permunation {
+    static H(arg) {
+        const outputLength = 32;
+        const enc = new TextEncoder();
+        const message = enc.encode(arg);
+        const buf = Buffer.alloc(outputLength);
+        blake2b(buf.length, undefined).update(message).final(buf);
+        const items = buf.toJSON().data;
+        let sum = BigNumber.from('0');
+        var i = 0;
+        for (var i = 0; i < items.length; i++) {
+            const itemBigInt = BigNumber.from(items[i]);
+            const tmp = itemBigInt.mul(BigNumber.from('256').pow(BigNumber.from(i)));
+            sum = sum.add(tmp);
+        }
+        return sum;
+    }
+    static H_Bigint(arg) {
+        const outputLength = 32;
+        const message = new Uint8Array(SignatureScheme.to_bytes(arg));
+        const buf = Buffer.alloc(outputLength);
+        blake2b(buf.length, undefined).update(message).final(buf);
+        const items = buf.toJSON().data;
+        let sum = BigNumber.from('0');
+        var i = 0;
+        for (var i = 0; i < items.length; i++) {
+            const itemBigInt = BigNumber.from(items[i]);
+            const tmp = itemBigInt.mul(BigNumber.from('256').pow(BigNumber.from(i)));
+            sum = sum.add(tmp);
+        }
+        return sum;
+    }
+    static poseidon_constants(p, seed, n) {
+        let c;
+        c = [];
+        let seedBigInt = this.H(seed);
+        const result = seedBigInt.mod(p);
+        c.push(result);
+        for (let i = 0; i < n - 1; i++) {
+            seedBigInt = this.H_Bigint(seedBigInt);
+            const result = seedBigInt.mod(p);
+            c.push(result);
+        }
+        return c;
+    }
+    static poseidon_matrix(p, seed, t) {
+        const c = this.poseidon_constants(p, seed, t * 2);
+        let matrix;
+        matrix = [];
+        for (let i = 0; i < t; i++) {
+            let row;
+            row = [];
+            for (let j = 0; j < t; j++) {
+                const c_i = c[i];
+                const c_t_j = c[t + j];
+                const p_c = p;
+                const c_t_j_p = c_t_j.mod(p_c);
+                const left = c_i.sub(c_t_j_p);
+                const p_2 = p_c.sub(2);
+                const item_c = modulo(left, p_2, p_c);
+                row.push(item_c);
+            }
+            matrix.push(row);
+        }
+        return matrix;
+    }
+    static poseidon_sbox(state, i, params) {
+        /*
+        iacr.org/2019/458 § 2.2 The Hades Strategy (pg 6)
+    
+        In more details, assume R_F = 2 · R_f is an even number. Then
+        - the first R_f rounds have a full S-Box layer,
+        - the middle R_P rounds have a partial S-Box layer (i.e., 1 S-Box layer),
+        - the last R_f rounds have a full S-Box layer
+        */
+        const half_F = params.nRoundsF / 2;
+        if (i < half_F || i >= half_F + params.nRoundsP) {
+            for (let j = 0; j < state.length; j++) {
+                const element_c = state[j];
+                const e_c = params.e;
+                const p_c = params.p;
+                const item = modulo(element_c, e_c, p_c);
+                state[j] = item;
+            }
+        }
+        else {
+            const element_c = state[0];
+            const e_c = params.e;
+            const p_c = params.p;
+            const item = modulo(element_c, e_c, p_c);
+            state[0] = item;
+        }
+        return state;
+    }
+    static poseidon_mix(state, M, p) {
+        /*
+        The mixing layer is a matrix vector product of the state with the mixing matrix
+          - https://mathinsight.org/matrix_vector_multiplication
+        */
+        let newState;
+        newState = [];
+        for (let i = 0; i < M.length; i++) {
+            let sum = BigNumber.from(0);
+            for (let j = 0; j < state.length; j++) {
+                const element = state[j];
+                sum = sum.add(M[i][j].mul(element));
+            }
+            newState.push(sum.mod(p));
+        }
+        return newState;
+    }
+    // poseidon
+    /*
+      Main instansiation of the Poseidon permutation
+  
+      The state is `t` elements wide, there are `F` full-rounds
+      followed by `P` partial rounds, then `F` full rounds again.
+  
+          [    ARK    ]    --,
+            | | | | | |       |
+          [    SBOX   ]       -  Full Round
+            | | | | | |       |
+          [    MIX    ]    --`
+  
+  
+          [    ARK    ]    --,
+            | | | | | |       |
+          [    SBOX   ]       -  Partial Round
+                      |       |   Only 1 element is substituted in partial round
+          [    MIX    ]    --`
+  
+      There are F+P rounds for the full permutation.
+  
+      You can provide `r = N - 2s` bits of input per round, where `s` is the desired
+      security level, in most cases this means you can provide `t-1` inputs with
+      appropriately chosen parameters. The permutation can be 'chained' together
+      to form a sponge construct.
+    */
+    static poseidon(inputs, params) {
+        let state;
+        state = [];
+        state = state.concat(inputs);
+        for (var i = 0; i < params.t - inputs.length; i++) {
+            state.push(BigNumber.from(0));
+        }
+        for (var i = 0; i < params.constants_C.length; i++) {
+            const C_i = params.constants_C[i];
+            for (let index = 0; index < state.length; index++) {
+                const element = state[index];
+                state[index] = element.add(C_i);
+            }
+            state = this.poseidon_sbox(state, i, params);
+            state = this.poseidon_mix(state, params.constants_M, params.p);
+        }
+        return state[0];
+    }
+}

package/dist/lib/loopring/poseidon/EDDSAUtil.d.ts

@@ -0,0 +1,14 @@
+export declare class EDDSAUtil {
+    static sign(PrivateKey: string | undefined, hash: any): {
+        Rx: string;
+        Ry: string;
+        s: string;
+    };
+    static formatted(hexString: string): string;
+    static generateKeyPair(seed: any): {
+        publicKeyX: string;
+        publicKeyY: string;
+        secretKey: string;
+    };
+    static pack(publicKeyX: string, publicKeyY: string): any;
+}

package/dist/lib/loopring/poseidon/EDDSAUtil.js

@@ -0,0 +1,61 @@
+import { BigNumber } from "ethers";
+import { SignatureScheme } from "./eddsa";
+import { FQ } from "../field";
+import { jubjub } from "../jubjub";
+import { babyJub } from "./babyJub";
+export class EDDSAUtil {
+    static sign(PrivateKey, hash) {
+        const strKey = BigNumber.from(PrivateKey);
+        const msg = BigNumber.from(hash);
+        const copyKey = new FQ(strKey);
+        const B = SignatureScheme.B();
+        const signed = SignatureScheme.sign(msg, copyKey, B);
+        const x = EDDSAUtil.formatted(signed.sig.R.x.n.toHexString().slice(2));
+        const y = EDDSAUtil.formatted(signed.sig.R.y.n.toHexString().slice(2));
+        const s = EDDSAUtil.formatted(signed.sig.s.n.toHexString().slice(2));
+        const result = `0x${x}${y}${s}`;
+        return {
+            "Rx": signed.sig.R.x.n.toString(),
+            "Ry": signed.sig.R.y.n.toString(),
+            "s": signed.sig.s.n.toString()
+        };
+    }
+    static formatted(hexString) {
+        const outputLength = 32 * 2;
+        const more = outputLength - hexString.length;
+        if (more > 0) {
+            for (let i = 0; i < more; i++) {
+                hexString = "0" + (hexString);
+            }
+        }
+        else {
+            hexString = hexString.slice(0, outputLength);
+        }
+        return hexString;
+    }
+    static generateKeyPair(seed) {
+        let bigInt = BigNumber.from(0);
+        for (let i = 0; i < seed.length; i++) {
+            const item = seed[i];
+            const itemBigInt = BigNumber.from(item);
+            const tmp = BigNumber.from("256").pow(BigNumber.from(i));
+            bigInt = bigInt.add(itemBigInt.mul(tmp));
+        }
+        const secretKey = bigInt.mod(jubjub.JUBJUB_L);
+        const copySecretKey = BigNumber.from(secretKey.toString());
+        const B = SignatureScheme.B();
+        const publicKey = B.mul(copySecretKey);
+        const keyPair = {
+            "publicKeyX": publicKey.x.n.toString(),
+            "publicKeyY": publicKey.y.n.toString(),
+            "secretKey": secretKey.toString()
+        };
+        return keyPair;
+    }
+    static pack(publicKeyX, publicKeyY) {
+        const P0 = BigNumber.from(publicKeyX);
+        const P1 = BigNumber.from(publicKeyY);
+        const newPack = babyJub.packPoint(P0, P1);
+        return newPack;
+    }
+}

package/dist/lib/loopring/poseidon/babyJub.d.ts

@@ -0,0 +1,6 @@
+import { BigNumber } from "ethers";
+export declare class babyJub {
+    static packPoint(P0: BigNumber, P1: BigNumber): any;
+    static lt(a: BigNumber, b: BigNumber): boolean;
+    static gt(a: BigNumber, b: BigNumber): boolean;
+}

package/dist/lib/loopring/poseidon/babyJub.js

@@ -0,0 +1,51 @@
+import { BigNumber } from "ethers";
+import { SignatureScheme, bytesToHexString } from "./eddsa";
+import { field } from "../field";
+export class babyJub {
+    static packPoint(P0, P1) {
+        const packed = SignatureScheme.to_bytes(P1).reverse();
+        if (babyJub.lt(P0, BigNumber.from("0"))) {
+            packed[0] = packed[0] | 0x80;
+        }
+        const hexStr = bytesToHexString(packed);
+        return hexStr;
+    }
+    static lt(a, b) {
+        const half = field.SNARK_SCALAR_FIELD.div(BigNumber.from("2"));
+        const p = field.SNARK_SCALAR_FIELD;
+        let aa;
+        let bb;
+        if (a.gt(half)) {
+            aa = a.sub(p);
+        }
+        else {
+            aa = a;
+        }
+        if (b.gt(half)) {
+            bb = b.sub(p);
+        }
+        else {
+            bb = b;
+        }
+        return aa.lt(bb);
+    }
+    static gt(a, b) {
+        const half = field.SNARK_SCALAR_FIELD.div(BigNumber.from("2"));
+        const p = field.SNARK_SCALAR_FIELD;
+        let aa;
+        let bb;
+        if (a.gt(half)) {
+            aa = a.sub(p);
+        }
+        else {
+            aa = a;
+        }
+        if (b.gt(half)) {
+            bb = b.sub(p);
+        }
+        else {
+            bb = b;
+        }
+        return aa.gt(bb);
+    }
+}

package/dist/lib/loopring/poseidon/eddsa.d.ts

@@ -0,0 +1,29 @@
+import { BigNumber } from "ethers";
+import { FQ } from "../field";
+import { Point } from "../jubjub";
+export declare class Signature {
+    R: Point;
+    s: FQ;
+    constructor(R: Point, s: FQ);
+    toStr(): string;
+}
+export declare class SignedMessage {
+    A: Point;
+    sig: Signature;
+    msg: BigNumber;
+    constructor(A: Point, sig: Signature, msg: BigNumber);
+    toStr(): string;
+}
+export declare class SignatureScheme {
+    static to_bytes(arg: BigNumber): number[];
+    static prehash_message(M: BigNumber): BigNumber;
+    static hash_secret_python(k: FQ, arg: BigNumber): BigNumber;
+    static B(): Point;
+    static sign(msg: BigNumber, key: FQ, B: Point): SignedMessage;
+    static as_scalar(point: Point): BigNumber[];
+    static hash_public(R: Point, A: Point, M: BigNumber): any;
+}
+export declare function bnToBuf(bn: string): number[];
+export declare function bnToBufWithFixedLength(bn: string, outputLength: number): number[];
+export declare function bufToBn(buf: any): bigint;
+export declare function bytesToHexString(bytes: any): any;

package/dist/lib/loopring/poseidon/eddsa.js

@@ -0,0 +1,210 @@
+/*
+Implements Pure-EdDSA and Hash-EdDSA
+
+The signer has two secret values:
+
+    * k = Secret key
+    * r = Per-(message,key) nonce
+
+The signer provides a signature consiting of two values:
+
+    * R = Point, image of `r*B`
+    * s = Image of `r + (k*t)`
+
+The signer provides the verifier with their public key:
+
+    * A = k*B
+
+Both the verifier and the signer calculate the common reference string:
+
+    * t = H(R, A, M)
+
+The nonce `r` is secret, and protects the value `s` from revealing the
+signers secret key.
+
+For Hash-EdDSA, the message `M` is compressed before H(R,A,M)
+
+For further information see: https://ed2519.cr.yp.to/eddsa-20150704.pdf
+*/
+import { BigNumber } from "ethers";
+import { field, FQ } from "../field";
+import { jubjub, Point } from "../jubjub";
+import { sha512 } from "js-sha512";
+import { permunation, PoseidonParams } from "../permutation";
+export class Signature {
+    constructor(R, s) {
+        this.R = R;
+        this.s = s;
+    }
+    toStr() {
+        return `${this.R.x.n} ${this.R.y.n} ${this.s.n}`;
+    }
+}
+export class SignedMessage {
+    constructor(A, sig, msg) {
+        this.A = A;
+        this.sig = sig;
+        this.msg = msg;
+    }
+    toStr() {
+        return `${this.A.x.n} ${this.A.y.n} ${this.sig.toStr()} ${this.msg.toString()}`;
+    }
+}
+export class SignatureScheme {
+    static to_bytes(arg) {
+        const outputLength = 32;
+        let bitIntDataItems = bnToBuf(arg.toString());
+        const more = outputLength - bitIntDataItems.length;
+        if (more > 0) {
+            for (let i = 0; i < more; i++) {
+                bitIntDataItems = [0].concat(bitIntDataItems);
+            }
+        }
+        else {
+            bitIntDataItems = bitIntDataItems.slice(0, outputLength);
+        }
+        bitIntDataItems = bitIntDataItems.reverse();
+        return bitIntDataItems;
+    }
+    /*
+    Identity function for message
+  
+    Can be used to truncate the message before hashing it
+    as part of the public parameters.
+    */
+    static prehash_message(M) {
+        return M;
+    }
+    /*
+    Hash the key and message to create `r`, the blinding factor for this signature.
+  
+    If the same `r` value is used more than once, the key for the signature is revealed.
+  
+    From: https://eprint.iacr.org/2015/677.pdf (EdDSA for more curves)
+  
+    Page 3:
+  
+        (Implementation detail: To save time in the computation of `rB`, the signer
+        can replace `r` with `r mod L` before computing `rB`.)
+    */
+    static hash_secret_python(k, arg) {
+        const byteArray0 = this.to_bytes(k.n);
+        const byteArray1 = this.to_bytes(arg);
+        const sum = byteArray0.concat(byteArray1);
+        // let byteArrayHexStr = bytesToHexString(sum)
+        const digest1 = sha512.array(new Uint8Array(sum).buffer);
+        // let digest1 = createHash('sha512').update .digest("SHA-512", new Uint8Array(sum).buffer)
+        let sha512StrItems;
+        for (let i = 0; i < digest1.length; i++) {
+            const itemInt = digest1[i];
+            let st = itemInt.toString(16);
+            if (st.length == 1) {
+                st = "0" + st;
+            }
+            sha512StrItems = [st].concat(sha512StrItems);
+        }
+        const sha512MessageHexStr = sha512StrItems.join("");
+        const sha512MessageHexStrBigInt = BigNumber.from("0x" + sha512MessageHexStr);
+        const hashed = sha512MessageHexStrBigInt.mod(jubjub.JUBJUB_L);
+        return hashed;
+    }
+    static B() {
+        return Point.generate();
+    }
+    static sign(msg, key, B) {
+        const copyKey = new FQ(key.n, key.m);
+        const A = B.mul(copyKey.n);
+        const M = this.prehash_message(msg);
+        const r = this.hash_secret_python(key, M);
+        const copy_r = BigNumber.from(r.toString());
+        const R = B.mul(copy_r);
+        const t = this.hash_public(R, A, M);
+        const t_c = t;
+        const key_n_t = key.n.mul(t_c);
+        const left = r.add(key_n_t);
+        const S = left.mod(jubjub.JUBJUB_E);
+        const signatureResult = new Signature(R, new FQ(S));
+        const signedMessage = new SignedMessage(A, signatureResult, msg);
+        return signedMessage;
+    }
+    static as_scalar(point) {
+        return [point.x.n, point.y.n];
+    }
+    static hash_public(R, A, M) {
+        let inputMsg;
+        inputMsg = this.as_scalar(R).concat(this.as_scalar(A)).concat([M]);
+        const params = new PoseidonParams(field.SNARK_SCALAR_FIELD, 6, 6, 52, "poseidon", BigNumber.from(5), null, null, 128);
+        const result = permunation.poseidon(inputMsg, params);
+        return result;
+    }
+}
+export function bnToBuf(bn) {
+    let hex = BigInt(bn).toString(16);
+    if (hex.length % 2) {
+        hex = "0" + hex;
+    }
+    const len = hex.length / 2;
+    const u8 = new Uint8Array(len);
+    let i = 0;
+    let j = 0;
+    while (i < len) {
+        u8[i] = parseInt(hex.slice(j, j + 2), 16);
+        i += 1;
+        j += 2;
+    }
+    return Array.from(u8);
+}
+export function bnToBufWithFixedLength(bn, outputLength) {
+    let hex = BigInt(bn).toString(16);
+    if (hex.length % 2) {
+        hex = "0" + hex;
+    }
+    const len = hex.length / 2;
+    const u8 = new Uint8Array(len);
+    let i = 0;
+    let j = 0;
+    while (i < len) {
+        u8[i] = parseInt(hex.slice(j, j + 2), 16);
+        i += 1;
+        j += 2;
+    }
+    let bitIntDataItems = Array.from(u8);
+    const more = outputLength - bitIntDataItems.length;
+    if (more > 0) {
+        for (let i = 0; i < more; i++) {
+            bitIntDataItems = [0].concat(bitIntDataItems);
+        }
+    }
+    else {
+        bitIntDataItems = bitIntDataItems.slice(0, outputLength);
+    }
+    return bitIntDataItems;
+}
+export function bufToBn(buf) {
+    let hex;
+    hex = [];
+    const u8 = Uint8Array.from(buf);
+    u8.forEach(function (i) {
+        let h = i.toString(16);
+        if (h.length % 2) {
+            h = "0" + h;
+        }
+        hex.push(h);
+    });
+    return BigInt("0x" + hex.join(""));
+}
+export function bytesToHexString(bytes) {
+    let strItems;
+    strItems = [];
+    for (let i = 0; i < bytes.length; i++) {
+        const item = bytes[i];
+        let st = item.toString(16);
+        if (st.length == 1) {
+            st = "0" + st;
+        }
+        // st = st.toUpperCase()
+        strItems.push(st);
+    }
+    const strItemsJoined = strItems.join("");
+    return strItemsJoined;
+}