aljaz/zksync-lite-market-maker
1
1
Fork 0
mirror of https://github.com/ZigZagExchange/zksync-lite-market-maker.git synced 2025-12-17 07:04:23 +01:00
Code Issues Packages Projects Releases Wiki Activity

revert format

Browse Source
This commit is contained in:
Trooper
2022-06-27 20:19:24 +02:00
parent 903e139700
commit e6fe732a05
1 changed files with 229 additions and 230 deletions
Download Patch File Download Diff File Expand all files Collapse all files

459
marketmaker.js
View File

@@ -32,7 +32,7 @@ else {
MM_CONFIG = JSON.parse(mmConfigFile);
}
if (MM_CONFIG.feeToken) {
FEE_TOKEN = MM_CONFIG.feeToken;
FEE_TOKEN = MM_CONFIG.feeToken;
}
let activePairs = [];
for (let marketId in MM_CONFIG.pairs) {
@@ -48,7 +48,7 @@ const CHAIN_ID = parseInt(MM_CONFIG.zigzagChainId);
const ETH_NETWORK = (CHAIN_ID === 1) ? "mainnet" : "rinkeby";
let ethersProvider;
const providerUrl = (process.env.INFURA_URL || MM_CONFIG.infuraUrl);
if (providerUrl && ETH_NETWORK == "mainnet") {
if(providerUrl && ETH_NETWORK=="mainnet") {
ethersProvider = ethers.getDefaultProvider(providerUrl);
} else {
ethersProvider = ethers.getDefaultProvider(ETH_NETWORK);
@@ -62,7 +62,7 @@ try {
syncProvider = await zksync.getDefaultProvider(ETH_NETWORK);
const keys = [];
const ethPrivKey = (process.env.ETH_PRIVKEY || MM_CONFIG.ethPrivKey);
if (ethPrivKey && ethPrivKey != "") { keys.push(ethPrivKey); }
if(ethPrivKey && ethPrivKey != "") { keys.push(ethPrivKey); }
let ethPrivKeys;
if (process.env.ETH_PRIVKEYS) {
ethPrivKeys = JSON.parse(process.env.ETH_PRIVKEYS);
@@ -70,14 +70,14 @@ try {
else {
ethPrivKeys = MM_CONFIG.ethPrivKeys;
}
if (ethPrivKeys && ethPrivKeys.length > 0) {
ethPrivKeys.forEach(key => {
if (key != "" && !keys.includes(key)) {
if(ethPrivKeys && ethPrivKeys.length > 0) {
ethPrivKeys.forEach( key => {
if(key != "" && !keys.includes(key)) {
keys.push(key);
}
});
}
for (let i = 0; i < keys.length; i++) {
for(let i=0; i<keys.length; i++) {
let ethWallet = new ethers.Wallet(keys[i]);
let syncWallet = await zksync.Wallet.fromEthSigner(ethWallet, syncProvider);
if (!(await syncWallet.isSigningKeySet())) {
@@ -117,13 +117,13 @@ function onWsOpen() {
indicateLiquidityInterval = setInterval(indicateLiquidity, 5000);
for (let market in MM_CONFIG.pairs) {
if (MM_CONFIG.pairs[market].active) {
const msg = { op: "subscribemarket", args: [CHAIN_ID, market] };
const msg = {op:"subscribemarket", args:[CHAIN_ID, market]};
zigzagws.send(JSON.stringify(msg));
}
}
}
function onWsClose() {
function onWsClose () {
console.log("Websocket closed. Restarting");
setTimeout(() => {
clearInterval(fillOrdersInterval)
@@ -138,12 +138,12 @@ function onWsClose() {
async function handleMessage(json) {
const msg = JSON.parse(json);
if (!(["lastprice", "liquidity2", "fillstatus", "marketinfo"]).includes(msg.op)) console.log(json.toString());
switch (msg.op) {
switch(msg.op) {
case 'error':
const accountId = msg.args?.[1];
if (msg.args[0] == 'fillrequest' && accountId) {
if(msg.args[0] == 'fillrequest' && accountId) {
WALLETS[accountId]['ORDER_BROADCASTING'] = false;
}
}
break;
case 'orders':
const orders = msg.args[0];
@@ -154,8 +154,8 @@ async function handleMessage(json) {
if (fillable.fillable) {
sendFillRequest(order, fillable.walletId);
} else if ([
"sending order already",
"badprice"
"sending order already",
"badprice"
].includes(fillable.reason)) {
OPEN_ORDERS[orderId] = order;
}
@@ -166,14 +166,14 @@ async function handleMessage(json) {
const orderId = msg.args[1];
const fillOrder = msg.args[3];
const wallet = WALLETS[fillOrder.accountId];
if (!wallet) {
console.error("No wallet with this accountId: " + fillOrder.accountId);
if(!wallet) {
console.error("No wallet with this accountId: "+fillOrder.accountId);
break
} else {
try {
await broadcastFill(chainId, orderId, msg.args[2], fillOrder, wallet);
} catch (e) {
const orderCommitMsg = { op: "orderstatusupdate", args: [[[chainId, orderId, 'r', null, e.message]]] }
const orderCommitMsg = {op:"orderstatusupdate", args:[[[chainId,orderId,'r',null,e.message]]]}
zigzagws.send(JSON.stringify(orderCommitMsg));
console.error(e);
}
@@ -182,8 +182,8 @@ async function handleMessage(json) {
break
case "marketinfo":
const marketInfo = msg.args[0];
const marketId = marketInfo.alias;
if (!marketId) break
const marketId = marketInfo.alias;
if(!marketId) break
let oldBaseFee = "N/A", oldQuoteFee = "N/A";
try {
oldBaseFee = MARKETS[marketId].baseFee;
@@ -196,18 +196,18 @@ async function handleMessage(json) {
const newQuoteFee = MARKETS[marketId].quoteFee;
console.log(`marketinfo ${marketId} - update baseFee ${oldBaseFee} -> ${newBaseFee}, quoteFee ${oldQuoteFee} -> ${newQuoteFee}`);
if (FEE_TOKEN) break
if (
marketInfo.baseAsset.enabledForFees &&
!FEE_TOKEN_LIST.includes(marketInfo.baseAsset.id)
if(
marketInfo.baseAsset.enabledForFees &&
!FEE_TOKEN_LIST.includes(marketInfo.baseAsset.id)
) {
FEE_TOKEN_LIST.push(marketInfo.baseAsset.id);
}
if (
marketInfo.quoteAsset.enabledForFees &&
!FEE_TOKEN_LIST.includes(marketInfo.quoteAsset.id)
FEE_TOKEN_LIST.push(marketInfo.baseAsset.id);
}
if(
marketInfo.quoteAsset.enabledForFees &&
!FEE_TOKEN_LIST.includes(marketInfo.quoteAsset.id)
) {
FEE_TOKEN_LIST.push(marketInfo.quoteAsset.id);
}
FEE_TOKEN_LIST.push(marketInfo.quoteAsset.id);
}
break
default:
break
@@ -229,7 +229,7 @@ function isOrderFillable(order) {
const expires = order[7];
const side = order[3];
const price = order[4];
const now = Date.now() / 1000 | 0;
if (now > expires) {
@@ -249,7 +249,7 @@ function isOrderFillable(order) {
let quote;
try {
quote = genQuote(chainId, marketId, side, baseQuantity);
quote = genQuote(chainId, marketId, side, baseQuantity);
} catch (e) {
return { fillable: false, reason: e.message }
}
@@ -263,7 +263,7 @@ function isOrderFillable(order) {
const sellCurrency = (side === 's') ? market.quoteAsset.symbol : market.baseAsset.symbol;
const sellDecimals = (side === 's') ? market.quoteAsset.decimals : market.baseAsset.decimals;
const sellQuantity = (side === 's') ? quote.quoteQuantity : baseQuantity;
const neededBalanceBN = sellQuantity * 10 ** sellDecimals;
const neededBalanceBN = sellQuantity * 10**sellDecimals;
let goodWalletIds = [];
Object.keys(WALLETS).forEach(accountId => {
const walletBalance = WALLETS[accountId]['account_state'].committed.balances[sellCurrency];
@@ -284,39 +284,39 @@ function isOrderFillable(order) {
return { fillable: false, reason: "sending order already" };
}
return { fillable: true, reason: null, walletId: goodWalletIds[0] };
return { fillable: true, reason: null, walletId: goodWalletIds[0]};
}
function genQuote(chainId, marketId, side, baseQuantity) {
const market = MARKETS[marketId];
if (CHAIN_ID !== chainId) throw new Error("badchain");
if (!market) throw new Error("badmarket");
if (!(['b', 's']).includes(side)) throw new Error("badside");
if (baseQuantity <= 0) throw new Error("badquantity");
const market = MARKETS[marketId];
if (CHAIN_ID !== chainId) throw new Error("badchain");
if (!market) throw new Error("badmarket");
if (!(['b','s']).includes(side)) throw new Error("badside");
if (baseQuantity <= 0) throw new Error("badquantity");
validatePriceFeed(marketId);
validatePriceFeed(marketId);
const mmConfig = MM_CONFIG.pairs[marketId];
const mmSide = mmConfig.side || 'd';
if (mmSide !== 'd' && mmSide === side) {
throw new Error("badside");
}
const primaryPrice = (mmConfig.invert)
? (1 / PRICE_FEEDS[mmConfig.priceFeedPrimary])
: PRICE_FEEDS[mmConfig.priceFeedPrimary];
if (!primaryPrice) throw new Error("badprice");
const SPREAD = mmConfig.minSpread + (baseQuantity * mmConfig.slippageRate);
let quoteQuantity;
if (side === 'b') {
quoteQuantity = (baseQuantity * primaryPrice * (1 + SPREAD)) + market.quoteFee;
}
else if (side === 's') {
quoteQuantity = (baseQuantity - market.baseFee) * primaryPrice * (1 - SPREAD);
}
const quotePrice = (quoteQuantity / baseQuantity).toPrecision(6);
if (quotePrice < 0) throw new Error("Amount is inadequate to pay fee");
if (isNaN(quotePrice)) throw new Error("Internal Error. No price generated.");
return { quotePrice, quoteQuantity };
const mmConfig = MM_CONFIG.pairs[marketId];
const mmSide = mmConfig.side || 'd';
if (mmSide !== 'd' && mmSide === side) {
throw new Error("badside");
}
const primaryPrice = (mmConfig.invert)
? (1 / PRICE_FEEDS[mmConfig.priceFeedPrimary])
: PRICE_FEEDS[mmConfig.priceFeedPrimary];
if (!primaryPrice) throw new Error("badprice");
const SPREAD = mmConfig.minSpread + (baseQuantity * mmConfig.slippageRate);
let quoteQuantity;
if (side === 'b') {
quoteQuantity = (baseQuantity * primaryPrice * (1 + SPREAD)) + market.quoteFee;
}
else if (side === 's') {
quoteQuantity = (baseQuantity - market.baseFee) * primaryPrice * (1 - SPREAD);
}
const quotePrice = (quoteQuantity / baseQuantity).toPrecision(6);
if (quotePrice < 0) throw new Error("Amount is inadequate to pay fee");
if (isNaN(quotePrice)) throw new Error("Internal Error. No price generated.");
return { quotePrice, quoteQuantity };
}
function validatePriceFeed(marketId) {
@@ -346,81 +346,81 @@ function validatePriceFeed(marketId) {
// If the secondary price feed varies from the primary price feed by more than 1%, assume something is broken
const percentDiff = Math.abs(primaryPrice - secondaryPrice) / primaryPrice;
if (percentDiff > 0.03) {
console.error("Primary and secondary price feeds do not match!");
throw new Error("Circuit breaker triggered");
console.error("Primary and secondary price feeds do not match!");
throw new Error("Circuit breaker triggered");
}
return true;
}
async function sendFillRequest(orderreceipt, accountId) {
const chainId = orderreceipt[0];
const orderId = orderreceipt[1];
const marketId = orderreceipt[2];
const market = MARKETS[marketId];
const baseCurrency = market.baseAssetId;
const quoteCurrency = market.quoteAssetId;
const side = orderreceipt[3];
const baseQuantity = orderreceipt[5];
const quoteQuantity = orderreceipt[6];
const quote = genQuote(chainId, marketId, side, baseQuantity);
let tokenSell, tokenBuy, sellQuantity, buyQuantity, buySymbol, sellSymbol;
if (side === "b") {
tokenSell = market.baseAssetId;
tokenBuy = market.quoteAssetId;
const chainId = orderreceipt[0];
const orderId = orderreceipt[1];
const marketId = orderreceipt[2];
const market = MARKETS[marketId];
const baseCurrency = market.baseAssetId;
const quoteCurrency = market.quoteAssetId;
const side = orderreceipt[3];
const baseQuantity = orderreceipt[5];
const quoteQuantity = orderreceipt[6];
const quote = genQuote(chainId, marketId, side, baseQuantity);
let tokenSell, tokenBuy, sellQuantity, buyQuantity, buySymbol, sellSymbol;
if (side === "b") {
tokenSell = market.baseAssetId;
tokenBuy = market.quoteAssetId;
sellSymbol = market.baseAsset.symbol;
buySymbol = market.quoteAsset.symbol;
// Add 1 bip to to protect against rounding errors
sellQuantity = (baseQuantity * 1.0001).toFixed(market.baseAsset.decimals);
buyQuantity = (quote.quoteQuantity * 0.9999).toFixed(market.quoteAsset.decimals);
} else if (side === "s") {
tokenSell = market.quoteAssetId;
tokenBuy = market.baseAssetId;
sellSymbol = market.baseAsset.symbol;
buySymbol = market.quoteAsset.symbol;
// Add 1 bip to to protect against rounding errors
sellQuantity = (baseQuantity * 1.0001).toFixed(market.baseAsset.decimals);
buyQuantity = (quote.quoteQuantity * 0.9999).toFixed(market.quoteAsset.decimals);
} else if (side === "s") {
tokenSell = market.quoteAssetId;
tokenBuy = market.baseAssetId;
sellSymbol = market.quoteAsset.symbol;
buySymbol = market.baseAsset.symbol;
// Add 1 bip to to protect against rounding errors
sellQuantity = (quote.quoteQuantity * 1.0001).toFixed(market.quoteAsset.decimals);
buyQuantity = (baseQuantity * 0.9999).toFixed(market.baseAsset.decimals);
}
const sellQuantityParsed = syncProvider.tokenSet.parseToken(
tokenSell,
sellQuantity
);
const sellQuantityPacked = zksync.utils.closestPackableTransactionAmount(sellQuantityParsed);
const tokenRatio = {};
tokenRatio[tokenBuy] = buyQuantity;
tokenRatio[tokenSell] = sellQuantity;
const oneMinExpiry = (Date.now() / 1000 | 0) + 60;
const orderDetails = {
tokenSell,
tokenBuy,
amount: sellQuantityPacked,
ratio: zksync.utils.tokenRatio(tokenRatio),
validUntil: oneMinExpiry
}
const fillOrder = await WALLETS[accountId].syncWallet.getOrder(orderDetails);
sellSymbol = market.quoteAsset.symbol;
buySymbol = market.baseAsset.symbol;
// Add 1 bip to to protect against rounding errors
sellQuantity = (quote.quoteQuantity * 1.0001).toFixed(market.quoteAsset.decimals);
buyQuantity = (baseQuantity * 0.9999).toFixed(market.baseAsset.decimals);
}
const sellQuantityParsed = syncProvider.tokenSet.parseToken(
tokenSell,
sellQuantity
);
const sellQuantityPacked = zksync.utils.closestPackableTransactionAmount(sellQuantityParsed);
const tokenRatio = {};
tokenRatio[tokenBuy] = buyQuantity;
tokenRatio[tokenSell] = sellQuantity;
const oneMinExpiry = (Date.now() / 1000 | 0) + 60;
const orderDetails = {
tokenSell,
tokenBuy,
amount: sellQuantityPacked,
ratio: zksync.utils.tokenRatio(tokenRatio),
validUntil: oneMinExpiry
}
const fillOrder = await WALLETS[accountId].syncWallet.getOrder(orderDetails);
// Set wallet flag
WALLETS[accountId]['ORDER_BROADCASTING'] = true;
// Set wallet flag
WALLETS[accountId]['ORDER_BROADCASTING'] = true;
// ORDER_BROADCASTING should not take longer as 5 sec
setTimeout(function () {
WALLETS[accountId]['ORDER_BROADCASTING'] = false;
}, 5000);
// ORDER_BROADCASTING should not take longer as 5 sec
setTimeout(function() {
WALLETS[accountId]['ORDER_BROADCASTING'] = false;
}, 5000);
const resp = { op: "fillrequest", args: [chainId, orderId, fillOrder] };
zigzagws.send(JSON.stringify(resp));
rememberOrder(chainId,
marketId,
orderId,
quote.quotePrice,
sellSymbol,
sellQuantity,
buySymbol,
buyQuantity
);
const resp = { op: "fillrequest", args: [chainId, orderId, fillOrder] };
zigzagws.send(JSON.stringify(resp));
rememberOrder(chainId,
marketId,
orderId,
quote.quotePrice,
sellSymbol,
sellQuantity,
buySymbol,
buyQuantity
);
}
async function broadcastFill(chainId, orderId, swapOffer, fillOrder, wallet) {
@@ -428,21 +428,21 @@ async function broadcastFill(chainId, orderId, swapOffer, fillOrder, wallet) {
const nonce = swapOffer.nonce;
const userNonce = NONCES[swapOffer.accountId];
if (nonce <= userNonce) {
const orderCommitMsg = { op: "orderstatusupdate", args: [[[chainId, orderId, 'r', null, "Order failed userNonce check."]]] }
const orderCommitMsg = {op:"orderstatusupdate", args:[[[chainId,orderId,'r',null,"Order failed userNonce check."]]]}
zigzagws.send(JSON.stringify(orderCommitMsg));
return;
}
// select token to match user's fee token
let feeToken;
if (FEE_TOKEN) {
feeToken = FEE_TOKEN
feeToken = FEE_TOKEN
} else {
feeToken = (FEE_TOKEN_LIST.includes(swapOffer.tokenSell))
? swapOffer.tokenSell
: 'ETH'
feeToken = (FEE_TOKEN_LIST.includes(swapOffer.tokenSell))
? swapOffer.tokenSell
: 'ETH'
}
const randInt = (Math.random() * 1000).toFixed(0);
const randInt = (Math.random()*1000).toFixed(0);
console.time('syncswap' + randInt);
const swap = await wallet['syncWallet'].syncSwap({
orders: [swapOffer, fillOrder],
@@ -450,7 +450,7 @@ async function broadcastFill(chainId, orderId, swapOffer, fillOrder, wallet) {
nonce: fillOrder.nonce
});
const txHash = swap.txHash.split(":")[1];
const txHashMsg = { op: "orderstatusupdate", args: [[[chainId, orderId, 'b', txHash]]] }
const txHashMsg = {op:"orderstatusupdate", args:[[[chainId,orderId,'b',txHash]]]}
zigzagws.send(JSON.stringify(txHashMsg));
console.timeEnd('syncswap' + randInt);
@@ -467,19 +467,19 @@ async function broadcastFill(chainId, orderId, swapOffer, fillOrder, wallet) {
success = false;
}
console.timeEnd('receipt' + randInt);
console.log("Swap broadcast result", { swap, receipt });
console.log("Swap broadcast result", {swap, receipt});
let newStatus, error;
if (success) {
if(success) {
afterFill(chainId, orderId, wallet);
newStatus = 'f';
error = null;
} else {
} else {
newStatus = 'r';
error = swap.error.toString();
}
}
const orderCommitMsg = { op: "orderstatusupdate", args: [[[chainId, orderId, newStatus, txHash, error]]] }
const orderCommitMsg = {op:"orderstatusupdate", args:[[[chainId,orderId,newStatus,txHash,error]]]}
zigzagws.send(JSON.stringify(orderCommitMsg));
}
@@ -490,25 +490,25 @@ async function fillOpenOrders() {
if (fillable.fillable) {
sendFillRequest(order, fillable.walletId);
delete OPEN_ORDERS[orderId];
} else if (![
}else if (![
"sending order already",
"badprice"
].includes(fillable.reason)) {
].includes(fillable.reason)) {
delete OPEN_ORDERS[orderId];
}
}
}
async function setupPriceFeeds() {
const cryptowatch = [], chainlink = [], uniswapV3 = [];
const cryptowatch = [], chainlink = [], uniswapV3 = [];
for (let market in MM_CONFIG.pairs) {
const pairConfig = MM_CONFIG.pairs[market];
if (!pairConfig.active) { continue; }
if(!pairConfig.active) { continue; }
// This is needed to make the price feed backwards compatalbe with old constant mode:
// "DYDX-USDC": {
// "mode": "constant",
// "initPrice": 20,
if (pairConfig.mode == "constant") {
if(pairConfig.mode == "constant") {
const initPrice = pairConfig.initPrice;
pairConfig['priceFeedPrimary'] = "constant:" + initPrice.toString();
}
@@ -517,38 +517,38 @@ async function setupPriceFeeds() {
// parse keys to lower case to match later PRICE_FEED keys
if (primaryPriceFeed) {
MM_CONFIG.pairs[market].priceFeedPrimary = primaryPriceFeed.toLowerCase();
MM_CONFIG.pairs[market].priceFeedPrimary = primaryPriceFeed.toLowerCase();
}
if (secondaryPriceFeed) {
MM_CONFIG.pairs[market].priceFeedSecondary = secondaryPriceFeed.toLowerCase();
MM_CONFIG.pairs[market].priceFeedSecondary = secondaryPriceFeed.toLowerCase();
}
[primaryPriceFeed, secondaryPriceFeed].forEach(priceFeed => {
if (!priceFeed) { return; }
if(!priceFeed) { return; }
const [provider, id] = priceFeed.split(':');
switch (provider.toLowerCase()) {
switch(provider.toLowerCase()) {
case 'cryptowatch':
if (!cryptowatch.includes(id)) { cryptowatch.push(id); }
if(!cryptowatch.includes(id)) { cryptowatch.push(id); }
break;
case 'chainlink':
if (!chainlink.includes(id)) { chainlink.push(id); }
if(!chainlink.includes(id)) { chainlink.push(id); }
break;
case 'uniswapv3':
if (!uniswapV3.includes(id)) { uniswapV3.push(id); }
if(!uniswapV3.includes(id)) { uniswapV3.push(id); }
break;
case 'constant':
PRICE_FEEDS['constant:' + id] = parseFloat(id);
PRICE_FEEDS['constant:'+id] = parseFloat(id);
break;
default:
throw new Error("Price feed provider " + provider + " is not available.")
throw new Error("Price feed provider "+provider+" is not available.")
break;
}
});
}
if (chainlink.length > 0) await chainlinkSetup(chainlink);
if (cryptowatch.length > 0) await cryptowatchWsSetup(cryptowatch);
if (uniswapV3.length > 0) await uniswapV3Setup(uniswapV3);
}
});
}
if(chainlink.length > 0) await chainlinkSetup(chainlink);
if(cryptowatch.length > 0) await cryptowatchWsSetup(cryptowatch);
if(uniswapV3.length > 0) await uniswapV3Setup(uniswapV3);
console.log(PRICE_FEEDS);
console.log(PRICE_FEEDS);
}
async function cryptowatchWsSetup(cryptowatchMarketIds) {
@@ -563,7 +563,7 @@ async function cryptowatchWsSetup(cryptowatchMarketIds) {
const exchange = cryptowatchMarket.exchange;
const pair = cryptowatchMarket.pair;
const key = `market:${exchange}:${pair}`;
PRICE_FEEDS['cryptowatch:' + cryptowatchMarketIds[i]] = cryptowatchMarketPrices.result[key];
PRICE_FEEDS['cryptowatch:'+cryptowatchMarketIds[i]] = cryptowatchMarketPrices.result[key];
} catch (e) {
console.error("Could not set price feed for cryptowatch:" + cryptowatchMarketId);
}
@@ -594,7 +594,7 @@ async function cryptowatchWsSetup(cryptowatchMarketIds) {
function onopen() {
cryptowatch_ws.send(JSON.stringify(subscriptionMsg));
}
function onmessage(data) {
function onmessage (data) {
const msg = JSON.parse(data);
if (!msg.marketUpdate) return;
@@ -604,7 +604,7 @@ async function cryptowatchWsSetup(cryptowatchMarketIds) {
let price = ask / 2 + bid / 2;
PRICE_FEEDS[marketId] = price;
}
function onclose() {
function onclose () {
setTimeout(cryptowatchWsSetup, 5000, cryptowatchMarketIds);
}
}
@@ -620,9 +620,9 @@ async function chainlinkSetup(chainlinkMarketAddress) {
// get inital price
const response = await provider.latestRoundData();
PRICE_FEEDS[key] = parseFloat(response.answer) / 10 ** decimals;
PRICE_FEEDS[key] = parseFloat(response.answer) / 10**decimals;
} catch (e) {
throw new Error("Error while setting up chainlink for " + address + ", Error: " + e);
throw new Error ("Error while setting up chainlink for "+address+", Error: "+e);
}
});
await Promise.all(results);
@@ -634,14 +634,14 @@ async function chainlinkUpdate() {
await Promise.all(Object.keys(CHAINLINK_PROVIDERS).map(async (key) => {
const [provider, decimals] = CHAINLINK_PROVIDERS[key];
const response = await provider.latestRoundData();
PRICE_FEEDS[key] = parseFloat(response.answer) / 10 ** decimals;
PRICE_FEEDS[key] = parseFloat(response.answer) / 10**decimals;
}));
chainlink_error_counter = 0;
} catch (err) {
chainlink_error_counter += 1;
console.log(`Failed to update chainlink, retry: ${err.message}`);
if (chainlink_error_counter > 4) {
throw new Error("Failed to update chainlink since 150 seconds!")
if(chainlink_error_counter > 4) {
throw new Error ("Failed to update chainlink since 150 seconds!")
}
}
}
@@ -651,39 +651,39 @@ async function uniswapV3Setup(uniswapV3Address) {
try {
const IUniswapV3PoolABI = JSON.parse(fs.readFileSync('ABIs/IUniswapV3Pool.abi'));
const ERC20ABI = JSON.parse(fs.readFileSync('ABIs/ERC20.abi'));
const provider = new ethers.Contract(address, IUniswapV3PoolABI, ethersProvider);
let [
slot0,
addressToken0,
addressToken1
] = await Promise.all([
provider.slot0(),
provider.token0(),
provider.token1()
slot0,
addressToken0,
addressToken1
] = await Promise.all ([
provider.slot0(),
provider.token0(),
provider.token1()
]);
const tokenProvier0 = new ethers.Contract(addressToken0, ERC20ABI, ethersProvider);
const tokenProvier1 = new ethers.Contract(addressToken1, ERC20ABI, ethersProvider);
let [
decimals0,
decimals1
] = await Promise.all([
tokenProvier0.decimals(),
tokenProvier1.decimals()
decimals0,
decimals1
] = await Promise.all ([
tokenProvier0.decimals(),
tokenProvier1.decimals()
]);
const key = 'uniswapv3:' + address;
const decimalsRatio = (10 ** decimals0 / 10 ** decimals1);
const decimalsRatio = (10**decimals0 / 10**decimals1);
UNISWAP_V3_PROVIDERS[key] = [provider, decimalsRatio];
// get inital price
const price = (slot0.sqrtPriceX96 * slot0.sqrtPriceX96 * decimalsRatio) / (2 ** 192);
const price = (slot0.sqrtPriceX96*slot0.sqrtPriceX96*decimalsRatio) / (2**192);
PRICE_FEEDS[key] = price;
} catch (e) {
throw new Error("Error while setting up uniswapV3 for " + address + ", Error: " + e);
throw new Error ("Error while setting up uniswapV3 for "+address+", Error: "+e);
}
});
await Promise.all(results);
@@ -695,7 +695,7 @@ async function uniswapV3Update() {
await Promise.all(Object.keys(UNISWAP_V3_PROVIDERS).map(async (key) => {
const [provider, decimalsRatio] = UNISWAP_V3_PROVIDERS[key];
const slot0 = await provider.slot0();
PRICE_FEEDS[key] = (slot0.sqrtPriceX96 * slot0.sqrtPriceX96 * decimalsRatio) / (2 ** 192);
PRICE_FEEDS[key] = (slot0.sqrtPriceX96*slot0.sqrtPriceX96*decimalsRatio) / (2**192);
}));
// reset error counter if successful
uniswap_error_counter = 0;
@@ -703,31 +703,30 @@ async function uniswapV3Update() {
uniswap_error_counter += 1;
console.log(`Failed to update uniswap, retry: ${err.message}`);
console.log(err.message);
if (uniswap_error_counter > 4) {
throw new Error("Failed to update uniswap since 150 seconds!")
if(uniswap_error_counter > 4) {
throw new Error ("Failed to update uniswap since 150 seconds!")
}
}
}
function indicateLiquidity(pairs = MM_CONFIG.pairs) {
for (const marketId in pairs) {
function indicateLiquidity (pairs = MM_CONFIG.pairs) {
for(const marketId in pairs) {
const mmConfig = pairs[marketId];
if (!mmConfig || !mmConfig.active) continue;
if(!mmConfig || !mmConfig.active) continue;
try {
validatePriceFeed(marketId);
} catch (e) {
console.error("Can not indicateLiquidity (" + marketId + ") because: " + e);
} catch(e) {
console.error("Can not indicateLiquidity ("+marketId+") because: " + e);
continue;
}
const marketInfo = MARKETS[marketId];
if (!marketInfo) continue;
const midPrice = (mmConfig.invert)
? (1 / PRICE_FEEDS[mmConfig.priceFeedPrimary])
: PRICE_FEEDS[mmConfig.priceFeedPrimary];
if (!midPrice) continue;
const expires = (Date.now() / 1000 | 0) + 10; // 10s expiry
@@ -744,8 +743,8 @@ function indicateLiquidity(pairs = MM_CONFIG.pairs) {
maxQuoteBalance = walletQuote;
}
});
const baseBalance = maxBaseBalance / 10 ** marketInfo.baseAsset.decimals;
const quoteBalance = maxQuoteBalance / 10 ** marketInfo.quoteAsset.decimals;
const baseBalance = maxBaseBalance / 10**marketInfo.baseAsset.decimals;
const quoteBalance = maxQuoteBalance / 10**marketInfo.quoteAsset.decimals;
const maxSellSize = Math.min(baseBalance, mmConfig.maxSize);
const maxBuySize = Math.min(quoteBalance / midPrice, mmConfig.maxSize);
@@ -754,23 +753,23 @@ function indicateLiquidity(pairs = MM_CONFIG.pairs) {
const usdQuoteBalance = quoteBalance * marketInfo.quoteAsset.usdPrice;
let buySplits = (usdQuoteBalance && usdQuoteBalance < 1000) ? 1 : (mmConfig.numOrdersIndicated || 4);
let sellSplits = (usdBaseBalance && usdBaseBalance < 1000) ? 1 : (mmConfig.numOrdersIndicated || 4);
if (usdQuoteBalance && usdQuoteBalance < (10 * buySplits)) buySplits = Math.floor(usdQuoteBalance / 10)
if (usdBaseBalance && usdBaseBalance < (10 * sellSplits)) sellSplits = Math.floor(usdBaseBalance / 10)
const liquidity = [];
for (let i = 1; i <= buySplits; i++) {
const buyPrice = midPrice * (1 - mmConfig.minSpread - (mmConfig.slippageRate * maxBuySize * i / buySplits));
if ((['b', 'd']).includes(side)) {
for (let i=1; i <= buySplits; i++) {
const buyPrice = midPrice * (1 - mmConfig.minSpread - (mmConfig.slippageRate * maxBuySize * i/buySplits));
if ((['b','d']).includes(side)) {
liquidity.push(["b", buyPrice, maxBuySize / buySplits, expires]);
}
}
for (let i = 1; i <= sellSplits; i++) {
const sellPrice = midPrice * (1 + mmConfig.minSpread + (mmConfig.slippageRate * maxSellSize * i / sellSplits));
if ((['s', 'd']).includes(side)) {
liquidity.push(["s", sellPrice, maxSellSize / sellSplits, expires]);
}
}
for (let i=1; i <= sellSplits; i++) {
const sellPrice = midPrice * (1 + mmConfig.minSpread + (mmConfig.slippageRate * maxSellSize * i/sellSplits));
if ((['s','d']).includes(side)) {
liquidity.push(["s", sellPrice, maxSellSize / sellSplits, expires]);
}
}
const msg = { op: "indicateliq2", args: [CHAIN_ID, marketId, liquidity] };
try {
@@ -782,7 +781,7 @@ function indicateLiquidity(pairs = MM_CONFIG.pairs) {
}
}
function cancelLiquidity(chainId, marketId) {
function cancelLiquidity (chainId, marketId) {
const msg = { op: "indicateliq2", args: [chainId, marketId, []] };
try {
zigzagws.send(JSON.stringify(msg));
@@ -794,18 +793,18 @@ function cancelLiquidity(chainId, marketId) {
async function afterFill(chainId, orderId, wallet) {
const order = PAST_ORDER_LIST[orderId];
if (!order) { return; }
if(!order) { return; }
const marketId = order.marketId;
const mmConfig = MM_CONFIG.pairs[marketId];
if (!mmConfig) { return; }
if(!mmConfig) { return; }
// update account state from order
const account_state = wallet['account_state'].committed.balances;
const buyTokenParsed = syncProvider.tokenSet.parseToken(
const buyTokenParsed = syncProvider.tokenSet.parseToken (
order.buySymbol,
order.buyQuantity
);
const sellTokenParsed = syncProvider.tokenSet.parseToken(
const sellTokenParsed = syncProvider.tokenSet.parseToken (
order.sellSymbol,
order.sellQuantity
);
@@ -815,12 +814,12 @@ async function afterFill(chainId, orderId, wallet) {
const oldSellTokenParsed = ethers.BigNumber.from(oldSellBalance);
account_state[order.buySymbol] = (oldBuyTokenParsed.add(buyTokenParsed)).toString();
account_state[order.sellSymbol] = (oldSellTokenParsed.sub(sellTokenParsed)).toString();
const indicateMarket = {};
indicateMarket[marketId] = mmConfig;
if (mmConfig.delayAfterFill) {
if(mmConfig.delayAfterFill) {
let delayAfterFillMinSize
if (
if(
!Array.isArray(mmConfig.delayAfterFill) ||
!mmConfig.delayAfterFill[1]
) {
@@ -829,28 +828,28 @@ async function afterFill(chainId, orderId, wallet) {
delayAfterFillMinSize = mmConfig.delayAfterFill[1]
}
if (order.baseQuantity > delayAfterFillMinSize) {
if(order.baseQuantity > delayAfterFillMinSize) {
// no array -> old config
// or array and buyQuantity over minSize
mmConfig.active = false;
cancelLiquidity(chainId, marketId);
cancelLiquidity (chainId, marketId);
console.log(`Set ${marketId} passive for ${mmConfig.delayAfterFill} seconds.`);
setTimeout(() => {
mmConfig.active = true;
console.log(`Set ${marketId} active.`);
indicateLiquidity(indicateMarket);
}, mmConfig.delayAfterFill * 1000);
}
}, mmConfig.delayAfterFill * 1000);
}
}
// increaseSpreadAfterFill size might not be set
const increaseSpreadAfterFillMinSize = (mmConfig.increaseSpreadAfterFill?.[2])
const increaseSpreadAfterFillMinSize = (mmConfig.increaseSpreadAfterFill?.[2])
? mmConfig.increaseSpreadAfterFill[2]
: 0
if (
if(
mmConfig.increaseSpreadAfterFill &&
order.baseQuantity > increaseSpreadAfterFillMinSize
) {
const [spread, time] = mmConfig.increaseSpreadAfterFill;
mmConfig.minSpread = mmConfig.minSpread + spread;
@@ -864,10 +863,10 @@ async function afterFill(chainId, orderId, wallet) {
}
// changeSizeAfterFill size might not be set
const changeSizeAfterFillMinSize = (mmConfig.changeSizeAfterFill?.[2])
const changeSizeAfterFillMinSize = (mmConfig.changeSizeAfterFill?.[2])
? mmConfig.changeSizeAfterFill[2]
: 0
if (
if(
mmConfig.changeSizeAfterFill &&
order.baseQuantity > changeSizeAfterFillMinSize
) {
@@ -877,7 +876,7 @@ async function afterFill(chainId, orderId, wallet) {
indicateLiquidity(indicateMarket);
setTimeout(() => {
mmConfig.maxSize = mmConfig.maxSize - size;
console.log(`Changed ${marketId} maxSize by ${(size * (-1))}.`);
console.log(`Changed ${marketId} maxSize by ${(size* (-1))}.`);
indicateLiquidity(indicateMarket);
}, time * 1000);
}
@@ -893,7 +892,7 @@ function rememberOrder(chainId, marketId, orderId, price, sellSymbol, sellQuanti
const [baseSymbol, quoteSymbol] = marketId.split('-')
let baseQuantity, quoteQuantity;
if (sellSymbol === baseSymbol) {
if(sellSymbol === baseSymbol) {
baseQuantity = sellQuantity;
quoteQuantity = buyQuantity;
} else {
@@ -912,7 +911,7 @@ function rememberOrder(chainId, marketId, orderId, price, sellSymbol, sellQuanti
'sellQuantity': sellQuantity,
'buySymbol': buySymbol,
'buyQuantity': buyQuantity,
'expiry': expiry
'expiry':expiry
};
}
@@ -923,7 +922,7 @@ async function updateAccountState() {
WALLETS[accountId]['account_state'] = state;
})
});
} catch (err) {
} catch(err) {
// pass
}
}