@layerswap/widget 0.1.4 → 0.1.14

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

@@ -1,19 +0,0 @@
-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

@@ -1,79 +0,0 @@
-/*
-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

@@ -1,22 +0,0 @@
-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

@@ -1,198 +0,0 @@
-/*
- 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

@@ -1,14 +0,0 @@
-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

@@ -1,61 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,210 +0,0 @@
-/*
-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;
-}