@layerswap/widget 0.1.4 → 0.1.14

package/dist/lib/loopring/formatter.js

@@ -1,516 +0,0 @@
-import * as ethUtil from 'ethereumjs-util';
-import BN from 'bn.js';
-import BigNumber from 'bignumber.js';
-import { Buffer } from 'buffer';
-import { MarketStatus, SEP, SoursURL, LOOPRING_URLs } from './defs';
-BigNumber.config({
-    EXPONENTIAL_AT: 100,
-    RANGE: [-100000, 10000000],
-    ROUNDING_MODE: 1,
-});
-/**
- * Returns hex string with '0x' prefix
- * @param input
- * @returns {string}
- */
-export function addHexPrefix(input) {
-    if (typeof input === 'string') {
-        return input.startsWith('0x') ? input : '0x' + input;
-    }
-    throw new Error('Unsupported type');
-}
-/**
- *
- * @param mixed Buffer|number|string (hex string must be with '0x' prefix)
- * @returns {Buffer}
- */
-export function toBuffer(mixed) {
-    if (mixed instanceof Buffer) {
-        return mixed;
-    }
-    else if (typeof mixed === 'string' && !mixed.startsWith('0x')) {
-        return Buffer.from(mixed);
-    }
-    else {
-        return ethUtil.toBuffer(mixed);
-    }
-}
-/**
- *
- * @param num number|string (hex string must be with '0x' prefix)
- * @param places number of zeros to pad
- * @returns {Buffer}
- */
-export function zeroPad(num, places) {
-    return toBuffer(String(num).padStart(places, '0'));
-}
-/**
- *
- * @param mixed number | BigNumber |  BN  | Buffer | string | Uint8Array
- * @returns {string}
- */
-export function toHex(mixed) {
-    if (typeof mixed === 'number') {
-        return addHexPrefix(toBig(mixed).toString(16));
-    }
-    if (mixed instanceof BigNumber || mixed instanceof BN) {
-        return addHexPrefix(mixed.toString(16));
-    }
-    if (mixed instanceof Buffer || mixed instanceof Uint8Array) {
-        return addHexPrefix(mixed.toString('hex'));
-    }
-    if (typeof mixed === 'string') {
-        const regex = new RegExp(/^0x[0-9a-fA-F]*$/);
-        return regex.test(mixed) ? mixed : addHexPrefix(toBuffer(mixed).toString('hex'));
-    }
-    throw new Error('Unsupported type');
-}
-/**
- *
- * @param mixed number | BigNumber |  BN  | Buffer | string | Uint8Array
- * @returns {number}
- */
-export function toNumber(mixed) {
-    if (typeof mixed === 'number') {
-        return mixed;
-    }
-    if (mixed instanceof BigNumber || mixed instanceof BN) {
-        return mixed.toNumber();
-    }
-    if (typeof mixed === 'string') {
-        return Number(mixed);
-    }
-    if (mixed instanceof Buffer || mixed instanceof Uint8Array) {
-        return Number(mixed.toString('hex'));
-    }
-    throw new Error('Unsupported type');
-}
-/**
- *
- * @param mixed number | BigNumber |  BN  | Buffer | string | Uint8Array
- * @returns {BigNumber}
- */
-export function toBig(mixed) {
-    if (mixed instanceof BigNumber) {
-        return mixed;
-    }
-    if (typeof mixed === 'number') {
-        return new BigNumber(mixed.toString());
-    }
-    if (typeof mixed === 'string') {
-        return new BigNumber(mixed);
-    }
-    if (mixed instanceof Buffer || mixed instanceof Uint8Array) {
-        return new BigNumber(mixed.toString('hex'));
-    }
-    throw new Error('Unsupported type');
-}
-/**
- *
- * @param mixed number | BigNumber |  BN  | Buffer | string
- * @returns {BN}
- */
-export function toBN(mixed) {
-    return mixed instanceof BN ? mixed : new BN(toBig(mixed).toString(10), 10);
-}
-/**
- *
- * @param value number | BigNumber | Buffer | string
- * @returns {BN}
- */
-export function fromGWEI(value) {
-    return new BigNumber(toBig(value).times(1e9).toFixed(0));
-}
-/**
- *
- * @param value number | BigNumber | Buffer | string
- * @returns {BN}
- */
-export function toGWEI(value) {
-    return toBig(value).div(1e9);
-}
-/**
- * Returns formatted hex string of a given private key
- * @param mixed Buffer | string | Uint8Array
- * @returns {string}
- */
-export function formatKey(mixed) {
-    if (mixed instanceof Buffer || mixed instanceof Uint8Array) {
-        return mixed.toString('hex');
-    }
-    if (typeof mixed === 'string') {
-        return mixed.startsWith('0x') ? mixed.slice(2) : mixed;
-    }
-    throw new Error('Unsupported type');
-}
-/**
- * Returns hex string of a given address
- * @param mixed Buffer | string |Uint8Array
- * @returns {string}
- */
-export function formatAddress(mixed) {
-    if (mixed instanceof Buffer || mixed instanceof Uint8Array) {
-        return ethUtil.toChecksumAddress('0x' + mixed.toString('hex'));
-    }
-    if (typeof mixed === 'string') {
-        return ethUtil.toChecksumAddress(mixed.startsWith('0x') ? mixed : '0x' + mixed);
-    }
-    throw new Error('Unsupported type');
-}
-/**
- * Returns hex string without '0x' prefix
- * @param input string
- * @returns {string}
- */
-export function clearHexPrefix(input) {
-    if (typeof input === 'string') {
-        return input.startsWith('0x') ? input.slice(2) : input;
-    }
-    throw new Error('Unsupported type');
-}
-/**
- *
- * @param hex
- * @returns {string}
- */
-export function padLeftEven(hex) {
-    return hex.length % 2 !== 0 ? `0${hex}` : hex;
-}
-/**
- * Returns symbol of a given kind of currency
- * @param settingsCurrency
- * @returns {*}
- */
-export function getDisplaySymbol(settingsCurrency) {
-    switch (settingsCurrency) {
-        case 'CNY':
-            return '￥';
-        case 'USD':
-            return '$';
-        default:
-            return '';
-    }
-}
-/**
- * Returns number in string with a given precision
- * @param number number | BigNumber
- * @param precision number
- * @param ceil bool  round up
- * @returns {string}
- */
-export function toFixed(number, precision, ceil) {
-    precision = precision || 0;
-    if (number instanceof BigNumber) {
-        const rm = ceil ? 0 : 1;
-        return number.toFixed(precision, rm);
-    }
-    if (typeof number === 'number') {
-        return ceil
-            ? (Math.ceil(number * Number('1e' + precision)) / Number('1e' + precision)).toFixed(precision)
-            : (Math.floor(number * Number('1e' + precision)) / Number('1e' + precision)).toFixed(precision);
-    }
-    throw new Error('Unsupported type');
-}
-export function formatEddsaKey(key) {
-    const hexKey = clearHexPrefix(key);
-    return addHexPrefix(String(hexKey).padStart(64, '0'));
-}
-/**
- * Returns a number with commas as thousands separators
- * @param number number
- * @returns {*}
- */
-export function numberWithCommas(number) {
-    if (number) {
-        number = number.toString().replace(/,/g, '');
-        if (isNaN(Number(number))) {
-            return '-';
-        }
-        try {
-            const parts = number.toString().split('.');
-            parts[0] = parts[0].replace(/\B(?=(\d{3})+(?!\d))/g, ',');
-            return parts.join('.');
-        }
-        catch (err) {
-            return '-';
-        }
-    }
-    else {
-        return number;
-    }
-}
-export function sortObjDictionary(obj) {
-    const dataToSig = new Map();
-    if (obj) {
-        Reflect.ownKeys(obj)
-            .sort((a, b) => a.toString().localeCompare(b.toString()))
-            .forEach((key) => {
-            dataToSig.set(key.toString(), obj[key.toString()]);
-        });
-    }
-    return dataToSig;
-}
-export function makeMarket(raw_data) {
-    const coinMap = {};
-    const totalCoinMap = {};
-    const addressIndex = {};
-    const idIndex = {};
-    const tokensMap = {};
-    if (raw_data instanceof Array) {
-        raw_data.forEach((item) => {
-            if (item?.symbol.startsWith('LP-')) {
-                item.isLpToken = true;
-            }
-            else {
-                item.isLpToken = false;
-            }
-            tokensMap[item.symbol] = item;
-            const coinInfo = {
-                icon: SoursURL + `ethereum/assets/${item.address}/logo.png`,
-                name: item.name,
-                simpleName: item.symbol,
-                description: item.type,
-                company: item.name,
-            };
-            if (!item.symbol.startsWith('LP-')) {
-                coinMap[item.symbol] = coinInfo;
-            }
-            totalCoinMap[item.symbol] = coinInfo;
-            addressIndex[item.address.toLowerCase()] = item.symbol;
-            // @ts-ignore
-            idIndex[/vault/gi.test(item.type?.toLowerCase()) ? item?.vaultTokenId : item.tokenId] =
-                item.symbol;
-        });
-    }
-    return {
-        tokensMap,
-        coinMap,
-        totalCoinMap,
-        idIndex,
-        addressIndex,
-    };
-}
-export function makeAmmPool(raw_data) {
-    const ammpools = {};
-    const pairs = {};
-    if (raw_data?.pools instanceof Array) {
-        raw_data.pools.forEach((item) => {
-            const market = item.market;
-            ammpools[market] = item;
-            let base = '', quote = '';
-            const ind = market.indexOf('-');
-            const ind2 = market.lastIndexOf('-');
-            base = market.substring(ind + 1, ind2);
-            quote = market.substring(ind2 + 1, market.length);
-            if (!pairs[base]) {
-                pairs[base] = {
-                    tokenId: item.tokens.pooled[0],
-                    tokenList: [quote],
-                };
-            }
-            else {
-                pairs[base].tokenList = [...pairs[base].tokenList, quote];
-            }
-            if (!pairs[quote]) {
-                pairs[quote] = {
-                    tokenId: item.tokens.pooled[1],
-                    tokenList: [base],
-                };
-            }
-            else {
-                pairs[quote].tokenList = [...pairs[quote].tokenList, base];
-            }
-        });
-    }
-    return {
-        ammpools,
-        pairs,
-    };
-}
-export function makeMarkets(raw_data, url = LOOPRING_URLs.GET_MARKETS) {
-    const markets = {};
-    const pairs = {};
-    const isMix = url === LOOPRING_URLs.GET_MIX_MARKETS;
-    if (raw_data?.markets instanceof Array) {
-        raw_data.markets.forEach((item) => {
-            const marketInfo = {
-                ...item,
-                baseTokenId: item.baseTokenId,
-                enabled: item.enabled,
-                market: item.market,
-                orderbookAggLevels: item.orderbookAggLevels,
-                precisionForPrice: item.precisionForPrice,
-                quoteTokenId: item.quoteTokenId,
-            };
-            if (isMix) {
-                marketInfo.status = item.status;
-                marketInfo.isSwapEnabled =
-                    marketInfo.status === MarketStatus.ALL || marketInfo.status === MarketStatus.AMM;
-                marketInfo.createdAt = parseInt(item.createdAt);
-            }
-            markets[item.market] = marketInfo;
-            if (item.enabled) {
-                const market = item.market;
-                const ind = market.indexOf('-');
-                const base = market.substring(0, ind);
-                const quote = market.substring(ind + 1, market.length);
-                if (!pairs[base]) {
-                    pairs[base] = {
-                        tokenId: item.baseTokenId,
-                        tokenList: [quote],
-                    };
-                }
-                else {
-                    pairs[base].tokenList = [...pairs[base].tokenList, quote];
-                }
-                if (!pairs[quote]) {
-                    pairs[quote] = {
-                        tokenId: item.quoteTokenId,
-                        tokenList: [base],
-                    };
-                }
-                else {
-                    pairs[quote].tokenList = [...pairs[quote].tokenList, base];
-                }
-            }
-        });
-    }
-    const marketArr = Reflect.ownKeys(markets);
-    const tokenArr = Reflect.ownKeys(pairs);
-    return {
-        markets,
-        pairs,
-        tokenArr,
-        tokenArrStr: tokenArr.join(SEP),
-        marketArr,
-        marketArrStr: marketArr.join(SEP),
-    };
-}
-export function makeMarketsWithIdIndex(raw_data, url = LOOPRING_URLs.GET_MARKETS, idIndex) {
-    const markets = {};
-    const pairs = {};
-    const isMix = url === LOOPRING_URLs.GET_MIX_MARKETS;
-    if (raw_data?.markets instanceof Array) {
-        raw_data.markets.forEach((item) => {
-            const marketInfo = {
-                ...item,
-                baseTokenId: item.baseTokenId,
-                enabled: item.enabled,
-                market: item.market,
-                orderbookAggLevels: item.orderbookAggLevels,
-                precisionForPrice: item.precisionForPrice,
-                quoteTokenId: item.quoteTokenId,
-            };
-            if (isMix) {
-                marketInfo.status = item.status;
-                marketInfo.isSwapEnabled =
-                    marketInfo.status === MarketStatus.ALL || marketInfo.status === MarketStatus.AMM;
-                marketInfo.createdAt = parseInt(item.createdAt);
-            }
-            const base = idIndex[item.baseTokenId];
-            const quote = idIndex[item.quoteTokenId];
-            markets[`${base}-${quote}`] = {
-                ...marketInfo,
-                market: `${base}-${quote}`,
-            };
-            if (item.enabled) {
-                if (!pairs[base]) {
-                    pairs[base] = {
-                        tokenId: item.baseTokenId,
-                        tokenList: [quote],
-                    };
-                }
-                else {
-                    pairs[base].tokenList = [...pairs[base].tokenList, quote];
-                }
-                if (!pairs[quote]) {
-                    pairs[quote] = {
-                        tokenId: item.quoteTokenId,
-                        tokenList: [base],
-                    };
-                }
-                else {
-                    pairs[quote].tokenList = [...pairs[quote].tokenList, base];
-                }
-            }
-        });
-    }
-    const marketArr = Reflect.ownKeys(markets);
-    const tokenArr = Reflect.ownKeys(pairs);
-    return {
-        markets,
-        pairs,
-        tokenArr,
-        tokenArrStr: tokenArr.join(SEP),
-        marketArr,
-        marketArrStr: marketArr.join(SEP),
-    };
-}
-export function makeInvestMarkets(raw_data, types) {
-    let markets = {};
-    let pairs = {};
-    // const isMix = url === LOOPRING_URLs.GET_MIX_MARKETS;
-    if (raw_data?.markets instanceof Array) {
-        let _markets = [];
-        if (types) {
-            _markets = raw_data.markets.filter((item) => types.includes(item.type?.toUpperCase()));
-        }
-        else {
-            _markets = raw_data.markets;
-        }
-        _markets.forEach((item) => {
-            const marketInfo = {
-                ...item,
-            };
-            markets[item.market] = marketInfo;
-            if (item.enabled) {
-                const [_markets, type, base, quote] = item.market.match(/^(\w+-)?(\w+)-(\w+)$/i);
-                if (type === 'DUAL-' && base && quote) {
-                    if (!pairs[base]) {
-                        pairs[base] = {
-                            tokenId: item.baseTokenId,
-                            tokenList: [quote],
-                        };
-                    }
-                    else {
-                        pairs[base].tokenList = [...pairs[base].tokenList, quote];
-                    }
-                    if (!pairs[quote]) {
-                        pairs[quote] = {
-                            tokenId: item.baseTokenId,
-                            tokenList: [base],
-                        };
-                    }
-                    else {
-                        pairs[quote].tokenList = [...pairs[quote].tokenList, base];
-                    }
-                }
-                else if (base && quote) {
-                    const market = item.market;
-                    // const ind = market.indexOf("-");
-                    // const base = market.substring(0, ind);
-                    // const quote = market.substring(ind + 1, market.length);
-                    if (!pairs[base]) {
-                        pairs[base] = {
-                            tokenId: item.baseTokenId,
-                            tokenList: [quote],
-                        };
-                    }
-                    else {
-                        pairs[base].tokenList = [...pairs[base].tokenList, quote];
-                    }
-                }
-            }
-        });
-    }
-    const marketArr = Reflect.ownKeys(markets);
-    const tokenArr = Reflect.ownKeys(pairs);
-    return {
-        markets,
-        pairs,
-        tokenArr,
-        tokenArrStr: tokenArr.join(SEP),
-        marketArr,
-        marketArrStr: marketArr.join(SEP),
-    };
-}

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

@@ -1,36 +0,0 @@
-import { AccountInfo, LpFee, OffchainFeeReqType, UnlockedAccount } from "./defs";
-import { Token } from "../../Models/Network";
-import { Config } from "wagmi";
-export declare function unlockAccount(accInfo: AccountInfo, config: Config): Promise<UnlockedAccount>;
-export declare function getOffchainFeeAmt(accountId: number, type: OffchainFeeReqType): Promise<LpFee>;
-type TransferProps = {
-    unlockedAccount: UnlockedAccount;
-    accInfo: AccountInfo;
-    token: Token;
-    depositAddress: `0x${string}`;
-    amount: string;
-    call_data: string | undefined;
-};
-type TransferApiRes = {
-    hash: string;
-    resultInfo: undefined;
-} | {
-    hash: undefined;
-    resultInfo: {
-        code: number;
-        message: string;
-    };
-};
-export declare function transfer({ accInfo, amount, depositAddress, call_data, token, unlockedAccount }: TransferProps, config: Config): Promise<TransferApiRes>;
-type ActivateAccountProps = {
-    token: {
-        symbol: string;
-        id: number;
-    };
-    accInfo: AccountInfo;
-};
-export declare function activateAccount({ token, accInfo }: ActivateAccountProps, config: Config): Promise<{
-    x: string;
-    y: string;
-}>;
-export {};

package/dist/lib/loopring/helpers.js

@@ -1,140 +0,0 @@
-import { LoopringAPI } from "./LoopringAPI";
-import { sortObjDictionary } from "./formatter";
-import { signTypedData } from '@wagmi/core';
-import { signMessage } from '@wagmi/core';
-import { parseUnits } from 'viem';
-import { KEY_MESSAGE, LOOPRING_URLs, OffchainFeeReqType } from "./defs";
-import { generateKey, getEdDSASig, getTransferTypedData, getUpdateAccountEcdsaTypedData, get_EddsaSig_Transfer } from "./utils";
-export async function unlockAccount(accInfo, config) {
-    let keySeed = accInfo.keySeed;
-    if (!keySeed) {
-        const exchangeInfo = await getExchangeInfo();
-        keySeed = KEY_MESSAGE.replace("${exchangeAddress}", exchangeInfo.exchangeAddress).replace("${nonce}", '0');
-    }
-    const sig = await signMessage(config, { message: keySeed });
-    const eddsaKeyData = generateKey(sig);
-    const { sk } = eddsaKeyData;
-    const { accountId } = accInfo;
-    const url = `${LoopringAPI.BaseApi}${LOOPRING_URLs.API_KEY_ACTION}?accountId=${accountId}`;
-    const dataToSign = sortObjDictionary({ accountId });
-    const eddsa = getEdDSASig("GET", LoopringAPI.BaseApi, LOOPRING_URLs.API_KEY_ACTION, dataToSign, sk);
-    const res = await (await fetch(url, {
-        headers: {
-            'X-Api-Sig': eddsa
-        }
-    })).json();
-    if (res.apiKey) {
-        return { eddsaKey: eddsaKeyData, apiKey: res.apiKey };
-    }
-    else {
-        throw Error(`Could not unlock account, error:${res.resultInfo?.message || ' unknown'}`);
-    }
-}
-async function getExchangeInfo() {
-    const result = await (await fetch(`${LoopringAPI.BaseApi}${LOOPRING_URLs.GET_EXCHANGE_INFO}`)).json();
-    return result;
-}
-export async function getOffchainFeeAmt(accountId, type) {
-    const result = await (await fetch(`${LoopringAPI.BaseApi}${LOOPRING_URLs.GET_OFFCHAIN_FEE_AMT}?accountId=${accountId}&requestType=${type}`)).json();
-    return result;
-}
-async function getNextStorageId(req, apiKey) {
-    const { accountId, tokenId } = req;
-    const url = `${LoopringAPI.BaseApi}${LOOPRING_URLs.GET_NEXT_STORAGE_ID}?accountId=${accountId}&sellTokenId=${tokenId}`;
-    const result = await (await fetch(url, {
-        headers: {
-            'X-Api-Key': apiKey
-        }
-    })).json();
-    return result;
-}
-export async function transfer({ accInfo, amount, depositAddress, call_data, token, unlockedAccount }, config) {
-    const exchangeInfo = await getExchangeInfo();
-    const { apiKey, eddsaKey } = unlockedAccount;
-    const storageId = await getNextStorageId({
-        accountId: accInfo.accountId,
-        tokenId: Number(token?.contract),
-    }, apiKey);
-    const feeData = await getOffchainFeeAmt(accInfo.accountId, OffchainFeeReqType.TRANSFER);
-    const fee = feeData.fees.find(f => f.token.toUpperCase() == token.symbol.toUpperCase())?.fee;
-    if (!fee) {
-        throw new Error(`Could not get fee for ${token.symbol.toUpperCase()}`);
-    }
-    const req = {
-        exchange: exchangeInfo.exchangeAddress,
-        payerAddr: accInfo.owner,
-        payerId: accInfo.accountId,
-        payeeAddr: depositAddress,
-        payeeId: 0,
-        storageId: storageId.offchainId,
-        token: {
-            tokenId: Number(token?.contract),
-            volume: parseUnits(amount, Number(token?.decimals)).toString(),
-        },
-        maxFee: {
-            tokenId: Number(token?.contract),
-            volume: fee,
-        },
-        validUntil: Math.round(Date.now() / 1000) + 30 * 86400,
-        ...(call_data ? { memo: call_data } : {}),
-    };
-    return await submitInternalTransfer(req, apiKey, eddsaKey.sk, config);
-}
-async function submitInternalTransfer(req, apiKey, eddsaKey, config) {
-    const typedData = getTransferTypedData(req, LoopringAPI.CHAIN);
-    const ecdsaSignature = (await signTypedData(config, typedData)).slice(0, 132);
-    const eddsaSignature = get_EddsaSig_Transfer(req, eddsaKey).result;
-    return await (await fetch(`${LoopringAPI.BaseApi}${LOOPRING_URLs.POST_INTERNAL_TRANSFER}`, {
-        method: "POST",
-        body: JSON.stringify({
-            ...req,
-            eddsaSignature,
-            ecdsaSignature: ecdsaSignature,
-        }),
-        headers: {
-            'Content-Type': 'application/json',
-            'X-Api-Sig': ecdsaSignature,
-            'X-Api-Key': apiKey
-        }
-    })).json();
-}
-export async function activateAccount({ token, accInfo }, config) {
-    const exchangeInfo = await getExchangeInfo();
-    const message = KEY_MESSAGE.replace("${exchangeAddress}", exchangeInfo.exchangeAddress).replace("${nonce}", accInfo.nonce.toString());
-    const sig = await signMessage(config, { message });
-    const eddsaKeyData = generateKey(sig);
-    const { formatedPx, formatedPy } = eddsaKeyData;
-    const publicKey = { x: formatedPx, y: formatedPy };
-    const feeData = await getOffchainFeeAmt(accInfo.accountId, OffchainFeeReqType.UPDATE_ACCOUNT);
-    const fee = feeData.fees.find(f => f.token.toUpperCase() == token.symbol.toUpperCase())?.fee;
-    if (!fee) {
-        throw new Error(`Could not get fee for ${token.symbol.toUpperCase()}`);
-    }
-    const req = {
-        exchange: exchangeInfo.exchangeAddress,
-        owner: accInfo.owner,
-        accountId: accInfo.accountId,
-        publicKey,
-        maxFee: {
-            tokenId: token.id,
-            volume: fee,
-        },
-        keySeed: message,
-        validUntil: Math.round(Date.now() / 1000) + 30 * 86400,
-        nonce: accInfo.nonce,
-    };
-    const typedData = getUpdateAccountEcdsaTypedData(req, LoopringAPI.CHAIN);
-    const ecdsaSignature = (await signTypedData(config, typedData)).slice(0, 132);
-    const activationReq = await (await fetch(`${LoopringAPI.BaseApi}${LOOPRING_URLs.ACCOUNT_ACTION}`, {
-        method: "POST",
-        body: JSON.stringify({ ...req, ecdsaSignature: ecdsaSignature }),
-        headers: {
-            'Content-Type': 'application/json',
-            'X-Api-Sig': ecdsaSignature
-        }
-    })).json();
-    if (activationReq?.resultInfo?.message) {
-        throw new Error(activationReq.resultInfo.message);
-    }
-    return publicKey;
-}