@layerswap/widget 0.1.18 → 1.0.0-alpha0.1

package/dist/lib/loopring/formatter.js

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

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

@@ -0,0 +1,140 @@
+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;
+}