@layerswap/widget 0.1.18 → 1.0.0-alpha0.1

package/dist/lib/loopring/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/eddsa.js

@@ -0,0 +1,208 @@
+/*
+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);
+        const digest1 = sha512.array(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;
+}

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

@@ -0,0 +1,17 @@
+import { BigNumber } from "ethers";
+export declare class field {
+    static SNARK_SCALAR_FIELD: BigNumber;
+    static FR_ORDER: BigNumber;
+}
+export declare class FQ {
+    m: BigNumber;
+    n: BigNumber;
+    constructor(n: BigNumber, field_modulus?: BigNumber);
+    add(other: BigNumber): FQ;
+    mul(other: BigNumber): FQ;
+    sub(other: BigNumber): FQ;
+    div(other: BigNumber): FQ;
+    static one(modulus?: BigNumber): FQ;
+    static zero(modulus?: BigNumber): FQ;
+}
+export declare function modulo(n: BigNumber, p: BigNumber, m: BigNumber): BigNumber;

package/dist/lib/loopring/field.js

@@ -0,0 +1,61 @@
+import { BigNumber } from "ethers";
+import { BigInteger } from "jsbn";
+export class field {
+}
+// Fq is the base field of Jubjub
+field.SNARK_SCALAR_FIELD = BigNumber.from("21888242871839275222246405745257275088548364400416034343698204186575808495617");
+// Fr is the scalar field of Jubjub
+field.FR_ORDER = BigNumber.from("21888242871839275222246405745257275088614511777268538073601725287587578984328");
+// A class for field elements in FQ. Wrap a number in this class,
+// and it becomes a field element.
+export class FQ {
+    constructor(n, field_modulus = field.SNARK_SCALAR_FIELD) {
+        this.m = field_modulus;
+        this.n = n.mod(this.m);
+    }
+    //
+    // Use this.n as other
+    //
+    add(other) {
+        const on = other;
+        const n = (this.n.add(on)).mod(this.m);
+        return new FQ(n, this.m);
+    }
+    mul(other) {
+        const on = other;
+        const n = this.n.mul(on).mod(this.m);
+        return new FQ(n, this.m);
+    }
+    sub(other) {
+        const on = other;
+        let new_n;
+        if (this.n.gte(on)) {
+            new_n = (this.n.sub(on)).mod(this.m);
+        }
+        else {
+            new_n = (this.n.sub(on).add(this.m)).mod(this.m);
+        }
+        return new FQ(new_n, this.m);
+    }
+    div(other) {
+        const on_c = other;
+        const m_c = this.m;
+        const two_c = BigNumber.from("2");
+        const on_power_c = modulo(on_c, m_c.sub(two_c), m_c);
+        const n_on_power_remainder = this.n.mul(on_power_c).mod(this.m);
+        return new FQ(n_on_power_remainder, this.m);
+    }
+    static one(modulus = field.SNARK_SCALAR_FIELD) {
+        return new FQ(BigNumber.from("1"), modulus);
+    }
+    static zero(modulus = field.SNARK_SCALAR_FIELD) {
+        return new FQ(BigNumber.from("0"), modulus);
+    }
+}
+export function modulo(n, p, m) {
+    const n_ = new BigInteger(n.toString());
+    const p_ = new BigInteger(p.toString());
+    const m_ = new BigInteger(m.toString());
+    const result = n_.modPow(p_, m_);
+    return BigNumber.from(result.toString());
+}

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

@@ -0,0 +1,137 @@
+import * as ethUtil from 'ethereumjs-util';
+import BN from 'bn.js';
+import BigNumber from 'bignumber.js';
+import { Buffer } from 'buffer';
+import { AmmPoolInfoV3, LoopringMap, MarketInfo, TokenInfo, TOKENMAPLIST, TokenRelatedInfo, DefiMarketInfo } from './defs';
+/**
+ * Returns hex string with '0x' prefix
+ * @param input
+ * @returns {string}
+ */
+export declare function addHexPrefix(input: any): string;
+/**
+ *
+ * @param mixed Buffer|number|string (hex string must be with '0x' prefix)
+ * @returns {Buffer}
+ */
+export declare function toBuffer(mixed: any): Buffer;
+/**
+ *
+ * @param num number|string (hex string must be with '0x' prefix)
+ * @param places number of zeros to pad
+ * @returns {Buffer}
+ */
+export declare function zeroPad(num: any, places: any): Buffer<ArrayBufferLike>;
+/**
+ *
+ * @param mixed number | BigNumber |  BN  | Buffer | string | Uint8Array
+ * @returns {string}
+ */
+export declare function toHex(mixed: number | BigNumber | BN | Buffer | string | Uint8Array | BigInt): string;
+/**
+ *
+ * @param mixed number | BigNumber |  BN  | Buffer | string | Uint8Array
+ * @returns {number}
+ */
+export declare function toNumber(mixed: number | BigNumber | BN | Buffer | string | Uint8Array): number;
+/**
+ *
+ * @param mixed number | BigNumber |  BN  | Buffer | string | Uint8Array
+ * @returns {BigNumber}
+ */
+export declare function toBig(mixed: number | BigNumber | BN | Buffer | string | Uint8Array): BigNumber;
+/**
+ *
+ * @param mixed number | BigNumber |  BN  | Buffer | string
+ * @returns {BN}
+ */
+export declare function toBN(mixed: any): ethUtil.BN;
+/**
+ *
+ * @param value number | BigNumber | Buffer | string
+ * @returns {BN}
+ */
+export declare function fromGWEI(value: any): BigNumber;
+/**
+ *
+ * @param value number | BigNumber | Buffer | string
+ * @returns {BN}
+ */
+export declare function toGWEI(value: any): BigNumber;
+/**
+ * Returns formatted hex string of a given private key
+ * @param mixed Buffer | string | Uint8Array
+ * @returns {string}
+ */
+export declare function formatKey(mixed: Buffer | string | Uint8Array): string;
+/**
+ * Returns hex string of a given address
+ * @param mixed Buffer | string |Uint8Array
+ * @returns {string}
+ */
+export declare function formatAddress(mixed: Buffer | string | Uint8Array): string;
+/**
+ * Returns hex string without '0x' prefix
+ * @param input string
+ * @returns {string}
+ */
+export declare function clearHexPrefix(input: any): string;
+/**
+ *
+ * @param hex
+ * @returns {string}
+ */
+export declare function padLeftEven(hex: any): any;
+/**
+ * Returns symbol of a given kind of currency
+ * @param settingsCurrency
+ * @returns {*}
+ */
+export declare function getDisplaySymbol(settingsCurrency: any): "" | "￥" | "$";
+/**
+ * Returns number in string with a given precision
+ * @param number number | BigNumber
+ * @param precision number
+ * @param ceil bool  round up
+ * @returns {string}
+ */
+export declare function toFixed(number: any, precision: any, ceil: any): string;
+export declare function formatEddsaKey(key: any): string;
+/**
+ * Returns a number with commas as thousands separators
+ * @param number number
+ * @returns {*}
+ */
+export declare function numberWithCommas(number: any): any;
+export declare function sortObjDictionary(obj: {
+    [key: string]: any;
+}): Map<string, any>;
+export declare function makeMarket<R extends TokenInfo = TokenInfo>(raw_data: R[]): TOKENMAPLIST;
+export declare function makeAmmPool<R>(raw_data: any): {
+    ammpools: LoopringMap<AmmPoolInfoV3>;
+    pairs: LoopringMap<TokenRelatedInfo>;
+};
+export declare function makeMarkets<R, C extends MarketInfo>(raw_data: any, url?: string): {
+    markets: LoopringMap<C>;
+    pairs: LoopringMap<TokenRelatedInfo>;
+    tokenArr: string[];
+    tokenArrStr: string;
+    marketArr: string[];
+    marketArrStr: string;
+};
+export declare function makeMarketsWithIdIndex<C extends MarketInfo>(raw_data: any, url: string | undefined, idIndex: any): {
+    markets: LoopringMap<C>;
+    pairs: LoopringMap<TokenRelatedInfo>;
+    tokenArr: string[];
+    tokenArrStr: string;
+    marketArr: string[];
+    marketArrStr: string;
+};
+export declare function makeInvestMarkets<C extends DefiMarketInfo>(raw_data: any, types?: string[]): {
+    markets: LoopringMap<C>;
+    pairs: LoopringMap<TokenRelatedInfo>;
+    tokenArr: string[];
+    tokenArrStr: string;
+    marketArr: string[];
+    marketArrStr: string;
+};